MySQL-Joins-Guide: Joins meistern mit Beispielen

Wenn du schon mal versucht hast, Daten aus mehreren MySQL-Tabellen abzufragen, und dich dabei verloren gefühlt hast, bist du nicht allein. Joins gehören zu den Konzepten, die anfangs einschüchternd wirken, aber unglaublich mächtig werden, sobald du den Dreh raus hast.

Stell dir Joins als eine Möglichkeit vor, MySQL zu sagen: „Hey, ich will Daten aus dieser Tabelle UND aus jener Tabelle, aber nur dort, wo bestimmte Bedingungen übereinstimmen.“ Sobald du die grundlegenden Muster verstanden hast, kombinierst du Daten wie ein Profi.

🔖 Kurzreferenz: Brauchst du etwas zum schnellen Nachschlagen? Schau dir unser SQL JOIN Cheat Sheet an – mit allen JOIN-Typen, anschaulichen Diagrammen und Codebeispielen an einem Ort.

Der Join-Stammbaum

Im Kern kannst du mit einem Join Zeilen aus verschiedenen Tabellen kombinieren, wenn sie etwas gemeinsam haben. Das ist so, als würdest du zwei Freundeskreise einander vorstellen, die gemeinsame Bekannte haben.

Diese Join-Typen schauen wir uns an:

• INNER JOIN – Zeig mir nur Datensätze, die in beiden Tabellen vorkommen
• LEFT JOIN – Zeig mir alles aus der linken Tabelle, plus Treffer aus der rechten
• RIGHT JOIN – Das Gegenteil von LEFT JOIN (wobei ehrlich gesagt die meisten einfach die Tabellen vertauschen)
• FULL JOIN – Alles aus beiden Tabellen (dafür lässt MySQL uns ein bisschen arbeiten)
• CROSS JOIN – Jede mögliche Kombination (mit Vorsicht verwenden!)
• SELF JOIN – Wenn eine Tabelle mit sich selbst reden muss

INNER JOIN – Der Perfektionist

INNER JOIN ist wählerisch. Er liefert dir nur Zeilen, bei denen beide Tabellen passende Daten haben. Stell es dir als Schnittmenge in einem Venn-Diagramm vor.

Beispiel:

Arbeiten wir mit zwei einfachen Tabellen – employees und departments:

-- Employees Table
+----+----------+-------------+
| id | name     | department_id|
+----+----------+-------------+
| 1  | Alice    | 1           |
| 2  | Bob      | 2           |
| 3  | Charlie  | NULL        |
+----+----------+-------------+

-- Departments Table
+----+-------------+
| id | department  |
+----+-------------+
| 1  | HR          |
| 2  | IT          |
+----+-------------+

INNER-JOIN-Abfrage:

SELECT employees.name, departments.department
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

Ergebnis:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

LEFT JOIN – Der Inklusive

LEFT JOIN ist großzügiger als INNER JOIN. Er sagt: „Ich will alles aus der linken Tabelle, und wenn es in der rechten Tabelle passende Daten gibt, super! Wenn nicht, setze ich einfach NULL ein.“

Achte darauf, dass Charlie diesmal auftaucht, obwohl er keine Abteilung hat:

LEFT-JOIN-Abfrage:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id;

Ergebnis:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

RIGHT JOIN – Die Kehrseite

RIGHT JOIN ist einfach ein LEFT JOIN mit vertauschten Tabellen. Die meisten Entwickler meiden ihn und stellen stattdessen ihre FROM-Klausel um – so ist es weniger verwirrend.

RIGHT-JOIN-Abfrage:

SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Ergebnis:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

FULL JOIN – Alles inklusive

Hier wird MySQL etwas lästig – es hat keinen eingebauten FULL JOIN. Aber wir können ihn mit einem UNION-Trick nachbauen:

FULL-JOIN-Simulation:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id
UNION
SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Ergebnis:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

CROSS JOIN – Der Chaos-Stifter

CROSS JOIN ist wie der Freund, der auf einer Party jeden mit jedem bekannt macht. Er kombiniert jede einzelne Zeile der ersten Tabelle mit jeder einzelnen Zeile der zweiten Tabelle. Bei 3 Mitarbeitern und 2 Abteilungen bekommen wir 6 Kombinationen:

CROSS-JOIN-Abfrage:

SELECT employees.name, departments.department
FROM employees
CROSS JOIN departments;

Ergebnis:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Alice | IT         |
| Bob   | HR         |
| Bob   | IT         |
| Charlie | HR       |
| Charlie | IT       |
+-------+------------+

SELF JOIN – Der Nachdenkliche

Self Joins kommen vor, wenn eine Tabelle auf sich selbst verweist. Das klassische Beispiel ist eine Mitarbeitertabelle, in der manche Mitarbeiter andere Mitarbeiter leiten.

Beispiel:

Hier ist eine managers-Tabelle, in der mgr_id auf eine andere Zeile derselben Tabelle verweist:

-- Managers Table
+----+----------+--------+
| id | name     | mgr_id |
+----+----------+--------+
| 1  | Tom      | NULL   |
| 2  | Jerry    | 1      |
| 3  | Spike    | 1      |
+----+----------+--------+

SELF-JOIN-Abfrage:

SELECT m1.name AS manager, m2.name AS employee
FROM managers m1
LEFT JOIN managers m2 ON m1.id = m2.mgr_id;

Ergebnis:

+---------+----------+
| manager | employee |
+---------+----------+
| Tom     | Jerry    |
| Tom     | Spike    |
| Jerry   | NULL     |
| Spike   | NULL     |
+---------+----------+

Fazit

Joins wirken anfangs vielleicht überwältigend, aber eigentlich sind sie nur verschiedene Arten zu sagen: „Zeig mir Daten aus mehreren Tabellen nach diesen Regeln.“ Fang mit INNER und LEFT Joins an – damit deckst du 90 % von dem ab, was du brauchst.

Am besten wirst du mit Joins vertraut, indem du mit deinen eigenen Daten übst. Leg ein paar Testtabellen an, füg Beispieldaten ein und fang an zu experimentieren. Schon bald joinst du Tabellen links und rechts (Wortspiel beabsichtigt).

Und denk dran: Wenn dein Join viel mehr Zeilen zurückgibt als erwartet, hast du wahrscheinlich versehentlich einen CROSS JOIN gebaut. Ist uns allen schon passiert!