SQLite CASE: WHEN, THEN, ELSE und IIF erklärt

CASE ist das If/Else von SQL

Mit CASE bringst du Bedingungslogik direkt in deine Abfrage. SQLite arbeitet die WHEN-Zweige der Reihe nach ab, nimmt den ersten passenden Treffer und gibt den Wert hinter THEN zurück. Passt nichts, kommt der ELSE-Wert zurück – oder NULL, falls du keinen angegeben hast.

Wichtig ist hier das Wort Ausdruck. CASE liefert einen Wert und darf deshalb überall stehen, wo ein Wert erlaubt ist: als Spalte im SELECT, als Sortierschlüssel im ORDER BY, auf der rechten Seite eines Vergleichs oder als Argument einer Funktion.

SELECT
    'Apfel' AS item,
    CASE
        WHEN 5 > 3 THEN 'ja'
        ELSE 'nein'
    END AS bigger;

Mehr steckt nicht dahinter: CASE, ein oder mehrere WHEN ... THEN ..., optional ein ELSE, am Ende END. Das END ist Pflicht – es zu vergessen ist der absolute Klassiker unter den Tippfehlern.

Ein praxisnahes Beispiel

Angenommen, du hast eine Bestelltabelle und möchtest jede Zeile nach Größe einordnen. Bauen wir uns dafür schnell eine kleine Tabelle direkt im Query, damit du es selbst ausprobieren kannst:

WITH orders(id, total) AS (
    VALUES
        (1, 12.00),
        (2, 89.50),
        (3, 250.00),
        (4, 5.25),
        (5, 1200.00)
)
SELECT
    id,
    total,
    CASE
        WHEN total < 10 THEN 'winzig'
        WHEN total < 100 THEN 'klein'
        WHEN total < 500 THEN 'mittel'
        ELSE 'groß'
    END AS size_bucket
FROM orders;

Die Verzweigungen werden von oben nach unten geprüft. Der erste Treffer gewinnt – ordne sie also vom Speziellsten zum Allgemeinsten an. Das ELSE fängt alles ab, was vorher nicht gepasst hat. Lässt du es weg, käme bei 1200.00 ein NULL zurück statt 'groß'.

Searched CASE vs. Simple CASE

Was du oben gesehen hast, ist die searched-Variante: jedes WHEN hat seine eigene boolesche Bedingung. Wenn du allerdings nur einen Ausdruck mit mehreren festen Werten vergleichen willst, gibt es eine kürzere Schreibweise – die simple-Variante:

WITH users(id, status) AS (
    VALUES
        (1, 'A'),
        (2, 'B'),
        (3, 'C'),
        (4, 'A')
)
SELECT
    id,
    status,
    CASE status
        WHEN 'A' THEN 'aktiv'
        WHEN 'B' THEN 'gesperrt'
        WHEN 'C' THEN 'geschlossen'
        ELSE 'unbekannt'
    END AS status_label
FROM users;

Der Ausdruck nach CASE wird einmal ausgewertet und per = mit jedem WHEN-Wert verglichen. Übersichtlicher, wenn du einfache Gleichheitsprüfungen auf einer einzelnen Spalte machst.

Ein Stolperstein: Das einfache CASE arbeitet mit =, und NULL = NULL ist in SQL nicht wahr. Falls status auch NULL sein kann, greifen die Zweige für 'A', 'B' und 'C' nicht – du landest im ELSE. Um NULL sauber abzufangen, nimmst du die searched-Variante mit WHEN status IS NULL THEN ....

CASE in ORDER BY

ORDER BY akzeptiert beliebige Ausdrücke, also funktioniert CASE auch dort problemlos. Praktisch, wenn du eine eigene Sortierreihenfolge brauchst, die weder alphabetisch noch numerisch passt:

WITH tickets(id, priority) AS (
    VALUES
        (1, 'low'),
        (2, 'high'),
        (3, 'medium'),
        (4, 'high'),
        (5, 'low')
)
SELECT id, priority
FROM tickets
ORDER BY
    CASE priority
        WHEN 'high' THEN 1
        WHEN 'medium' THEN 2
        WHEN 'low' THEN 3
    END,
    id;

'high' < 'low' < 'medium' – alphabetisch sortiert ergibt das für eine Triage natürlich keinen Sinn. Wenn du jede Priorität per CASE auf eine Zahl abbildest, bekommst du genau die Reihenfolge, die du wirklich willst. Das angehängte , id sorgt dafür, dass gleichrangige Einträge stabil sortiert werden.

CASE in WHERE verwenden

Du kannst CASE auch in der WHERE-Klausel einsetzen, brauchst es dort aber meistens gar nicht – verkettete AND/OR-Ausdrücke sind in der Regel übersichtlicher. So richtig auszahlen tut sich CASE hier erst dann, wenn die Bedingung selbst von einem anderen Wert abhängt:

WITH products(id, name, price, on_sale) AS (
    VALUES
        (1, 'Tasse', 12.00, 1),
        (2, 'Hemd', 25.00, 0),
        (3, 'Mütze', 18.00, 1),
        (4, 'Tasche', 45.00, 0)
)
SELECT id, name, price
FROM products
WHERE price < CASE WHEN on_sale = 1 THEN 20 ELSE 30 END;

Sale-Artikel zählen unter 20, normale Artikel unter 30. Die Schwelle selbst hängt also von einer Bedingung ab. Ohne CASE müsstest du (on_sale = 1 AND price < 20) OR (on_sale = 0 AND price < 30) schreiben — gleiches Ergebnis, aber deutlich mehr Rauschen.

CASE in Aggregatfunktionen

Hier zeigt CASE seine wahre Stärke. Kombiniert mit SUM oder COUNT kannst du Summen über eine Teilmenge der Zeilen in einem einzigen Durchlauf berechnen — das SQL-Pendant zu „Wie viele davon passen auf die Bedingung?":

WITH orders(id, total, status) AS (
    VALUES
        (1, 50.00, 'paid'),
        (2, 30.00, 'pending'),
        (3, 75.00, 'paid'),
        (4, 20.00, 'cancelled'),
        (5, 100.00, 'paid')
)
SELECT
    COUNT(*) AS all_orders,
    SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) AS paid_count,
    SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid_revenue
FROM orders;

Das CASE liefert 1 für passende Zeilen und sonst 0 – aus SUM wird also eine bedingte Zählung. Derselbe Trick funktioniert auch für den Umsatz: Auf den passenden Zeilen total zurückgeben, sonst überall 0. Ein einziger Tabellendurchlauf, mehrere bedingte Aggregate gleichzeitig.

IIF: die Kurzform für zwei Zweige

Wenn du nur eine Bedingung mit zwei möglichen Ergebnissen hast, bietet SQLite IIF(cond, when_true, when_false) an. Das ist reine Kurzschreibweise für CASE WHEN cond THEN when_true ELSE when_false END:

WITH accounts(id, balance) AS (
    VALUES
        (1, 100.00),
        (2, -25.00),
        (3, 0.00),
        (4, 1500.00)
)
SELECT
    id,
    balance,
    IIF(balance < 0, 'überzogen', 'ok') AS state
FROM accounts;

IIF ist die richtige Wahl, wenn die Logik binär ist und sich als Einzeiler besser liest. Sobald du drei oder mehr Verzweigungen hast, NULL gesondert behandeln musst oder die Reihenfolge mehrerer WHEN-Klauseln nutzen willst, greifst du zu CASE.

Stolperfallen, die du kennen solltest

Ein paar Dinge, über die viele stolpern:

• END vergessen. CASE öffnet einen Block, END schließt ihn. SQLite wirft dir einen Parse-Fehler oft erst lange nach der eigentlichen Fehlerstelle um die Ohren.
• Ohne ELSE gibt's NULL. Trifft keiner deiner WHEN-Zweige zu und du hast ELSE weggelassen, ist das Ergebnis NULL. Manchmal genau das, was du willst – meistens aber nicht.
• Die Reihenfolge der Zweige zählt. Beim searched CASE gewinnt der erste passende WHEN. Schreibst du WHEN total < 500 vor WHEN total < 100, ist der zweite Zweig schlicht nicht erreichbar.
• Typen-Mix. Jeder Zweig kann einen anderen Typ zurückgeben, und SQLite meckert nicht – aber der Code drumherum vielleicht schon. Halte die Rückgabetypen besser kompatibel (alles Text oder alles numerisch).
• Simple CASE und NULL. Wie schon erwähnt: Die einfache Form vergleicht mit =, und das matcht nie auf NULL. Sobald Nulls im Spiel sind, nimm die searched-Variante.

Als Nächstes: String-Funktionen

Mit CASE verzweigst du auf Werten; im nächsten Kapitel geht es ums Transformieren von Werten. String-Funktionen – UPPER, LOWER, SUBSTR, REPLACE, LIKE-Muster – erledigen die alltägliche Arbeit beim Säubern und Umformatieren von Textspalten. Geht's gleich los.