devkuma – データベース

SQLite | データ型（Data Type） | SQLiteで使用できるデータ型

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

テーブルに値を保存する列を定義するときは、各列に保存する値に応じてデータ型を指定できます。ここでは、SQLiteの列に指定できるデータ型について説明します。

保存される値のデータ型

多くのデータベースでは列ごとにデータ型を指定し、その列に保存できる値を決定します。SQLite3では、テーブルを定義するときに各列のデータ型を指定する必要はありません。データ型を指定していない列には、さまざまな形式の値を保存できます。

列のデータ型を指定していなくても、保存された各値にはデータ型があります。SQLiteでは、値をNULL、INTEGER、REAL、TEXT、BLOBの5つのストレージクラスに分類します。

データ型	説明
NULL	NULL値
INTEGER	1、2、3、4、6、または8バイトで保存される符号付き整数
REAL	8バイトで保存される浮動小数点数
TEXT	UTF-8、UTF-16BE、またはUTF-16LEで保存されるテキスト
BLOB	入力データをそのまま保存するBinary Large Object

SQL文での表記方法によって値のデータ型が決まります。たとえば、シングルクォート（'）で囲んだ値はTEXT、小数点も指数もない数値はINTEGER、小数点または指数を含む数値はREALになります。

列のデータ型

テーブルを作成するときに列のデータ型を指定できますが、必須ではありません。

次の例では、id列をINTEGER型、name列をTEXT型としてテーブルを作成します。

create table customer (id integer, name text);

SQLite3では、列にTEXT、NUMERIC、INTEGER、REAL、NONEの5つの型アフィニティがあります。

TEXT
NUMERIC
INTEGER
REAL
NONE

列にデータ型を指定した場合でも、異なるデータ型の値を保存できます。列の型アフィニティと値のデータ型の組み合わせによって、値が変換されて保存されることがあります。

TEXT列にINTEGERまたはREALの値を入れると、TEXTに変換して保存します。
NUMERIC列にTEXTの値を入れると、INTEGERまたはREALへの変換を試みます。成功した場合は変換後の値を保存し、失敗した場合はTEXTのまま保存します。
34.0のように整数で表現できるREAL値、または同等のTEXT値をINTEGER列に入れると、INTEGERに変換して保存します。
REAL列にINTEGER値を入れると、REALに変換して保存します。
NONE型の列では変換処理を行いません。

列にデータ型を指定する方法

SQLite3の型アフィニティはTEXT、NUMERIC、INTEGER、REAL、NONEの5つですが、他のデータベースとの互換性などを考慮して、integerの代わりにintと宣言することもできます。列の型アフィニティは次の規則で決まります。

宣言したデータ型にINTという文字列が含まれる場合はINTEGERになります。

create table customer (id int, name text); -- integerの代わりにintを使用

宣言したデータ型にCHAR、CLOB、TEXTのいずれかが含まれる場合はTEXTになります。

create table customer (id integer, name varchar); -- textの代わりにvarcharを使用

宣言したデータ型にBLOBが含まれる場合、またはデータ型を指定しない場合はNONEになります。

宣言したデータ型にREAL、FLOA、DOUBのいずれかが含まれる場合はREALになります。

上記のいずれにも該当しない場合はNUMERICになります。

SQLite | データ型 | 保存された値のデータ型を確認する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

カラムに型を指定した場合と指定しない場合で、値がどの型として保存されるかを比較します。保存値は最終的にNULL、INTEGER、REAL、TEXT、BLOBの5つに分類されます。

カラムにデータ型を指定しない場合

型を指定しない2つのカラムを持つテーブルを作成します。この場合はNONEアフィニティとなり、値は自動変換されずに保存されます。

create table test (val1, val2);

$ sqlite3 test.sqlite3
SQLite version 3.19.3 2017-06-27 16:48:08
Enter ".help" for usage hints.
sqlite> 
sqlite> create table test (val1, val2);
sqlite>

3行を追加します。

insert into test values(null, 51);
insert into test values(3.14, 'devkuma');
insert into test values('Good Morning', 1.3e-2);

sqlite> insert into test values(null, 51);
sqlite> insert into test values(3.14, 'devkuma');
sqlite> insert into test values('Good Morning', 1.3e-2);
sqlite>

保存したデータを検索します。

select * from test;

見やすいように.modeと.headersを変更します。

sqlite> select * from test;
|51
3.14|devkuma
Good Morning|0.013
sqlite> 
sqlite> .mode column
sqlite> .header on
sqlite> 
sqlite> select * from test;
val1        val2      
----------  ----------
            51        
3.14        devkuma   
Good Morni  0.013     
sqlite>

typeof()を使い、各値と保存クラスを表示します。

select val1, typeof(val1), val2, typeof(val2) from test;

sqlite> select val1, typeof(val1), val2, typeof(val2) from test;
val1        typeof(val1)  val2        typeof(val2)
----------  ------------  ----------  ------------
            null          51          integer     
3.14        real          devkuma     text        
Good Morni  text          0.013       real        
sqlite>

NULLはNULL、整数はINTEGER、文字列はTEXT、浮動小数点数はREALとして保存されます。保存型は追加した値に従います。

カラムにデータ型を指定する場合

次に、カラムの宣言型が保存値にどう影響するかを確認します。

第1カラムをTEXT、第2カラムをNUMERICにしたテーブルを作成します。

create table test2 (val1 text, val2 numeric);

sqlite> create table test2 (val1 text, val2 numeric);
sqlite>

3行を追加します。

insert into test2 values ('Summer', 'Summer');
insert into test2 values (48, 48);
insert into test2 values ('72', '72');
insert into test2 values (39.24, 39.24);
insert into test2 values ('0.17', '0.17');
insert into test2 values (null, null);

sqlite> insert into test2 values('Summer', 'Summer');
sqlite> insert into test2 values(48, 48);
sqlite> insert into test2 values('72', '72');
sqlite> insert into test2 values(39.24, 39.24);
sqlite> insert into test2 values('0.17', '0.17');
sqlite> insert into test2 values(null, null);
sqlite>

値と保存クラスを検索します。

select val1, typeof(val1), val2, typeof(val2) from test2;

sqlite> select val1, typeof(val1), val2, typeof(val2) from test2;
val1        typeof(val1)  val2        typeof(val2)
----------  ------------  ----------  ------------
Summer      text          Summer      text        
48          text          48          integer     
72          text          72          integer     
39.24       text          39.24       real        
0.17        text          0.17        real        
            null                      null        
sqlite>

TEXTカラムでは文字列はそのまま保存され、整数と実数はTEXTへ変換されます。NULLは変換されません。

NUMERICカラムでは文字列をINTEGERまたはREALへ変換し、失敗した場合はTEXTのまま保存します。NULLは変換されません。

この例から、宣言型によって値が変換されて保存される場合があることが分かります。

SQLite | データ型（Data Type） | 文字列のエスケープ処理

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

SQLiteのテーブルに保存する文字列はシングルクォート（'）で囲みます。文字列にシングルクォートが含まれる場合は、エスケープ処理が必要です。ここでは、文字列をエスケープする方法について説明します。

文字列のエスケープ処理

SQLiteで文字列を記述するには、次のように値をシングルクォート（'）で囲みます。

'文字列'

ダブルクォート（"）で囲んだものは識別子になります。文字列が必要な場所に識別子を記述すると文字列のように扱われることがありますが、文字列はシングルクォートで囲む必要があります。

シングルクォートは文字列の区切り文字として使われるため、文字列内のシングルクォートはエスケープしなければなりません。

例として次のテーブルを作成します。

create table test (val text);

同名のテストテーブルがすでに存在する場合は、先に削除してから作成します。

sqlite> drop table test;
sqlite> create table test (val text);
sqlite>

シングルクォートを含む次の文字列を保存するとします。

I'm a student.

次の文を実行してもすぐにはエラーにならず、SQL文が完結していないため入力待ちになります。文字列の開始位置と終了位置を判別できないためです。

insert into test values('I'm a student.');

sqlite> insert into test values('I'm a student.');
   ...> 
   ...> ';
Error: near "m": syntax error
sqlite>

文字列内のシングルクォートをエスケープするには、その直前にシングルクォートをもう1つ記述します。

insert into test values('I''m a student.');

sqlite> 
sqlite> insert into test values('I''m a student.');
sqlite>

これで値が正常に保存されました。テーブルを検索して確認します。

select * from test;

sqlite> select * from test;
I'm a student.

シングルクォートを含む文字列は、エスケープしないと正しく保存できません。文字列内のシングルクォートは必ずエスケープしてください。

SQLite | テーブル | テーブルを作成する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

テーブルは、データベース内で実際の値を保存する場所です。1つのデータベースに複数のテーブルを作成できます。ここでは、テーブルの作成方法を説明します。

CREATE TABLE文でテーブルを作成する

SQLiteでテーブルを作成する基本構文は次のとおりです。

CREATE TABLE テーブル名 (列名1, 列名2, ...);

テーブル名は任意に指定できますが、sqlite_で始まる名前はSQLite自身が使用するため指定できません。

テーブルには少なくとも1つの列が必要です。複数の列はカンマで区切ります。

次の文は、id列とname列を持つcustomerテーブルを作成します。

create table customer (id, name);

sqlite> 
sqlite> create table customer (id, name);
sqlite>

上のようにコマンドが完了すれば、テーブルは作成されています。

列にデータ型を指定してテーブルを作成する

SQLiteでは、列のデータ型を指定せずにテーブルを作成できますが、指定することもできます。詳細はSQLiteのデータ型を参照してください。

CREATE TABLE テーブル名 (列名1 データ型, 列名2 データ型, ...)

列名の後ろに空白を置き、その列のデータ型を指定します。

次の文は、INTEGER型のid列とTEXT型のname列を持つcustomer2テーブルを作成します。

create table customer2 (id integer, name text);

sqlite> 
sqlite> create table customer2 (id integer, name text);
sqlite>

上のようにコマンドが完了すれば、テーブルは作成されています。

データベース内のテーブル一覧を確認する

SQLiteの.tablesコマンドを使います。

.tables
.tables? TABLE?

引数を省略するとすべてのテーブルを表示し、名前のパターンを指定すると一致するテーブルを表示します。

.tables

sqlite> .tables
customer   customer2  test       test2    
sqlite>

このページで作成したcustomerとcustomer2が表示されています。

名前またはパターンも指定できます。

.tables customer
.tables customer%

sqlite> .tables customer
customer
sqlite> 
sqlite> .tables customer%
customer   customer2
sqlite>

最初のコマンドは正確なテーブル名を指定し、2番目はパーセント記号（%）で指定したパターンに一致する名前を検索しています。

SQLite | テーブル（Table） | テーブルスキーマ（構造）の確認

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

テーブルの作成に使用されたCREATE文を確認する方法について説明します。sqlite_masterテーブルを検索する方法と、.schemaコマンドを使用する方法があります。

sqlite_masterテーブルを検索する

最初の方法ではsqlite_masterテーブルを使用します。次のSQL文を実行します。見やすくするため、例では先に.modeコマンドで出力モードをlineに変更しています。

select * from sqlite_master;

sqlite> select * from sqlite_master;
table|customer|customer|2|CREATE TABLE customer (id, name)
table|customer2|customer2|3|CREATE TABLE customer2 (id integer, name text)
sqlite> 
sqlite> .mode line
sqlite> 
sqlite> select * from sqlite_master;
    type = table
    name = customer
tbl_name = customer
rootpage = 2
     sql = CREATE TABLE customer (id, name)

    type = table
    name = customer2
tbl_name = customer2
rootpage = 3
     sql = CREATE TABLE customer2 (id integer, name text)
sqlite>

上記のようにデータを取得できます。

現在は2つのテーブルが作成されているため、sqlite_masterテーブルには2行が表示されます。各行のname列にはテーブル名、sql列にはテーブル作成時のCREATE TABLE文が格納されています。sqlite_masterを検索することで、各テーブルがどのように作成されたかを確認できます。

特定のテーブルのCREATE TABLE文を確認するには、WHERE句を追加します。

select * from sqlite_master where type='table' and name='customer';

sqlite> select * from sqlite_master where type='table' and name='customer';
    type = table
    name = customer
tbl_name = customer
rootpage = 2
     sql = CREATE TABLE customer (id, name)

指定したテーブルの行だけが取得されました。

.schemaコマンドを使用する

スキーマ情報だけを確認する場合は、SQLiteの.schemaコマンドも使用できます。

.schema
.schema ?TABLE?

引数を省略すると、すべてのテーブルとインデックスのスキーマ情報を表示します。テーブル名を指定すると、一致するテーブルと関連オブジェクトのスキーマ情報を表示します。

.schemaを次のように実行します。

.schema

sqlite> .schema
CREATE TABLE customer (id, name);
CREATE TABLE customer2 (id integer, name text);
sqlite>

現在のデータベースにある2つのテーブルのCREATE文が表示されます。.schemaコマンドでも、テーブルがどのように作成されたかを確認できます。

SQLite | テーブル | テーブル名の変更とカラムの追加・削除

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

既存テーブルの名前を変更し、カラムを追加または削除する方法を説明します。

テーブル名を変更する

既存テーブルの名前を変更するにはALTER TABLEを使います。構文は次のとおりです。

ALTER TABLE テーブル名 RENAME TO 新しいテーブル名;

たとえばtable_oldをtable_newへ変更します。

alter table table_old rename to table_new;

.tablesで現在のテーブルを確認します。この例にはcustomerとcustomer2があります。

sqlite> .table
customer   customer2
sqlite>

customer2をuserへ変更します。

alter table customer2 rename to user;

sqlite> 
sqlite> alter table customer2 rename to user;
sqlite>

再度.tablesを実行し、一覧がcustomerとuserになったことを確認します。

sqlite> .table
customer  user    
sqlite>

カラムを追加する

既存テーブルにカラムを追加するにはALTER TABLEを使います。構文は次のとおりです。

ALTER TABLE テーブル名 ADD COLUMN カラム名 [データ型];

この例で使用しているSQLiteではカラムの追加はできますが、DROP COLUMNは使用できません。

新しいカラムはテーブルの末尾に追加され、次の条件を満たす必要があります。

PRIMARY KEYまたはUNIQUE制約は設定できません。
DEFAULTにCURRENT_TIME、CURRENT_DATE、CURRENT_TIMESTAMPは指定できません。
NOT NULLを設定する場合は、NULL以外の既定値が必要です。

たとえばmytableにnew_columnを追加します。

alter table mytable add column new_column;

既存のuserテーブルにTEXT型のaddressを追加します。まず.schemaで現在のスキーマを確認します。

.schema user

sqlite> .schema user
CREATE TABLE IF NOT EXISTS "user" (id integer, name text);
sqlite>

userにaddressを追加します。

alter table user add column address text;

sqlite> 
sqlite> alter table user add column address text;
sqlite>

再度.schemaを実行し、addressが追加されたことを確認します。

.schema user

sqlite> .schema user
CREATE TABLE IF NOT EXISTS "user" (id integer, name text, address text);
sqlite>

カラムを削除する

古いSQLiteではDROP COLUMNを使用できません。代わりにDROP TABLEとALTER TABLE RENAMEを使います。

置き換え用のテーブルを作成し、必要なデータを移す方法です。

まず.schemaで現在のuserスキーマを確認します。

sqlite> .schema user
CREATE TABLE IF NOT EXISTS "user" (id integer, name text, address text);
sqlite>

user2を作成し、userのデータをコピーします。

sqlite> create table user2 (id integer, name text);
sqlite> 
sqlite> insert into user2 (id, name) select id, name from user;

元のuserを削除し、user2をuserへ変更します。

sqlite> drop table user;
sqlite> 
sqlite> alter table user2 rename to user;

再度.schemaを実行し、addressがなくなったことを確認します。

sqlite> .schema user
CREATE TABLE IF NOT EXISTS "user" (id integer, name text);

SQLite | テーブル（Table） | テーブルの削除

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

作成済みのテーブルを削除する方法について説明します。

作成済みテーブルの削除

作成済みのテーブルを削除するには、DROP TABLE文を使用します。構文は次のとおりです。

DROP TABLE テーブル名;

テーブルを削除すると、そのテーブルに関連付けられたインデックスとトリガーも削除されます。

たとえば、mytableテーブルを削除するには次のように実行します。

drop table mytable;

テーブルの削除によってデータベースに生じた未使用領域を解放するには、VACUUM文を実行する必要があります。VACUUMについては、空き領域の整理（VACUUM）を参照してください。

それでは、実際にテーブルを削除してみましょう。まずSQLiteの.tablesコマンドを使用し、customerテーブルとuserテーブルが存在することを確認します。

.tables

sqlite> .table
customer  user    
sqlite>

userテーブルを削除します。

drop table user;

sqlite> drop table user;
sqlite>

.tablesコマンドを再度実行し、userテーブルが削除されたことを確認します。

sqlite> .table
customer    
sqlite>

結果から、userテーブルが削除されたことを確認できます。

SQLite | テーブル（Table） | NOT NULL制約

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

列にNULLを保存できないようにするには、その列にNOT NULL制約を設定します。ここでは、NOT NULL制約の使い方について説明します。

NOT NULL制約とは

NOT NULL制約を設定した列にはNULLを保存できません。列にNOT NULL制約を設定する構文は次のとおりです。

CREATE TABLE テーブル名 (列名 NOT NULL, ...);

実際に制約を設定してみましょう。次の文は、name列にNOT NULL制約を設定したテーブルを作成します。

create table user (name text not null, address text);

sqlite> create table user (name text not null, address text);
sqlite>

次にデータを追加します。address列にはNULLを保存できます。

insert into user values ('dekuma', 'Seoul');
insert into user values ('kimkc', null);

sqlite> insert into user values ('dekuma', 'Seoul');
sqlite> insert into user values ('kimkc', null);
sqlite>

name列にはNOT NULL制約が設定されているため、NULLを保存しようとするとError: NOT NULL constraint failed: user.nameというエラーメッセージが表示されます。

insert into user values (null, 'Busan');

sqlite> insert into user values (null, 'Busan');
Error: NOT NULL constraint failed: user.name
sqlite>

NOT NULL制約が設定された列の値を省略した場合も、自動的にNULLを保存しようとするため同じエラーが発生します。

insert into user (address) values ('Daejeon');

sqlite> insert into user (address) values ('Daejeon');
Error: NOT NULL constraint failed: user.name
sqlite>

データの追加時に必ず値が必要な列には、NOT NULL制約を設定してください。

SQLite | テーブル | UNIQUE制約

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

UNIQUE制約を設定すると、カラムに重複した値が保存されるのを防げます。ここでは、UNIQUE制約の使い方を説明します。

UNIQUE制約とは

カラムにUNIQUE制約を設定すると、重複する値を保存できません。構文は次のとおりです。

CREATE TABLE テーブル名 (カラム名 UNIQUE, ...);

次のテーブルを作成します。idカラムにはUNIQUE制約が設定されています。

create table user (id integer unique, name text);

sqlite> create table user (id integer unique, name text);
sqlite>

いくつかの行を追加します。

insert into user values (1, 'devkuma');
insert into user values (2, 'kimkc');
insert into user values (4, 'araikuma');

sqlite> insert into user values (1, 'devkuma');
sqlite> insert into user values (2, 'kimkc');
sqlite> insert into user values (4, 'araikuma');
sqlite>

既存の行と同じidを追加すると、Error: UNIQUE constraint failed: user.idと表示されます。

insert into user values (2, 'happykuma');

sqlite> insert into user values (2, 'happykuma');
Error: UNIQUE constraint failed: user.id
sqlite>

この制約により、カラムへの重複値の保存を防げます。

ただし、UNIQUE制約があっても複数のNULL値は保存できます。

insert into user values (null, 'mykuma');
insert into user values (null, 'yourkuma');

sqlite> insert into user values (null, 'mykuma');
sqlite> insert into user values (null, 'yourkuma');
sqlite>

NULLを許可しない場合は、NOT NULL制約も設定します。

複数カラムの組み合わせにUNIQUE制約を設定する

UNIQUE制約は、複数カラムの組み合わせにも設定できます。構文は次のとおりです。

CREATE TABLE テーブル名 (カラム名1, カラム名2, ... , UNIQUE (カラム名1, カラム名2, ...));

2つのカラムに制約を設定した場合、各カラム単独の重複は許可されますが、同じ値の組み合わせは保存できません。

noとunitの組み合わせにUNIQUE制約を設定したテーブルを作成します。

create table employee (no integer, unit text, name text, unique (no, unit));

sqlite> create table employee (no integer, unit text, name text, unique (no, unit));
sqlite>

いくつかの行を追加します。

insert into employee values (1, 'Sales', 'devkuma');
insert into employee values (4, 'Dev', 'kimkc');
insert into employee values (2, 'Office', 'araikuma');

sqlite> insert into employee values (1, 'Sales', 'devkuma');
sqlite> insert into employee values (4, 'Dev', 'kimkc');
sqlite> insert into employee values (2, 'Office', 'araikuma');
sqlite>

noだけ、またはunitだけが既存行と同じ行を追加します。組み合わせ全体は異なるため、エラーになりません。

insert into employee values (4, 'Design', 'mykuma');
insert into employee values (7, 'Sales', 'yourkuma');

sqlite> insert into employee values (4, 'Design', 'mykuma');
sqlite> insert into employee values (7, 'Sales', 'yourkuma');
sqlite>

既存行と同じnoとunitの組み合わせを追加すると、Error: UNIQUE constraint failed: employee.no, employee.unitと表示されます。

insert into employee values (2, 'Office', 'blackkuma');

sqlite> insert into employee values (2, 'Office', 'blackkuma');
Error: UNIQUE constraint failed: employee.no, employee.unit
sqlite>

このように、単一カラムだけでなく複数カラムの組み合わせにもUNIQUE制約を設定できます。

SQLite | テーブル | DEFAULT制約

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

行を追加するときにカラム値を省略すると、通常はNULLが保存されます。DEFAULT制約を使うと、代わりに既定値を保存できます。ここでは、その使い方を説明します。

DEFAULT制約とは

DEFAULT制約を設定すると、追加時にカラム値を省略した場合の既定値を指定できます。構文は次のとおりです。

CREATE TABLE テーブル名 (カラム名 DEFAULT 値, ...);

既定値にはNULL、数値、文字列を指定できます。

次のテーブルを作成します。nameとpriceにはそれぞれDEFAULT制約があります。

create table product (id integer, name text default 'no name', price integer default 0);

sqlite> create table product (id integer, name text default 'no name', price integer default 0);
sqlite>

まず、各カラムの値を明示して行を追加します。指定した値がそのまま保存されます。

insert into product values (1, 'PC', 75000);
insert into product values (4, 'Desk', 18000);

sqlite> insert into product values (1, 'PC', 75000);
sqlite> insert into product values (4, 'Desk', 18000);
sqlite>

nameを省略すると、既定値のno nameが保存されます。

insert into product (id, price) values (6, 18000);

sqlite> insert into product (id, price) values (6, 18000);
sqlite> 
sqlite> .mode column
sqlite> .header on
sqlite> 
sqlite> select * from product;
id          name        price     
----------  ----------  ----------
4           Desk        18000     
1           PC          75000     
6           no name     18000     
sqlite>

同様にpriceを省略すると、既定値の0が保存されます。

insert into product (id, name) values (8, 'Chair');

sqlite> insert into product (id, name) values (8, 'Chair');
sqlite> 
sqlite> select * from product;
id          name        price     
----------  ----------  ----------
4           Desk        18000     
1           PC          75000     
6           no name     18000     
8           Chair       0         
sqlite>

このようにDEFAULT制約を使うと、値を省略した場合にNULLではなく指定した既定値を保存できます。

追加日時を既定値にする

次の値を既定値にすると、行を追加した時点の日付や時刻をカラムに保存できます。

指定値	形式
CURRENT_TIME	HH : MM : SS
CURRENT_DATE	YYYY-MM-DD
CURRENT_TIMESTAMP	YYYY-MM-DD HH : MM : SS
タイムゾーンはUTCです。

date_timeの既定値にCURRENT_TIMESTAMPを指定したテーブルを作成します。

create table user (id integer, name text, date_time default CURRENT_TIMESTAMP);

sqlite> create table user (id integer, name text, date_time default CURRENT_TIMESTAMP);
sqlite>

date_timeを省略して行を追加します。

insert into user (id, name) values (1, 'devkuma');
insert into user (id, name) values (3, 'kimkc');

sqlite> insert into user (id, name) values (1, 'devkuma');
sqlite> insert into user (id, name) values (3, 'kimkc');
sqlite> 
sqlite> select * from user;
id          name        date_time          
----------  ----------  -------------------
1           devkuma     2019-10-22 14:43:07
3           kimkc       2019-10-22 14:43:08
sqlite>

date_timeに各行を追加した日時が保存されていることを確認できます。

SQLite | テーブル | CHECK制約

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

CHECK制約を使うと、カラムに保存する値が条件を満たすか検証できます。ここでは、CHECK制約の使い方を説明します。

CHECK制約とは

カラムにCHECK制約を設定すると、追加する値が指定した条件を満たすか確認できます。カラム単位の構文は次のとおりです。

CREATE TABLE テーブル名 (カラム名 CHECK (条件式), ...);

条件式には、0以上の値だけを許可するなど、カラムに保存できる値の条件を記述します。

複数のカラムを組み合わせた条件には、次のテーブル単位の形式を使用できます。

CREATE TABLE テーブル名 (カラム名1, カラム名2, ..., CHECK (条件式));

次のテーブルを作成します。oldカラムにはCHECK制約があり、18より大きい整数だけを保存できます。

create table user (id integer, name text, old integer check (old> 18));

sqlite> create table user (id integer, name text, old integer check (old> 18));
sqlite>

oldの値が条件を満たす行は問題なく追加できます。

insert into user values (1, 'devkuma', 19);
insert into user values (4, 'kimkc', 21);

qlite> insert into user values (1, 'devkuma', 19);
sqlite> insert into user values (4, 'kimkc', 21);
sqlite> 
sqlite> select * from user;
id          name        old       
----------  ----------  ----------
1           devkuma     19        
4           kimkc       21        
sqlite>

条件を満たさないoldの値を追加すると、Error: CHECK constraint failed: userと表示されます。

insert into user values (7, 'araikuma', 16);

sqlite> insert into user values (7, 'araikuma', 16);
Error: CHECK constraint failed: user
sqlite>

このようにCHECK制約でカラムに保存できる値を制限できます。

ANDとORで複雑な条件を定義する

ANDやORを使うと、より複雑な条件式を記述できます。次の例ではoldを18より大きく30未満の値に制限します。

create table user (id integer, name text,
  old integer check (old > 18 and old < 30));

次の例ではgenderをmanまたはwomanに制限します。

create table user (id integer, name text,
  gender text check (gender = 'man' or gender = 'woman'));

複数のカラムを使う条件にはテーブル単位の制約を使用します。この例では、genderがwomanまたはoldが20より大きい行を追加できます。

create table user (name text, old integer, gender text,
  check (gender = 'woman' or old> 20));

最後の例のテーブルを実際に作成します。

sqlite> create table user (name text, old integer, gender text, check (gender = 'woman' or old> 20));
sqlite>

データを追加します。性別がwoman、または年齢が20より大きい行は正常に追加されます。

insert into user values ( 'dekuma', 16, 'woman');
insert into user values ( 'kimkc', 31, 'man');
insert into user values ( 'araikuma', 24, 'woman');

sqlite> insert into user values ( 'dekuma', 16, 'woman');
sqlite> insert into user values ( 'kimkc', 31, 'man');
sqlite> insert into user values ( 'araikuma', 24, 'woman');
sqlite>

CHECK条件を満たさない行を追加すると、Error: CHECK constraint failed: userと表示されます。

insert into user values ('happykuma', 15, 'man');

sqlite> insert into user values ('happykuma', 15, 'man');
Error: CHECK constraint failed: user
sqlite>

このようにANDやORを組み合わせて複雑なCHECK制約を定義できます。

SQLite | ビュー | ビューを作成する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

ビューは選択カラムと検索条件で定義する仮想テーブルです。ここではビューの作成と利用方法を説明します。

ビューを作成する

次の構文でビューを作成します。

CREATE VIEW ビュー名 AS SELECT文;

ASの後に、元テーブルのカラムと条件を指定するSELECT文を書きます。

create view myview as select name, price from product where price> 3000;

ビューはテーブルの一部を別テーブルのように公開します。検索はできますが、この例ではビュー経由の追加や更新はできません。

元になるテーブルを作成します。

create table user (id integer, name text, address text, old integer);

sqlite> create table user (id integer, name text, address text, old integer);
sqlite>

テーブルにデータを追加します。

insert into user values (1, 'devkuma', 'Seoul', 23);
insert into user values (2, 'kimkc', 'Busan', 19);
insert into user values (3, 'araikuma', 'Seoul', 38);
insert into user values (4, 'happykuma', 'Seoul', 24);
insert into user values (5, 'mykuma', 'Daejeon', 18);

sqlite> insert into user values (1, 'devkuma', 'Seoul', 23);
sqlite> insert into user values (2, 'kimkc', 'Busan', 19);
sqlite> insert into user values (3, 'araikuma', 'Seoul', 38);
sqlite> insert into user values (4, 'happykuma', 'Seoul', 24);
sqlite> insert into user values (5, 'mykuma', 'Daejeon', 18);
sqlite>

seouluserというビューを作成します。

create view seouluser as select id, name from user where address = 'Seoul';

sqlite> create view seouluser as select id, name from user where address = 'Seoul';
sqlite>

このビューはaddressがSeoulの行について、userのidとnameを公開します。データ自体は保持しません。

ビューを検索します。

select * from tokyouser;

sqlite> select * from seouluser;
1|devkuma
3|araikuma
4|happykuma

ビューはテーブルと同様に検索でき、元のSELECTと同じ結果になります。

select id, name from user where address = 'Tokyo';

sqlite> select id, name from user where address = 'Seoul';
1|devkuma
3|araikuma
4|happykuma
sqlite>

ビューを使うと必要なデータを簡単に検索できます。

ビューが返すデータ

ビューが保存するのは検索定義だけで、データ自体ではありません。検索のたびに元テーブルの現在のデータを読むため、元データが変わると結果も変わります。

現在の元データを確認します。

select * from user;

sqlite> select * from user;
1|devkuma|Seoul|23
2|kimkc|Busan|19
3|araikuma|Seoul|38
4|happykuma|Seoul|24
5|mykuma|Daejeon|18

ビューを検索します。

select * from seouluser;

sqlite> select * from seouluser;
1|devkuma
3|araikuma
4|happykuma

元テーブルにデータを追加して再度ビューを検索すると、新しい一致行も表示されます。

insert into user values (6, 'yourkuma', ' Seoul', 17);

sqlite> insert into user values (6, 'yourkuma', ' Seoul', 17);
sqlite> 
sqlite> select * from seouluser;
1|devkuma
3|araikuma
4|happykuma
6|yourkuma
sqlite>

ビューは独自のデータを持たず、常に元テーブルを参照します。

ビュー経由の追加・更新・削除

このビューは検索できますが、追加、削除、更新はできません。

変更を試みるとError: cannot modify seouluser because it is a viewになります。

insert into seouluser values (8, 'kuma');

sqlite> insert into seouluser values (8, 'kuma');
Error: cannot modify seouluser because it is a view
sqlite>

ビューの一覧を確認する

.tablesはテーブルとビューの両方を表示します。

.tables

sqlite> .table
seouluser  user     
sqlite>

sqlite_masterを検索すると、ビュー名と定義SQLを取得できます。

select name, sql from sqlite_master where type = 'view';

sqlite> select name, sql from sqlite_master where type = 'view';
seouluser|CREATE VIEW seouluser as select id, name from user where address = 'Seoul'
sqlite>

SQLite | ビュー（View） | ビューの削除

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

作成済みのビューを削除する方法について説明します。

ビューの削除

作成済みのビューを削除するには、次の構文を使用します。

DROP VIEW ビュー名;

ビューを削除しても、元のテーブルやテーブルに保存されているデータには影響しません。

ビューを削除する前に、SQLiteの.tablesコマンドを実行して作成済みのビューとテーブルを確認します。

.tables

sqlite> .table
seouluser  user     
sqlite>

seouluserビューを削除します。

drop view seouluser;

sqlite> drop view seouluser;
sqlite>

.tablesコマンドを再度実行し、seouluserビューが削除されたことを確認します。

.tables

sqlite> .table
user
sqlite>

結果から、seouluserビューが削除されたことを確認できます。

SQLite | インデックス（Index） | インデックスの意味とメリット・デメリット

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

テーブルに多数の列や大量のデータが含まれている場合、特定のデータを検索するのに時間がかかることがあります。このような場合、適切な列にインデックスを作成すると検索を高速化できます。ここでは、インデックスの概要と、使用する場合のメリット・デメリットについて説明します。

インデックスとは

インデックスとは、検索条件として頻繁に使用する列の値を取り出し、見つけやすいように整理したものです。たとえば、次の4つの列を持つテーブルがあるとします。

id	name	address	old
1	devkuma	Seoul	23
2	kimkc	Busan	19
3	araikuma	Seoul	38
4	mykuma	Daejeon	18
5	yourkuma	Seoul	17
6	happykuma	Seoul	24

name列の値を検索する場合、データは名前順に並んでいないため、保存された行を順番に調べることになります。この程度のデータ量なら問題ありませんが、数百万件のデータが保存されている場合、先頭から探す方法は非常に非効率です。

このような場合、インデックスを作成すると検索速度を向上できます。簡単に言えば、インデックスは対象列のデータを高速に検索できる形に加工して保存したものです。たとえば、name列を対象にしたインデックスは次のようになります。

id	name
3	araikuma
1	devkuma
2	kimkc
6	happykuma
4	mykuma
5	yourkuma

このインデックスはid列とname列の値だけを保持し、name列の値を昇順に並べて保存しています。元のテーブルよりデータ量が少なく、すでに並べ替えられているため、より高速に検索できます。

検索を高速化する仕組みには、B-tree方式や関数を利用する方式などさまざまな方法があります。重要なのは、インデックスが検索に必要なデータだけを、検索に適した状態でテーブルとは別に保存するという点です。

インデックスのメリットとデメリット

インデックスは便利ですが、メリットだけではありません。テーブルとは別に独自のデータを保持するため、テーブルにデータを追加するとインデックスも更新されます。また、並び順も維持する必要があるため、データ追加時の処理速度は低下します。

データ量が少ないテーブルや、値の種類が少ない列にインデックスを作成しても、大きな効果は期待できません。検索にほとんど使用しない列にインデックスを作成する意味もありません。

インデックスは検索に有用ですが、データ追加時の負荷が増えるというデメリットもあります。必要性を十分に検討してから作成してください。

SQLite | インデックス | インデックスを作成する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

SQLiteでインデックスを作成する方法と、データベース内のインデックスを一覧表示する方法を説明します。

CREATE INDEX文でインデックスを作成する

構文は次のとおりです。

CREATE INDEX インデックス名 ON テーブル名 (列名1, 列名2, ...);

インデックスはテーブルの列を対象とします。1つの列だけでなく、複数列の組み合わせにも作成できます。

例で使用するテーブルを作成します。

create table user (name text, old integer, address text);

sqlite> create table user (name text, old integer, address text);
sqlite>

データを追加します。

insert into user values ('devkuma', 28, 'Seoul');
insert into user values ('kimkc', 22, 'Busan');
insert into user values ('araikuma', 32, 'Seoul');
insert into user values ('happykuma', 23, 'Seoul');
insert into user values ('mykuma', 23, 'Daejeon');

sqlite> insert into user values ('devkuma', 28, 'Seoul');
sqlite> insert into user values ('kimkc', 22, 'Busan');
sqlite> insert into user values ('araikuma', 32, 'Seoul');
sqlite> insert into user values ('happykuma', 23, 'Seoul');
sqlite> insert into user values ('mykuma', 23, 'Daejeon');
sqlite>

name列にnameindexというインデックスを作成します。

create index nameindex on user (name);

sqlite> create index nameindex on user (name);
sqlite>

これでインデックスが作成されました。

インデックスを使ったデータ検索

インデックスによって検索が高速になる場合がありますが、インデックスの有無によってクエリの書き方が変わることはありません。SQLiteはクエリ実行時に適切なインデックスを自動的に使用します。

select * from user where name = 'devkuma';

sqlite> select * from user where name = 'devkuma';
devkuma|28|Seoul

クエリでインデックスを明示的に指定する必要はありません。

データベース内のインデックスを一覧表示する

SQLiteの.indicesコマンドを使います。

.indices
.indices? TABLE?

引数を省略するとすべてのインデックスを表示し、テーブル名を指定すると一致するテーブルのインデックスを表示します。

.indices

sqlite> .indices
nameindex
sqlite>

このページで作成したインデックスが表示されます。

sqlite> .indices user
nameindex
sqlite>

2番目のコマンドでは、userテーブルを対象とするnameindexが表示されます。

SQLite | インデックス | UNIQUEインデックスを作成する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

通常のインデックスには重複する値を含められますが、UNIQUEインデックスは対象列の重複を禁止します。ここでは、UNIQUEインデックスの使い方を説明します。

UNIQUEインデックスの作成

構文は次のとおりです。

CREATE UNIQUE INDEX インデックス名 ON テーブル名 (列名1, 列名2, ...);

対象列に重複する値があると、UNIQUEインデックスは作成できません。作成後は、既存のインデックス値と重複する行を追加できません。

複数列のインデックスでは、個々の列に重複があっても、対象列全体の値の組み合わせが一意であれば作成できます。

例で使用するテーブルを作成します。

create table user (name text, old integer, address text);

sqlite> create table user (name text, old integer, address text);
sqlite>

次のデータを追加します。

insert into user values ('devkuma', 28, 'Seoul');
insert into user values ('kimkc', 22, 'Busan');
insert into user values ('araikuma', 32, 'Seoul');
insert into user values ('happykuma', 23, 'Seoul');

sqlite> insert into user values ('devkuma', 28, 'Seoul');
sqlite> insert into user values ('kimkc', 22, 'Busan');
sqlite> insert into user values ('araikuma', 32, 'Seoul');
sqlite> insert into user values ('happykuma', 23, 'Seoul');
sqlite>

name列には現在重複がないため、UNIQUEインデックスを作成できます。

create unique index nameindex on user (name);

sqlite> create unique index nameindex on user (name);
sqlite>

UNIQUEインデックスが作成されました。

–

既存のインデックス値と重複する値は追加できません。次の文はdevkumaが既に存在するためエラーになります。

insert into user values ('devkuma', 18, 'Busan');

sqlite> insert into user values ('devkuma', 18, 'Busan');
Error: UNIQUE constraint failed: user.name
sqlite>

UNIQUEインデックスの対象列には複数のNULL値を保存できます。

–

address列には重複する値があるため、その列にUNIQUEインデックスを作成するとエラーになります。

create unique index nameindex2 on user (address);

sqlite> create unique index nameindex2 on user (address);
Error: UNIQUE constraint failed: user.address
sqlite>

PRIMARY KEY制約およびUNIQUE制約との関係

テーブルの列にPRIMARY KEY制約やUNIQUE制約を設定できます。

これらの制約はUNIQUEインデックスと同様に動作します。SQLiteの公式ドキュメントによると、INTEGER PRIMARY KEYとWITHOUT ROWIDテーブルの主キーを除き、UNIQUE制約とPRIMARY KEY制約は通常UNIQUEインデックスで実装されます。次のスキーマは論理的に同等です。

SQLite Query Language: CREATE TABLE

CREATE TABLE t1(a, b UNIQUE);

CREATE TABLE t1(a, b PRIMARY KEY);

CREATE TABLE t1(a, b);
CREATE UNIQUE INDEX t1b ON t1(b);

PRIMARY KEY制約は1つのテーブルに1つしか設定できませんが、UNIQUE制約とUNIQUEインデックスは複数設定できます。動作は似ていますが設計上の意図が異なるため、目的に合う方法を選択してください。

SQLite | インデックス | インデックスのスキーマ（構造）を確認する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

作成済みのインデックスがどのCREATE INDEX文で作成されたかを確認する方法を説明します。sqlite_masterテーブルを照会する方法と.schemaコマンドを使う方法があります。

sqlite_masterテーブルから照会する

次のSQL文を実行します。例では見やすくするため、.modeコマンドで表示モードをlineに変更します。

select * from sqlite_master;

sqlite> select * from sqlite_master;
table|user|user|2|CREATE TABLE user (name text, old integer, address text, colunm name)
index|nameindex|user|3|CREATE UNIQUE INDEX nameindex on user (name)
sqlite> 
sqlite> .mode line
sqlite> 
sqlite> select * from sqlite_master;
    type = table
    name = user
tbl_name = user
rootpage = 2
     sql = CREATE TABLE user (name text, old integer, address text)

    type = index
    name = nameindex
tbl_name = user
rootpage = 3
     sql = CREATE UNIQUE INDEX nameindex on user (name)
sqlite>

作成済みのテーブルとインデックスの情報を取得できます。インデックスのデータは次の部分です。

    type = index
    name = nameindex
tbl_name = user
rootpage = 3
     sql = CREATE UNIQUE INDEX nameindex on user (name)

インデックスの場合、typeはindexです。name列にインデックス名、tbl_name列に対象テーブル名、sql列に作成時のSQL文が表示されます。

インデックスだけを表示するにはWHERE句を使います。

select * from sqlite_master where type = 'index';

sqlite> select * from sqlite_master where type = 'index';
    type = index
    name = nameindex
tbl_name = user
rootpage = 3
     sql = CREATE UNIQUE INDEX nameindex on user (name)

.schemaコマンドを使って照会する

SQLiteの.schemaコマンドでもスキーマ情報を確認できます。

.schema
.schema? TABLE?

引数を省略すると、すべてのテーブルとインデックスのスキーマ情報を表示します。テーブル名を指定すると、そのテーブルまたは一致するインデックス名に関連する情報を表示します。

.schema

sqlite> .schema
CREATE TABLE user (name text, old integer, address text, colunm name);
CREATE UNIQUE INDEX nameindex on user (name);
sqlite>

現在のデータベースにあるテーブルとインデックスのCREATE文が表示されます。

SQLite | インデックス（Index） | インデックスの削除

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

作成済みのインデックスを削除する方法について説明します。

作成済みインデックスの削除

作成済みのインデックスを削除するには、DROP INDEX文を使用します。構文は次のとおりです。

DROP INDEX インデックス名;

実際にインデックスを削除してみましょう。削除する前に、SQLiteの.indicesコマンドを使用して作成済みのインデックスを確認します。

.indices

sqlite> .indices
nameindex
sqlite>

nameindexインデックスを削除するには、次のように実行します。

drop index nameindex;

sqlite> drop index nameindex;
sqlite>

.indicesコマンドを再度実行し、nameindexインデックスが削除されたことを確認します。

.indices

sqlite> .indices
sqlite>

結果が空になり、nameindexインデックスが削除されたことを確認できます。

SQLite | トリガー（Trigger） | トリガーのスキーマを確認する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

トリガーの作成に使われたCREATE文を確認する2つの方法、sqlite_masterテーブルを検索する方法と.schemaコマンドを使う方法を説明します。

sqlite_masterテーブルを検索する

sqlite_masterテーブルを検索します。先にlineモードへ切り替えると結果を読みやすくできます。

select * from sqlite_master;

sqlite> .mode line
sqlite> select * from sqlite_master;
    type = table
    name = product
tbl_name = product
rootpage = 3
     sql = CREATE TABLE product (id integer, name text)

    type = table
    name = history
tbl_name = history
rootpage = 2
     sql = CREATE TABLE history (user text, name text, sales integer)

    type = trigger
    name = updateproduct
tbl_name = product
rootpage = 0
     sql = CREATE TRIGGER updateproduct update of name on product
begin
update history set name = new.name where name = old.name;
end

トリガーの場合、typeはtriggerです。nameにはトリガー名、tbl_nameには対象テーブル名、sqlにはトリガーを作成したSQL文が表示されます。トリガーだけを表示するにはWHERE句を追加します。

select * from sqlite_master where type = 'trigger';

type = trigger
name = updateproduct
tbl_name = product
rootpage = 0
sql = CREATE TRIGGER updateproduct update of name on product
begin
update history set name = new.name where name = old.name;
end

.schemaコマンドで確認する

.schemaコマンドでもトリガーのスキーマを確認できます。

.schema
.schema? TABLE?

引数を省略すると、すべてのテーブルとトリガーのスキーマが表示されます。テーブル名を指定すると、一致するテーブルと関連するトリガーが表示されます。

sqlite> .schema
CREATE TABLE product (id integer, name text);
CREATE TABLE history (user text, name text, sales integer);
CREATE TRIGGER updateproduct update of name on product
begin
update history set name = new.name where name = old.name;
end;

現在のデータベースにある2つのテーブルと1つのトリガーのCREATE文を確認できます。

SQLite | トリガー | トリガーを削除する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

トリガーを削除する方法を説明します。トリガーは直接削除できるほか、関連するテーブルが削除されたときにも自動的に削除されます。

作成済みのトリガーを削除する

DROP TRIGGER文を使います。

DROP TRIGGER トリガー名;

削除前に.schemaコマンドでトリガーを確認します。

.schema

sqlite> .schema
CREATE TABLE product (id integer, name text);
CREATE TABLE history (user text, name text, sales integer);
CREATE TRIGGER updateproduct update of name on product
begin
update history set name = new.name where name = old.name;
end;
sqlite>

updateproductトリガーを削除します。

drop trigger updateproduct;

sqlite> drop trigger updateproduct;
sqlite>

.schemaを再度実行して削除を確認します。

.schema

sqlite> .schema
CREATE TABLE product (id integer, name text);
CREATE TABLE history (user text, name text, sales integer);
sqlite>

updateproductトリガーが表示されなくなりました。

トリガーが設定されたテーブルを削除する

テーブルを削除すると、そのトリガーも自動的に削除されます。

.schemaで現在のテーブルとトリガーを表示します。

.schema

.schema
CREATE TABLE product (id integer, name text);
CREATE TABLE history (user text, name text, sales integer);
CREATE TRIGGER updateproduct update of name on product
begin
update history set name = new.name where name = old.name;
end;
sqlite>

前の例でトリガーが削除されている場合は、表示されたスキーマから再作成してください。

updateproductトリガーはproductテーブルに設定されています。テーブルを削除し、.schemaを再度実行します。

drop table product;

sqlite> drop table product;
sqlite> 
sqlite> .schema
CREATE TABLE history (user text, name text, sales integer);
sqlite>

productテーブルを削除すると、updateproductトリガーも自動的に削除されます。

SQLite | データの追加・更新・削除 | 別のテーブルから取得したデータを追加する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

INSERT文で明示的に指定した値を追加するほかに、SELECT文で別のテーブルから取得した行も追加できます。ここでは、その方法を説明します。

別のテーブルから取得したデータを追加する

構文は次のとおりです。

INSERT INTO テーブル名 SQL文;

追加先テーブルの列数とクエリ結果の列数は同じである必要があります。列名は異なっていても問題ありません。

INSERT INTO テーブル1 SELECT C1, C2, C3 FROM テーブル2 WHERE 条件式;

この例では、テーブル1に3つの列が定義されている必要があります。

追加先の列も指定できます。

INSERT INTO テーブル名 (列名1, 列名2, ...) SQL文;

指定した追加先の列数とクエリが返す列数は、この場合も同じである必要があります。

INSERT INTO テーブル1 (N1, N2, N3) SELECT C1, C2, C3 FROM テーブル2 WHERE 条件式;

ソーステーブルを作成し、データを追加します。

create table user (id integer, name text, old integer);

insert into user values (1, 'devkuma', 24);
insert into user values (2, 'kimkc', 31);
insert into user values (3, 'araikuma', 18);
insert into user values (4, 'happykuma', 25);
insert into user values (5, 'mykuma', 19);

sqlite> create table user (id integer, name text, old integer);
sqlite> 
sqlite> insert into user values (1, 'devkuma', 24);
sqlite> insert into user values (2, 'kimkc', 31);
sqlite> insert into user values (3, 'araikuma', 18);
sqlite> insert into user values (4, 'happykuma', 25);
sqlite> insert into user values (5, 'mykuma', 19);
sqlite>

追加先テーブルを作成します。

create table olduser (id integer, name text, address text);

sqlite> create table olduser (id integer, name text, address text);
sqlite>

userテーブルからold列が20より大きい行を選択し、id列とname列の値をolduserテーブルに追加します。

insert into olduser (id, name) select id, name from user where old> 20;

sqlite> insert into olduser (id, name) select id, name from user where old> 20;
sqlite>

olduserテーブルを照会して、追加された行を確認します。例では比較のために先にuserテーブルを照会しています。

select * from olduser;

sqlite> select * from user;
id          name        old       
----------  ----------  ----------
1           devkuma     24        
2           kimkc       31        
3           araikuma    18        
4           happykuma   25        
5           mykuma      19        
sqlite> 
sqlite> select * from olduser;
id          name        address   
----------  ----------  ----------
1           devkuma               
2           kimkc                 
4           happykuma      
sqlite>

old列が20より大きいソース行だけが追加されました。olduserのaddress列の値は指定していないため、デフォルト値のNULLが保存されます。

SQLite | データの追加・更新・削除 | データの更新（UPDATE）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

UPDATE文を使って、テーブルに保存されているデータを新しい値に更新する方法を説明します。

テーブルのデータを更新する

保存済みのデータを更新するには、次の形式でUPDATE文を使います。

UPDATE テーブル名 SET カラム名1 = 値1, カラム名2 = 値2, ... WHERE 条件式;

WHERE句で更新対象の行を指定します。条件に一致する行が複数あれば、すべて一括で更新されます。WHERE句を省略すると、テーブルの全行が対象になります。SET句では更新するカラムと新しい値を指定し、複数のカラムを同時に更新することもできます。

テーブルを作成し、サンプルデータを追加します。

create table employee (id integer, name text, unit text, flag text);
insert into employee values (1, 'devkuma', 'Sales', 'Yes');
insert into employee values (2, 'kimkc', 'Office', 'No');
insert into employee values (3, 'araikuma', 'Office', 'Yes');
insert into employee values (4, 'happykuma', 'Tech', 'Yes');
insert into employee values (5, 'mykuma', 'Sales', 'No');

まず、idが3の行のnameを更新し、結果を確認します。

update employee set name = 'raccoon' where id = 3;
select * from employee where id = 3;

id          name        unit        flag
----------  ----------  ----------  ----------
3           raccoon     Office      Yes

次に、unitがOfficeの複数行をまとめてDeskに更新します。

update employee set unit = 'Desk' where unit = 'Office';
select * from employee;

1  devkuma    Sales  Yes
2  kimkc      Desk   No
3  raccoon    Desk   Yes
4  happykuma  Tech   Yes
5  mykuma     Sales  No

最後に、WHERE句を省略して全行のflagを更新します。

update employee set flag = 'unknown';
select * from employee;

1  devkuma    Sales  unknown
2  kimkc      Desk   unknown
3  raccoon    Desk   unknown
4  happykuma  Tech   unknown
5  mykuma     Sales  unknown

SQLite | データの追加・更新・削除 | データの削除（DELETE）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

DELETE文を使用して、テーブルに保存されているデータを削除する方法について説明します。

テーブルのデータを削除する

テーブルからデータを削除するには、DELETE文を使用します。構文は次のとおりです。

DELETE FROM テーブル名 WHERE 条件式;

削除する行をWHERE句の条件式で指定します。条件に一致する行が複数ある場合は、まとめて削除されます。WHERE句を省略すると、テーブル内のすべての行が削除されます。

実際に試してみましょう。次のテーブルを作成し、データを追加します。

create table user (id integer, name text, old integer);

insert into user values (1, 'devkuma', 32);
insert into user values (2, 'kimkc', 15);
insert into user values (3, 'araikuma', 18);
insert into user values (4, 'happykuma', 24);
insert into user values (5, 'mykuma', 19);

sqlite> create table user (id integer, name text, old integer);
sqlite> 
sqlite> insert into user values (1, 'devkuma', 32);
sqlite> insert into user values (2, 'kimkc', 15);
sqlite> insert into user values (3, 'araikuma', 18);
sqlite> insert into user values (4, 'happykuma', 24);
sqlite> insert into user values (5, 'mykuma', 19);
sqlite>

まず、old列の値が20未満の行を削除し、テーブルを検索して削除されたことを確認します。

delete from user where old < 20;

select * from user;

sqlite> delete from user where old < 20;
sqlite> 
sqlite> select * from user;
id          name        old       
----------  ----------  ----------
1           devkuma     32        
4           happykuma   24        
sqlite>

次に、テーブル内のすべてのデータを削除します。次の文を実行すると、すべての行が削除されます。

delete from user;

select * from user;

sqlite> delete from user;
sqlite> 
sqlite> select * from user;
sqlite>

SQLite | データの検索 | SELECT文でデータを取得する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

テーブルに保存されたデータはSELECT文で取得します。ここでは基本的な構文を説明します。

SELECT文でデータを取得する

テーブルのデータを取得するにはSELECTを使います。基本構文は次のとおりです。

SELECT カラム1, カラム2, ... FROM テーブル名;

FROMの後にテーブル名、SELECTの後に取得するカラムを記述します。複数のカラムはカンマで区切ります。

条件を指定しない場合はすべての行を取得します。条件に合う行だけを取得するにはWHERE句を使います。

–

例として次のテーブルを作成します。

create table user (id integer, name text, address text);

sqlite> create table user (id integer, name text, address text);
sqlite>

テーブルにデータを追加します。

insert into user values (1, 'devkuma', 'Seoul');
insert into user values (2, 'kimkc', 'Busan');
insert into user values (3, 'araikuma', 'Seoul');
insert into user values (4, 'happykuma', 'Seoul');
insert into user values (5, 'mykuma', 'Daejeon');

sqlite> insert into user values (1, 'devkuma', 'Seoul');
sqlite> insert into user values (2, 'kimkc', 'Busan');
sqlite> insert into user values (3, 'araikuma', 'Seoul');
sqlite> insert into user values (4, 'happykuma', 'Seoul');
sqlite> insert into user values (5, 'mykuma', 'Daejeon');
sqlite>

userテーブルのidとnameを取得します。

select id, name from user;

指定したテーブルから目的のカラムを取得できました。

sqlite> select id, name from user;
1|devkuma
2|kimkc
3|araikuma
4|happykuma
5|mykuma

SQLite CLIコマンドで結果の表示形式を変更できます。以降の例では次の設定を使います。

.header on
.mode column

sqlite> .header on
sqlite> .mode column
sqlite> 
sqlite> select id, name from user;
id          name      
----------  ----------
1           devkuma   
2           kimkc     
3           araikuma  
4           happykuma 
5           mykuma    
sqlite>

すべてのカラムを取得する

すべてのカラムを取得するには、SELECTに各カラムを列挙できます。

select id, name, address from user;

sqlite> select id, name, address from user;
id          name        address   
----------  ----------  ----------
1           devkuma     Seoul     
2           kimkc       Busan     
3           araikuma    Seoul     
4           happykuma   Seoul     
5           mykuma      Daejeon   
sqlite>

また、アスタリスク（*）を使うと、すべてのカラムをテーブル順に取得できます。

SELECT * FROM テーブル名;

*を使ってuserテーブルを検索します。

select * from user;

すべてのカラムを取得できました。

sqlite> select * from user;
id          name        address   
----------  ----------  ----------
1           devkuma     Seoul     
2           kimkc       Busan     
3           araikuma    Seoul     
4           happykuma   Seoul     
5           mykuma      Daejeon   
sqlite>

rowidのような特殊値は*に含まれません。必要な場合は、アスタリスクとは別に指定します。

select *, rowid from user;

結果には通常の全カラムに加えて、明示したrowidも含まれます。

sqlite> select *, rowid from user;
id          name        address     rowid     
----------  ----------  ----------  ----------
1           devkuma     Seoul       1         
2           kimkc       Busan       2         
3           araikuma    Seoul       3         
4           happykuma   Seoul       4         
5           mykuma      Daejeon     5         
sqlite>

SQLite | データの検索 | ORDER BYで行を並べ替える

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

検索結果を指定カラムで並べ替えるにはORDER BY句を使います。ここでは、その使い方を説明します。

ORDER BY句で並べ替える

SELECTでORDER BYを使うと、指定カラムを基準に並べ替えられます。構文は次のとおりです。

SELECT カラム名, ... FROM テーブル名 ORDER BY カラム名 [ASC|DESC];

ORDER BYの後にカラムと方向を指定します。昇順はASC、降順はDESCで、省略時は昇順です。

複数カラムはカンマで区切ります。最初のカラムで並べ替え、同値の行を次のカラムで並べ替えます。

SELECT カラム名, ... FROM テーブル名
  ORDER BY カラム名1 [ASC|DESC], カラム名2 [ASC|DESC] ...;

–

例として次のテーブルを作成します。

create table user (name text, old integer, address text);

sqlite> create table user (name text, old integer, address text);
sqlite>

テーブルにデータを追加します。

insert into user values ('devkuma', 39, 'Seoul');
insert into user values ('kimkc', 34, 'Busan');
insert into user values ('araikuma', 26, 'Seoul');
insert into user values ('happykuma', 19, 'Seoul');
insert into user values ('mykuma', 27, 'Daejeon');
insert into user values ('yourkuma', 28, 'Gwangju');
insert into user values ('raccoon', 31, 'Busan');

sqlite> insert into user values ('devkuma', 39, 'Seoul');
sqlite> insert into user values ('kimkc', 34, 'Busan');
sqlite> insert into user values ('araikuma', 26, 'Seoul');
sqlite> insert into user values ('happykuma', 19, 'Seoul');
sqlite> insert into user values ('mykuma', 27, 'Daejeon');
sqlite> insert into user values ('yourkuma', 28, 'Gwangju');
sqlite> insert into user values ('raccoon', 31, 'Busan');
sqlite>

まず明示的に並べ替えずに検索します。

select * from user;

sqlite> select * from user;
name        old         address   
----------  ----------  ----------
devkuma     39          Seoul     
kimkc       34          Busan     
araikuma    26          Seoul     
happykuma   19          Seoul     
mykuma      27          Daejeon   
yourkuma    28          Gwangju   
raccoon     31          Busan     
sqlite>

oldを昇順で並べ替えます。

select * from user order by old asc;

oldが小さい順に表示されます。

sqlite> select * from user order by old asc;
name        old         address   
----------  ----------  ----------
happykuma   19          Seoul     
araikuma    26          Seoul     
mykuma      27          Daejeon   
yourkuma    28          Gwangju   
raccoon     31          Busan     
kimkc       34          Busan     
devkuma     39          Seoul     
sqlite>

次にoldを降順で並べ替えます。

select * from user order by old desc;

sqlite> select * from user order by old desc;
name        old         address   
----------  ----------  ----------
devkuma     39          Seoul     
kimkc       34          Busan     
raccoon     31          Busan     
yourkuma    28          Gwangju   
mykuma      27          Daejeon   
araikuma    26          Seoul     
happykuma   19          Seoul     
sqlite>

oldが大きい順に表示されます。

このように指定カラムで昇順または降順に並べ替えられます。

複数カラムで並べ替える

まずaddressだけで並べ替えます。

select * from user order by address asc;

sqlite> select * from user order by address asc;
name        old         address   
----------  ----------  ----------
kimkc       34          Busan     
raccoon     31          Busan     
mykuma      27          Daejeon   
yourkuma    28          Gwangju   
devkuma     39          Seoul     
araikuma    26          Seoul     
happykuma   19          Seoul     
sqlite>

次にaddressで並べ替え、同じ住所の行をoldで並べ替えます。ORDER BYに記述する順序が優先順位になります。

select * from user order by address asc, old asc;

sqlite> select * from user order by address asc, old asc;
name        old         address   
----------  ----------  ----------
raccoon     31          Busan     
kimkc       34          Busan     
mykuma      27          Daejeon   
yourkuma    28          Gwangju   
happykuma   19          Seoul     
araikuma    26          Seoul     
devkuma     39          Seoul     
sqlite>

結果は最初にaddress、次にoldで並んでいます。

SQLite | データの検索 | 指定した値の範囲と比較する（BETWEEN句）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

BETWEEN句を使うと、カラム値が指定した範囲内にあるかどうかを条件式で判定できます。ここでは、その書き方を説明します。WHERE句の基本については、検索条件を設定する（WHERE句）を参照してください。

BETWEEN句を使った条件式

BETWEENは両端の値も範囲に含みます。

SELECT カラム名, ... FROM テーブル名 WHERE カラム名 BETWEEN 値1 AND 値2;

この条件は、比較演算子と論理演算子を使った次の条件と同じです。

SELECT カラム名, ... FROM テーブル名 WHERE カラム名 >= 値1 AND カラム名 <= 値2;

指定範囲の外にある値を取得するにはNOT BETWEENを使います。

SELECT カラム名, ... FROM テーブル名 WHERE カラム名 NOT BETWEEN 値1 AND 値2;

テーブルを作成し、サンプルデータを追加します。

create table user (name text, old integer, address text);
insert into user values ('devkuma', 39, 'Seoul');
insert into user values ('kimkc', 34, 'Busan');
insert into user values ('araikuma', 26, 'Seoul');
insert into user values ('happykuma', 19, 'Seoul');
insert into user values ('mykuma', 27, 'Daejeon');
insert into user values ('yourkuma', 28, 'Gwangju');
insert into user values ('raccoon', 31, 'Busan');

条件を指定しなければ、すべての行が返されます。

sqlite> select * from user;
devkuma     39  Seoul
kimkc       34  Busan
araikuma    26  Seoul
happykuma   19  Seoul
mykuma      27  Daejeon
yourkuma    28  Gwangju
raccoon     31  Busan

次のクエリは、oldが20以上30以下の行を返します。

select * from user where old between 20 and 30;

araikuma    26  Seoul
mykuma      27  Daejeon
yourkuma    28  Gwangju

NOTを追加すると、その範囲外の行が返されます。

select * from user where old not between 20 and 30;

devkuma     39  Seoul
kimkc       34  Busan
happykuma   19  Seoul
raccoon     31  Busan

SQLite | データの検索 | 値の一覧と比較する（IN句）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

IN句を使うと、カラム値が一覧内のいずれかと一致するか判定できます。ここでは、その使い方を説明します。

条件付き検索についてはWHERE句の記事を参照してください。

IN句を使った条件式

INに値の一覧を指定して一致を判定します。構文は次のとおりです。

SELECT カラム名, ... FROM テーブル名 WHERE カラム IN (値1, 値2, ...);

カラム値が一覧のいずれかと一致すると行を取得します。これは等価比較をORで結ぶ場合と同じです。

SELECT カラム名, ... FROM テーブル名 WHERE カラム = 値1 OR カラム = 値2 OR ...;

NOT INを使うと一覧に含まれない行を取得できます。

SELECT カラム名, ... FROM テーブル名 WHERE カラム NOT IN (値1, 値2, ...);

–

例として次のテーブルを作成します。

create table user (name text, old integer, address text);

sqlite> create table user (name text, old integer, address text);
sqlite>

テーブルにデータを追加します。

insert into user values ('devkuma', 39, 'Seoul');
insert into user values ('kimkc', 34, 'Busan');
insert into user values ('araikuma', 26, 'Paju');
insert into user values ('happykuma', 19, 'Paju');
insert into user values ('mykuma', 27, 'Daejeon');
insert into user values ('yourkuma', 28, 'Seongnam');
insert into user values ('raccoon', 31, 'Suwon');

sqlite> insert into user values ('devkuma', 39, 'Seoul');
sqlite> insert into user values ('kimkc', 34, 'Busan');
sqlite> insert into user values ('araikuma', 26, 'Paju');
sqlite> insert into user values ('happykuma', 19, 'Paju');
sqlite> insert into user values ('mykuma', 27, 'Daejeon');
sqlite> insert into user values ('yourkuma', 28, 'Seongnam');
sqlite> insert into user values ('raccoon', 31, 'Suwon');
sqlite>

条件なしで検索すると次の結果になります。

select * from user;

sqlite> select * from user;
name        old         address   
----------  ----------  ----------
devkuma     39          Seoul     
kimkc       34          Busan     
araikuma    26          Paju      
happykuma   19          Paju      
mykuma      27          Daejeon   
yourkuma    28          Seongnam  
raccoon     31          Suwon     
sqlite>

addressがPaju、Seongnam、Suwonのいずれかに一致する行を検索します。

select * from user where address in ('Paju', 'Seongnam', 'Suwon');

sqlite> select * from user where address in ('Paju', 'Seongnam', 'Suwon');
name        old         address   
----------  ----------  ----------
araikuma    26          Paju      
happykuma   19          Paju      
yourkuma    28          Seongnam  
raccoon     31          Suwon     
sqlite>

条件に一致する行だけが返されます。

別のテーブルから取得した値と比較する

値を直接列挙する代わりに、サブクエリで別テーブルから一覧を取得できます。構文は次のとおりです。

SELECT カラム名, ... FROM テーブル名 WHERE カラム IN (SELECT カラム名 FROM テーブル名);

サブクエリは1カラムだけを返す必要があります。その結果のいずれかと一致する行を取得します。

次のテーブルを作成します。

create table gyeonggi (id integer, region text);

sqlite> create table gyeonggi (id integer, region text);
sqlite>

テーブルにデータを追加します。

insert into gyeonggi values (1, 'Paju');
insert into gyeonggi values (2, 'Seongnam');
insert into gyeonggi values (3, 'Suwon');
insert into gyeonggi values (4, 'Gimpo');

sqlite> insert into gyeonggi values (1, 'Paju');
sqlite> insert into gyeonggi values (2, 'Seongnam');
sqlite> insert into gyeonggi values (3, 'Suwon');
sqlite> insert into gyeonggi values (4, 'Gimpo');
sqlite>

addressがgyeonggiテーブルのregionと一致するuser行を検索します。

select * from user where address in (select region from gyeonggi);

sqlite> select * from user where address in (select region from gyeonggi);
name        old         address   
----------  ----------  ----------
araikuma    26          Paju      
happykuma   19          Paju      
yourkuma    28          Seongnam  
raccoon     31          Suwon     
sqlite>

条件に一致する行だけが返されます。

SQLite | データの検索 | NULL値の行を検索する（IS NULL）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

IS NULL句を使うと、カラムにNULLが格納されているかどうかを判定できます。ここでは、IS NULLを使った条件式の書き方を説明します。

WHERE句については、検索条件を設定する（WHERE句）を参照してください。

IS NULL句を使った条件式

IS NULLを使うと、カラム値がNULLかどうかを判定できます。構文は次のとおりです。

SELECT カラム名, ... FROM テーブル名 WHERE カラム名 IS NULL;

カラム値がNULLの行だけを取得します。IS NULLの代わりにISNULLも使用できます。

カラム値がNULLではない行を検索するには、IS NOT NULLを使います。

SELECT カラム名, ... FROM テーブル名 WHERE カラム名 IS NOT NULL;

カラム値がNULLではない行だけを取得します。SQLiteではNOTNULLとNOT NULLも使用できます。

–

実際に試してみます。次のテーブルを作成します。

create table user (id integer, name text, address text);

sqlite> create table user (id integer, name text, address text);
sqlite>

INSERT文でテーブルにデータを追加します。

insert into user values (1, 'devkuma', 'Seoul');
insert into user values (2, 'kimkc', null);
insert into user values (3, 'araikuma', 'Busan');
insert into user values (4, 'happykuma', 'Daejeon');
insert into user values (5, 'mykuma', null);

sqlite> insert into user values (1, 'devkuma', 'Seoul');
sqlite> insert into user values (2, 'kimkc', null);
sqlite> insert into user values (3, 'araikuma', 'Busan');
sqlite> insert into user values (4, 'happykuma', 'Daejeon');
sqlite> insert into user values (5, 'mykuma', null);
sqlite>

条件を指定せずに検索すると、次の結果になります。addressカラムにNULLを含む行があります。

select * from user;

sqlite> select * from user;
id          name        address   
----------  ----------  ----------
1           devkuma     Seoul     
2           kimkc                 
3           araikuma    Busan     
4           happykuma   Daejeon   
5           mykuma                
sqlite>

IS NULLを使い、addressがNULLの行だけを検索します。

select * from user where address is null;

sqlite> select * from user where address is null;
id          name        address   
----------  ----------  ----------
2           kimkc                 
5           mykuma                
sqlite>

addressがNULLの行だけを取得できました。

次にIS NOT NULLを使い、addressがNULLではない行を検索します。

select * from user where address is not null;

sqlite> select * from user where address is not null;
id          name        address   
----------  ----------  ----------
1           devkuma     Seoul     
3           araikuma    Busan     
4           happykuma   Daejeon   
sqlite>

addressがNULLではない行だけを取得できました。

等価演算子（=）でカラム値とNULLを比較しても、正しい結果は得られません。次のSELECT文を実行してみます。

select * from user where address = null;
select * from user where address = NULL;
select * from user where address = '';

sqlite> select * from user where address = null;
sqlite> select * from user where address = NULL;
sqlite> select * from user where address = '';
sqlite>

どのクエリも行を返しません。値がNULLかどうかを調べるにはIS NULLを使用します。

SQLite | データの検索 | カラムに別名を付ける（AS句）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

SELECT文でデータを検索するとき、AS句を使うと元の名前とは異なるカラム名で結果を表示できます。ここでは、カラムに別名を付ける方法を説明します。

AS句でカラムに別名を付ける

AS句を使うと、SELECTの結果に表示するカラム名を変更できます。構文は次のとおりです。

SELECT カラム名 AS 別名 ... FROM テーブル名;

カラム名の後にASを記述し、別名を指定します。

–

実際に試してみます。次のテーブルを作成します。

create table product (name text, num integer, price integer);

sqlite> create table product (name text, num integer, price integer);
sqlite>

INSERT文でテーブルにデータを追加します。

insert into product values ('Mouse', 10, 2500);
insert into product values ('Printer', 4, 8200);
insert into product values ('NotePC', 6, 54000);
insert into product values ('Display', 5, 18000);
insert into product values ('Desk', 8, 27000);

sqlite> insert into product values ('Mouse', 10, 2500);
sqlite> insert into product values ('Printer', 4, 8200);
sqlite> insert into product values ('NotePC', 6, 54000);
sqlite> insert into product values ('Display', 5, 18000);
sqlite> insert into product values ('Desk', 8, 27000);
sqlite>

このテーブルをそのまま検索すると、次の結果になります。

select name, num, price from product;

sqlite> select name, num, price from product;
name        num         price     
----------  ----------  ----------
Mouse       10          2500      
Printer     4           8200      
NotePC      6           54000     
Display     5           18000     
Desk        8           27000     
sqlite>

AS句を使い、priceカラムをvalueという名前で表示します。

select name, num, price as value from product;

sqlite> select name, num, price as value from product;
name        num         value     
----------  ----------  ----------
Mouse       10          2500      
Printer     4           8200      
NotePC      6           54000     
Display     5           18000     
Desk        8           27000     
sqlite>

結果のカラム名がvalueになっていることを確認できます。

–

SELECT文では、カラム値を使った演算結果も取得できます。

select name, num, price, num * price from product;

sqlite> select name, num, price, num * price from product;
name        num         price       num * price
----------  ----------  ----------  -----------
Mouse       10          2500        25000      
Printer     4           8200        32800      
NotePC      6           54000       324000     
Display     5           18000       90000      
Desk        8           27000       216000     
sqlite>

既定では式のnum * priceが結果のカラム名になります。この式にASを使ってvalueという別名を付けます。

select name, num, price, num * price as value from product;

sqlite> select name, num, price, num * price as value from product;
name        num         price       value     
----------  ----------  ----------  ----------
Mouse       10          2500        25000     
Printer     4           8200        32800     
NotePC      6           54000       324000    
Display     5           18000       90000     
Desk        8           27000       216000    
sqlite>

このように、演算結果にも分かりやすいカラム名を設定できます。

SQLite | データの検索 | DISTINCTで重複を除外する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

検索結果に重複値が含まれる場合、DISTINCTで除外できます。ここでは、その使い方を説明します。

DISTINCTで重複を除外する

SELECTの結果から重複を除くにはDISTINCTを使います。構文は次のとおりです。

SELECT DISTINCT カラム名, ... FROM テーブル名;

重複は元の行全体ではなく、選択したカラムで判定されます。1カラムなら同じ値、複数なら同じ値の組み合わせが除外されます。

重複を含めるにはALLを使います。構文は次のとおりです。

SELECT ALL カラム名, ... FROM テーブル名;

どちらも省略した場合はALLと同じため、通常は記述不要です。

–

例として次のテーブルを作成します。

create table product (id integer, name text, color text);

sqlite> create table product (id integer, name text, color text);
sqlite>

テーブルにデータを追加します。

insert into product values (1, 'Mouse', 'White');
insert into product values (2, 'Pen', 'Green');
insert into product values (3, 'Mouse', 'Black');
insert into product values (4, 'NotePC', 'Black');
insert into product values (5, 'Display', 'Yellow');
insert into product values (6, 'Mouse', 'White');

sqlite> insert into product values (1, 'Mouse', 'White');
sqlite> insert into product values (2, 'Pen', 'Green');
sqlite> insert into product values (3, 'Mouse', 'Black');
sqlite> insert into product values (4, 'NotePC', 'Black');
sqlite> insert into product values (5, 'Display', 'Yellow');
sqlite> insert into product values (6 'Mouse', 'White');
Error: near "'Mouse'": syntax error
sqlite> insert into product values (6, 'Mouse', 'White');
sqlite>

まずproductのnameを重複を含めて検索します。

select name from product;

sqlite> select name from product;
name      
----------
Mouse     
Pen       
Mouse     
NotePC    
Display   
Mouse     
sqlite>

次にDISTINCTを付けてnameを検索します。

select distinct name from product;

sqlite> select distinct name from product;
name      
----------
Mouse     
Pen       
NotePC    
Display   
sqlite>

重複するnameが除外されました。

colorについてもDISTINCTの有無を比較します。

select color from product;

sqlite> select color from product;
color     
----------
White     
Green     
Black     
Black     
Yellow    
White     
sqlite>

select distinct color from product;

sqlite> select distinct color from product;
color     
----------
White     
Green     
Black     
Yellow    
sqlite>

DISTINCTにより重複するcolorが除外されました。

複数カラムの重複を除外する

複数カラムでは、選択値の組み合わせが同じ行を除外します。次の例ではnameとcolorに適用します。

select distinct name, color from product;

qlite> select distinct name, color from product;
name        color     
----------  ----------
Mouse       White     
Pen         Green     
Mouse       Black     
NotePC      Black     
Display     Yellow    
sqlite>

個々の値は重複していても、両方の値が同じ行だけが除外されます。

SQLite | データの検索 | カラム値の四則演算結果を取得する

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

データを検索するとき、1つまたは複数のカラム値に四則演算を適用した結果を取得できます。ここでは、その方法を説明します。

カラムに対する四則演算

演算子	説明
a + b	aにbを加える
a - b	aからbを引く
a * b	aにbを掛ける
a / b	aをbで割る
a % b	aをbで割った余りを返す

SELECT文では、次のように演算子を使います。

SELECT カラム名 演算子 値 FROM テーブル名;
select id, sale * 3 from report;
select id, price * count from report;

最初の例はsaleの3倍、次の例はpriceとcountを掛けた値を行ごとに返します。

テーブルを作成し、サンプルデータを追加します。

create table product (name text, num integer, price integer, discount integer);
insert into product values ('Mouse', 7, 2500, 0);
insert into product values ('NotePC', 2, 65000, 12000);
insert into product values ('Display', 4, 35000, 0);
insert into product values ('Printer', 5, 8000, 2000);
insert into product values ('Keyboard', 4, 10000, 0);

priceからdiscountを引きます。

select *, price - discount from product;

name        num         price       discount    price - discount
Mouse       7           2500        0           2500
NotePC      2           65000       12000       53000
Display     4           35000       0           35000
Printer     5           8000        2000        6000
Keyboard    4           10000       0           10000

演算式は結果カラムの既定名になります。分かりやすい名前を付けるにはAS句を使います。詳細は検索結果のカラムに別名を付ける（AS句）を参照してください。

select *, price - discount as result from product;

name        num         price       discount    result
Mouse       7           2500        0           2500
NotePC      2           65000       12000       53000
Display     4           35000       0           35000
Printer     5           8000        2000        6000
Keyboard    4           10000       0           10000

SQLite | データの検索 | CASE式で条件に応じた値を返す

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

CASE式は条件やカラム値に応じて異なる値を返します。ここでは2つの形式を説明します。

CASE式で条件分岐する

主な形式は2つあります。最初の形式は条件を評価し、最初に真となった結果を返します。

SELECT
  CASE
    WHEN 条件1 THEN 結果1
    WHEN 条件2 THEN 結果2
    ELSE 結果3
  END
FROM テーブル名;

条件1が真なら結果1、そうでなく条件2が真なら結果2、すべて偽ならELSEの結果を返します。

–

例として次のテーブルを作成します。

create table exam (name text, result integer);

sqlite> create table exam (name text, result integer);
sqlite>

テーブルにデータを追加します。

insert into exam values ('devkuma', 85);
insert into exam values ('kimkc', 54);
insert into exam values ('araikuma', 78);
insert into exam values ('happykuma', 98);
insert into exam values ('mykuma', 48);
insert into exam values ('raccoon', 68);

sqlite> insert into exam values ('devkuma', 85);
sqlite> insert into exam values ('kimkc', 54);
sqlite> insert into exam values ('araikuma', 78);
sqlite> insert into exam values ('happykuma', 98);
sqlite> insert into exam values ('mykuma', 48);
sqlite> insert into exam values ('raccoon', 68);
sqlite>

resultに応じて3種類の値を返し、結果カラムをjudgmentとします。

select
  name, result, 
  case
    when result > 80 then 'Pass'
    when result > 60 then 'ReTest'
    else 'Fail'
  end as judgment
from exam;

sqlite> select
   ...>   name, result, 
   ...>   case
   ...>     when result > 80 then 'Pass'
   ...>     when result > 60 then 'ReTest'
   ...>     else 'Fail'
   ...>   end as judgment
   ...> from exam;
name        result      judgment  
----------  ----------  ----------
devkuma     85          Pass      
kimkc       54          Fail      
araikuma    78          ReTest    
happykuma   98          Pass      
mykuma      48          Fail      
raccoon     68          ReTest    
sqlite>

条件に応じた値が返されました。

CASE式で値を比較する

2つ目の形式は式を複数の値と順番に比較します。

SELECT
  CASE 式
    WHEN 値1 THEN 結果1
    WHEN 値2 THEN 結果2
    ELSE 結果3
  END
FROM テーブル名;

値1なら結果1、値2なら結果2、どれにも一致しなければELSEの結果を返します。

条件1が真なら結果1、そうでなく条件2が真なら結果2、すべて偽ならELSEの結果を返します。

–

例として次のテーブルを作成します。

create table company (name text, address text);

sqlite> create table company (name text, address text);
sqlite>

テーブルにデータを追加します。

insert into company values ('A_Electric', 'Seoul');
insert into company values ('B_Motor', 'California');
insert into company values ('C_Mobile', 'Suwon');
insert into company values ('D_Shipping', 'Beijing');

sqlite> insert into company values ('A_Electric', 'Seoul');
sqlite> insert into company values ('B_Motor', 'California');
sqlite> insert into company values ('C_Mobile', 'Suwon');
sqlite> insert into company values ('D_Shipping', 'Beijing');
sqlite>

addressに応じた結果を返し、結果カラムをSalesとします。

select
  name, address, 
  case address
    when 'California' then 'America'
    when 'Seoul' then 'Korea'
    when 'Beijing' then 'China'
    else 'Unknown'
  end as country
from company;

sqlite> select
   ...>   name, address, 
   ...>   case address
   ...>     when 'California' then 'America'
   ...>     when 'Seoul' then 'Korea'
   ...>     when 'Beijing' then 'China'
   ...>     else 'Unknown'
   ...>   end as country
   ...> from company;
name        address     country   
----------  ----------  ----------
A_Electric  Seoul       Korea     
B_Motor     California  America   
C_Mobile    Suwon       Unknown   
D_Shipping  Beijing     China     
sqlite>

条件に応じた値が返されました。

SQLite | データの結合 | 外部結合（OUTER JOIN）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

外部結合は一致する行に加えて、一方にしかない行も取得します。ここではLEFT OUTER JOINを説明します。

外部結合

外部結合は指定カラムの値を照合し、内部結合とは異なり一致しない行も返します。

図では左テーブルの部門IDと右テーブルのIDを照合します。

右側に一致するIDがなくても左側の行を取得します。

注意
LEFT OUTER JOINは左側、RIGHT OUTER JOINは右側、FULL OUTER JOINは両側の一致しない行を保持します。

この例で使用しているSQLiteはLEFT OUTER JOINだけをサポートし、RIGHTとFULL OUTER JOINはエラーになります。

LEFT OUTER JOINの使い方

SELECTとLEFT OUTER JOINを組み合わせます。構文は次のとおりです。

SELECT テーブル名. カラム名, ... FROM テーブル名1
  LEFT OUTER JOIN テーブル名2
  ON テーブル名1.カラム名1 = テーブル名2.カラム名2;

簡略化すると次の形式です。

SELECT (取得カラム) FROM テーブル名1
  LEFT OUTER JOIN テーブル名2 ON (結合条件);

必要に応じて取得カラムをテーブル名.カラム名で修飾します。結合条件はテーブル1.カラム1 = テーブル2.カラム2と記述します。

左外部結合は一致する行に加え、FROM直後のテーブルにしかない行も返します。

–

employeeとdeptテーブルを作成し、サンプルデータを追加します。

create table employee (id integer, name text, dept_id integer);

insert into employee values (1, 'dekuma', 1);
insert into employee values (2, 'kimkc', 3);
insert into employee values (3, 'araikuma', 1);
insert into employee values (4, 'happykuma', 2);
insert into employee values (5, 'mykuma', 4);
insert into employee values (6, 'raccoon', 3);

sqlite> create table employee (id integer, name text, dept_id integer);
sqlite> 
sqlite> insert into employee values (1, 'dekuma', 1);
sqlite> insert into employee values (2, 'kimkc', 3);
sqlite> insert into employee values (3, 'araikuma', 1);
sqlite> insert into employee values (4, 'happykuma', 2);
sqlite> insert into employee values (5, 'mykuma', 4);
sqlite> insert into employee values (6, 'raccoon', 3);
sqlite>

create table dept (id integer, name text);

insert into dept values (1, 'Sales');
insert into dept values (2, 'Manage');
insert into dept values (3, 'Dev');

sqlite> create table dept (id integer, name text);
sqlite> 
sqlite> insert into dept values (1, 'Sales');
sqlite> insert into dept values (2, 'Manage');
sqlite> insert into dept values (3, 'Dev');
sqlite>

–

まずemployeeにdeptを左外部結合します。

select * from employee left outer join dept on employee.dept_id = dept.id;

sqlite> select * from employee left outer join dept on employee.dept_id = dept.id;
id          name        dept_id     id          name      
----------  ----------  ----------  ----------  ----------
1           dekuma      1           1           Sales     
2           kimkc       3           3           Dev       
3           araikuma    1           1           Sales     
4           happykuma   2           2           Manage    
5           mykuma      4                                 
6           raccoon     3           3           Dev       
sqlite>

外部結合ではFROM直後のテーブルの不一致行を保持するため、テーブル順で結果が変わります。順序を逆にします。

select * from dept left outer join employee on dept.id = employee.dept_id;

sqlite> select * from employee left outer join employee on dept.id = employee.dept_id;
id          name        id          name        dept_id    
----------  ----------  ----------  ----------  ----------
1           Sales       1           dekuma      1         
1           Sales       3           araikuma    1         
2           Manage      4           happykuma   2         
3           Dev         2           kimkc       3         
3           Dev         6           raccoon     3         
sqlite>

deptだけにある行がないため、結果は内部結合と同じです。

取得するカラムを指定する

カラム指定は内部結合と同じです。両テーブルにある名前は修飾し、一方だけならテーブル名を省略できます。

外部結合でもカラムを指定します。

select employee.id, employee.name, dept.name from employee
  left outer join dept on employee.dept_id = dept.id;

sqlite> select employee.id, employee.name, dept.name from employee
   ...>   left outer join dept on employee.dept_id = dept.id;
id          name        name      
----------  ----------  ----------
1           dekuma      Sales     
2           kimkc       Dev       
3           araikuma    Sales     
4           happykuma   Manage    
5           mykuma                
6           raccoon     Dev       
sqlite>

SQLite | データの結合 | クロス結合（CROSS JOIN）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

クロス結合は、2つのテーブルにある行のすべての組み合わせを取得します。ここでは、CROSS JOIN句の使い方を説明します。

クロス結合

クロス結合は、2つのテーブルにある行のすべての組み合わせを返します。

左側の各行に対して右側のすべての行を順番に組み合わせ、左側の全行について繰り返します。

左側にn行、右側にm行ある場合、結果はn × m行になります。非常に大きな結果になる場合があるため注意してください。

CROSS JOIN句の使い方

SELECT文とCROSS JOIN句を組み合わせて、2つのテーブルをクロス結合できます。構文は次のとおりです。

SELECT テーブル名.カラム名, ... FROM テーブル1
  CROSS JOIN テーブル2
  ON テーブル1.カラム1 = テーブル2.カラム2;

簡略化すると次の形式になります。

SELECT (取得カラム) FROM テーブル1
  CROSS JOIN テーブル2 ON (結合条件);

ON句も指定できますが、通常CROSS JOINは結合条件なしで使うため、以降の例では省略します。

–

商品を登録するproductテーブルと色を登録するcolorテーブルを作成し、サンプルデータを追加します。

create table product (id integer, name text);

insert into product values (1, 'Desk');
insert into product values (2, 'Cabinet');
insert into product values (3, 'Chair');

sqlite> create table product (id integer, name text);
sqlite> 
sqlite> insert into product values (1, 'Desk');
sqlite> insert into product values (2, 'Cabinet');
sqlite> insert into product values (3, 'Chair');
sqlite>

create table color (id integer, name text);

insert into color values (1, 'Red');
insert into color values (2, 'Blue');
insert into color values (3, 'White');

sqlite> create table color (id integer, name text);
sqlite> 
sqlite> insert into color values (1, 'Red');
sqlite> insert into color values (2, 'Blue');
sqlite> insert into color values (3, 'White');
sqlite>

次のクロス結合を実行します。

select * from product cross join color;

sqlite> select * from product cross join color;
id          name        id          name      
----------  ----------  ----------  ----------
1           Desk        1           Red       
1           Desk        2           Blue      
1           Desk        3           White     
2           Cabinet     1           Red       
2           Cabinet     2           Blue      
2           Cabinet     3           White     
3           Chair       1           Red       
3           Chair       2           Blue      
3           Chair       3           White     
sqlite>

productの各行とcolorのすべての行が組み合わされていることを確認できます。

取得するカラムを指定する

カラムの指定方法は内部結合と同じです。両方のテーブルに同名カラムがある場合はテーブル名.カラム名と記述し、一方だけにある名前はテーブル名を省略できます。

クロス結合でも実際にカラムを指定してみます。

select product.id, product.name, color.name from product cross join color;

sqlite> select product.id, product.name, color.name from product cross join color;
id          name        name      
----------  ----------  ----------
1           Desk        Red       
1           Desk        Blue      
1           Desk        White     
2           Cabinet     Red       
2           Cabinet     Blue      
2           Cabinet     White     
3           Chair       Red       
3           Chair       Blue      
3           Chair       White     
sqlite>

SQLite | データの結合 | 自然結合（NATURALキーワード）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

内部結合や外部結合では通常、結合条件にカラムを指定します。NATURALキーワードを使うと、両方のテーブルにある同名カラムが自動的に使われます。ここでは自然結合を説明します。

自然結合の使い方

内部結合または外部結合にNATURALを指定します。構文は次のとおりです。

内部結合の場合

SELECT テーブル名.カラム名, ... FROM テーブル1
   NATURAL INNER JOIN テーブル2;

外部結合の場合

SELECT テーブル名.カラム名, ... FROM テーブル1
   NATURAL LEFT OUTER JOIN テーブル2;

自然結合では同名カラムが自動的に比較されるため、結合条件は不要です。それ以外は対応する内部結合や外部結合と同じです。

–

employeeテーブルとdeptテーブルを作成します。どちらにもdept_idカラムがあり、サンプルデータを追加します。

create table employee (id integer, name text, dept_id integer);

insert into employee values (1, 'dekuma', 1);
insert into employee values (2, 'kimkc', 3);
insert into employee values (3, 'araikuma', 1);
insert into employee values (4, 'happykuma', 2);
insert into employee values (5, 'mykuma', 4);
insert into employee values (6, 'raccoon', 3);

sqlite> create table employee (id integer, name text, dept_id integer);
sqlite> 
sqlite> insert into employee values (1, 'dekuma', 1);
sqlite> insert into employee values (2, 'kimkc', 3);
sqlite> insert into employee values (3, 'araikuma', 1);
sqlite> insert into employee values (4, 'happykuma', 2);
sqlite> insert into employee values (5, 'mykuma', 4);
sqlite> insert into employee values (6, 'raccoon', 3);
sqlite>

create table dept(dept_id integer, deptname text);

insert into dept values(1, 'Sales');
insert into dept values(2, 'Manage');
insert into dept values(3, 'Dev');

sqlite> create table dept(dept_id integer, deptname text);
sqlite> 
sqlite> insert into dept values(1, 'Sales');
sqlite> insert into dept values(2, 'Manage');
sqlite> insert into dept values(3, 'Dev');
sqlite>

まず自然内部結合を実行します。両テーブルにdept_idがあるため、このカラムで結合されます。

select * from employee natural inner join dept;

sqlite> select * from employee natural inner join dept;
id          name        dept_id     deptname  
----------  ----------  ----------  ----------
1           dekuma      1           Sales     
2           kimkc       3           Dev       
3           araikuma    1           Sales     
4           happykuma   2           Manage    
6           raccoon     3           Dev       
sqlite>

NATURALを使うと、同名カラムは結果に1つだけ表示されます。

これは明示的なON条件を使った内部結合と同じです。

select * from employee inner join dept on employee.dept_id = dept.dept_id;

sqlite> select * from employee inner join dept on employee.dept_id = dept.dept_id; 
id          name        dept_id     dept_id     deptname  
----------  ----------  ----------  ----------  ----------
1           dekuma      1           1           Sales     
2           kimkc       3           3           Dev       
3           araikuma    1           1           Sales     
4           happykuma   2           2           Manage    
6           raccoon     3           3           Dev       
sqlite>

次に自然外部結合を実行します。この場合も共通のdept_idで結合されます。

select * from employee natural left outer join employee;

sqlite> select * from employee natural left outer join employee;
id          name        dept_id    
----------  ----------  ----------
1           dekuma      1         
2           kimkc       3         
3           araikuma    1         
4           happykuma   2         
5           mykuma      4         
6           raccoon     3         
sqlite>

これは明示的なON条件を使った外部結合と同じです。

select * from employee left outer join dept on employee.dept_id = dept.dept_id;

sqlite> select * from employee left outer join dept on employee.dept_id = dept.dept_id;
id          name        dept_id     dept_id     deptname  
----------  ----------  ----------  ----------  ----------
1           dekuma      1           1           Sales     
2           kimkc       3           3           Dev       
3           araikuma    1           1           Sales     
4           happykuma   2           2           Manage    
5           mykuma      4                                 
6           raccoon     3           3           Dev       
sqlite>

SQLite | データの結合 | 同じテーブルを結合する（SELF JOIN）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

内部結合や外部結合では通常複数のテーブルを結合しますが、テーブルをそれ自身と結合することもできます。これを自己結合（SELF JOIN）と呼びます。

自己結合の使い方

自己結合は同じテーブルに対して内部結合または外部結合を行います。同じテーブルを2回使用するため、それぞれに別の別名を指定します。

SELECT 別名1.列名, ...
  FROM テーブル名 別名1 INNER JOIN テーブル名 別名2
  ON 別名1.列名 = 別名2.列名;

FROMの後とJOINの後のテーブルは同じです。別名によって、結合条件や結果で重複する列名を区別できます。

–

例で使用するテーブルを作成します。

create table employee (id integer, name text, boss_id integer);

sqlite> create table employee (id integer, name text, boss_id integer);
sqlite>

次のデータを追加します。

insert into employee values (1, 'devkuma', 3);
insert into employee values (2, 'kimkc', 4);
insert into employee values (3, 'araikuma', 5);
insert into employee values (4, 'happykuma', 3);
insert into employee values (5, 'raccoon', 0);

sqlite> insert into employee values (1, 'devkuma', 3);
sqlite> insert into employee values (2, 'kimkc', 4);
sqlite> insert into employee values (3, 'araikuma', 5);
sqlite> insert into employee values (4, 'happykuma', 3);
sqlite> insert into employee values (5, 'raccoon', 0);
sqlite>

employeeテーブルには、識別番号のid、従業員名のname、上司の識別番号のboss_idがあります。上司も同じテーブルに保存され、boss_idは別の行のidを参照します。

自己結合で上司の名前を取得します。

select staff.id, staff.name, boss.name from employee staff
  left outer join employee boss
  on staff.boss_id = boss.id;

sqlite> select staff.id, staff.name, boss.name from employee staff
   ...>   left outer join employee boss
   ...>   on staff.boss_id = boss.id;
id          name        name      
----------  ----------  ----------
1           devkuma     araikuma  
2           kimkc       happykuma 
3           araikuma    raccoon   
4           happykuma   araikuma  
5           raccoon               
sqlite>

AS句で結果列に別名を付けることもできます。詳細は取得したデータの列に別名を設定する（AS句）を参照してください。

select staff.id, staff.name, boss.name as bossname
  from employee staff
  left outer join employee boss
  on staff.boss_id = boss.id;

sqlite> select staff.id, staff.name, boss.name as bossname
   ...>   from employee staff
   ...>   left outer join employee boss
   ...>   on staff.boss_id = boss.id;
id          name        bossname  
----------  ----------  ----------
1           devkuma     araikuma  
2           kimkc       happykuma 
3           araikuma    raccoon   
4           happykuma   araikuma  
5           raccoon               
sqlite>

この例は外部結合を使いましたが、同じ手法を内部結合にも適用できます。

SQLite | SQLiteコマンド | 現在の設定内容を確認する（.showコマンド）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

.showコマンドを実行すると、出力先や区切り文字など、さまざまな設定項目の現在値を確認できます。ここでは、.showコマンドの使い方について説明します。

.showコマンドの使い方

.showを実行すると、各設定項目の現在値が表示されます。

.show

実際に確認してみましょう。

.show

sqlite> .show
        echo: off
         eqp: off
     explain: auto
     headers: off
        mode: list
   nullvalue: ""
      output: stdout
colseparator: "|"
rowseparator: "\n"
       stats: off
       width: 
    filename: mydb.sqlite3
sqlite>

.showで確認できる設定項目と現在値は上記のとおりです。

次に、modeの設定を変更します。modeの変更には.modeコマンドを使用します。

.mode html

sqlite> .mode html
sqlite>

.showを再度実行して設定内容を確認します。

.show

sqlite> .mode html
sqlite> 
sqlite> .show
        echo: off
         eqp: off
     explain: auto
     headers: off
        mode: html
   nullvalue: ""
      output: stdout
colseparator: "|"
rowseparator: "\n"
       stats: off
       width: 
    filename: mydb.sqlite3
sqlite>

modeの値が変更されたことを確認できます。

SQLite | SQLiteコマンド | SELECT結果にカラム名を表示する（.headers）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

.headersコマンドはSELECT結果にカラム名を表示するか設定します。ここでは、その使い方を説明します。

.headersコマンドの使い方

.headersでカラム名のヘッダーを表示または非表示にします。構文は次のとおりです。

.headers on|off

.headers onで表示し、.headers offで非表示にします。.headerも使用できます。

現在の設定は.showで確認できます。

.show

sqlite> .show
        echo: off
         eqp: off
     explain: auto
     headers: off
        mode: list
   nullvalue: ""
      output: stdout
colseparator: "|"
rowseparator: "\n"
       stats: off
       width: 
    filename: mydb.sqlite3
sqlite>

headersがoffの場合、ヘッダーは表示されません。

既定設定で検索します。

select * from user;

sqlite> select * from user;
1|devkuma|Seoul
2|kimkc|Busan
3|araikuma|Seoul
4|happykuma|Seoul
5|mykuma|Daejeon
sqlite>

データだけが表示されます。ヘッダーを有効にして再度検索します。

.headers on

sqlite> .headers on
sqlite> 
sqlite> select * from user;
id|name|address
1|devkuma|Seoul
2|kimkc|Busan
3|araikuma|Seoul
4|happykuma|Seoul
5|mykuma|Daejeon
sqlite>

先頭行にカラム名が表示されました。

次に出力モードを変更してヘッダー表示を確認します。

mode = csv :

sqlite> .mode csv
sqlite> 
sqlite> select * from user;
id,name,address
1,devkuma,Seoul
2,kimkc,Busan
3,araikuma,Seoul
4,happykuma,Seoul
5,mykuma,Daejeon
sqlite>

mode = column :

sqlite> .mode column
sqlite> 
sqlite> select * from user;
id          name        address   
----------  ----------  ----------
1           devkuma     Seoul     
2           kimkc       Busan     
3           araikuma    Seoul     
4           happykuma   Seoul     
5           mykuma      Daejeon   
sqlite>

mode = html :

sqlite> select * from user;
<TR><TH>id</TH>
<TH>name</TH>
<TH>address</TH>
</TR>
<TR><TD>1</TD>
<TD>devkuma</TD>
<TD>Seoul</TD>
</TR>
<TR><TD>2</TD>
<TD>kimkc</TD>
<TD>Busan</TD>
</TR>
<TR><TD>3</TD>
<TD>araikuma</TD>
<TD>Seoul</TD>
</TR>
<TR><TD>4</TD>
<TD>happykuma</TD>
<TD>Seoul</TD>
</TR>
<TR><TD>5</TD>
<TD>mykuma</TD>
<TD>Daejeon</TD>
</TR>
sqlite>

mode = tabs :

sqlite> .mode tabs
sqlite> 
sqlite> select * from user;
id	name	address
1	devkuma	Seoul
2	kimkc	Busan
3	araikuma	Seoul
4	happykuma	Seoul
5	mykuma	Daejeon
sqlite>

mode = tcl :

sqlite> .mode tcl
sqlite> 
sqlite> select * from user;
"id" "name" "address"
"1" "devkuma" "Seoul"
"2" "kimkc" "Busan"
"3" "araikuma" "Seoul"
"4" "happykuma" "Seoul"
"5" "mykuma" "Daejeon"
sqlite>

ヘッダーは現在の出力モードに合わせて表示されます。

SQLite | SQLiteコマンド | SELECT結果の区切り文字を変更する（.separatorコマンド）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

.separatorコマンドを実行すると、SELECT文の結果を表示するときに使う既定の区切り文字を変更できます。ここでは、その使い方を説明します。

.separatorコマンドの使い方

区切り文字は、クエリ結果の値を区切るほか、.importコマンドでファイルを読み込むときのフィールド区切りにも使われます。

.separator COL? ROW?

第1引数にはカラムの区切り文字を指定します。省略可能な第2引数には行の区切り文字を指定します。カラム区切りの初期値は|で、1文字だけでなく文字列も指定できます。現在の設定は.showで確認できます。

sqlite> .show
        echo: off
         eqp: off
     explain: auto
     headers: off
        mode: list
   nullvalue: ""
      output: stdout
colseparator: "|"
rowseparator: "\n"
       stats: off
       width:
    filename: mydb.sqlite3

初期設定では、値が|で区切られます。

sqlite> select * from user;
1|devkuma|Seoul
2|kimkc|Busan
3|araikuma|Seoul
4|happykuma|Seoul
5|mykuma|Daejeon

区切り文字をカンマに変更して、同じクエリを実行します。

sqlite> .separator ,
sqlite> select * from user;
1,devkuma,Seoul
2,kimkc,Busan
3,araikuma,Seoul
4,happykuma,Seoul
5,mykuma,Daejeon

複数の文字からなる文字列も指定できます。

sqlite> .separator /-/
sqlite> select * from user;
1/-/devkuma/-/Seoul
2/-/kimkc/-/Busan
3/-/araikuma/-/Seoul
4/-/happykuma/-/Seoul
5/-/mykuma/-/Daejeon

空白を含む場合は、文字列全体を二重引用符で囲みます。

sqlite> .separator ", "
sqlite> select * from user;
1, devkuma, Seoul
2, kimkc, Busan
3, araikuma, Seoul
4, happykuma, Seoul
5, mykuma, Daejeon

SQLite | SQLiteコマンド | columnモードで列幅を指定する（.widthコマンド）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

.mode columnが有効なとき、.widthコマンドで各カラムの表示幅を設定できます。ここでは、その使い方を説明します。

.widthコマンドの使い方

.widthコマンドは各カラムの表示幅を設定します。.modeでcolumnモードにした場合に使用できます。構文は次のとおりです。

.width NUM NUM ...

各引数にはカラム幅を文字数で指定します。複数の幅は空白で区切ります。

引数を1つだけ指定すると、最初のカラムだけが変更されます。また、幅に関係なくカラム間には2文字分の空白が入ります。

実際に試します。columnモードに切り替え、既定の設定でデータを表示します。

.mode column

qlite> .mode column
sqlite> 
sqlite> select * from user;
1           devkuma     Seoul     
2           kimkc       Busan     
3           araikuma    Seoul     
4           happykuma   Seoul     
5           mykuma      Daejeon   
sqlite>

既定のカラム幅は10文字で、カラム間にはさらに2文字分の空白が入ります。

最初のカラムだけを4文字幅に設定し、SELECT文を実行します。

.width 4

sqlite> select * from user;
1     devkuma     Seoul     
2     kimkc       Busan     
3     araikuma    Seoul     
4     happykuma   Seoul     
5     mykuma      Daejeon   
sqlite>

最初のカラムは4文字幅になり、残りは既定の10文字幅のままです。

次に、最初のカラムを4文字、2番目を6文字に設定します。

.width 4 6

sqlite> .width 4 6
sqlite> 
sqlite> select * from user;
1     devkum  Seoul     
2     kimkc   Busan     
3     araiku  Seoul     
4     happyk  Seoul     
5     mykuma  Daejeon   
sqlite>

最初のカラムは4文字、2番目は6文字になり、残りは既定の10文字幅です。

データが指定幅を超える場合

値がカラム幅を超える場合、超過した文字は切り詰めて表示されます。

次の例では、最初と2番目のカラムを4文字幅に設定します。

.width 4 4

sqlite> .width 4 4
sqlite> 
sqlite> select * from user;
1     devk  Seoul     
2     kimk  Busan     
3     arai  Seoul     
4     happ  Seoul     
5     myku  Daejeon   
sqlite>

2番目のカラムには4文字を超える値がありますが、表示は4文字で切り詰められます。保存されている値には影響しません。

データを右揃えで表示する

.widthに負の値を指定すると、データを右揃えで表示できます。

次の.widthコマンドで幅を指定し、右揃えに設定します。

.width -4 -10

sqlite> select * from user;
   1     devkuma  Seoul     
   2       kimkc  Busan     
   3    araikuma  Seoul     
   4   happykuma  Seoul     
   5      mykuma  Daejeon   
sqlite>

各カラムが指定幅の中で右揃えになっていることを確認できます。

SQLite | SQLiteコマンド | CSVファイルからデータを取り込む（.importコマンド）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

SQLiteではCSVファイルを読み込み、そのデータをテーブルに取り込めます。ここでは、.importコマンドの使い方を説明します。

.importコマンドの使い方

データファイルをテーブルに取り込むには.importを使います。構文は次のとおりです。

.import FILE TABLE

第1引数にファイル名、第2引数に取り込み先のテーブル名を指定します。ファイルは絶対パス、またはSQLite CLIを起動したディレクトリからの相対パスで指定します。

既存テーブルと新規テーブルでは取り込み方法が異なります。

既存テーブルに取り込む

まず、取り込み先のテーブルを作成し、既存データを数行追加します。

create table user (id integer, name text, address text);

insert into user values (1, 'devkuma', 'Seoul');
insert into user values (2, 'kimkc', 'Busan');

sqlite> create table user (id integer, name text, address text);
sqlite> 
sqlite> insert into user values (1, 'devkuma', 'Seoul');
sqlite> insert into user values (2, 'kimkc', 'Busan');
sqlite>

次のCSVデータを作成し、現在のディレクトリにuserdata.csvとして保存します。

3,araikuma,Seoul
4,happykuma,Seoul
5,mykuma,Daejeon

.modeでCSVモードに切り替えてから、ファイルをuserテーブルに取り込みます。

.mode csv
.import ./userdata.csv user

sqlite> .mode csv
sqlite> .import ./userdata.csv user
sqlite>

取り込み後にuserテーブルを検索します。

select * from user;

sqlite> select * from user;
1,devkuma,Seoul
2,kimkc,Busan
3,araikuma,Seoul
4,happykuma,Seoul
5,mykuma,Daejeon
sqlite>

取り込んだ行が既存データの後に追加されています。

新しいテーブルに取り込む

取り込み先が存在しない場合、SQLiteは新しいテーブルを作成し、CSVの先頭行をカラム名として使用します。

次のCSVデータを作成し、現在のディレクトリにuserdata2.csvとして保存します。

id,name,address
1,devkuma,Seoul
2,kimkc,Busan
3,araikuma,Seoul

CSVモードに切り替え、ファイルを新しいuser2テーブルに取り込みます。

.mode csv
.import ./userdata2.csv user2

sqlite> .mode csv
sqlite> .import ./userdata2.csv user2
sqlite>

user2が作成され、取り込んだデータが保存されます。

.schemaで作成されたテーブルを確認します。

.schema user2

sqlite> .schema user2
CREATE TABLE user2(
  "id" TEXT,
  "name" TEXT,
  "address" TEXT
);
sqlite>

CSVの先頭行がカラム名になり、すべてのカラム型はTEXTです。

次にuser2テーブルを検索します。

select * from user2;

sqlite> select * from user2;
1,devkuma,Seoul
2,kimkc,Busan
3,araikuma,Seoul
sqlite>

CSVの2行目以降がテーブルデータとして保存されています。

SQLite | SQLiteコマンド | データベースのダンプ（.dump）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

データベースのスキーマとデータをSQL文として出力することをダンプと呼びます。ここでは.dumpの使い方を説明します。

ダンプからデータベースを再構築するには.readコマンドを使用します。

.dumpの使い方

.dumpでSQLiteデータベースを出力します。構文は次のとおりです。

.dump? TABLE? ...

引数なしならデータベース全体、テーブル名を指定するとそのテーブルだけを出力します。

サンプルのテーブルとデータを作成します。

create table user (name text, old integer, address text);
 
insert into user values ('devkuma', 28, 'Seoul');
insert into user values ('kimkc', 22, 'Busan');
insert into user values ('araikuma', 32, 'Seoul');
insert into user values ('happykuma', 23, 'Seoul');
insert into user values ('mykuma', 23, 'Daejeon');

create index nameindex on user (name);

create table color (id integer, name text);

insert into color values (1, 'Red');
insert into color values (2, 'Blue');
insert into color values (3, 'White');

2つのテーブルと1つのインデックスを持つデータベースで.dumpを実行します。

.dump

sqlite> .dump
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE user (name text, old integer, address text);
INSERT INTO user VALUES('devkuma',28,'Seoul');
INSERT INTO user VALUES('kimkc',22,'Busan');
INSERT INTO user VALUES('araikuma',32,'Seoul');
INSERT INTO user VALUES('happykuma',23,'Seoul');
INSERT INTO user VALUES('mykuma',23,'Daejeon');
CREATE TABLE color (id integer, name text);
INSERT INTO color VALUES(1,'Red');
INSERT INTO color VALUES(2,'Blue');
INSERT INTO color VALUES(3,'White');
CREATE INDEX nameindex on user (name);
COMMIT;
sqlite>

出力にはスキーマ用のCREATE TABLEとデータ用のINSERTが含まれ、順に実行するとデータベースを再構築できます。

userを指定してそのテーブルだけをダンプします。

.dump user

sqlite> .dump user
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE user (name text, old integer, address text);
INSERT INTO user VALUES('devkuma',28,'Seoul');
INSERT INTO user VALUES('kimkc',22,'Busan');
INSERT INTO user VALUES('araikuma',32,'Seoul');
INSERT INTO user VALUES('happykuma',23,'Seoul');
INSERT INTO user VALUES('mykuma',23,'Daejeon');
CREATE INDEX nameindex on user (name);
COMMIT;
sqlite>

ダンプをファイルへ出力する

.dumpの前に.outputを使うと、出力をファイルへリダイレクトできます。

現在のディレクトリのdump.txtへ出力します。この設定はクエリ結果にも適用されます。

.output ./dump.txt

sqlite> .output ./dump.txt
sqlite>

出力先がdump.txtになりました。.dumpを実行します。

.dump

sqlite> .dump
sqlite>

ダンプはファイルへ書かれるため画面には表示されません。

現在のディレクトリに新しいdump.txtがあります。

$ ls -al
total 5056
drwxr-xr-x@  8 kimkc  staff      272 11  4 01:24 .
drwxr-xr-x   9 kimkc  staff      306 10 17 23:49 ..
drwxr-xr-x  24 kimkc  staff      816 11  4 01:24 bak
-rw-r--r--   1 kimkc  staff    16384 11  4 01:14 dump.sqlite3
-rw-r--r--   1 kimkc  staff      538 11  4 01:21 dump.txt
-rwxr-xr-x@  1 kimkc  staff   691768 10 11 18:31 sqldiff
-rwxr-xr-x@  1 kimkc  staff  1152260 10 11 18:32 sqlite3
-rwxr-xr-x@  1 kimkc  staff   719796 10 11 18:31 sqlite3_analyzer
$

テキストファイルを開くとダンプ内容を確認できます。

$ cat dump.txt 
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE user (name text, old integer, address text);
INSERT INTO user VALUES('devkuma',28,'Seoul');
INSERT INTO user VALUES('kimkc',22,'Busan');
INSERT INTO user VALUES('araikuma',32,'Seoul');
INSERT INTO user VALUES('happykuma',23,'Seoul');
INSERT INTO user VALUES('mykuma',23,'Daejeon');
CREATE TABLE color (id integer, name text);
INSERT INTO color VALUES(1,'Red');
INSERT INTO color VALUES(2,'Blue');
INSERT INTO color VALUES(3,'White');
CREATE INDEX nameindex on user (name);
COMMIT;
$

.output stdoutで画面出力へ戻します。

.output stdout

sqlite> .output stdout
sqlite>

出力先を戻すかCLIを終了するまで、ファイルがロックされる場合があります。

SQLite | SQLiteコマンド | ダンプからデータベースを再構築する（.readコマンド）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

.dumpコマンドはデータベースのスキーマとデータをSQL文として保存します。.readコマンドでそのダンプファイルを実行すると、同じ内容のデータベースを作成できます。

ダンプの作成方法はデータベースのダンプ（.dumpコマンド）を参照してください。

ダンプファイルを読み込む

新しいデータベースにダンプを読み込むには.readを使います。

.read FILENAME

読み込むファイル名を指定します。ファイルには、.dumpの出力のようなSQL文が必要です。SQLiteはファイルを読み込むとSQL文を順番に実行します。

次のdump.txtには既存データベースのダンプが保存されています。

PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE user (name text, old integer, address text);
INSERT INTO user VALUES('devkuma',28,'Seoul');
INSERT INTO user VALUES('kimkc',22,'Busan');
INSERT INTO user VALUES('araikuma',32,'Seoul');
INSERT INTO user VALUES('happykuma',23,'Seoul');
INSERT INTO user VALUES('mykuma',23,'Daejeon');
CREATE TABLE color (id integer, name text);
INSERT INTO color VALUES(1,'Red');
INSERT INTO color VALUES(2,'Blue');
INSERT INTO color VALUES(3,'White');
CREATE INDEX nameindex on user (name);
COMMIT;

空の新しいデータベースnewdb.sqlite3を作成します。

sqlite3 newdb.sqlite3

$ sqlite3 newdb.sqlite3
SQLite version 3.19.3 2017-06-27 16:48:08
Enter ".help" for usage hints.
sqlite>

.readでファイルを読み込みます。

.read ./dump.txt

sqlite> .read ./dump.txt
sqlite>

ファイル内のSQL文が順番に実行され、2つのテーブルとそのデータが作成されます。

.tablesでテーブルを確認します。

.tables

sqlite> .tables
color  user 
sqlite>

各テーブルを照会し、データを確認します。

select * from user;

sqlite> select * from user;
devkuma|28|Seoul
kimkc|22|Busan
araikuma|32|Seoul
happykuma|23|Seoul
mykuma|23|Daejeon
sqlite>

select * from color;

sqlite> select * from color;
1|Red
2|Blue
3|White
sqlite>

データベースのダンプを新しいデータベースに読み込むと、スキーマとデータを再構築できます。

SQLite | SQLiteコマンド | データベースのバックアップと復元（.backup/.restore）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

SQLiteデータベースはファイルのコピーやダンプの取り込みでもバックアップできます。ここでは、別の方法として.backupと.restoreコマンドを説明します。

.backupコマンドでバックアップする

.backupでデータベースをバックアップします。構文は次のとおりです。

.backup ?DB? FILE

第1引数はバックアップするデータベース名です。省略時は、通常プライマリデータベースに割り当てられるmainになります。

第2引数はバックアップファイル名です。名前と拡張子は自由に指定でき、存在しない場合は新しく作成されます。

–

バックアップ対象のデータベースに接続します。この例には2つのテーブルがあります。

.tables

sqlite> .tables
color  user 
sqlite>

現在のディレクトリのmydb.backにバックアップします。ファイルは存在しないため自動的に作成されます。

.backup ./mydb.back

sqlite> .backup ./mydb.back
sqlite>

完了すると現在のディレクトリにmydb.backが作成されます。これはテキストではなくバイナリのデータベースファイルです。

$ ls -al
total 5080
drwxr-xr-x@  8 kimkc  staff      272 11  4 23:31 .
drwxr-xr-x   9 kimkc  staff      306 10 17 23:49 ..
drwxr-xr-x  27 kimkc  staff      918 11  4 23:31 bak
-rw-r--r--   1 kimkc  staff    16384 11  4 23:30 mydb.back
-rw-r--r--   1 kimkc  staff    16384 11  4 22:38 mydb.sqlite3
-rwxr-xr-x@  1 kimkc  staff   691768 10 11 18:31 sqldiff
-rwxr-xr-x@  1 kimkc  staff  1152260 10 11 18:32 sqlite3
-rwxr-xr-x@  1 kimkc  staff   719796 10 11 18:31 sqlite3_analyzer
$

これでデータベースのバックアップは完了です。

.restoreコマンドで復元する

.restoreでバックアップからデータベースを復元します。構文は次のとおりです。

.restore ?DB? FILE

第1引数は復元先のデータベース名で、省略時はmainです。第2引数にはバックアップファイルを指定します。

復元先に接続してから実行します。復元すると現在のテーブルやデータが削除され、バックアップ内容に置き換わるため注意してください。

–

復元先として新しいnewdb.sqlite3データベースを作成します。

sqlite3 newdb.sqlite3

$ sqlite3 newdb.sqlite3
SQLite version 3.19.3 2017-06-27 16:48:08
Enter ".help" for usage hints.
sqlite>

先ほど作成したmydb.backを指定して.restoreを実行します。

.restore ./mydb.back

sqlite> .restore ./mydb.back
sqlite>

データベースの内容がバックアップに保存されていたデータへ置き換わります。

スキーマを確認すると、2つのテーブルが復元されています。

.tables

sqlite> .tables
color  user 
sqlite>

テーブルを検索し、バックアップどおりのデータが保存されていることを確認します。

select * from user;

sqlite> select * from user;
devkuma|28|Seoul
kimkc|22|Busan
araikuma|32|Seoul
happykuma|23|Seoul
mykuma|23|Daejeon
sqlite>

select * from color;

sqlite> select * from color;
1|Red
2|Blue
3|White
sqlite>

これでバックアップしたデータベースを新しいデータベースへ復元できました。

SQLite | SQLite関数 | 列またはテーブル全体の行数を求める（count関数）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

count関数を使うと、指定した列またはテーブルの行数を求められます。ここでは使い方を説明します。

count関数の使い方

構文は次のとおりです。

count(列名)

引数に列名またはアスタリスク（*）を指定します。列名を指定するとNULL以外の行数を返し、*を指定するとテーブルのすべての行数を返します。GROUP BY句を使用する場合は、グループごとの行数を返します。

–

例で使用するテーブルを作成します。

create table user (id integer, name text, address text, gender text);

sqlite> create table user (id integer, name text, address text, gender text);
sqlite>

データを追加します。

insert into user values (1, 'devkuma', 'Seoul', 'Man');
insert into user values (2, 'kimkc', 'Busan', 'Woman');
insert into user values (3, 'arikuma', 'Suwan', 'Man');
insert into user values (4, 'happykuma', NULL, 'Man');
insert into user values (5, 'raccoon', 'Seoul', 'Woman');

sqlite> insert into user values (1, 'devkuma', 'Seoul', 'Man');
sqlite> insert into user values (2, 'kimkc', 'Busan', 'Woman');
sqlite> insert into user values (3, 'arikuma', 'Suwan', 'Man');
sqlite> insert into user values (4, 'happykuma', NULL, 'Man');
sqlite> insert into user values (5, 'raccoon', 'Seoul', 'Woman');
sqlite>

name列とaddress列の行数を求めます。

select count(name), count(address) from user;

sqlite> select count(name), count(address) from user;
5|4
sqlite>

address列にはNULLの行が1つあるため、name列よりカウントが1少なくなります。

テーブル全体の行数を求めます。

select count(*) from user;

sqlite> select count(*) from user;
5
sqlite>

すべての列値がNULLの行があっても、他の行と同様に数えられます。

最後に、gender列でグループ化して行数を求めます。

select gender, count(*) from user group by gender;

sqlite> select gender, count(*) from user group by gender;
Man|3
Woman|2
sqlite>

GROUP BY句を使用すると、グループごとに行数が計算されます。詳細はデータをグループ化して合計と平均を計算する（GROUP BY句、HAVING句）を参照してください。

SQLite | SQLite関数 | sum関数とtotal関数で合計を求める

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

sum()とtotal()はカラム値の合計を計算します。

sum関数とtotal関数の使い方

sum()で合計を計算します。構文は次のとおりです。

sum(カラム名)

指定カラムの合計を返し、GROUP BYを使うとグループごとに計算します。

total()も合計を計算します。

total(カラム名)

同様にGROUP BYでグループごとの合計を取得できます。

入力がすべて整数ならsum()は整数、total()は常に浮動小数点数を返します。浮動小数点値を含む場合は両方とも浮動小数点数です。

すべてNULLの場合、sum()はNULL、total()は0.0を返します。

–

例として次のテーブルを作成します。

create table store (address text, sales);

sqlite> create table store (address text, sales);
sqlite>

次のデータを追加します。

insert into store values ('Seoul', NULL);

sqlite> insert into store values ('Seoul', NULL);
sqlite> 
sqlite> select * from store;
address     sales     
----------  ----------
Seoul                 
sqlite>

現在はsalesがNULLの1行だけです。両関数で合計を求めます。

select sum(sales), total(sales) from store;

sqlite> .mode column
sqlite> .header on
sqlite> 
sqlite> select sum(sales), total(sales) from store;
sum(sales)  total(sales)
----------  ------------
            0.0         
sqlite>

NULLだけの場合、sum()はNULL、total()は0.0です。

データを追加します。

insert into store values ('Busan', 450);
insert into store values ('Daejeon', 380);
insert into store values ('Seoul', 95);

sqlite> insert into store values ('Busan', 450);
sqlite> insert into store values ('Daejeon', 380);
sqlite> insert into store values ('Seoul', 95);
sqlite> 
sqlite> select * from store;
address     sales     
----------  ----------
Seoul                 
Busan       450       
Daejeon     380       
Seoul       95        
sqlite>

もう一度合計を求めます。

select sum(sales), total(sales) from store;

sqlite> select sum(sales), total(sales) from store;
sum(sales)  total(sales)
----------  ------------
925         925.0       
sqlite>

すべて整数なのでsum()は整数、total()は浮動小数点数を返します。

浮動小数点値を追加します。

insert into store values ('Busan', 320.45);

sqlite> insert into store values ('Busan', 320.45);
sqlite> 
sqlite> select * from store;
address     sales     
----------  ----------
Seoul                 
Busan       450       
Daejeon     380       
Seoul       95        
Busan       320.45    
sqlite>

もう一度合計を求めます。

select sum(sales), total(sales) from store;

sqlite> select sum(sales), total(sales) from store;
sum(sales)  total(sales)
----------  ------------
1245.45     1245.45     
sqlite>

浮動小数点値を含む場合、両関数とも浮動小数点数を返します。

最後にaddressでグループ化し、グループごとの合計を求めます。

select address, sum(sales), total(sales) from store group by address;

sqlite> select address, sum(sales), total(sales) from store group by address;
address     sum(sales)  total(sales)
----------  ----------  ------------
Busan       770.45      770.45      
Daejeon     380         380.0       
Seoul       95          95.0        
sqlite>

住所ごとの合計が返されます。

SQLite | SQLite関数 | avg関数で平均値を求める

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

avg()関数は指定したカラムの平均値を求めます。ここでは、その使い方を説明します。

avg関数の使い方

avg()で平均値を計算します。構文は次のとおりです。

avg(カラム名)

指定カラムのNULL以外を平均します。すべてNULLならNULLを返し、GROUP BYを使うとグループごとに計算します。

数値に変換できない文字列は0として扱われます。

–

例として次のテーブルを作成します。

create table user (name text, point integer, gender text);

sqlite> create table user (name text, point integer, gender text);
sqlite>

次のデータを追加します。

insert into user values ('dekuma', 72, 'Man');
insert into user values ('kimkc', 94, 'Woman');
insert into user values ('araikuma', 58, 'Woman');
insert into user values ('happykuma', 82, 'Man');

sqlite> insert into user values ('dekuma', 72, 'Man');
sqlite> insert into user values ('kimkc', 94, 'Woman');
sqlite> insert into user values ('araikuma', 58, 'Woman');
sqlite> insert into user values ('happykuma', 82, 'Man');
sqlite>

avg()でpointの平均を求めます。

select avg(point) from user;

sqlite> .mode column
sqlite> .header on
sqlite> 
sqlite> select avg(point) from user;
avg(point)
----------
76.5      
sqlite>

平均は(72 + 94 + 58 + 82) ÷ 4 = 76.5です。

次にgenderでグループ化して平均を求めます。

select gender, avg(point) from user group by gender;

sqlite> select gender, avg(point) from user group by gender;
gender      avg(point)
----------  ----------
Man         77.0      
Woman       76.0      
sqlite>

GROUP BYを使うとグループ単位で計算され、manは77、womanは76になります。

平均対象にNULLや文字列がある場合

NULLは計算から除外されます。次の行を追加します。

insert into user values ('raccoon', NULL, 'Man');

sqlite> insert into user values ('raccoon', NULL, 'Man');
sqlite> 
sqlite> select * from user;
name        point       gender    
----------  ----------  ----------
dekuma      72          Man       
kimkc       94          Woman     
araikuma    58          Woman     
happykuma   82          Man       
raccoon                 Man       
sqlite>

もう一度pointの平均を求めます。

select avg(point) from user;

sqlite> select avg(point) from user;
avg(point)
----------
76.5      
sqlite>

NULLは無視されるため、平均は76.5のままです。

次に、数値へ変換できない文字列を追加します。これは0として扱われます。

insert into user values ('mykuma', 'NODATA', 'Woman');

sqlite> insert into user values ('mykuma', 'NODATA', 'Woman');
sqlite> 
sqlite> select * from user;
name        point       gender    
----------  ----------  ----------
dekuma      72          Man       
kimkc       94          Woman     
araikuma    58          Woman     
happykuma   82          Man       
raccoon                 Man       
mykuma      NODATA      Woman     
sqlite>

avg()でpointの平均を求めます。

select avg(point) from user;

sqlite> select avg(point) from user;
avg(point)
----------
61.2      
sqlite>

文字列を0として含めるため、平均は(72 + 94 + 58 + 82 + 0) ÷ 5 = 61.2です。除外されない点に注意してください。

SQLite | SQLite関数 | 列の最大値と最小値を求める（max関数、min関数）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

max関数を使用すると、指定した列に保存されている最大値を取得できます。min関数を使用すると最小値を取得できます。ここでは、両方の関数の使い方について説明します。

max関数とmin関数の使い方

max関数は最大値を求めるために使用します。構文は次のとおりです。

max(列名)

指定した列に保存されている値のうち、最大の値を返します。GROUP BY句を使用した場合は、グループごとに最大値を返します。

min関数は最小値を求めるために使用します。構文は次のとおりです。

min(列名)

指定した列に保存されているNULL以外の値のうち、最小の値を返します。GROUP BY句を使用した場合は、グループごとに最小値を返します。

どちらの関数も、指定した列にNULLしかない場合はNULLを返します。

–

実際に最大値と最小値を求めてみましょう。まず、次のテーブルを作成します。

create table user (name text, point integer, gender text);

sqlite> create table user (name text, point integer, gender text);
sqlite>

INSERT文を使用して次のデータを追加します。

insert into user values ('dekuma', 72, 'Man');
insert into user values ('kimkc', 94, 'Woman');
insert into user values ('araikuma', 58, 'Woman');
insert into user values ('happykuma', 82, 'Man');

sqlite> insert into user values ('dekuma', 72, 'Man');
sqlite> insert into user values ('kimkc', 94, 'Woman');
sqlite> insert into user values ('araikuma', 58, 'Woman');
sqlite> insert into user values ('happykuma', 82, 'Man');
sqlite>

max関数とmin関数を使用して、point列の最大値と最小値を求めます。

select max(point), min(point) from user;

sqlite> select max(point), min(point) from user;
max(point)  min(point)
----------  ----------
94          58        
sqlite>

列にある値の最大値と最小値を取得できました。

次に、gender列でグループ化し、グループごとの最大値と最小値を求めます。

select gender, max (point), min (point) from user group by gender;

sqlite> select gender, max (point), min (point) from user group by gender;
gender      max (point)  min (point)
----------  -----------  -----------
Man         82           72         
Woman       94           58         
sqlite>

GROUP BY句を使用すると、グループごとに最大値と最小値を計算できます。詳しくは、データをグループ化して合計と平均を計算する（GROUP BY句、HAVING句）を参照してください。

SQLite | SQLite関数 | 列の値を連結する（group_concat関数）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

group_concat関数は、指定した列の値を区切り文字で連結した文字列を返します。ここでは使い方を説明します。

group_concat関数の使い方

構文は次のとおりです。

group_concat(列名)

指定した列のNULL以外の値を連結します。GROUP BY句を使用すると、グループごとに結果を作成します。

デフォルトではカンマで値を区切ります。別の区切り文字を使う場合は第2引数に指定します。

group_concat(列名, 区切り文字)

–

例で使用するテーブルを作成します。

create table user (id integer, name text, gender text);

sqlite> create table user (id integer, name text, gender text);
sqlite>

次のデータを追加します。

insert into user values (1, 'devkuma', 'Man');
insert into user values (2, 'kimkc', 'Woman');
insert into user values (3, 'araikuma', 'Man');
insert into user values (4, NULL, 'Man');
insert into user values (5, 'raccoon', 'Woman');

sqlite> insert into user values (1, 'devkuma', 'Man');
sqlite> insert into user values (2, 'kimkc', 'Woman');
sqlite> insert into user values (3, 'araikuma', 'Man');
sqlite> insert into user values (4, NULL, 'Man');
sqlite> insert into user values (5, 'raccoon', 'Woman');
sqlite>

name列の値を連結します。

select group_concat(name) from user;

sqlite> select group_concat(name) from user;
group_concat(name)            
------------------------------
devkuma,kimkc,araikuma,raccoon
sqlite>

NULL以外の名前がデフォルトのカンマで連結されました。

次に、gender列でグループ化し、各グループの名前を連結します。

select gender, group_concat (name) from user group by gender;

sqlite> select gender, group_concat (name) from user group by gender;
gender      group_concat (name)
----------  -------------------
Man         devkuma,araikuma   
Woman       kimkc,raccoon      
sqlite>

GROUP BY句を使うと、グループごとに値が連結されます。詳細はデータをグループ化して合計と平均を計算する（GROUP BY句、HAVING句）を参照してください。

区切り文字を指定する

デフォルトのカンマを別の文字に変更するには、group_concatの第2引数に区切り文字を指定します。

次のクエリは、プラス記号（+）で名前を連結します。

select group_concat(name, '+') from user;

sqlite> select group_concat(name, '+') from user;
group_concat(name, '+')       
------------------------------
devkuma+kimkc+araikuma+raccoon
sqlite>

指定したプラス記号で名前を区切った1つの文字列が表示されました。

SQLite | SQLite関数 | 文字列の文字数を返す（length関数）

kc@example.com (kc kim) — Mon, 14 Oct 2019 23:19:51 +0900

length関数を使用すると、文字列の文字数を取得できます。ここでは、length関数の使い方について説明します。

length関数の使い方

length関数は文字列の長さを取得するために使用します。構文は次のとおりです。

length(文字列)

引数に指定した文字列の文字数を返します。BLOB型の値の場合はバイト数を返します。文字列を直接指定するほか、列名を指定すると、その列に保存されている値の文字数を返します。

–

実際に試してみましょう。まず、次のテーブルを作成します。

create table product (id integer, name_eng text, name_kor text);

sqlite> create table product (id integer, name_eng text, name_kor text);
sqlite>

INSERT文を使用して次のデータを追加します。

insert into product values (1, 'Apple', '사과');
insert into product values (2, 'Car', '자동차');
insert into product values (3, 'Television', '텔레비전');
insert into product values (4, 'Mobile', '휴대');

sqlite> insert into product values (1, 'Apple', '사과');
sqlite> insert into product values (2, 'Car', '자동차');
sqlite> insert into product values (3, 'Television', '텔레비전');
sqlite> insert into product values (4, 'Mobile', '휴대');
sqlite>

length関数を使用して、name_eng列とname_kor列に保存されている値の文字数を取得します。

select name_eng, length(name_eng), name_kor, length(name_kor) from product;

sqlite> select name_eng, length(name_eng), name_kor, length(name_kor) from product;
name_eng    length(name_eng)  name_kor    length(name_kor)
----------  ----------------  ----------  ----------------
Apple       5                 사과          2               
Car         3                 자동차         3               
Television  10                텔레비전        4               
Mobile      6                 휴대          2               
sqlite>

列に保存されている各値の文字数を取得できました。

length関数には文字列を直接指定することもできます。

select length('Flower');

sqlite> select length('Flower');
length('Flower')
----------------
6               
sqlite>