OUTER JOINs im Detail

Schnell-Wiederholung

Mit denselben Daten wie im Inner/Outer-Grundlagen-Artikel:

-- Carol hat keine Bestellung, eine Bestellung hat NULL als customer_id

SELECT c.name, o.id AS order_id, o.total
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

 name  | order_id | total
-------+----------+-------
 Alice |        1 | 99.95
 Alice |        2 | 49.95
 Bob   |        3 | 19.95
 Carol |     NULL |  NULL    <- Carol ohne Bestellung

Die häufigste Falle: WHERE macht aus LEFT ein INNER

Wer einen LEFT JOIN hat und dann eine Bedingung auf die rechte Tabelle in WHERE schreibt, verliert die NULL-Zeilen — und damit den OUTER-Effekt:

-- Versuch: alle Kunden, mit Bestellungen über 50 Euro
SELECT c.name, o.total
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.total > 50;

Output:

 name  | total
-------+-------
 Alice | 99.95

Carol ist verschwunden! Bob auch. Der Grund: für Carol war o.total ja NULL. Und NULL > 50 ist nicht TRUE, also fällt sie aus dem WHERE raus. Effektiv ist der LEFT JOIN zum INNER JOIN geworden.

Lösung: die Filter-Bedingung in die ON-Klausel verschieben:

SELECT c.name, o.total
FROM customers c
LEFT JOIN orders o
    ON o.customer_id = c.id
   AND o.total > 50;

Output:

 name  | total
-------+-------
 Alice | 99.95
 Bob   |  NULL    <- Bob hat keine Bestellung > 50
 Carol |  NULL    <- Carol hat überhaupt keine Bestellungen

Jetzt zeigt das Resultat, was wir wollten: alle Kunden, mit ihrer großen Bestellung — falls vorhanden.

ON vs. WHERE — die Regel

Der Unterschied ist subtil aber zentral:

Faustregel:

• Filter auf die rechte Tabelle eines LEFT JOIN → in ON.
• Filter auf die linke Tabelle eines LEFT JOIN → in WHERE (oder ON, beides funktioniert).
• Filter auf NULL-Status (WHERE o.id IS NULL) → in WHERE (siehe nächster Abschnitt).

Pattern: „nur Zeilen ohne Match“

Wenn du wissen willst, welche Zeilen kein Match haben, ist das LEFT-JOIN-mit-NULL-Filter-Pattern der Standard:

SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

Output:

 id | name
----+-------
  3 | Carol

Die Logik: LEFT JOIN ergänzt Carol mit NULL für o.id. Das WHERE o.id IS NULL filtert dann auf genau diese Nicht-Match-Zeilen. Carol hat keine id aus orders bekommen → sie kommt durch.

Wichtig: filter auf eine NOT-NULL-Spalte der rechten Tabelle (z. B. den Primary Key o.id). Wenn man auf eine optional-NULL-Spalte filtert, verwechselt man „kein Match" mit „NULL-Wert in der Spalte".

Alternative: NOT EXISTS (oft sauberer und etwa gleich schnell):

SELECT c.id, c.name
FROM customers c
WHERE NOT EXISTS (
    SELECT 1 FROM orders o WHERE o.customer_id = c.id
);

Mehr dazu im Artikel EXISTS vs. IN vs. JOIN.

FULL OUTER JOIN für Datenqualitäts-Reports

FULL OUTER JOIN zeigt beide Arten von Nicht-Matches gleichzeitig:

SELECT
    c.id   AS customer_id,
    c.name,
    o.id   AS order_id,
    o.total
FROM customers c
FULL OUTER JOIN orders o ON o.customer_id = c.id
WHERE c.id IS NULL OR o.id IS NULL;

Output:

 customer_id | name  | order_id | total
-------------+-------+----------+-------
           3 | Carol |     NULL |  NULL
        NULL | NULL  |        4 |  9.95

Beide Probleme sichtbar in einer Query: Kunden ohne Bestellung und Bestellungen ohne Kunde. Für ETL-Validierung oder „warum stimmt mein Report nicht?"-Analysen sehr nützlich.

NULL-Werte im Join — wann matcht NULL?

Wichtige Eigenheit: NULL = NULL ist nicht TRUE in SQL. Wer also einen FK auf eine Spalte mit NULL-Werten joint:

-- orders mit customer_id NULL match NICHT auf c.id NULL
-- (auch wenn beide Spalten NULL wären)
SELECT c.name, o.id
FROM customers c
INNER JOIN orders o ON c.id = o.customer_id;

NULL-Werte fallen aus jeder normalen Equality-Bedingung. Wer NULL-Werte als „gleich" behandeln will (selten gewollt):

ON c.id IS NOT DISTINCT FROM o.customer_id

IS NOT DISTINCT FROM behandelt zwei NULLs als gleich. Funktioniert, ist aber kaum index-fähig — Performance leidet auf großen Tabellen. Mehr im Artikel NULL und Three-Valued Logic.

RIGHT JOIN ist (fast) immer als LEFT umschreibbar

A RIGHT JOIN B ist semantisch identisch zu B LEFT JOIN A — nur die Tabellen sind getauscht:

SELECT c.name, o.total
FROM customers c
RIGHT JOIN orders o ON o.customer_id = c.id;

-- Identisch zu:
SELECT c.name, o.total
FROM orders o
LEFT JOIN customers c ON o.customer_id = c.id;

In großen Codebasen siehst du fast nie RIGHT JOIN — alle formulieren um auf LEFT JOIN. Lesbar einheitlicher.

Weiterführende Ressourcen

Externe Quellen

• Joined Tables – PostgreSQL Documentation
• Don't Do This: bare column reference – PostgreSQL Wiki
• Comparison Operators – IS NOT DISTINCT FROM

Verwandte Artikel

• INNER und OUTER Join — Grundlagen
• EXISTS vs. IN vs. JOIN
• NULL und Three-Valued Logic
• SELECT und WHERE