SQLite ORDER BYの使い方を徹底解説【データ並べ替え】

データベースからデータを取得する際、単にレコードを抽出するだけでは不十分なことがほとんどです。取得したデータは、特定のルールに基づいて整然と並べ替えられている必要があります。例えば、ECサイトで商品を価格順に表示したり、ブログ記事を新しい順に表示したり、従業員リストを名前のアルファベット順に表示したりする場合などです。

このような「データの並べ替え」をデータベースで行うために、SQLにはORDER BY句が用意されています。SQLiteももちろんこのORDER BY句をサポートしており、非常に柔軟かつ強力な方法でデータを並べ替えることができます。

この記事では、SQLiteにおけるORDER BY句の使い方を徹底的に解説します。基本的な構文から始まり、単一カラム、複数カラムでの並べ替え、昇順・降順の指定、NULL値の扱い、カラム位置や式を使った並べ替え、さらにはCASE式による条件付き並べ替え、他のSQL句 (LIMIT, OFFSET, GROUP BY) との組み合わせ、そしてパフォーマンスに関する考慮事項まで、網羅的に説明します。この記事を読めば、SQLiteでのデータ並べ替えの全てを理解し、自在に使いこなせるようになるでしょう。

はじめに：なぜORDER BYが必要なのか？

データベースからデータを取得する際に使用するSELECT文は、基本的にデータが格納されている物理的な順序（あるいはインデックスの順序、またはクエリ実行計画による最適化の結果）でレコードを返します。特別な指定をしない限り、取得されるレコードの順序は保証されません。 同じSELECT文を実行しても、データベースの状態やバージョン、実行時の状況によって結果の順序が変わる可能性があります。

しかし、人間がデータを理解したり利用したりする際には、何らかの論理的な順序が必要です。売上データを日付順に見たい、顧客リストを名前順に整理したい、テスト結果を点数の高い順に並べたい、といった要求は日常的に発生します。

ORDER BY句は、まさにこの要求に応えるために存在します。ORDER BY句を使用することで、取得したデータセットを一つ以上のカラム（列）の値に基づいて、昇順（小さい値から大きい値へ）または降順（大きい値から小さい値へ）に並べ替えることができます。これにより、ユーザーにとって意味のある、整理された形でデータを提供することが可能になります。

SQLiteは組み込みデータベースとして、アプリケーション内で広く利用されています。スマートフォンアプリのデータ管理、デスクトップアプリケーションの設定保存、小規模なWebサイトのバックエンドなど、その用途は多岐にわたります。どのようなアプリケーションであれ、取得したデータを適切に並べ替えることは、ユーザーエクスペリエンスを向上させる上で非常に重要です。

さあ、ORDER BY句の具体的な使い方を見ていきましょう。

ORDER BY句の基本構文

ORDER BY句は、SELECT文の末尾近く、FROM句、WHERE句、GROUP BY句、HAVING句の後に指定します。基本的な構文は以下の通りです。

sql
SELECT column1, column2, ...
FROM table_name
WHERE condition
-- GROUP BY column(s)
-- HAVING condition
ORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...;

角括弧 [] 内は省略可能であることを示します。ASCは昇順 (Ascending) を、DESCは降順 (Descending) を指定します。

最もシンプルなケースは、単一のカラムで並べ替える場合です。

単一カラムでの並べ替え

特定の1つのカラムの値に基づいて並べ替えを行います。

例1：昇順 (ASC)

商品のリストを価格の安い順に並べ替える場合を考えます。まず、サンプル用のテーブルを作成し、データを挿入しましょう。

“`sql
— サンプルテーブルの作成
CREATE TABLE products (
product_id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
price REAL NOT NULL,
stock INTEGER NOT NULL
);

— サンプルデータの挿入
INSERT INTO products (name, price, stock) VALUES (‘Apple’, 1.20, 100);
INSERT INTO products (name, price, stock) VALUES (‘Banana’, 0.50, 250);
INSERT INTO products (name, price, stock) VALUES (‘Orange’, 0.80, 150);
INSERT INTO products (name, price, stock) VALUES (‘Grape’, 3.50, 80);
INSERT INTO products (name, price, stock) VALUES (‘Mango’, 2.80, 50);

— データを確認
SELECT * FROM products;
/
product_id|name |price|stock
———-|——|—–|—–
1 |Apple |1.2 |100
2 |Banana|0.5 |250
3 |Orange|0.8 |150
4 |Grape |3.5 |80
5 |Mango |2.8 |50
/
“`

このテーブルから、価格の安い順（昇順）に商品を取得するには、ORDER BY price ASCと指定します。

sql
SELECT *
FROM products
ORDER BY price ASC;
/*
product_id|name |price|stock
----------|------|-----|-----
2 |Banana|0.5 |250
3 |Orange|0.8 |150
1 |Apple |1.2 |100
5 |Mango |2.8 |50
4 |Grape |3.5 |80
*/

価格が0.50のバナナが最初に、3.50のグレープが最後に表示されています。意図通り、価格の昇順に並んでいます。

ASCは省略可能です。ORDER BY句で並べ替え方向を指定しない場合、デフォルトで昇順（ASC）になります。上のクエリは、次のように書くこともできます。

sql
SELECT *
FROM products
ORDER BY price; -- ASCが省略されている
/*
product_id|name |price|stock
----------|------|-----|-----
2 |Banana|0.5 |250
3 |Orange|0.8 |150
1 |Apple |1.2 |100
5 |Mango |2.8 |50
4 |Grape |3.5 |80
*/
結果は全く同じです。可読性を高めるために明示的にASCを指定することも多いですが、省略しても問題ありません。

例2：降順 (DESC)

在庫数の多い順（降順）に商品を並べ替えたい場合は、ORDER BY stock DESCと指定します。

sql
SELECT *
FROM products
ORDER BY stock DESC;
/*
product_id|name |price|stock
----------|------|-----|-----
2 |Banana|0.5 |250
3 |Orange|0.8 |150
1 |Apple |1.2 |100
4 |Grape |3.5 |80
5 |Mango |2.8 |50
*/
在庫数が250のバナナが最初に、50のマンゴーが最後に表示されています。在庫数の降順に並んでいます。

複数カラムでの並べ替え

複数のカラムを指定して並べ替えることも可能です。この場合、最初に指定したカラムで並べ替えが行われ、もしそのカラムの値が同じレコードが複数ある場合は、次に指定したカラムで並べ替えが行われます。この優先順位は、指定したカラムの順序で決まります。

例3：複数カラムでの並べ替え

まず在庫数の多い順に並べ替え、もし在庫数が同じ商品がある場合は、価格の安い順に並べ替えたいとします。この場合は、ORDER BY stock DESC, price ASCと指定します。

“`sql
— stockが同じになるデータを追加
INSERT INTO products (name, price, stock) VALUES (‘Cherry’, 0.30, 150);
INSERT INTO products (name, price, stock) VALUES (‘Peach’, 1.80, 150);

— データを確認
SELECT * FROM products;
/
product_id|name |price|stock
———-|——|—–|—–
1 |Apple |1.2 |100
2 |Banana|0.5 |250
3 |Orange|0.8 |150
4 |Grape |3.5 |80
5 |Mango |2.8 |50
6 |Cherry|0.3 |150
7 |Peach |1.8 |150
/

— 複数カラムで並べ替え
SELECT *
FROM products
ORDER BY stock DESC, price ASC;
/
product_id|name |price|stock
———-|——|—–|—–
2 |Banana|0.5 |250 — 在庫 250 (最大)
6 |Cherry|0.3 |150 — 在庫 150, 価格 0.3 (最小)
3 |Orange|0.8 |150 — 在庫 150, 価格 0.8
7 |Peach |1.8 |150 — 在庫 150, 価格 1.8 (最大)
1 |Apple |1.2 |100 — 在庫 100
4 |Grape |3.5 |80 — 在庫 80
5 |Mango |2.8 |50 — 在庫 50 (最小)
/
``
結果を見ると、まず在庫数が多い順 (250 -> 150 -> 100 -> 80 -> 50) に並んでいます。在庫数が150の商品が3つありますが (Orange, Cherry, Peach)、これらは次に指定したprice ASC`に従って、価格の安い順 (Cherry: 0.3 -> Orange: 0.8 -> Peach: 1.8) に並んでいます。

このように、複数のカラムを指定することで、より細かく、意図した通りの順序でデータを並べ替えることができます。各カラムに対して、個別にASCまたはDESCを指定できる点も重要です。

並べ替えの対象：カラム名、位置、式

ORDER BY句では、単にカラム名を指定するだけでなく、いくつかの方法で並べ替えの基準を指定できます。

カラム名 (Column Name)

これが最も一般的で推奨される方法です。SELECT句で指定されているかどうかにかかわらず、テーブルに存在するカラムの名前を指定できます。

sql
SELECT name, price FROM products ORDER BY stock DESC; -- SELECT句にstockはないがORDER BYで使える
このクエリは、名前と価格だけを選択していますが、並べ替えは在庫数で行っています。

カラムのインデックス (Column Index)

SELECT句で指定したカラムの位置を数値で指定することも可能です。左端のカラムが1、その次が2、… となります。

sql
-- 価格の昇順に並べ替え (priceは2番目のカラム)
SELECT name, price, stock
FROM products
ORDER BY 2 ASC; -- price (2番目のカラム) で並べ替え
/*
name |price|stock
------|-----|-----
Banana|0.5 |250
Orange|0.8 |150
Apple |1.2 |100
Mango |2.8 |50
Grape |3.5 |80
Cherry|0.3 |150 -- あれ？CherryがBananaの次に来てしまった。
Peach |1.8 |150 -- PeachとOrangeもおかしい。
*/
あれ？価格の昇順にはなっていますが、先ほどの例と順序が違います。なぜでしょうか？

カラムインデックスでの指定は、SELECT句でのカラムの並び順に依存するという点に注意が必要です。先ほどの例では、SELECT name, price, stockとしていました。この場合、nameが1番目、priceが2番目、stockが3番目です。したがって、ORDER BY 2はpriceによる並べ替えを意味します。

一方、最初に使った例ではSELECT *を使っていました。*を使うと、テーブル定義時のカラムの並び順（またはデータベースが内部的に管理する順序）でカラムが展開されます。私たちのproductsテーブルはproduct_id, name, price, stockの順に定義しました。

sql
-- SELECT * でカラムの並び順を確認
SELECT * FROM products LIMIT 1;
/*
product_id|name |price|stock
----------|------|-----|-----
1 |Apple |1.2 |100
*/
-- product_id=1, name=2, price=3, stock=4 の順になっている！
したがって、SELECT * FROM products ORDER BY 3 ASC; は、priceによる並べ替えを意味します。

sql
-- SELECT * を使って、価格の昇順に並べ替え (priceは3番目のカラム)
SELECT *
FROM products
ORDER BY 3 ASC; -- price (3番目のカラム) で並べ替え
/*
product_id|name |price|stock
----------|------|-----|-----
6 |Cherry|0.3 |150
2 |Banana|0.5 |250
3 |Orange|0.8 |150
1 |Apple |1.2 |100
7 |Peach |1.8 |150
5 |Mango |2.8 |50
4 |Grape |3.5 |80
*/
今度は意図通り、価格の昇順になりました。

カラムインデックスでの指定は、SELECT句で計算結果などのエイリアスに名前を付けなかった場合に便利ですが、どのカラムが何番目に来るかはSELECT句の書き方に強く依存するため、クエリの可読性やメンテナンス性を低下させる可能性があります。 特にSELECT *を使う場合は、テーブル定義が変わると並べ替え順序が変わってしまうリスクもあります。

可読性と安全性を考慮すると、カラム名で指定する方法を強く推奨します。

式 (Expression)

カラムの値をそのまま使うのではなく、計算式や関数、あるいはCASE式などの評価結果に基づいて並べ替えることもできます。これは非常に強力な機能です。

例4：計算結果による並べ替え

例えば、商品の合計金額（価格 * 在庫数）の高い順に並べ替えたい場合。

sql
SELECT name, price, stock, price * stock AS total_value
FROM products
ORDER BY price * stock DESC; -- 計算結果で並べ替え
/*
name |price|stock|total_value
------|-----|-----|-----------
Banana|0.5 |250 |125.0
Apple |1.2 |100 |120.0
Grape |3.5 |80 |280.0 -- あれ？Greap (280) が一番上に来るはずでは？
Orange|0.8 |150 |120.0
Mango |2.8 |50 |140.0 -- Mango (140) もおかしい
Cherry|0.3 |150 |45.0
Peach |1.8 |150 |270.0 -- Peach (270) もおかしい
*/
結果が期待通りになりません。SQLiteでは、ORDER BY句で直接式を指定した場合、その式が評価されます。しかし、SELECT句で同じ式にエイリアスを付けている場合、ORDER BY句ではそのエイリアス名を指定することも可能です。そして、多くの場合、エイリアス名で指定する方が推奨されます。

例5：エイリアスを使った式による並べ替え

先ほどの合計金額の例で、SELECT句で計算結果にtotal_valueというエイリアスを付けました。ORDER BY句でこのエイリアス名を使用できます。

sql
SELECT name, price, stock, price * stock AS total_value
FROM products
ORDER BY total_value DESC; -- エイリアス名で並べ替え
/*
name |price|stock|total_value
------|-----|-----|-----------
Grape |3.5 |80 |280.0
Peach |1.8 |150 |270.0
Mango |2.8 |50 |140.0
Banana|0.5 |250 |125.0
Apple |1.2 |100 |120.0
Orange|0.8 |150 |120.0
Cherry|0.3 |150 |45.0
*/
今度は意図通り、合計金額の高い順に並びました。エイリアスを使った方が、クエリの意図が明確になり、可読性が向上します。

例6：関数を使った並べ替え

例えば、商品名の長さの短い順に並べ替えたい場合。SQLiteの文字列長関数であるLENGTH()を使用します。

sql
SELECT name, LENGTH(name) AS name_length
FROM products
ORDER BY name_length ASC; -- エイリアス名で並べ替え
/*
name |name_length
------|-----------
Apple |5
Grape |5
Mango |5
Peach |5
Banana|6
Orange|6
Cherry|6
*/
名前の長さが同じ場合は、元のテーブル順（おそらくproduct_id順）に並んでいます。もし名前の長さが同じ場合は名前のアルファベット順にしたい場合は、複数カラムでの並べ替えと同様に、ORDER BY LENGTH(name) ASC, name ASC または ORDER BY name_length ASC, name ASC と指定します。

sql
SELECT name, LENGTH(name) AS name_length
FROM products
ORDER BY name_length ASC, name ASC; -- 長さの昇順、次に名前の昇順
/*
name |name_length
------|-----------
Apple |5
Grape |5
Mango |5
Peach |5
Banana|6
Cherry|6
Orange|6
*/
これで、長さが同じ場合は名前のアルファベット順になりました。

式を使った並べ替えは非常に柔軟ですが、計算が必要になるため、パフォーマンスに影響を与える可能性があります。特に大きなテーブルに対して複雑な式で並べ替える場合は、注意が必要です（パフォーマンスのセクションで詳しく説明します）。

NULL値の並べ替え

NULLは「値がない」ことを示す特別なマーカーです。並べ替えにおいて、NULL値をどのように扱うかはデータベースシステムによって異なります。SQLiteは、NULL値を以下のように扱います。

• 昇順 (ASC): NULL値は最後に並べられます。
• 降順 (DESC): NULL値は最初に並べられます。

これは、多くの他のデータベースシステム（PostgreSQLなどではNULLは小さい値とみなされ昇順で先頭、MySQLでは昇順で先頭）と異なる可能性があるため、注意が必要です。

サンプルデータにNULL値を含むカラムを追加して確認しましょう。

“`sql
— 新しいカラム (expiry_date) を追加し、NULL値を含むデータを挿入
ALTER TABLE products ADD COLUMN expiry_date TEXT; — SQLiteではALTER TABLE ADD COLUMNは比較的制限が少ない

— いくつかの商品に有効期限を設定
UPDATE products SET expiry_date = ‘2023-12-31’ WHERE product_id IN (1, 3, 5);
UPDATE products SET expiry_date = ‘2024-06-15’ WHERE product_id = 2;
— 他の商品はexpiry_dateがNULLのまま

SELECT * FROM products;
/
product_id|name |price|stock|expiry_date
———-|——|—–|—–|———–
1 |Apple |1.2 |100 |2023-12-31
2 |Banana|0.5 |250 |2024-06-15
3 |Orange|0.8 |150 |2023-12-31
4 |Grape |3.5 |80 |
5 |Mango |2.8 |50 |2023-12-31
6 |Cherry|0.3 |150 |
7 |Peach |1.8 |150 |
/
``
Grape, Cherry, Peachのexpiry_date`がNULLです。

例7：NULLを含むカラムの昇順並べ替え

有効期限の古い順（昇順）に並べ替えます。

sql
SELECT name, expiry_date
FROM products
ORDER BY expiry_date ASC;
/*
name |expiry_date
------|-----------
Apple |2023-12-31 -- NULL以外の最小値
Orange|2023-12-31
Mango |2023-12-31
Banana|2024-06-15 -- NULL以外の最大値
Grape |
Cherry|
Peach |
*/
NULL値を持つGrape, Cherry, Peachがリストの最後に表示されています。SQLiteのデフォルトの挙動通り、昇順ではNULLは末尾に来ます。

例8：NULLを含むカラムの降順並べ替え

有効期限の新しい順（降順）に並べ替えます。

sql
SELECT name, expiry_date
FROM products
ORDER BY expiry_date DESC;
/*
name |expiry_date
------|-----------
Grape |
Cherry|
Peach |
Banana|2024-06-15 -- NULL以外の最大値
Apple |2023-12-31 -- NULL以外の最小値
Orange|2023-12-31
Mango |2023-12-31
*/
NULL値を持つGrape, Cherry, Peachがリストの最初に表示されています。SQLiteのデフォルトの挙動通り、降順ではNULLは先頭に来ます。

NULLS FIRST / NULLS LAST (SQLite 3.30.0以降)

SQLite 3.30.0 (2019-10-16) 以降のバージョンでは、NULL値の並べ替え順序を明示的に制御するために、NULLS FIRSTまたはNULLS LAST句を使用できます。これは標準SQLの一部であり、他の多くのデータベースシステムでもサポートされています。

構文は以下の通りです。

sql
ORDER BY column [ASC|DESC] [NULLS FIRST|NULLS LAST]

例9：昇順でNULL値を先頭に表示

有効期限の古い順に並べ替えたいが、有効期限が設定されていない商品（NULL）をリストの先頭に持ってきたい場合。

sql
SELECT name, expiry_date
FROM products
ORDER BY expiry_date ASC NULLS FIRST;
/*
name |expiry_date
------|-----------
Grape |
Cherry|
Peach |
Apple |2023-12-31 -- NULL以外の最小値
Orange|2023-12-31
Mango |2023-12-31
Banana|2024-06-15 -- NULL以外の最大値
*/
NULL値がリストの先頭に来て、それ以外の値は日付の古い順（昇順）に並んでいます。

例10：降順でNULL値を末尾に表示

有効期限の新しい順に並べ替えたいが、有効期限が設定されていない商品（NULL）をリストの末尾に持ってきたい場合。

sql
SELECT name, expiry_date
FROM products
ORDER BY expiry_date DESC NULLS LAST;
/*
name |expiry_date
------|-----------
Banana|2024-06-15 -- NULL以外の最大値
Apple |2023-12-31 -- NULL以外の最小値
Orange|2023-12-31
Mango |2023-12-31
Grape |
Cherry|
Peach |
*/
NULL値がリストの末尾に来て、それ以外の値は日付の新しい順（降順）に並んでいます。

NULLS FIRST / NULLS LAST はNULL値の並べ替え順序を明確に指定できるため、可読性が高く、データベースシステム間の互換性も高まります。SQLiteのバージョンが3.30.0以降であれば、積極的に利用することをお勧めします。

古いバージョンでの代替策 (CASE式)

もし使用しているSQLiteのバージョンが3.30.0より古い場合、NULLS FIRSTやNULLS LASTは使えません。その場合は、CASE式を使って同様の並べ替えを実現できます。

基本的な考え方は、「NULLであるかどうか」や「NULL以外の値」に基づいて、並べ替え用の「一時的な値」を生成し、その値で並べ替えるというものです。

• NULLS FIRSTを実現する場合（昇順/降順問わず）：NULLであるレコードに最も「小さい」並べ替え用の値を割り当てます。
• NULLS LASTを実現する場合（昇順/降順問わず）：NULLであるレコードに最も「大きい」並べ替え用の値を割り当てます。

例11：CASE式でNULLS FIRSTを実現 (古いバージョン向け)

有効期限の古い順に並べ替えたいが、有効期限がNULLの商品を先頭にしたい場合。

sql
SELECT name, expiry_date
FROM products
ORDER BY
CASE WHEN expiry_date IS NULL THEN 0 ELSE 1 END ASC, -- NULLなら0、それ以外なら1。ASCなので0が先頭に来る。
expiry_date ASC; -- 次に実際のexpiry_dateで昇順並べ替え
/*
name |expiry_date
------|-----------
Grape |
Cherry|
Peach |
Apple |2023-12-31
Orange|2023-12-31
Mango |2023-12-31
Banana|2024-06-15
*/
最初のCASE式は、expiry_dateがNULLなら0を、そうでなければ1を返します。これを昇順 (ASC) で並べると、0を持つレコード（つまりNULLのレコード）が先に、1を持つレコードが後に来ます。次に、expiry_date ASCで、NULL以外のレコードを実際の有効期限の昇順に並べます。これにより、NULLS FIRSTと同じ結果が得られます。

例12：CASE式でNULLS LASTを実現 (古いバージョン向け)

有効期限の新しい順に並べ替えたいが、有効期限がNULLの商品を末尾にしたい場合。

sql
SELECT name, expiry_date
FROM products
ORDER BY
CASE WHEN expiry_date IS NULL THEN 1 ELSE 0 END ASC, -- NULLなら1、それ以外なら0。ASCなので0が先頭に来る (NULL以外の値が先に来る)。
expiry_date DESC; -- 次に実際のexpiry_dateで降順並べ替え
/*
name |expiry_date
------|-----------
Banana|2024-06-15
Apple |2023-12-31
Orange|2023-12-31
Mango |2023-12-31
Grape |
Cherry|
Peach |
*/
最初のCASE式は、expiry_dateがNULLなら1を、そうでなければ0を返します。これを昇順 (ASC) で並べると、0を持つレコード（つまりNULL以外のレコード）が先に、1を持つレコードが後に来ます。次に、expiry_date DESCで、NULL以外のレコードを実際の有効期限の降順に並べます。これにより、NULLS LASTと同じ結果が得られます。

CASE式を使った方法は、古いバージョンでも利用できる汎用的なテクニックです。ただし、NULLS FIRST/NULLS LASTがある場合は、そちらを使う方が簡潔で意図も伝わりやすいです。

CASE式による条件付き並べ替え

前述のNULL値の扱いでも触れましたが、CASE式はORDER BY句の中で非常に強力なツールとなります。特定の条件に基づいて、レコードの並べ替え順序を細かく制御したい場合に利用します。

基本的なアイデアは、各レコードに対してCASE式で並べ替えの優先度や基準となる値を算出し、その値で並べ替えるというものです。

例13：特定の値を常に先頭に表示する

例えば、特定のproduct_idを持つ商品を、リストの最初に常に表示したい場合。product_idが4のGrapeを先頭に、それ以外の製品を価格の昇順に並べたいとします。

sql
SELECT name, product_id, price
FROM products
ORDER BY
CASE WHEN product_id = 4 THEN 0 ELSE 1 END ASC, -- product_idが4なら0、それ以外なら1。ASCなので0が先頭。
price ASC; -- 次に価格の昇順
/*
name |product_id|price
------|----------|-----
Grape |4 |3.5 -- product_id=4 が先頭に来た
Cherry|6 |0.3
Banana|2 |0.5
Orange|3 |0.8
Apple |1 |1.2
Peach |7 |1.8
Mango |5 |2.8
*/
product_idが4のGrapeが最初に表示され、それ以外の製品は価格の昇順に並んでいます。CASE WHEN product_id = 4 THEN 0 ELSE 1 ENDという式は、Grapeに対しては0を返し、それ以外の製品に対しては1を返します。この結果を昇順で並べると、0を持つGrapeが最も優先されて先頭に来ます。

例14：複数の条件で優先順位を制御する

例えば、「在庫が50以下の商品は警告が必要なので常に先頭に表示」し、「それ以外は在庫数の多い順」に並べたい場合。在庫が50以下の商品の中での順序は問わないとします（あるいは別の基準を指定できます）。

sql
SELECT name, stock
FROM products
ORDER BY
CASE WHEN stock <= 50 THEN 0 ELSE 1 END ASC, -- 在庫<=50なら0 (優先度高), それ以外なら1 (優先度低)。ASCなので0が先頭。
stock DESC; -- 優先度1のグループ内で在庫数の降順
/*
name |stock
------|-----
Mango |50 -- 在庫<=50 のグループ
Grape |80 -- 在庫>50 のグループ (在庫数の降順)
Apple |100
Orange|150
Cherry|150
Peach |150
Banana|250
*/
在庫が50のMangoが先頭に来ました。在庫が50超の商品は、在庫数の多い順に並んでいます。

このように、CASE式を使うことで、複雑なビジネスロジックに基づいた並べ替え順序を柔軟に定義できます。

SELECT句とORDER BY句の関係

再確認ですが、ORDER BY句で指定するカラムは、必ずしもSELECT句で取得するカラムに含まれている必要はありません。

sql
SELECT name, price
FROM products
ORDER BY stock DESC; -- stockはSELECT句にない
このクエリは問題なく実行され、名前と価格だけを表示しますが、その並び順は在庫数の降順になります。

また、SELECT句で計算した式にエイリアスを付けた場合、そのエイリアス名をORDER BY句で使うことができます。これは式による並べ替えのセクションで説明しました。

sql
SELECT name, price * stock AS total_value
FROM products
ORDER BY total_value DESC; -- total_valueはエイリアス
この機能は、SELECT句で複雑な計算を行い、その結果で並べ替えたい場合に非常に便利です。

LIMIT句とOFFSET句との組み合わせ

LIMIT句は取得するレコード数を制限し、OFFSET句はスキップするレコード数を指定します。これらの句はORDER BY句と組み合わせて使うことが非常に多いです。なぜなら、単に上位N件や特定の範囲のレコードを取得したい場合、まずデータを並べ替えてから、その並べ替えられた順序で指定範囲のレコードを取得する必要があるからです。

構文は以下の通りです。

sql
SELECT ...
FROM ...
ORDER BY ...
LIMIT count OFFSET skip;
または

sql
SELECT ...
FROM ...
ORDER BY ...
LIMIT count, skip; -- SQLiteではLIMITの引数をカンマ区切りで指定する記法もサポートされている。この場合、最初の数値がskip、2番目の数値がcountになる。LIMIT skip, count の順序なので注意。
多くの他のデータベースシステムとは異なり、SQLiteのLIMIT count, skip形式では、最初の引数がOFFSET (スキップする件数)、2番目の引数がLIMIT (取得する件数) となることに注意が必要です。可読性を考えると、LIMIT count OFFSET skipの形式を使う方が混乱しにくいかもしれません。

例15：価格の高い方から3つの商品を取得

sql
SELECT name, price
FROM products
ORDER BY price DESC -- 価格の降順に並べる
LIMIT 3; -- 上位3件を取得
/*
name |price
------|-----
Grape |3.5
Mango |2.8
Peach |1.8
*/

例16：価格の安い方から2番目から3件の商品を取得 (ページネーション)

最初の2件をスキップし、その次の3件を取得します。価格の安い順に並べ替えてから行います。

sql
SELECT name, price
FROM products
ORDER BY price ASC -- 価格の昇順に並べる
LIMIT 3 OFFSET 2; -- 最初の2件をスキップして、次の3件を取得
/*
name |price
------|-----
Orange|0.8
Apple |1.2
Peach |1.8 -- Peachが来ているのは、Cherry(0.3)とBanana(0.5)の次、Orange(0.8)とApple(1.2)の間だから
*/
価格の昇順のリスト: Cherry(0.3), Banana(0.5), Orange(0.8), Apple(1.2), Peach(1.8), Mango(2.8), Grape(3.5)
ここから最初の2件 (Cherry, Banana) をスキップし、続く3件 (Orange, Apple, Peach) を取得しています。

LIMITとOFFSETは、特にWebサイトやアプリケーションでデータのページネーション（1ページあたりN件表示し、前のページ・次のページへ移動する機能）を実装する際によく利用されます。正確なページネーションを実現するためには、必ずORDER BY句で明確な並べ替え順序を指定することが重要です。並べ替え順序が不定の場合、ページを移動するたびに同じレコードが表示されたり、特定のレコードがスキップされたりする可能性があります。

GROUP BY句との組み合わせ

GROUP BY句は、指定したカラムの値に基づいてレコードをグループ化し、通常はCOUNT(), SUM(), AVG(), MIN(), MAX()などの集約関数と組み合わせて、各グループに関する統計情報を取得します。

ORDER BY句は、このグループ化および集約された結果の行を並べ替えるために使用されます。

例17：カテゴリごとの商品の平均価格を高い順に表示

カテゴリ情報を格納するテーブルと、商品テーブルを結合して使用する例を考えます。

“`sql
— カテゴリテーブルの作成
CREATE TABLE categories (
category_id INTEGER PRIMARY KEY,
category_name TEXT NOT NULL UNIQUE
);

— カテゴリデータの挿入
INSERT INTO categories (category_name) VALUES (‘Fruit’);
INSERT INTO categories (category_name) VALUES (‘Vegetable’);
INSERT INTO categories (category_name) VALUES (‘Dairy’);

— productsテーブルにcategory_idカラムを追加
ALTER TABLE products ADD COLUMN category_id INTEGER REFERENCES categories(category_id);

— 各商品にカテゴリを設定
UPDATE products SET category_id = (SELECT category_id FROM categories WHERE category_name = ‘Fruit’) WHERE name IN (‘Apple’, ‘Banana’, ‘Orange’, ‘Grape’, ‘Mango’, ‘Cherry’, ‘Peach’);
— 製品によっては別のカテゴリを設定してもよいが、ここでは全てFruitとする（例をシンプルにするため）
— INSERT INTO products (name, price, stock, category_id) VALUES (‘Milk’, 1.50, 200, (SELECT category_id FROM categories WHERE category_name = ‘Dairy’));

SELECT p.name, c.category_name
FROM products p
JOIN categories c ON p.category_id = c.category_id;
/
name |category_name
——|————-
Apple |Fruit
Banana|Fruit
Orange|Fruit
Grape |Fruit
Mango |Fruit
Cherry|Fruit
Peach |Fruit
/

— カテゴリごとの平均価格を計算し、平均価格の高い順に並べ替え
SELECT c.category_name, AVG(p.price) AS avg_price
FROM products p
JOIN categories c ON p.category_id = c.category_id
GROUP BY c.category_name — カテゴリ名でグループ化
ORDER BY avg_price DESC; — 計算された平均価格で降順並べ替え
/
category_name|avg_price
————-|———
Fruit |1.5571428571428572
/
“`
この例では、全ての製品が’Fruit’カテゴリに属しているため、結果は1行だけになります。複数のカテゴリがあれば、各カテゴリの平均価格が計算され、その平均価格の高い順に並んで表示されます。

重要なのは、ORDER BY句で指定できるのは、GROUP BY句で指定したカラム (category_name)、または集約関数 (AVG(p.price)) の結果（エイリアス名 avg_priceを含む）であるということです。GROUP BY句を使用した場合、個々の非集約カラム（例: p.name, p.priceの元の値）をORDER BY句で直接指定することは、通常意味がありません（SQLiteでは許可される場合もありますが、結果の順序は保証されませんし、他のDBではエラーになります）。並べ替えは、グループ化された結果の「行」（つまり、各グループの集約結果）に対して行われます。

パフォーマンスに関する考慮事項

ORDER BY句は、クエリの結果を特定の順序に並べ替えるために、SQLiteに余分な作業を要求します。並べ替えは、クエリのパフォーマンスに大きな影響を与える可能性があります。特に、大量のデータを扱う場合や、応答時間が求められるアプリケーションでは、この影響を無視できません。

並べ替えのメカニズム

SQLiteは、並べ替えを実行するために、通常、以下のいずれかの方法を選択します。

1. インデックスの利用: ORDER BY句で指定されたカラムに適切なインデックスが存在する場合、SQLiteはそのインデックスを利用して、物理的に並べ替えられた順序でデータを読み出すことができます。これは最も高速な方法です。
2. ファイルソート (またはメモリソート): 適切なインデックスがない場合、SQLiteは取得したデータを一時的にメモリ上（メモリが足りなければディスク上の一時ファイル）に保持し、そこで並べ替えを行います。このプロセスを「ソート」と呼びます。データ量が多くなると、メモリやディスクへのアクセスが増加し、ソートにかかる時間が大幅に増加します。ディスクを使ったソートは特に低速です。

インデックスの重要性

ORDER BY句で使用されるカラムにインデックスを作成すると、パフォーマンスが劇的に向上する可能性があります。

例18：インデックス作成とクエリ実行計画の確認

productsテーブルのpriceカラムにインデックスを作成してみましょう。

sql
CREATE INDEX idx_products_price ON products (price);

インデックスを作成する前と後で、クエリの実行計画を比較してみます。SQLiteではEXPLAIN QUERY PLAN文を使って実行計画を確認できます。

インデックス作成前:

sql
EXPLAIN QUERY PLAN
SELECT * FROM products ORDER BY price ASC;
/*
addr|opcode |p1|p2|p3|p4 |p5|comment
----|--------------|--|--|--|------------------------|--|-------
1 |Scan |0 |0 |0 |TABLE products |0 |
11 |Sort |1 |0 |0 |k(price) |0 |
12 |ResultRow |4 |5 |0 | |0 |
13 |Goto |1 |0 |0 | |0 |
14 |End |0 |0 |0 | |0 |
*/
Sortというopcodeが表示されています。これは、SQLiteがデータを読み込んだ後にメモリ上または一時ファイル上で並べ替えを行うことを意味します。

インデックス作成後:

sql
EXPLAIN QUERY PLAN
SELECT * FROM products ORDER BY price ASC;
/*
addr|opcode |p1|p2|p3|p4 |p5|comment
----|--------------|--|--|--|---------------------------|--|-------
1 |OpenRead |0 |2 |0 |keyinfo(1,BINARY) |2 |
2 |Rewind |0 |12|0 | |0 |
3 |Column |0 |0 |0 | |0 |
4 |Column |0 |1 |0 | |0 |
5 |Column |0 |2 |0 | |0 |
6 |Column |0 |3 |0 | |0 |
7 |ResultRow |3 |4 |0 | |0 |
8 |Next |0 |3 |0 | |1 |
9 |Eof |0 |0 |0 | |0 |
10 |Close |0 |0 |0 | |0 |
11 |HaltPc |12|0 |0 | |0 |
12 |SetNumColumns |0 |4 |0 | |0 |
*/
Sort opcodeが消え、OpenReadとRewind/Next opcodeがインデックス (p2=2はおそらくインデックスに対応) を使ってテーブルをスキャンしていることを示しています。これは、インデックスの順序でデータが読み出されるため、別途ソートが必要ないことを意味します。

複合インデックスとORDER BY

複数のカラムで並べ替える場合、それらのカラムを含んだ複合インデックスが利用される可能性があります。ただし、インデックスの順序とORDER BY句で指定したカラムの順序や方向 (ASC/DESC) が一致している必要があります。

例えば、ORDER BY stock DESC, price ASCという並べ替えを行う場合、CREATE INDEX idx_products_stock_price ON products (stock DESC, price ASC); という複合インデックスがあれば、SQLiteはこれを利用してソートをスキップできる可能性があります。インデックスのカラム順序や方向がORDER BY句と異なると、インデックスが全く使われないか、部分的にしか使われない可能性があります。

インデックスが利用されにくいケース

以下のような場合、インデックスが使われず、ファイルソートが発生しやすいです。

• ORDER BY句でカラム名ではなくカラムインデックスを指定した場合 (SQLiteによっては利用されることもありますが、保証されませんし、エイリアスの場合はまず利用されません)。
• ORDER BY句で式や関数を指定した場合 (例: ORDER BY price * stock, ORDER BY LENGTH(name))。これらの結果はインデックスに格納されていないため、計算結果で並べ替えるにはソートが必要です。
• ORDER BY句で指定されたカラムが、既存の複合インデックスの先頭カラムではない場合、または複合インデックスの指定順序や方向と異なる場合。
• SELECT文にWHERE句があり、そのWHERE句の条件に合うレコードが非常に少ない場合。SQLiteはフルスキャンの方が効率的と判断することがあります。
• SELECT句で取得するカラムが多すぎる、あるいはサイズが大きい場合。並べ替えのために一時的に保持するデータ量が増大し、ファイルソートが発生しやすくなります。SELECT *は必要なカラムだけを取得するよりファイルソートを誘発しやすい傾向があります。

パフォーマンス改善のためのヒント

• ORDER BY句で頻繁に使用するカラムにはインデックスを作成することを検討しましょう。
• 複数カラムで並べ替える場合は、ORDER BY句のカラム順序と方向に合わせて複合インデックスを作成することを検討しましょう。
• 複雑な式で並べ替える場合は、並べ替えの必要がないようにデータを前処理したり、アプリケーション側で並べ替えを行ったりすることを検討するのも一つの手です。
• 本当に必要なカラムだけをSELECT句で取得しましょう。SELECT *を避けることで、一時ファイルソートの効率が改善する可能性があります。
• EXPLAIN QUERY PLANを使って、SQLiteがどのようにクエリを実行しているかを確認し、意図通りにインデックスが使われているか、不要なソートが発生していないかなどを確認する習慣をつけましょう。

パフォーマンスは、テーブルのサイズ、データの分布、クエリの複雑さ、実行環境など、多くの要因によって左右されます。ボトルネックとなっている箇所を特定するためには、実際の環境でクエリを実行し、そのパフォーマンスを測定することが重要です。

注意点とよくある間違い

ORDER BY句を使用する上で、いくつか注意すべき点や、陥りがちな間違いがあります。

1. 順序の不定性: ORDER BY句を指定しない場合、結果セットの順序は保証されません。開発中は特定の順序に見えても、運用環境では順序が変わる可能性があります。並べ替えが必要な場合は、必ず明示的にORDER BY句を使用しましょう。
2. 複数カラム並べ替えの優先順位: ORDER BY col1, col2のように複数指定した場合、まずcol1で並べ替えられ、col1の値が同じレコード群に対してのみcol2で並べ替えが行われます。この優先順位を正しく理解しておくことが重要です。
3. NULL値の並べ替え順序: SQLiteのデフォルトのNULL値の順序（昇順で末尾、降順で先頭）は、他のデータベースシステムと異なる場合があります。互換性が必要な場合や、特定の順序にしたい場合は、NULLS FIRST/NULLS LASTまたはCASE式を使用しましょう。
4. カラムインデックスの使用: ORDER BY句でカラムインデックスを使用すると、SELECT句のカラム順序に依存してしまい、クエリの可読性やメンテナンス性が低下します。できる限りカラム名を使用しましょう。
5. パフォーマンスへの影響: 大量データをORDER BYで並べ替える際には、インデックスの利用やEXPLAIN QUERY PLANでの確認など、パフォーマンスへの配慮が不可欠です。
6. 大文字・小文字の区別: SQLiteはデフォルトでは文字列の比較において大文字・小文字を区別しません ('apple'と'Apple'は同じとみなされる)。ただし、データベースやカラムのcollation設定によっては区別される場合もあります。文字列による並べ替えの際に、期待する順序にならない場合はcollationの設定を確認してください。必要であれば、ORDER BY COLLATE NOCASE（区別しない）や特定のcollation名を指定することで、並べ替え時の比較方法を制御できます。
7. データ型の違い: 異なるデータ型のカラムを混在させて並べ替えることは通常ありませんが、型変換が行われる場合は予期しない結果になる可能性があります。例えば、数値として格納されているがTEXT型になっているカラムを数値として並べ替えたい場合は、CAST関数を使うなど、明示的な型変換が必要になることがあります (ORDER BY CAST(price_text AS REAL))。

これらの注意点を理解しておけば、ORDER BY句をより効果的かつ安全に利用できます。

応用例

これまでに説明した基本やテクニックを組み合わせることで、さまざまな並べ替えの要件に対応できます。

例19：最新のN件を取得する

タイムスタンプや日付カラムを使って、最新のレコードを簡単に取得できます。

sql
-- orders テーブルの例
-- CREATE TABLE orders (order_id INTEGER PRIMARY KEY, order_date TEXT, total_amount REAL);
-- INSERT ...
SELECT order_id, order_date, total_amount
FROM orders
ORDER BY order_date DESC -- 日付の新しい順
LIMIT 10; -- 最新の10件

例20：ランキング表示

点数やスコアなどの数値に基づいて、上位から並べ替えるのはランキング表示の基本です。

sql
-- scores テーブルの例
-- CREATE TABLE scores (player_id INTEGER, score INTEGER);
-- INSERT ...
SELECT player_id, score
FROM scores
ORDER BY score DESC -- スコアの高い順
LIMIT 50; -- トップ50を表示
同点の場合の順序を定義したい場合は、次に別のカラム（例えばplayer_idや達成タイムなど）を指定して並べ替えればよいでしょう。

sql
SELECT player_id, score, achievement_time
FROM scores
ORDER BY score DESC, achievement_time ASC; -- スコアの高い順、同点なら達成タイムの早い順

例21：複数の並べ替え基準を動的に切り替える (アプリケーション側)

アプリケーション開発において、ユーザーが「名前順」「価格順」「新着順」などを選択できるようにしたい場合があります。この場合、アプリケーションコード側でユーザーの選択に応じてORDER BY句の内容を動的に生成します。

“`sql
— アプリケーションコードの例 (Python)
sort_key = user_selection # 例: ‘name_asc’, ‘price_desc’, ‘date_asc’

if sort_key == ‘name_asc’:
order_by_clause = ‘ORDER BY name ASC’
elif sort_key == ‘price_desc’:
order_by_clause = ‘ORDER BY price DESC’

… 他のケース …

else: # デフォルト
order_by_clause = ‘ORDER BY product_id ASC’ # あるいは任意

sql = f”SELECT product_id, name, price FROM products {order_by_clause};”
— 生成されたSQLを実行
``
このように、アプリケーション側でORDER BY`句を組み立てることで、柔軟な並べ替え機能を提供できます。この際、SQLインジェクションを防ぐために、ユーザー入力を直接SQL文字列に結合するのではなく、ホワイトリスト方式で許可されたカラム名と方向のみを使用するなどの対策が必要です。

まとめ

SQLiteのORDER BY句は、データベースから取得したデータを人間が理解しやすい論理的な順序に並べ替えるために不可欠な機能です。この記事では、ORDER BY句の基本から応用まで、以下の内容を詳しく解説しました。

• 基本的な構文: ORDER BY column [ASC|DESC]。デフォルトはASCです。
• 単一・複数カラムでの並べ替え: 複数のカラムをカンマ区切りで指定することで、優先順位を付けて並べ替えできます。
• 並べ替えの基準: カラム名、カラムインデックス、そして式（計算結果や関数、エイリアスを含む）を指定できます。カラム名とエイリアスによる指定が推奨されます。
• NULL値の扱い: SQLiteではデフォルトで昇順で末尾、降順で先頭に来ます。SQLite 3.30.0以降ではNULLS FIRST/NULLS LASTで明示的な制御が可能、古いバージョンではCASE式で代替できます。
• CASE式による条件付き並べ替え: 複雑な条件や特定の値を優先させるなど、柔軟な並べ替え順序を定義できます。
• 他の句との組み合わせ: LIMIT/OFFSETを使ったページネーション、GROUP BYを使った集約結果の並べ替えなどを紹介しました。正確な結果を得るためには、これらの句とORDER BYを適切に組み合わせることが重要です。
• パフォーマンス: ORDER BY句はパフォーマンスに大きな影響を与える可能性があります。インデックスの利用が最も効果的な改善策であり、EXPLAIN QUERY PLANを使って実行計画を確認する習慣をつけましょう。

ORDER BY句を使いこなすことで、SQLiteデータベースから取得するデータの表示方法を自在に制御し、アプリケーションのユーザビリティを大幅に向上させることができます。今回学んだ知識を活かして、ぜひ実際の開発で役立ててください。

次に学ぶべきこととしては、インデックスの詳細な設計方法や、より高度なクエリ最適化のテクニックなどがあります。これらを習得することで、大規模なデータや複雑な要件に対しても、効率的かつ信頼性の高いデータベース処理を実現できるようになるでしょう。