Die meisten Berichte erfordern eine gewisse Logik: Kennzeichnen Sie Bestellungen als groß oder klein, zählen Sie bezahlte und ausstehende Bestellungen nebeneinander oder zeigen Sie dringende Artikel zuerst an. SQL CASE WHEN verarbeitet all dies direkt in einer Abfrage und funktioniert in allen wichtigen Datenbanken.

Wir haben jede Abfrage hier in SQLite 3.50 ausgeführt und die angezeigten Ergebnisse stammen aus diesem Lauf. CASE ist Teil von Standard-SQL und verhält sich daher in diesen Beispielen in PostgreSQL, MySQL, SQL Server und Oracle gleich.

Was ist CASE WANN?

CASE ist ein Ausdruck, kein separater Befehl. Es wertet Bedingungen der Reihe nach aus und gibt einen Wert zurück, sodass es überall dort eingesetzt werden kann, wo ein Wert zulässig ist: in SELECT, WHERE, GROUP BY, ORDER BY oder innerhalb von Funktionen. Es endet immer mit END.

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  ELSE fallback
END

Die Beispieltabelle

CREATE TABLE orders (id INT, customer TEXT, total INT, status TEXT);

INSERT INTO orders VALUES
 (1,'Asha',1200,'paid'), (2,'Ben',300,'pending'),
 (3,'Asha',800,'paid'), (4,'Chitra',2500,'shipped'),
 (5,'Dev',150,'cancelled'), (6,'Ben',NULL,'pending');

Beachten Sie, dass Bestellung 6 keine Gesamtsumme hat. Diese Reihe ist später wichtig.

Gesucht CASE

Dies ist die flexiblere Form, da jedes WHEN eine eigene vollständige Bedingung hat:

SELECT id, total,
       CASE
         WHEN total >= 1000 THEN 'large'
         WHEN total >= 500 THEN 'medium'
         ELSE 'small'
       END AS size
FROM orders;

-- 1 | 1200 | large
-- 2 |  300 | small
-- 3 |  800 | medium
-- 4 | 2500 | large
-- 5 |  150 | small
-- 6 | NULL | small

Schauen Sie sich die letzte Reihe an. Bestellung 6 hat keine Gesamtsumme, ist aber mit „klein“ gekennzeichnet. Beide Vergleiche mit NULL waren nicht wahr, daher scheiterte es an ELSE. Im NULL-Abschnitt zeigen wir, wie man das behebt. Geben Sie dem Ergebnis immer einen Namen mit AS, sonst erhalten Sie möglicherweise einen umständlichen Spaltennamen.

Einfacher Fall

Wenn Sie eine Spalte mit festen Werten vergleichen, liest sich die kürzere Form besser:

SELECT id,
       CASE status
         WHEN 'paid' THEN 'Complete'
         WHEN 'shipped' THEN 'Complete'
         WHEN 'pending' THEN 'Waiting'
       END AS label
FROM orders;

-- 1 | Complete
-- 2 | Waiting
-- 3 | Complete
-- 4 | Complete
-- 5 | NULL
-- 6 | Waiting

Ordnung ist wichtig

CASE stoppt bei der ersten wahren Bedingung, und dies ist der häufigste Logikfehler. Vertauschen Sie die beiden Bedingungen aus unserer früheren Abfrage:

SELECT id, total,
       CASE
         WHEN total >= 500 THEN 'medium'
         WHEN total >= 1000 THEN 'large'
         ELSE 'small'
       END AS size
FROM orders WHERE id IN (1, 4);

-- 1 | 1200 | medium
-- 4 | 2500 | medium

Jetzt kann nichts mehr „groß“ sein. Insgesamt sind 2500 auch mindestens 500, der erste Zweig gewinnt also und der zweite wird nie erreicht. Es erscheint kein Fehler, nur falsche Beschriftungen. Stellen Sie bei Bereichen die restriktivste Bedingung an die erste Stelle oder schreiben Sie vollständige Bereiche, z. B. total >= 500 AND total < 1000.

Was passiert ohne ELSE?

In unserem einfachen CASE-Beispiel oben wurde Auftrag 5 storniert und keine Filiale hat dies bearbeitet, sodass das Ergebnis NULL war. Manchmal ist es genau das, was Sie wollen, wie der nächste Abschnitt zeigt. Bei der Erstellung von Beschriftungen ist Clear ELSE 'other' jedoch in der Regel besser, da dadurch unerwartete Werte sichtbar gemacht werden, anstatt Leerzeichen in einem Bericht zu hinterlassen.

Pivot-Berichte mit SUM

Dies ist eines der nützlichsten Muster im alltäglichen SQL. Durch das Einschließen von CASE in ein Aggregat werden Zeilen in Spalten umgewandelt, mit einer Zeile pro Kunde:

SELECT customer,
       SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid,
       SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_orders
FROM orders
GROUP BY customer
ORDER BY customer;

-- Asha   | 2000 | 0
-- Ben    |    0 | 2
-- Chitra |    0 | 0
-- Dev    |    0 | 0

Eine Abfrage liefert jetzt sowohl den bezahlten Umsatz als auch die Anzahl der ausstehenden Bestellungen, ohne dass separate Abfragen oder Verknüpfungen erforderlich sind. Das Muster funktioniert in fast jeder Datenbank, im Gegensatz zur dedizierten PIVOT-Syntax, die nur einige anbieten. Wenn GROUP BY für Sie neu ist, lesen Sie SQL GROUP BY und HAVING.

Bedingte Zählungen

COUNT überspringt NULL-Werte, sodass ein CASE ohne ELSE nur die Zeilen zählt, die übereinstimmen:

SELECT COUNT(*) AS all_orders,
       COUNT(CASE WHEN status = 'paid' THEN 1 END) AS paid_orders,
       COUNT(CASE WHEN total >= 1000 THEN 1 END) AS large_orders
FROM orders;

-- 6 | 2 | 2

Seien Sie vorsichtig: Wenn Sie ELSE 0 innerhalb einer COUNT hinzufügen, wird jede Zeile gezählt, da 0 nicht NULL ist. Verwenden Sie ELSE 0 mit SUM und lassen Sie es mit COUNT weg. PostgreSQL und SQLite unterstützen auch COUNT(*) FILTER (WHERE ...), was sich gut liest, aber nicht überall verfügbar ist.

Gruppierung nach einem CASE

Sie können Ihre eigenen Buckets erstellen und diese dann zusammenfassen:

SELECT CASE WHEN total >= 1000 THEN 'large' ELSE 'other' END AS bucket,
       COUNT(*)
FROM orders
GROUP BY bucket
ORDER BY bucket;

-- large | 2
-- other | 4

Die Gruppierung nach dem Alias funktioniert in SQLite, PostgreSQL und MySQL. SQL Server lässt dies nicht zu, daher müssten Sie den gesamten Ausdruck wiederholen oder die Abfrage zuerst in einen CTE oder eine Unterabfrage einfügen.

Benutzerdefinierte Sortierung mit ORDER BY

Eine alphabetische Reihenfolge ist selten das, was ein Unternehmen wünscht. Mit CASE können Sie Ihre eigene Reihenfolge definieren:

SELECT id, status FROM orders
ORDER BY CASE status
           WHEN 'pending' THEN 1
           WHEN 'paid' THEN 2
           ELSE 3
         END, id;

-- 2 | pending
-- 6 | pending
-- 1 | paid
-- 3 | paid
-- 4 | shipped
-- 5 | cancelled

Ausstehende Bestellungen stehen an erster Stelle, was für eine Arbeitswarteschlange praktisch ist. Die zweite Sortierspalte id sorgt dafür, dass die Zeilen innerhalb jeder Gruppe in einer vorhersehbaren Reihenfolge bleiben.

FALL im UPDATE

Mit CASE kann eine Anweisung unterschiedliche Änderungen auf verschiedene Zeilen anwenden. Hier werden kleine ausstehende Bestellungen zur Überprüfung markiert:

UPDATE orders
SET status = CASE
               WHEN status = 'pending' AND total < 500 THEN 'review'
               ELSE status
             END;

SELECT id, status FROM orders WHERE customer = 'Ben';

-- 2 | review
-- 6 | pending

Die ELSE status lässt andere Zeilen unverändert. Es wegzulassen ist gefährlich, da nicht übereinstimmende Zeilen auf NULL gesetzt würden. Ohne eine WHERE-Klausel betrifft diese Anweisung auch jede Zeile. Fügen Sie daher bei großen Tabellen einen Filter hinzu und erwägen Sie, die Änderung in eine Transaktion einzuschließen, damit Sie das Ergebnis überprüfen können, bevor Sie einen Commit durchführen. Beachten Sie auch, dass sich Reihenfolge 6 nicht geändert hat, da ihre NULL-Summe total < 500 nicht erfüllte.

NULL-Traps

NULL verursacht zwei separate Probleme mit CASE. Erstens vergleicht die einfache Form mit Gleichheit, und nichts ist gleich NULL, nicht einmal NULL selbst:

SELECT CASE NULL WHEN NULL THEN 'matched' ELSE 'not matched' END;

-- not matched

CASE col WHEN NULL stimmt also nie überein. Verwenden Sie stattdessen das gesuchte Formular mit IS NULL. Zweitens, wie wir bei Reihenfolge 6 gesehen haben, entgeht ein NULL-Wert den Vergleichen und landet in ELSE. Die Lösung besteht darin, zuerst danach zu suchen:

SELECT id,
       CASE
         WHEN total IS NULL THEN 'unknown'
         WHEN total >= 1000 THEN 'large'
         ELSE 'other'
       END AS size
FROM orders WHERE id IN (1, 2, 6);

-- 1 | large
-- 2 | other
-- 6 | unknown

Bestellung 6 bekommt nun ein ehrliches Label. Unser Leitfaden zu SQL-NULL-Werten behandelt dieses Verhalten vollständig.

CASE im Vergleich zu anderen Optionen

Die letzte Option verdient eine Überlegung. Wenn ein CASE auf dreißig Zweige anwächst und in fünf Abfragen erscheint, verschieben Sie die Zuordnung in eine Tabelle und verknüpfen Sie damit. Dann ist eine Änderung eine einzelne Zeilenaktualisierung und keine Codeänderung an fünf Stellen.

Häufige Fehler

• Falsche Bedingungsreihenfolge. Eine allgemeine Bedingung verbirgt zunächst die engeren.
• Vergessen END. Dies ist der häufigste Syntaxfehler.
• Verwenden von WHEN NULL. Es stimmt nie überein, also verwenden Sie WHEN col IS NULL.
• Hinzufügen von ELSE 0 innerhalb von COUNT. Es werden alle Zeilen gezählt.
• Weglassen von ELSE in einem UPDATE. Es können Werte mit NULL gelöscht werden.
• Filtern nach CASE in WHERE. Es kann verhindern, dass ein Index verwendet wird. Sehen Sie sich unseren Leitfaden zur SQL-Abfrageoptimierung an.

Fazit

CASE WHEN ist eine kleine Funktion, die viel Arbeit leistet. Denken Sie an drei Regeln: Der erste echte Zweig gewinnt, nicht übereinstimmende Zeilen werden zu NULL ohne ELSE und NULL benötigt eine eigene Prüfung. Nehmen Sie zum Üben einen Bericht, den Sie derzeit mit mehreren Abfragen erstellen, und versuchen Sie, ihn mithilfe von SUM(CASE ...) als eine Abfrage zu erstellen.

Häufige Fragen

Lerne weiter