SQLite & NULL: IS NULL, COALESCE und IFNULL richtig nutzen

NULL bedeutet „unbekannt"

Jeder andere Wert in SQLite steht für etwas Konkretes – eine Zahl, einen String, ein Blob. NULL ist anders. Es ist ein Platzhalter für einen Wert, der fehlt oder unbekannt ist. Diese eine Idee erklärt jedes seltsame Verhalten, das NULL in Abfragen an den Tag legt.

Legen wir eine kleine Tabelle an, mit der wir experimentieren können:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT * FROM users;

Zwei Spalten erlauben NULL-Werte. Boris hat keine E-Mail. Cleo hat kein Alter angegeben. Dan hat weder noch. Auf dem Rest der Seite geht es darum, solche Zeilen abzufragen, ohne in die typischen Fallen zu tappen.

= und <> funktionieren nicht mit NULL

Der erste Reflex ist, einfach WHERE email = NULL zu schreiben. Sieht logisch aus – liefert aber nichts zurück:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email FROM users WHERE email = NULL;

Null Zeilen — obwohl Boris und Dan offensichtlich keine E-Mail-Adresse haben. Der Grund: Jeder Vergleich mit NULL liefert wieder NULL zurück, nicht true oder false. Die WHERE-Klausel in SQLite behält aber nur Zeilen, bei denen die Bedingung wahr ist — und NULL ist eben nicht wahr. Also fliegt die Zeile raus.

Dieselbe Falle gibt es bei <>:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email FROM users WHERE email <> 'ada@example.com';

Eigentlich würde man erwarten, dass alle außer Ada zurückkommen. Stattdessen erscheint nur Cleo. Boris und Dan, deren E-Mail-Adressen NULL sind, fallen unter den Tisch – denn NULL <> 'ada@example.com' ergibt eben wieder NULL und nicht true.

Das ist mit Abstand die häufigste SQL-Falle. Wenn eine Abfrage plötzlich Zeilen verschluckt, mit denen du gerechnet hast, ist meistens eine Spalte mit NULL schuld.

IS NULL und IS NOT NULL richtig einsetzen

Der saubere Weg, in SQLite auf NULL zu prüfen, ist der IS-Operator. Im Gegensatz zu = kommt er mit NULL klar und liefert immer true oder false zurück – niemals NULL selbst:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name FROM users WHERE email IS NULL;

SELECT name FROM users WHERE email IS NOT NULL;

Die erste Abfrage liefert Boris und Dan zurück, die zweite Ada und Cleo. IS NULL und IS NOT NULL sind genau die beiden Operatoren, mit denen du fragst: „Fehlt dieser Wert?" Setz sie überall dort ein, wo du sonst versucht wärst, = NULL oder <> NULL zu schreiben.

Wenn du „alle außer Ada, inklusive der unbekannten Werte" haben willst, musst du beide Prüfungen explizit kombinieren:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email
FROM users
WHERE email <> 'ada@example.com' OR email IS NULL;

Jetzt tauchen Boris, Cleo und Dan alle auf.

NULL pflanzt sich durch Arithmetik und Verkettung fort

Diese "unbekannt"-Regel gilt nicht nur bei Vergleichen. Sobald irgendeine Operation auf NULL trifft, ist das Ergebnis ebenfalls NULL:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    age,
    age + 1       AS next_year,
    age * 2       AS doubled,
    'Hallo ' || name AS greeting,
    'Alter: ' || age AS labelled_age
FROM users;

next_year und doubled sind bei Cleo und Dan null. labelled_age übrigens auch – sobald man einen String mit NULL verkettet, kommt wieder NULL raus und eben nicht 'Age: '. Wenn eine Spalte also null sein kann und du am Ende einen brauchbaren Wert haben willst, musst du den Fall explizit abfangen. Genau dafür gibt es die nächsten beiden Funktionen.

IFNULL: Fallback mit zwei Argumenten

IFNULL(a, b) gibt a zurück – außer a ist null, dann kommt b. Das ist der einfachste Weg, um einen NULL-Wert in SQLite durch einen Default-Wert zu ersetzen:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    IFNULL(email, '(keine E-Mail)') AS email,
    IFNULL(age, 0)                  AS age
FROM users;

Boris und Dan bekommen (keine E-Mail). Cleo und Dan bekommen 0. Die Daten in der Tabelle ändern sich dabei nicht – IFNULL schreibt lediglich die Ausgabe um.

IFNULL erwartet immer genau zwei Argumente. Wer mehrere Fallbacks hintereinander braucht, greift zu COALESCE.

COALESCE: Der erste Nicht-NULL-Wert gewinnt

COALESCE(a, b, c, ...) geht die Argumente der Reihe nach durch und liefert den ersten zurück, der nicht NULL ist. Damit ist COALESCE quasi die verallgemeinerte Variante von IFNULL – nur eben mit beliebig vielen Fallbacks:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    COALESCE(email, name || '@unbekannt.local', 'anonym') AS contact
FROM users;

Bei Ada und Cleo wird die E-Mail-Adresse genommen. Bei Boris und Dan ist die E-Mail NULL – also greift SQLite auf das zweite Argument zurück, eine aus dem Namen zusammengebaute Adresse. Wäre diese ebenfalls NULL, würde am Ende 'anonym' herauskommen.

COALESCE ist die portable Variante: Jede größere SQL-Datenbank unterstützt es auf dieselbe Weise. IFNULL ist dagegen eine bequeme Abkürzung in SQLite und MySQL für den Fall mit genau zwei Argumenten. Im Zweifel also lieber COALESCE nehmen – IFNULL nur dann, wenn du wirklich nur zwei Argumente hast und den kürzeren Namen bevorzugst.

NULL ist nicht dasselbe wie ein leerer String

Ein häufiger Stolperstein: Viele behandeln NULL und '' so, als wären sie austauschbar. Sind sie aber nicht.

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    '' IS NULL          AS empty_is_null,
    NULL IS NULL        AS null_is_null,
    length('')          AS empty_length,
    length(NULL)        AS null_length,
    '' = ''             AS empty_equals_empty,
    NULL = NULL         AS null_equals_null;

'' ist ein echter String – er hat eben null Zeichen. NULL dagegen steht für das Fehlen eines Werts. length('') ergibt 0, während length(NULL) selbst wieder NULL ist. Und NULL = NULL liefert nicht 1, sondern NULL – genau deshalb gibt es überhaupt IS NULL.

Wenn eine Spalte sowohl '' als auch NULL enthalten kann, leg dich darauf fest, was bei dir „fehlender Wert" bedeutet, und bleib konsequent dabei. Sonst musst du in jeder Abfrage beide Fälle abdecken – und irgendwann vergisst du einen davon.

NULL bei IN, NOT IN und DISTINCT

Es gibt noch ein paar weitere Stellen, an denen dir NULL in die Quere kommt.

IN mit einer Liste, die NULL enthält, kann zu überraschenden Ergebnissen führen – vor allem in Kombination mit NOT IN:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, age FROM users WHERE age NOT IN (25, NULL);

Eigentlich würde man erwarten, dass alle zurückkommen, deren Alter nicht 25 ist. Stattdessen bekommt man: nichts. SQLite expandiert NOT IN (25, NULL) ungefähr zu age <> 25 AND age <> NULL, und age <> NULL ergibt immer NULL – die Gesamtbedingung wird also nie wahr. Die Lösung: NULL-Werte vor dem Vergleich aus der Liste (oder aus der Spalte) herausfiltern.

DISTINCT hingegen behandelt NULL-Werte beim Entfernen von Duplikaten als gleich:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT DISTINCT email FROM users;

Du bekommst drei Zeilen zurück: Adas E-Mail, Cleos E-Mail und ein einzelnes NULL (in das Boris und Dan zusammengefasst wurden). Bei GROUP BY und UNION läuft es genauso – beide behandeln NULL-Werte als eine einzige Gruppe, also genau andersherum als =. SQL ist hier nicht immer konsequent, deshalb lohnt es sich zu wissen, auf welcher Seite welcher Operator steht.

Kurze Checkliste

• Prüfe fehlende Werte mit IS NULL bzw. IS NOT NULL. Niemals mit = NULL.
• Sobald NULL bei Arithmetik, Verkettung oder Vergleichen mitspielt, ist das Ergebnis wieder NULL.
• Mit COALESCE(a, b, c, ...) ersetzt du NULL-Werte durch einen Fallback. Für zwei Argumente reicht die Kurzform IFNULL(a, b).
• Ein leerer String '' ist nicht dasselbe wie NULL. Entscheide dich pro Spalte für eine Variante, um „fehlt" auszudrücken.
• NOT IN (..., NULL) ist fast immer ein Bug. Filtere NULL-Werte vorher aus der Liste raus.

Weiter geht's: Ergebnisse sortieren

Wenn du Zeilen sauber filtern kannst – inklusive der mit NULL – ist der nächste Schritt, sie in eine sinnvolle Reihenfolge zu bringen. ORDER BY ist das nächste Thema, und auch dieses Schlüsselwort hat eine eigene Meinung dazu, wo NULL-Werte in der sortierten Ausgabe landen.