# SQL CASE WHEN: Beispiele und Tipps für Einsteiger
> Entdecke, wie du mit SQL CASE WHEN einfache if-then‑else-Logik in Abfragen integrierst. Verbessere deine SQL-Fähigkeiten mit Beispielen!

- Webseite: https://logicexcel.com/de/functions/sql-case-when
- Sprache: de
- Veröffentlicht am: 2026-08-10

# SQL CASE WHEN: Beispiele und Tipps für Einsteiger

![Von Hand SQL-CASE-WHEN-Anweisungen ins Notizbuch schreiben](https://csuxjmfbwmkxiegfpljm.supabase.co/storage/v1/object/public/blog-images/organization-42380/1786365415390_Hand-writing-SQL-CASE-WHEN-code-on-notebook.jpeg)

`CASE WHEN` ist der SQL-Weg, um if‑then‑else‑Logik direkt in eine Abfrage zu schreiben, ohne eine Programmiersprache zu brauchen. Ein minimales Beispiel zeigt es am schnellsten:

```sql
SELECT
    Produktname,
    Preis,
    CASE WHEN Preis < 20 THEN 'Günstig'
         WHEN Preis < 50 THEN 'Mittel'
         ELSE 'Teuer'
    END AS Preiskategorie
FROM Produkte;
```

[SQL CASE](https://www.postgresql.org/docs/19/functions-conditional.html) wertet die WHEN‑Bedingungen der Reihe nach aus und gibt den THEN‑Wert der ersten wahren Bedingung zurück. Trifft keine zu und fehlt `ELSE`, liefert die Abfrage `NULL`.

**Profi-Tipp:** *Schreibe immer einen `ELSE`-Zweig, auch wenn er nur `'Sonstiges'` oder `NULL` explizit nennt. Das macht das Verhalten der Abfrage sofort lesbar und verhindert unerwartete Lücken im Ergebnis.*

## Wichtige Erkenntnisse

`CASE WHEN` implementiert if‑then‑else‑Logik in SQL-Ausdrücken, stoppt bei der ersten wahren Bedingung, und gibt ohne `ELSE` immer `NULL` zurück.

| Thema | Details |
|---|---|
| Zwei Formen | Simple CASE prüft Gleichheit; Searched CASE erlaubt beliebige Bedingungen wie `>`, `BETWEEN`, `IS NULL`. |
| ELSE immer angeben | Fehlt `ELSE`, liefert CASE `NULL` für alle nicht übereinstimmenden Zeilen. |
| Aggregationen | `SUM(CASE WHEN ...)` berechnet konditionale Kennzahlen in einem einzigen Tabellenscan. |
| Viele WHENs | Ab etwa acht Zweigen ist eine Lookup-Tabelle mit JOIN wartbarer und oft performanter. |
| LogicExcel | Interaktive SQL-Übungen im Browser zum direkten Ausprobieren von CASE WHEN. |

## Inhaltsverzeichnis

- [Wie ist die Syntax von SQL CASE WHEN aufgebaut?](#wie-ist-die-syntax-von-sql-case-when-aufgebaut)
- [Praktische Beispiele: Kategorisieren, NULLs behandeln, mehrere WHENs](#praktische-beispiele-kategorisieren-nulls-behandeln-mehrere-whens)
- [Wie nutzt du CASE WHEN in Aggregationen?](#wie-nutzt-du-case-when-in-aggregationen)
- [Wo darf CASE überall stehen?](#wo-darf-case-uberall-stehen)
- [Was unterscheidet SQL Server, PostgreSQL, MySQL und Oracle?](#was-unterscheidet-sql-server-postgresql-mysql-und-oracle)
- [Wann ist CASE lesbar, und wann wird es zum Problem?](#wann-ist-case-lesbar-und-wann-wird-es-zum-problem)
- [Welche Fehler passieren mit CASE WHEN am häufigsten?](#welche-fehler-passieren-mit-case-when-am-haufigsten)
- [So übst du CASE WHEN praktisch](#so-ubst-du-case-when-praktisch)
- [Was ich an CASE WHEN wirklich schätze](#was-ich-an-case-when-wirklich-schatze)
- [LogicExcel: SQL direkt im Browser üben](#logicexcel-sql-direkt-im-browser-uben)
- [Quellen](#quellen)
- [FAQ](#faq)

## Wie ist die Syntax von SQL CASE WHEN aufgebaut?

Es gibt zwei Formen, und der Unterschied ist praktisch relevant.

**Simple CASE** vergleicht einen Ausdruck auf Gleichheit:

```sql
CASE Bewertung
    WHEN 1 THEN 'Schlecht'
    WHEN 2 THEN 'Okay'
    WHEN 3 THEN 'Gut'
    ELSE 'Unbekannt'
END
```

**Searched CASE** wertet beliebige boolesche Ausdrücke aus, also auch `>`, `<`, `BETWEEN`, `LIKE` oder `IS NULL`:

```sql
CASE
    WHEN Umsatz > 10000 THEN 'Top'
    WHEN Umsatz BETWEEN 5000 AND 10000 THEN 'Mittel'
    ELSE 'Niedrig'
END
```

Laut der PostgreSQL-Dokumentation stoppt die Auswertung beim ersten wahren WHEN. Das hat Konsequenzen: Überlappende Bedingungen liefern je nach Reihenfolge unterschiedliche Ergebnisse.

Wichtige Regeln auf einen Blick:

- **Rückgabetyp:** SQL wählt den Typ nach Typ-Präzedenz aus allen THEN/ELSE-Werten. Mischst du `VARCHAR` und `INT`, kann es zu impliziter Konvertierung oder Fehlern kommen.
- **Fehlendes ELSE:** Gibt `NULL` zurück, nicht leer, nicht null-Byte.
- **Verschachtelung:** Technisch möglich, aber in T‑SQL auf 10 Ebenen begrenzt (dazu mehr in Abschnitt 6).

| Merkmal | Simple CASE | Searched CASE |
|---|---|---|
| Vergleichsart | Nur Gleichheit (`=`) | Beliebige Bedingungen |
| Typische Nutzung | Feste Wertelisten | Bereiche, NULL-Prüfungen, komplexe Logik |
| NULL-Verhalten | `= NULL` schlägt fehl | `IS NULL` funktioniert korrekt |

## Praktische Beispiele: Kategorisieren, NULLs behandeln, mehrere WHENs

Drei Szenarien, die im Alltag immer wieder auftauchen.

**Kategorisierung nach Preis**

![Mit farbigen Etiketten werden Datenzeilen von Hand sortiert und kategorisiert.](https://csuxjmfbwmkxiegfpljm.supabase.co/storage/v1/object/public/blog-images/organization-42380/1786365407670_Hands-categorizing-data-rows-with-colored-labels.jpeg)

```sql
SELECT
    Produktname,
    CASE WHEN Preis < 20 THEN 'Günstig'
         WHEN Preis < 50 THEN 'Mittel'
         ELSE 'Teuer'
    END AS Preiskategorie
FROM Produkte;
```

Das Ergebnis erscheint als neue Spalte `Preiskategorie`. Ohne `AS` zeigt die Datenbank einen automatisch generierten, oft unlesbaren Spaltennamen.

**NULL-Werte explizit behandeln**

```sql
SELECT
    Kundenname,
    CASE WHEN Email IS NULL THEN 'Keine Angabe'
         ELSE Email
    END AS Kontakt
FROM Kunden;
```

`WHEN Email = NULL` funktioniert nicht, weil `NULL` kein Wert ist, der mit `=` verglichen werden kann. Immer `IS NULL` verwenden.

**Reihenfolge der WHENs entscheidet**

```sql
CASE WHEN Score >= 90 THEN 'Sehr gut'
     WHEN Score >= 70 THEN 'Gut'
     WHEN Score >= 50 THEN 'Ausreichend'
     ELSE 'Nicht bestanden'
END
```

Wer `Score >= 50` an erste Stelle setzt, bekommt für alle Werte ab 50 sofort `'Ausreichend'`, egal ob der Score 95 ist. Die Reihenfolge ist keine Kleinigkeit.

## Wie nutzt du CASE WHEN in Aggregationen?

Das Muster `SUM(CASE WHEN ...)` ist eines der nützlichsten Werkzeuge für Berichte und Dashboards. Statt mehrerer Abfragen berechnest du konditionale Kennzahlen in einem einzigen Durchlauf.

```sql
SELECT
    Abteilung,
    COUNT(*) AS Gesamt,
    SUM(CASE WHEN Status = 'aktiv' THEN 1 ELSE 0 END) AS Aktive,
    SUM(CASE WHEN Status = 'inaktiv' THEN 1 ELSE 0 END) AS Inaktive
FROM Mitarbeiter
GROUP BY Abteilung;
```

Die PostgreSQL-Dokumentation beschreibt dieses Muster als gängige Methode für konditionale Metriken. Kombiniert mit `GROUP BY` liefert es eine vollständige Pivot-ähnliche Auswertung ohne Subqueries.

Weitere Varianten:

- `AVG(CASE WHEN Kategorie = 'A' THEN Umsatz ELSE NULL END)` berechnet den Durchschnitt nur für Kategorie A. `NULL`-Werte werden von `AVG` ignoriert.
- `COUNT(CASE WHEN Bedingung THEN 1 END)` zählt Zeilen, die die Bedingung erfüllen. Das fehlende `ELSE` gibt hier bewusst `NULL` zurück, was `COUNT` nicht zählt.

**Profi-Tipp:** *Bei großen Tabellen ist ein einzelner Scan mit mehreren konditionalen Aggregaten deutlich schneller als mehrere separate Abfragen. Das gilt besonders, wenn die Tabelle nicht vollständig im Cache liegt.*

Für die Kombination mit GROUP BY in SQL lohnt es sich, die Aggregationslogik sauber zu trennen: Bedingungen in CASE, Gruppierung in GROUP BY.

## Wo darf CASE überall stehen?

`CASE` ist ein Ausdruck, kein Statement. Überall, wo SQL einen Ausdruck erwartet, kann `CASE` stehen.

- **SELECT:** Klassische Verwendung zur Ausgabe transformierter Werte, wie in allen Beispielen oben.
- **ORDER BY:** Bedingte Sortierung, etwa um bestimmte Werte an den Anfang zu stellen:

```sql
ORDER BY
    CASE WHEN Status = 'dringend' THEN 0 ELSE 1 END,
    Erstellungsdatum DESC;
```

- **WHERE:** Selten nötig, aber möglich, wenn die Bedingung selbst variabel ist. Direkte Bedingungen sind meist klarer.
- **HAVING:** Nützlich, wenn die Filterbedingung auf einem konditionalen Aggregat basiert:

```sql
HAVING SUM(CASE WHEN Retoure = 1 THEN 1 ELSE 0 END) > 5
```

- **UPDATE/SET:** Ein konditionaler Update in einer Anweisung statt mehrerer:

```sql
UPDATE Produkte
SET Rabatt = CASE WHEN Lagerbestand > 100 THEN 0.2
                  WHEN Lagerbestand > 50 THEN 0.1
                  ELSE 0
             END;
```

Wichtig: Laut W3Schools SQL CASE ersetzt `CASE` nicht `WHERE`. `WHERE` entscheidet, ob eine Zeile überhaupt erscheint. `CASE` verändert nur, was in einer Spalte steht.

## Was unterscheidet SQL Server, PostgreSQL, MySQL und Oracle?

Die Kernlogik ist überall gleich, aber die Details unterscheiden sich.

| DBMS | Besonderheit |
|---|---|
| [SQL Server (T‑SQL)](https://learn.microsoft.com/de-de/sql/t-sql/queries/search-condition-transact-sql?view=sql-server-ver17) | Maximal 10 Verschachtelungsebenen; CASE in Aggregaten wird vollständig ausgewertet |
| [PostgreSQL](https://www.postgresql.org/docs/19/functions-conditional.html) | Short-circuit-Evaluation: WHEN-Ausdrücke werden sequenziell geprüft, Seiteneffekte möglich |
| MySQL | Unterscheidet CASE-Expression (in Abfragen) und CASE-Statement (in Stored Programs mit `END CASE`) |
| Oracle | Sehr hohe Obergrenze für WHEN-Paare; Short-circuit-Verhalten dokumentiert |

Die T‑SQL-Dokumentation von Microsoft nennt explizit die Grenze von 10 Verschachtelungsebenen. Wer tiefer schachtelt, bekommt einen Compilerfehler. In der Praxis ist das selten ein Problem, weil stark verschachtelte CASE-Ausdrücke ohnehin schwer lesbar sind.

[MySQL unterscheidet](https://dev.mysql.com/doc/refman/8.4/en/case.html) klar zwischen der CASE-Expression in normalen Abfragen (endet mit `END`) und dem CASE-Statement in Stored Programs (endet mit `END CASE`). Wer das verwechselt, bekommt einen Syntaxfehler.

[Oracle erlaubt](https://docs.oracle.com/en/database/oracle/oracle-database/26/sqlrf/CASE-Expressions.html) eine sehr große Anzahl von WHEN-Paaren, was technisch viel Spielraum lässt, aber aus Wartbarkeitsgründen trotzdem nicht ausgereizt werden sollte.

**Profi-Tipp:** *Wenn du Code zwischen DBMS portierst, teste NULL-Vergleiche zuerst. `WHEN column = NULL` schlägt in allen Systemen still fehl; `WHEN column IS NULL` funktioniert überall korrekt.*

Noch ein Punkt, der Lernende oft verwirrt: `CASE` in SQL ist ein Ausdruck, kein Ablaufsteuerungselement. In Stored Procedures gibt es ein separates `CASE`-Statement mit anderer Syntax. Die [Snowflake-Dokumentation](https://docs.snowflake.com/en/sql-reference/functions/case) beschreibt das sequenzielle Evaluationsverhalten und weist auf Short-circuiting hin.

## Wann ist CASE lesbar, und wann wird es zum Problem?

Drei bis vier WHEN-Zweige sind kein Problem. Ab acht oder zehn wird der Code schnell unübersichtlich, und Änderungen werden fehleranfällig.

- **Einrückung:** Jeden WHEN-Zweig in eine eigene Zeile, THEN bündig ausrichten. Das kostet keine Laufzeit und spart Minuten beim Lesen.
- **ELSE immer definieren:** Auch wenn der Fall „eigentlich nicht vorkommen kann“. Daten sind selten so sauber wie erwartet.
- **Viele WHENs:** Ab einer gewissen Anzahl ist eine Lookup-Tabelle die bessere Wahl.

```sql
-- Statt:
CASE Ländercode
    WHEN 'DE' THEN 'Deutschland'
    WHEN 'AT' THEN 'Österreich'
    WHEN 'CH' THEN 'Schweiz'
    -- ... 40 weitere Zeilen
END

-- Besser:
SELECT p.*, l.Bezeichnung
FROM Produkte p
LEFT JOIN Laender l ON p.Ländercode = l.Code;
```

Laut Snowflake-Dokumentation steigt bei vielen Bedingungen die Komplexität erheblich; Referenztabellen sind wartbarer und oft auch performanter, weil der Optimizer Indizes nutzen kann.

**Profi-Tipp:** *Wenn du denselben CASE-Block in mehr als zwei Abfragen kopierst, ist es Zeit für eine View oder eine Lookup-Tabelle. Doppelter Code bedeutet doppelter Wartungsaufwand.*

## Welche Fehler passieren mit CASE WHEN am häufigsten?

**Fehlender ELSE-Zweig:** Die häufigste Ursache für unerwartete `NULL`-Werte in Berichten. Wer `ELSE` weglässt, bekommt `NULL` für alle Zeilen, die keine WHEN-Bedingung erfüllen.

**Typkonflikte:** Wenn ein THEN-Zweig `'0'` (Text) und ein anderer `0` (Zahl) zurückgibt, entscheidet SQL über implizite Konvertierung. Das Ergebnis ist nicht immer das erwartete. Einheitliche Typen in allen THEN/ELSE-Zweigen vermeiden das.

**Falsche Reihenfolge bei überlappenden Bedingungen:** Wer `WHEN Score >= 50` vor `WHEN Score >= 90` schreibt, bekommt für Score 95 den falschen Zweig. Spezifischere Bedingungen immer zuerst.

**NULL-Vergleich mit `=`:** `WHEN Spalte = NULL` ist immer falsch. Korrekt ist `WHEN Spalte IS NULL`.

**Division durch null:** Lässt sich mit CASE elegant verhindern:

```sql
CASE WHEN Nenner <> 0 THEN Zähler / Nenner ELSE 0 END
```

Die PostgreSQL-Dokumentation zeigt genau dieses Muster als Standardbeispiel für sichere Berechnungen.

Debugging-Tipp: Füge temporär eine Spalte `CASE WHEN ... THEN 'Zweig A' WHEN ... THEN 'Zweig B' ELSE 'Kein Treffer' END AS debug_label` hinzu. So siehst du sofort, welcher Zweig für welche Zeile greift.

![Welche Fehler passieren mit CASE WHEN am häufigsten?: Übersichtsgrafik](https://csuxjmfbwmkxiegfpljm.supabase.co/storage/v1/object/public/blog-images/organization-42380/1786365685048_Welche-Fehler-passieren-mit-CASE-WHEN-am-haufigsten-overview-diagram.jpeg)

## So übst du CASE WHEN praktisch

Theorie hilft, aber Schreiben festigt. Hier sind fünf Aufgaben, die die wichtigsten Fälle abdecken:

1. **Kategorisieren:** Schreibe eine Abfrage, die Produkte nach Preis in `'Günstig'` (unter 20), `'Mittel'` (20-50) und `'Teuer'` (über 50) einteilt. Nutze `AS Preiskategorie`.
2. **NULLs behandeln:** Erstelle eine Abfrage, die fehlende E-Mail-Adressen als `'Keine Angabe'` ausgibt, vorhandene unverändert lässt.
3. **Aggregation:** Berechne mit `SUM(CASE WHEN Status = 'aktiv' THEN 1 ELSE 0 END)` die Anzahl aktiver Nutzer pro Abteilung.
4. **ORDER BY mit CASE:** Sortiere eine Kundenliste so, dass VIP-Kunden immer oben erscheinen, alle anderen alphabetisch danach.
5. **UPDATE mit CASE:** Schreibe ein `UPDATE`, das Rabatte abhängig vom Lagerbestand setzt: über 100 Einheiten 20 %, über 50 Einheiten 10 %, sonst 0 %.

Die interaktiven SQL-Übungen auf LogicExcel eignen sich gut, um diese Aufgaben direkt im Browser auszuprobieren und sofortiges Feedback zu bekommen, ohne lokale Datenbank oder Installation.

## Was ich an CASE WHEN wirklich schätze

`CASE WHEN` ist das Werkzeug, das aus einer reinen Datenabruf-Abfrage eine Analyse macht. Wer KPIs in einem Bericht berechnet, braucht oft keine separate Programmierlogik, wenn `SUM(CASE WHEN ...)` in einer einzigen Abfrage mehrere Metriken gleichzeitig liefert.

Was ich in der Praxis gelernt habe: Die größte Gefahr ist nicht die falsche Syntax, sondern die falsche Reihenfolge der WHEN-Zweige. Ein Fehler dort ist still. Keine Fehlermeldung, nur ein falsches Ergebnis, das in einem Dashboard wochenlang unbemerkt bleibt.

Verschachtelte CASE-Ausdrücke sind verlockend, weil sie viel Logik in wenige Zeilen packen. Aber ab einer gewissen Tiefe liest kein Mensch mehr, was der Code tut, auch nicht der Autor selbst drei Monate später. Ich ziehe dann eine View oder eine Lookup-Tabelle vor. Kombiniert mit Window Functions wie `RANK()` oder `SUM() OVER (...)` entfaltet CASE sein volles Potenzial, ohne dass der Code unlesbar wird.

## LogicExcel: SQL direkt im Browser üben

Wer `CASE WHEN` wirklich beherrschen will, muss es schreiben, nicht nur lesen. LogicExcel bietet interaktive SQL-Übungen, die genau das ermöglichen: Aufgaben direkt im Browser lösen, sofortiges Feedback erhalten, ohne Installation.

![LogicExcel](https://csuxjmfbwmkxiegfpljm.supabase.co/storage/v1/object/public/blog-images/organization-42380/1784802457664_logicexcel.jpg)

Die Aufgaben decken Grundlagen wie `SELECT` und `WHERE` genauso ab wie Aggregationen mit `GROUP BY` und konditionale Logik mit `CASE WHEN`. Wer die fünf Übungsaufgaben aus dem vorherigen Abschnitt ausprobieren möchte, findet auf LogicExcel den passenden Rahmen dafür. Einfach die SQL-Übungsseite aufrufen und loslegen.

## Quellen

- [PostgreSQL: Documentation: 19: 9.19. Conditional Expressions](https://www.postgresql.org/docs/19/functions-conditional.html)
- [case - Snowflake Documentation](https://docs.snowflake.com/en/sql-reference/functions/case)
- [CASE Expressions - Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/26/sqlrf/CASE-Expressions.html)
- [CASE Syntax: MySQL Reference](https://dev.mysql.com/doc/refman/8.4/en/case.html)

## FAQ

### Wie schreibt man CASE WHEN in SQL?

```sql
CASE WHEN Bedingung THEN Ergebnis ELSE Alternative END
```

Die Abfrage wertet WHEN-Zweige der Reihe nach aus und gibt den THEN-Wert der ersten wahren Bedingung zurück.

### Warum gibt CASE WHEN manchmal NULL zurück?

Fehlt ein `ELSE`-Zweig und trifft keine WHEN-Bedingung zu, liefert CASE automatisch `NULL`. Immer einen expliziten `ELSE`-Wert angeben, um das zu verhindern.

### Wann nimmt man IF statt CASE in SQL?

In Standard-SQL gibt es kein `IF` auf Ausdrucksebene. MySQL kennt `IF(Bedingung, Wert_wahr, Wert_falsch)` als Funktion, aber `CASE WHEN` ist portabler und funktioniert in SQL Server, PostgreSQL, MySQL und Oracle gleichermaßen.

### Kann CASE WHEN in WHERE und ORDER BY stehen?

Ja. `CASE` ist ein Ausdruck und darf überall stehen, wo SQL einen Ausdruck erwartet: in `SELECT`, `ORDER BY`, `HAVING`, `WHERE` und `UPDATE SET`.

### Was ist der Unterschied zwischen Simple CASE und Searched CASE?

Simple CASE vergleicht einen Ausdruck auf Gleichheit (`CASE Spalte WHEN Wert THEN ...`). Searched CASE wertet beliebige boolesche Ausdrücke aus (`CASE WHEN Spalte > 100 THEN ...`) und ist damit flexibler, besonders für Bereiche und NULL-Prüfungen.

## Empfehlung

- [Excel-Übungen: Beispiele und Übungsaufgaben zur WENN-Funktion - LogicExcel](https://logicexcel.com/de/functions/if)
- [SQL-Übungen - SQL online lernen - LogicExcel](https://logicexcel.com/de/sql)
- [INDEXMATCH: Die leistungsstärkste Suchfunktion in Excel - LogicExcel](https://logicexcel.com/de/functions/index-match)
- [WENN-Kombinationen Online üben - Interaktive Excel-Übung - LogicExcel](https://logicexcel.com/de/practice/82)