Kapitel 9: Tabellenverbindungen (JOINs) ⭐⭐

Tabellenverbindungen werden verwendet, um Daten aus mehreren Tabellen gleichzeitig abzufragen.

9.1 Bedeutung von Tabellenverbindungen

In der Praxis sind Daten oft auf mehrere Tabellen verteilt:

Beispiel: Online-Shop
- Tabelle "users":    Speichert Benutzerinformationen
- Tabelle "orders":   Speichert Bestellungen
- Tabelle "products": Speichert Produktinformationen

Frage: Wie finde ich alle Bestellungen eines Benutzers?
Antwort: Tabellenverbindungen (JOINs) verwenden!

9.2 INNER JOIN (Inner Join) ⭐⭐ Wichtig!

INNER JOIN gibt nur Datensätze zurück, die in beiden Tabellen übereinstimmen.

Syntax

SELECT felder
FROM tabelle1
INNER JOIN tabelle2 
  ON tabelle1.feld = tabelle2.feld;

Beispiel

Szenario: Benutzer und ihre Bestellungen abfragen.

-- Testdaten erstellen
CREATE DATABASE IF NOT EXISTS shop_db;
USE shop_db;

CREATE TABLE users (
    user_id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50)
);

CREATE TABLE orders (
    bestell_id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT,
    produkt_name VARCHAR(200),
    menge INT
);

INSERT INTO users (username) VALUES ('Max'), ('Lisa'), ('John');
INSERT INTO orders (user_id, produkt_name, menge) 
VALUES (1, 'T-Shirt', 2), (1, 'Jeans', 1), (2, 'Sneaker', 1);

INNER JOIN verwenden:

SELECT 
    users.username,
    orders.produkt_name,
    orders.menge
FROM users
INNER JOIN orders 
  ON users.user_id = orders.user_id;

Ergebnis:

+----------+----------------+-------+
| username | produkt_name   | menge |
+----------+----------------+-------+
| Max      | T-Shirt        |     2 |
| Max      | Jeans          |     1 |
| Lisa     | Sneaker        |     1 |
+----------+----------------+-------+

Erklärung:

• John erscheint NICHT im Ergebnis, weil er keine Bestellungen hat
• Nur Übereinstimmungen in beiden Tabellen werden angezeigt

9.3 LEFT JOIN (Left Join) ⭐⭐

LEFT JOIN gibt alle Datensätze der linken Tabelle und die übereinstimmenden Datensätze der rechten Tabelle zurück.

• Wenn keine Übereinstimmung in der rechten Tabelle gefunden wird → NULL

Syntax

SELECT felder
FROM tabelle1  -- Linke Tabelle
LEFT JOIN tabelle2  -- Rechte Tabelle
  ON tabelle1.feld = tabelle2.feld;

Beispiel

SELECT 
    users.username,
    orders.produkt_name,
    orders.menge
FROM users
LEFT JOIN orders 
  ON users.user_id = orders.user_id;

Ergebnis:

+----------+----------------+-------+
| username | produkt_name   | menge |
+----------+----------------+-------+
| Max      | T-Shirt        |     2 |
| Max      | Jeans          |     1 |
| Lisa     | Sneaker        |     1 |
| John     | NULL           |  NULL |  ← John hat keine Bestellungen
+----------+----------------+-------+

9.4 RIGHT JOIN (Right Join)

RIGHT JOIN gibt alle Datensätze der rechten Tabelle und die übereinstimmenden Datensätze der linken Tabelle zurück.

• Wenn keine Übereinstimmung in der linken Tabelle gefunden wird → NULL

Syntax

SELECT felder
FROM tabelle1  -- Linke Tabelle
RIGHT JOIN tabelle2  -- Rechte Tabelle
  ON tabelle1.feld = tabelle2.feld;

Beispiel

SELECT 
    users.username,
    orders.produkt_name,
    orders.menge
FROM users
RIGHT JOIN orders 
  ON users.user_id = orders.user_id;

Ergebnis:

+----------+----------------+-------+
| username | produkt_name   | menge |
+----------+----------------+-------+
| Max      | T-Shirt        |     2 |
| Max      | Jeans          |     1 |
| Lisa     | Sneaker        |     1 |
+----------+----------------+-------+

Hinweis: RIGHT JOIN wird seltener verwendet. Meistens kann man LEFT JOIN umdrehen.

9.5 Mehrfache Tabellenverbindungen (3+ Tabellen)

Man kann mehrere Tabellen gleichzeitig verbinden!

Beispiel: Benutzer → Bestellungen → Produkte

-- Tabelle "products" erstellen
CREATE TABLE products (
    produkt_id INT PRIMARY KEY AUTO_INCREMENT,
    produkt_name VARCHAR(200),
    preis DECIMAL(10,2)
);

-- Daten einfügen
INSERT INTO products (produkt_name, preis)
VALUES ('T-Shirt', 19.99), ('Jeans', 59.99), ('Sneaker', 89.99);

-- orders-Tabelle um produkt_id erweitern
ALTER TABLE orders ADD COLUMN produkt_id INT;

-- produkt_id aktualisieren
UPDATE orders SET produkt_id = 1 WHERE bestell_id = 1;
UPDATE orders SET produkt_id = 2 WHERE bestell_id = 2;
UPDATE orders SET produkt_id = 3 WHERE bestell_id = 3;

3 Tabellen verbinden:

SELECT 
    users.username,
    products.produkt_name,
    products.preis,
    orders.menge
FROM users
INNER JOIN orders ON users.user_id = orders.user_id
INNER JOIN products ON orders.produkt_id = products.produkt_id;

Ergebnis:

+----------+----------------+-------+-------+
| username | produkt_name   | preis | menge |
+----------+----------------+-------+-------+
| Max      | T-Shirt        | 19.99 |     2 |
| Max      | Jeans          | 59.99 |     1 |
| Lisa     | Sneaker        | 89.99 |     1 |
+----------+----------------+-------+-------+

9.6 Praxisbeispiel: Komplexe Abfragen

Szenario: Blog-Datenbank mit Benutzern, Artikeln und Kommentaren.

Schritt 1: Tabellen erstellen

CREATE DATABASE IF NOT EXISTS blog_db;
USE blog_db;

CREATE TABLE users (
    user_id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50)
);

CREATE TABLE posts (
    post_id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT,
    titel VARCHAR(200),
    inhalt TEXT
);

CREATE TABLE comments (
    comment_id INT PRIMARY KEY AUTO_INCREMENT,
    post_id INT,
    user_id INT,
    kommentar TEXT
);

Schritt 2: Testdaten einfügen

INSERT INTO users (username) VALUES ('Max'), ('Lisa'), ('John');

INSERT INTO posts (user_id, titel, inhalt)
VALUES 
    (1, 'Mein erster Post', 'Hallo Welt!'),
    (1, 'Zweiter Post', 'Noch ein Test'),
    (2, 'Lisa schreibt', 'Ein Artikel von Lisa');

INSERT INTO comments (post_id, user_id, kommentar)
VALUES 
    (1, 2, 'Toller Artikel!'),
    (1, 3, 'Danke fürs Teilen'),
    (2, 3, 'Interessant...');

Schritt 3: Abfragen erstellen

1. Alle Artikel mit Autor-Namen anzeigen:

SELECT 
    posts.titel,
    users.username AS autor
FROM posts
INNER JOIN users ON posts.user_id = users.user_id;

2. Alle Kommentare zu einem Artikel mit Autor-Namen:

SELECT 
    posts.titel,
    users.username AS kommentar_von,
    comments.kommentar
FROM comments
INNER JOIN posts ON comments.post_id = posts.post_id
INNER JOIN users ON comments.user_id = users.user_id;

Häufige Fehler für Einsteiger

Fehler 1: Verbindungsbedingung falsch

-- ❌ Falsch: Verbindungsbedingung fehlt (Kartesisches Produkt!)
SELECT * FROM users INNER JOIN orders;

-- ✅ Richtig: ON-Bedingung angeben
SELECT * FROM users INNER JOIN orders ON users.user_id = orders.user_id;

Fehler 2: Mehrere Tabellen - Feldname nicht eindeutig

-- ❌ Falsch: user_id kommt in beiden Tabellen vor
SELECT user_id FROM users INNER JOIN orders ON ...;  -- FEHLER!

-- ✅ Richtig: Tabellennamen voranstellen
SELECT users.user_id, orders.user_id FROM users INNER JOIN orders ON ...;

Fehler 3: LEFT JOIN vs INNER JOIN verwechseln

-- INNER JOIN: Zeigt nur Benutzer MIT Bestellungen
SELECT * FROM users INNER JOIN orders ON users.user_id = orders.user_id;

-- LEFT JOIN: Zeigt ALLE Benutzer (auch solche OHNE Bestellungen)
SELECT * FROM users LEFT JOIN orders ON users.user_id = orders.user_id;

Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Warum Tabellenverbindungen notwendig sind
• ✅ INNER JOIN zu verwenden (nur Übereinstimmungen)
• ✅ LEFT JOIN zu verwenden (alle linke + übereinstimmende rechte)
• ✅ RIGHT JOIN zu verwenden (alle rechte + übereinstimmende linke)
• ✅ Mehrere Tabellen gleichzeitig zu verbinden
• ✅ Praxisbeispiele mit Blog-Datenbank

Übungen

1. Theorie: Was ist der Unterschied zwischen INNER JOIN und LEFT JOIN?
2. Praxis: Erstelle Tabellen students und grades, verbinde sie mit INNER JOIN
3. Praxis: Verwende LEFT JOIN, um alle Schüler anzuzeigen (auch solche ohne Noten)
4. Praxis: Verbinde 3 Tabellen: users → orders → products

Nächstes Kapitel

Im nächsten Kapitel lernen wir Unterabfragen (Subqueries) - wie man eine Abfrage innerhalb einer anderen Abfrage verwendet!