SQLite ORDER BY: Sortieren mit ASC, DESC & mehreren Spalten

Ohne ORDER BY ist die Zeilenreihenfolge undefiniert

Ein SELECT ohne ORDER BY liefert die Zeilen in der Reihenfolge zurück, die SQLite gerade am bequemsten ist. Auf kleinen Tabellen sieht das oft nach Einfügereihenfolge aus – und genau das verleitet viele dazu, sich darauf zu verlassen. Tu das nicht. Sobald ein Index ins Spiel kommt, die Tabelle wächst oder sich der Abfrageplan ändert, kann sich diese Reihenfolge ohne Vorwarnung verschieben.

Wenn dir die Reihenfolge der Zeilen wichtig ist, dann sag das auch explizit – mit SQLite sortieren per ORDER BY:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    country TEXT,
    signup_date TEXT
);

INSERT INTO users (name, country, signup_date) VALUES
    ('Boris', 'FR', '2024-03-12'),
    ('Ada',   'US', '2024-01-05'),
    ('Rosa',  'FR', '2024-02-20'),
    ('Chen',  'US', '2024-03-01');

SELECT name, country FROM users ORDER BY name;

ORDER BY name sortiert standardmäßig aufsteigend. Das Ergebnis kommt also als Ada, Boris, Chen, Rosa zurück – sauber alphabetisch, unabhängig davon, in welcher Reihenfolge die Zeilen physisch in der Datei liegen.

ASC und DESC: aufsteigend oder absteigend sortieren

ASC steht für aufsteigend (vom kleinsten zum größten Wert, A bis Z, alt nach neu). DESC ist das Gegenteil und sortiert absteigend. Da ASC der Standard ist, lässt man es in der Praxis fast immer weg:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    signup_date TEXT
);

INSERT INTO users (name, signup_date) VALUES
    ('Boris', '2024-03-12'),
    ('Ada',   '2024-01-05'),
    ('Rosa',  '2024-02-20'),
    ('Chen',  '2024-03-01');

SELECT name, signup_date FROM users ORDER BY signup_date DESC;

Damit bekommst du die neuesten Anmeldungen zuerst. Daten, die als ISO-8601-Strings (YYYY-MM-DD) gespeichert sind, lassen sich problemlos als Text sortieren – genau deshalb ist dieses Format in SQLite die erste Wahl für Datumsspalten, denn einen eigenen Datumstyp gibt es hier ja nicht.

SQLite ORDER BY mit mehreren Spalten

Wenn die erste Sortierspalte gleiche Werte enthält, zieht SQLite die zweite Spalte heran, um die Reihenfolge zu bestimmen. Dafür gibst du die Spalten einfach kommagetrennt an – in der Reihenfolge ihrer Priorität:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    country TEXT
);

INSERT INTO users (name, country) VALUES
    ('Boris', 'FR'),
    ('Ada',   'US'),
    ('Rosa',  'FR'),
    ('Chen',  'US');

SELECT name, country FROM users ORDER BY country, name;

Die Zeilen werden zunächst nach Land gruppiert (FR vor US) und innerhalb jedes Landes nach Name sortiert. Dabei kann jede Spalte ihre eigene Sortierrichtung haben:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    country TEXT,
    signup_date TEXT
);

INSERT INTO users (name, country, signup_date) VALUES
    ('Boris', 'FR', '2024-03-12'),
    ('Ada',   'US', '2024-01-05'),
    ('Rosa',  'FR', '2024-02-20'),
    ('Chen',  'US', '2024-03-01');

SELECT name, country, signup_date
FROM users
ORDER BY country ASC, signup_date DESC;

Land aufsteigend, innerhalb jedes Landes dann die neuesten Einträge zuerst. Wichtig: ASC und DESC gelten jeweils nur für die Spalte direkt davor — sie wirken nicht automatisch auf die nächste mit.

Sortieren nach Ausdrücken und Aliasen

In ORDER BY darfst du jeden beliebigen Ausdruck verwenden, nicht nur Spaltennamen. Praktisch ist das vor allem für berechnete Werte:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    quantity INTEGER
);

INSERT INTO products (name, price, quantity) VALUES
    ('Notizbuch', 4.50, 30),
    ('Stift',     1.20, 100),
    ('Lampe',    25.00, 5);

SELECT name, price * quantity AS revenue
FROM products
ORDER BY revenue DESC;

Den Alias revenue aus der SELECT-Liste darfst du im ORDER BY problemlos verwenden. Genauso gut kannst du den Ausdruck noch einmal ausschreiben — ORDER BY price * quantity DESC — das Ergebnis ist identisch.

Sortieren über die Spaltenposition geht ebenfalls, ist aber eine Angewohnheit, die du dir besser abgewöhnst:

SELECT name, price FROM products ORDER BY 2 DESC;

2 steht hier für die zweite Spalte in der SELECT-Liste. Funktioniert zwar, aber sobald jemand später die Spalten umsortiert, ändert sich klammheimlich die Bedeutung der Sortierung. Sortiere lieber nach Spaltenname oder Alias.

Wo NULL-Werte landen

NULL bedeutet "unbekannt", und SQLite muss entscheiden, wohin solche unbekannten Werte beim Sortieren gehören. Die Standardregel: NULL-Werte stehen bei ASC ganz oben, bei DESC ganz unten.

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    signup_date TEXT
);

INSERT INTO users (name, signup_date) VALUES
    ('Boris', '2024-03-12'),
    ('Ada',   NULL),
    ('Rosa',  '2024-02-20'),
    ('Chen',  NULL);

SELECT name, signup_date FROM users ORDER BY signup_date;

Ada und Chen tauchen oben auf, noch vor jedem echten Datum. Das ist beim Sortieren nach „neueste zuerst" praktisch nie das, was du willst. Mit NULLS LAST drehst du das Verhalten um:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    signup_date TEXT
);

INSERT INTO users (name, signup_date) VALUES
    ('Boris', '2024-03-12'),
    ('Ada',   NULL),
    ('Rosa',  '2024-02-20'),
    ('Chen',  NULL);

SELECT name, signup_date FROM users
ORDER BY signup_date DESC NULLS LAST;

Jetzt stehen echte Datumswerte vorn und die NULLs landen am Ende. NULLS FIRST macht genau das Gegenteil. Beides ist Teil des SQL-Standards und funktioniert ab SQLite 3.30.

Groß-/Kleinschreibung ignorieren mit COLLATE NOCASE

Standardmäßig vergleicht SQLite Texte binär – sortiert wird also anhand der Unicode-Codepoints. Das führt dazu, dass Großbuchstaben vor Kleinbuchstaben einsortiert werden und 'Zoe' somit vor 'apple' landet:

CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);

INSERT INTO users (name) VALUES ('apple'), ('Zoe'), ('Boris'), ('ada');

SELECT name FROM users ORDER BY name;

Das Ergebnis lautet ada, Boris, Zoe, apple (actual binary sort: Boris, Zoe, ada, apple) – erst die Großbuchstaben, danach die Kleinbuchstaben. Wer stattdessen case insensitive sortieren möchte, hängt einfach die Collation NOCASE an:

CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);

INSERT INTO users (name) VALUES ('apple'), ('Zoe'), ('Boris'), ('ada');

SELECT name FROM users ORDER BY name COLLATE NOCASE;

Das Ergebnis ist nun ada, apple, Boris, Zoe. NOCASE behandelt allerdings nur die ASCII-Buchstaben A–Z und a–z als gleichwertig – Akzente oder Zeichen außerhalb von ASCII werden nicht normalisiert. Für eine echte internationale Sortierung müsstest du eine eigene Collation auf Anwendungsebene definieren. Für typische englische Texte reicht NOCASE aber völlig aus.

Zufällige Reihenfolge mit SQLite ORDER BY RANDOM

Manchmal möchtest du Zeilen in zufälliger Reihenfolge ausgeben – etwa für ein "Tipp des Tages"-Feature oder um Stichproben für Tests zu ziehen. Dafür liefert dir die SQLite-Funktion random() eine zufällige Ganzzahl, nach der du dann sortieren kannst:

CREATE TABLE quotes (id INTEGER PRIMARY KEY, text TEXT);

INSERT INTO quotes (text) VALUES
    ('Erst funktionierend, dann richtig, dann schnell.'),
    ('Verfrühte Optimierung ist die Wurzel allen Übels.'),
    ('Einfach ist besser als kompliziert.'),
    ('Lesbarkeit zählt.');

SELECT text FROM quotes ORDER BY random() LIMIT 1;

Jede Zeile bekommt einen frischen Zufallswert, und nach diesem wird sortiert. Für kleine Tabellen völlig okay. Bei großen Tabellen ist ORDER BY random() allerdings lahm – SQLite muss für jede einzelne Zeile einen Zufallswert berechnen und das komplette Ergebnis sortieren. Wenn du nur eine zufällige Zeile aus einer riesigen Tabelle ziehen willst, sind clevere Tricks (z. B. eine zufällige rowid auswählen) deutlich schneller.

Typische Stolperfallen

Ein paar Dinge, über die viele stolpern:

• ORDER BY weglassen und auf eine bestimmte Reihenfolge hoffen. Ohne ORDER BY ist die Reihenfolge schlicht undefiniert. Selbst wenn sie stabil aussieht, ist sie es nicht.
• Zahlen sortieren, die als Text gespeichert sind. Lexikografisch steht '10' vor '2'. Wenn eine Spalte numerisch sortiert werden soll, speichere sie mit einer numerischen Affinität – oder caste explizit: ORDER BY CAST(value AS INTEGER).
• ASC und DESC über mehrere Spalten vermischen. Jede Spalte hat ihre eigene Richtung. ORDER BY a, b DESC sortiert a aufsteigend und b absteigend, nicht etwa beide absteigend.
• Riesige Ergebnismengen sortieren, nur um die ersten paar Zeilen zu nehmen. Kombiniere ORDER BY mit LIMIT und lege einen Index auf die Sortierspalte – mehr dazu im nächsten Kapitel.

Als Nächstes: LIMIT und OFFSET

ORDER BY sagt SQLite, wie die Zeilen anzuordnen sind; LIMIT und OFFSET legen fest, wie viele zurückkommen und wo angefangen wird. Zusammen bilden sie das Herzstück von Pagination und „Top N"-Abfragen – schauen wir uns das gleich an.