Vollständiges Zusammenführen von Daten mit FULL OUTER JOIN

Heute schauen wir uns die wohl demokratischste Art des Daten-Joins an – FULL OUTER JOIN. Hier kommt wirklich jeder ins Ergebnis, selbst wenn er kein passendes Gegenstück hat.

FULL OUTER JOIN ist eine Art von Join, bei dem alle Zeilen aus beiden Tabellen zurückgegeben werden. Wenn es für eine Zeile in der einen Tabelle kein passendes Gegenstück in der anderen gibt, werden die fehlenden Werte im Ergebnis mit NULL aufgefüllt. Das ist so, als würdest du alle Leute zählen, die auf zwei verschiedene Partys gekommen sind: Selbst wenn jemand nur auf einer war, taucht er trotzdem in der Liste auf.

Visuell sieht das so aus:

Tabelle A                     Tabelle B
+----+----------+             +----+----------+
| id | name     |             | id | course   |
+----+----------+             +----+----------+
| 1  | Alice    |             | 2  | Math     |
| 2  | Bob      |             | 3  | Physics  |
| 4  | Charlie  |             | 5  | History  |
+----+----------+             +----+----------+

FULL OUTER JOIN ERGEBNIS:
+----+----------+----------+
| id | name     | course   |
+----+----------+----------+
| 1  | Alice    | NULL     |
| 2  | Bob      | Math     |
| 3  | NULL     | Physics  |
| 4  | Charlie  | NULL     |
| 5  | NULL     | History  |
+----+----------+----------+

Zeilen ohne Übereinstimmung bleiben erhalten, aber die Daten für die fehlenden Spalten werden mit NULL gefüllt.

Syntax von FULL OUTER JOIN

Die Syntax ist easy, aber die Power ist groß:

SELECT
    spalten
FROM 
    tabelle1
FULL OUTER JOIN 
    tabelle2
ON tabelle1.gemeinsame_spalte = tabelle2.gemeinsame_spalte;

Der Schlüsselteil ist hier FULL OUTER JOIN, wodurch PostgreSQL alle Zeilen aus beiden Tabellen nimmt. Wenn für eine Zeile keine Übereinstimmung nach dem ON-Kriterium gefunden wird, werden die Werte durch NULL ersetzt.

Beispiele zur Verwendung

Schauen wir uns echte Beispiele mit der bekannten Datenbank university und den Tabellen students und enrollments an.

Beispiel 1: Liste aller Studenten und Kurse

Stell dir vor, wir haben zwei Tabellen:

Tabelle students:

Tabelle enrollments:

Unsere Aufgabe: Eine vollständige Liste aller Studenten und Kurse erstellen, inklusive der Studenten, die in keinem Kurs eingeschrieben sind, und Kurse ohne Studenten.

Hier der Query:

SELECT
    s.student_id, 
    s.name, 
    e.course
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Ergebnis:

Wie du siehst, sind alle Studenten und alle Kurse im Ergebnis. Student Charlie ist in keinem Kurs eingeschrieben, daher ist das Feld course für ihn NULL. Und der Kurs History hat keinen Studenten, daher sind student_id und name dort NULL.

Beispiel 2: Analyse von Verkäufen und Produkten

Jetzt denken wir an einen Shop. Wir haben zwei Tabellen:

Tabelle products:

Tabelle sales:

Wir wollen eine vollständige Liste aller Produkte und Verkäufe, inklusive der Produkte, die nicht verkauft wurden, und Verkäufe mit ungültigen product_ids.

Query:

SELECT
    p.product_id,
    p.name AS product_name,
    s.quantity
FROM 
    products p
FULL OUTER JOIN 
    sales s
ON 
    p.product_id = s.product_id;

Ergebnis:

Hier sehen wir, dass Smartphone nicht verkauft wurde (quantity = NULL), und der Verkauf mit product_id = 4 passt zu keinem Produkt.

Praktische Aufgabe

Versuch mal, einen Query für die Tabellen departments und employees zu schreiben:

Tabelle departments:

Tabelle employees:

Schreib einen FULL OUTER JOIN, um eine vollständige Liste aller Abteilungen und Mitarbeiter zu bekommen. Fehlende Daten füllst du mit NULL auf.

Wie man NULL-Werte behandelt

Das Problem mit NULL-Werten ist ein unvermeidlicher Nebeneffekt von FULL OUTER JOIN. In echten Aufgaben willst du vielleicht NULL durch sinnvollere Werte ersetzen. In PostgreSQL geht das easy mit der Funktion COALESCE().

Beispiel:

SELECT
    COALESCE(s.name, 'Kein Student') AS student_name,
    COALESCE(e.course, 'Kein Kurs') AS course_name
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Ergebnis:

Jetzt sehen wir statt NULL verständliche Werte, die Reports viel lesbarer machen.

Wann solltest du FULL OUTER JOIN verwenden?

FULL OUTER JOIN ist praktisch, wenn du alle Daten aus beiden Tabellen sehen willst, auch wenn sie nicht komplett zusammenpassen. Beispiele:

• Reports zu Verkäufen und Produkten – um sowohl verkaufte als auch nicht verkaufte Produkte zu sehen.
• Analyse von Studenten und Kursen – um zu checken, ob es unberücksichtigte Daten gibt.
• Vergleich von Listen – zum Beispiel, um Unterschiede zwischen zwei Datensätzen zu finden.

Ich hoffe, diese Vorlesung hat dir einen guten Überblick über FULL OUTER JOIN gegeben. Jetzt wartet die spannende Welt der komplexeren Joins und Datenbearbeitung auf dich!