andi@abow: ~/ausbildung_fachinformatiker/ $ cat fisi-sql-mit-xampp-joins-und-unterabfragen-teil-2.md
>_abow

how do you do IT

Alle möglichen Handkniffe, die ich mir so zusammentrage im Berufsalltag

← cd ~/

FISI // SQL mit XAMPP: JOINs und Unterabfragen (Teil 2)

In einer sauber normalisierten Datenbank steht fast nichts an einer Stelle beisammen. Die Inventarnummer eines Notebooks liegt in der Gerätetabelle, der Name der Person, die damit arbeitet, in der Mitarbeitertabelle, und wer die Abteilung leitet, steht wieder woanders. Sobald eine Frage mehr als eine Tabelle betrifft, brauchst du einen JOIN oder eine Unterabfrage. Genau das wird in der Abschlussprüfung gern verlangt, oft sogar mit dem Zusatz, die Aufgabe auf beide Arten zu lösen.

Das ist Teil 2 der Serie. In Teil 1 haben wir XAMPP eingerichtet und Abfragen auf einer einzelnen Tabelle geschrieben: WHERE, GROUP BY, HAVING und Aggregatfunktionen. Diese Grundlagen setze ich hier voraus. Warum die Daten überhaupt auf mehrere Tabellen verteilt sind, erklärt der Beitrag ERM und relationales Datenmodell.

Ziel

Nach dem Artikel kannst du

  • zwei und mehr Tabellen mit INNER JOIN ... ON verknüpfen und Tabellenaliase sinnvoll einsetzen,
  • den impliziten Join über WHERE lesen und erklären, was ohne Join-Bedingung passiert,
  • eine Tabelle mit sich selbst verknüpfen (Self Join),
  • beurteilen, wann NATURAL JOIN gefährlich wird,
  • mit LEFT JOIN auch Datensätze ohne Partner finden,
  • Unterabfragen mit =, IN und Aggregatfunktionen schreiben,
  • für eine Aufgabe entscheiden, ob Join oder Unterabfrage besser passt.

Die Übungsdatenbank erweitern

Wir arbeiten weiter mit der Datenbank inventar aus Teil 1. Die Tabelle geraet hat bereits die Spalten abt_nr und pers_nr, bisher aber nur als nackte Zahlen. Jetzt bekommen sie ihre Gegenstücke. Führe das Skript in phpMyAdmin im Reiter „SQL“ der Datenbank inventar aus:

CREATE TABLE mitarbeiter (
  pers_nr  INT         PRIMARY KEY,
  nachname VARCHAR(30) NOT NULL,
  vorname  VARCHAR(30) NOT NULL,
  abt_nr   INT         NOT NULL
);

CREATE TABLE abteilung (
  abt_nr INT         PRIMARY KEY,
  name   VARCHAR(30) NOT NULL,
  leiter INT         NOT NULL   -- pers_nr der Abteilungsleitung
);

INSERT INTO mitarbeiter VALUES
(1001,'Kaya','Deniz',10),
(1002,'Schulz','Anna',20),
(1003,'Brandt','Jonas',20),
(1004,'Weber','Lena',10),
(1005,'Yilmaz','Jonas',30),
(1006,'Krüger','Anna',30),
(1007,'Hoffmann','Tim',20);

INSERT INTO abteilung VALUES
(10,'IT',1001),
(20,'Vertrieb',1003),
(30,'Buchhaltung',1005);

Die Beziehungen sehen so aus: geraet.pers_nr verweist auf mitarbeiter.pers_nr, mitarbeiter.abt_nr und geraet.abt_nr verweisen auf abteilung.abt_nr, und abteilung.leiter verweist wieder auf mitarbeiter.pers_nr. Die Abteilungsleitung ist also selbst ein Mitarbeiter. Fremdschlüssel-Constraints lassen wir hier bewusst weg, die kommen in Teil 3. Für Abfragen sind sie nicht nötig, ein Join funktioniert über gleiche Werte, nicht über deklarierte Beziehungen.

Zwei Mitarbeiter, Krüger und Hoffmann, haben kein Gerät. Und fünf Geräte haben keinen festen Benutzer. Beides brauchen wir später.

INNER JOIN: Zeilen mit Partner verbinden

Gesucht: alle Geräte mit dem Nachnamen der Person, die sie nutzt.

SELECT g.inv_nr, g.typ, m.nachname
FROM geraet g
INNER JOIN mitarbeiter m ON g.pers_nr = m.pers_nr
ORDER BY g.inv_nr;
inv_nrtypnachname
MO-301MonitorKaya
MO-302MonitorSchulz
NB-101NotebookKaya
NB-102NotebookSchulz
NB-103NotebookBrandt
PC-201DesktopWeber
PC-202DesktopYilmaz

Das DBMS nimmt jede Zeile aus geraet und sucht in mitarbeiter die Zeilen, für die die Bedingung hinter ON wahr ist. Nur Paare, die zusammenpassen, landen im Ergebnis. Die fünf Geräte mit pers_nr IS NULL fallen raus, weil NULL = 1001 nie wahr ist. Krüger und Hoffmann tauchen ebenfalls nicht auf, ihnen ist kein Gerät zugeordnet.

g und m sind Tabellenaliase. Du vergibst sie direkt hinter dem Tabellennamen (ein AS ist erlaubt, aber nicht nötig) und sparst dir damit viel Schreibarbeit. Pflicht wird ein Präfix, sobald eine Spalte in beiden Tabellen vorkommt: pers_nr gibt es in geraet und in mitarbeiter. Ein nacktes SELECT pers_nr bricht mit der Meldung „Column ‘pers_nr’ in field list is ambiguous“ ab. Ich empfehle, bei Joins grundsätzlich jede Spalte mit Alias zu schreiben. Dann sieht man auch beim Korrigieren sofort, woher sie kommt.

Das Wort INNER darfst du weglassen, ein einfaches JOIN ist in MySQL, MariaDB und SQL Server ein Inner Join.

Der implizite Join und das kartesische Produkt

In älteren Lehrbüchern und in vielen Prüfungslösungen steht der Join noch in dieser Form:

SELECT g.inv_nr, g.typ, m.nachname
FROM geraet g, mitarbeiter m
WHERE g.pers_nr = m.pers_nr;

Das Ergebnis ist identisch. Die Tabellen stehen mit Komma getrennt hinter FROM, die Verknüpfungsbedingung steckt im WHERE. Beide Schreibweisen sind korrekt und werden in der Prüfung anerkannt.

Interessant ist, was passiert, wenn die Bedingung fehlt. Dann kombiniert das DBMS jede Zeile der einen Tabelle mit jeder Zeile der anderen. Das nennt man kartesisches Produkt oder Cross Join. Bei 12 Geräten und 7 Mitarbeitern sind das 84 Zeilen, in denen jedem Notebook jeder Mitarbeiter einmal zugeordnet ist. Fachlich ist das Unsinn, technisch aber eine gültige Abfrage, deshalb meldet das DBMS keinen Fehler. Genau dieser Fehler passiert in Klassenarbeiten ständig: Zwei Tabellen hinter FROM, eine Filterbedingung wie WHERE name = 'Vertrieb', aber keine Verknüpfung. Das Ergebnis enthält dann alle Mitarbeiter, jeweils mit „Vertrieb“ daneben.

Der explizite JOIN ... ON hat einen praktischen Vorteil: Verknüpfung und Filter stehen an getrennten Stellen. Du siehst sofort, ob zu jedem JOIN ein ON gehört.

Joins über drei Tabellen

Welche Geräte nutzen Mitarbeiter des Vertriebs? Der Abteilungsname steht nur in abteilung, also brauchen wir drei Tabellen. Jeder weitere JOIN hängt eine Tabelle an das bisherige Zwischenergebnis an und bekommt seine eigene ON-Bedingung:

SELECT g.inv_nr, g.modell, m.nachname
FROM geraet g
JOIN mitarbeiter m ON g.pers_nr = m.pers_nr
JOIN abteilung a   ON m.abt_nr  = a.abt_nr
WHERE a.name = 'Vertrieb'
ORDER BY g.inv_nr;
inv_nrmodellnachname
MO-302P2723DESchulz
NB-102ThinkPad T14Schulz
NB-103Latitude 5440Brandt

Als Faustregel gilt: Bei n Tabellen brauchst du mindestens n − 1 Join-Bedingungen. In manchen Lösungen siehst du Klammern um die einzelnen Joins, etwa FROM ((geraet g JOIN mitarbeiter m ON ...) JOIN abteilung a ON ...). Microsoft Access verlangt diese Klammern, MariaDB und SQL Server nicht. Falsch sind sie dort nicht.

Join über eine Spalte mit anderem Namen

Eine Join-Bedingung muss nicht zwei gleichnamige Spalten vergleichen. Welche Geräte nutzt die Leitung des Vertriebs?

SELECT g.inv_nr, g.modell
FROM geraet g
JOIN abteilung a ON g.pers_nr = a.leiter
WHERE a.name = 'Vertrieb';

Das Ergebnis ist NB-103, das Latitude von Jonas Brandt. Entscheidend ist, dass beide Spalten dieselbe Sache meinen, hier eine Personalnummer. Ein typischer Fehler wäre ON g.abt_nr = a.abt_nr: Das liefert alle fünf Geräte des Vertriebs, nicht die der Leitung. Lies die Aufgabe deshalb genau und frag dich, über welchen Fremdschlüssel die gesuchte Beziehung läuft.

Self Join: eine Tabelle mit sich selbst verknüpfen

Manchmal liegen beide Seiten einer Beziehung in derselben Tabelle. Dann nimmst du die Tabelle zweimal in die Abfrage und gibst ihr zwei verschiedene Aliase. Für das DBMS sind das danach zwei unabhängige Tabellen, die zufällig dieselben Daten enthalten.

Beispiel 1: Wer ist wessen Vorgesetzter? Die Leitung steht als Personalnummer in abteilung, der Name dazu wieder in mitarbeiter. Wir brauchen mitarbeiter also zweimal, einmal für die Mitarbeiterin oder den Mitarbeiter (m) und einmal für die Leitung (l):

SELECT m.nachname AS mitarbeiter, a.name AS abteilung, l.nachname AS leitung
FROM mitarbeiter m
JOIN abteilung a   ON m.abt_nr = a.abt_nr
JOIN mitarbeiter l ON a.leiter = l.pers_nr
WHERE m.pers_nr <> l.pers_nr          -- Leitung nicht als eigene Vorgesetzte zeigen
ORDER BY a.name, m.nachname;
mitarbeiterabteilungleitung
KrügerBuchhaltungYilmaz
WeberITKaya
HoffmannVertriebBrandt
SchulzVertriebBrandt

Self Join: Die Tabelle mitarbeiter wird zweimal mit unterschiedlichen Aliasen verwendet, einmal für die Mitarbeitenden und einmal für die Leitung

Beispiel 2: Gleiche Vornamen in zwei Abteilungen. Welche Mitarbeiter des Vertriebs (20) haben einen Vornamen, der auch in der Buchhaltung (30) vorkommt?

SELECT m1.pers_nr, m1.nachname, m1.vorname
FROM mitarbeiter m1
JOIN mitarbeiter m2 ON m1.vorname = m2.vorname
WHERE m1.abt_nr = 20
  AND m2.abt_nr = 30;

Ergebnis: Schulz (Anna) und Brandt (Jonas). m1 steht für die Leute aus dem Vertrieb, m2 für die aus der Buchhaltung, und die Join-Bedingung verlangt gleiche Vornamen. Gäbe es in der Buchhaltung zwei Annas, stünde Schulz zweimal im Ergebnis. Dann hilft ein SELECT DISTINCT.

NATURAL JOIN: bequem, aber tückisch

Ein NATURAL JOIN verknüpft zwei Tabellen automatisch über alle Spalten, die in beiden gleich heißen. Eine ON-Bedingung gibt es nicht.

SELECT inv_nr, nachname
FROM geraet
NATURAL JOIN mitarbeiter;

Das liefert hier dieselben sieben Zeilen wie der Inner Join oben. Allerdings nur zufällig. geraet und mitarbeiter haben zwei gleichnamige Spalten, pers_nr und abt_nr. Der Natural Join vergleicht also beide. Leiht die IT der Buchhaltung ein Notebook aus und trägt bei geraet.abt_nr die 30 ein, während der Benutzer weiterhin in Abteilung 10 geführt wird, verschwindet dieses Gerät kommentarlos aus dem Ergebnis. Dasselbe passiert, wenn jemand später in zwei Tabellen eine Spalte name oder bemerkung anlegt.

In der Prüfung kann der Natural Join als Begriff auftauchen. Du solltest ihn erklären können. Für eigene Abfragen nimm lieber JOIN ... ON, dann steht die Verknüpfung schwarz auf weiß da.

LEFT JOIN und RIGHT JOIN: auch Zeilen ohne Partner

Der Inner Join hat die Geräte ohne Benutzer verschluckt. Für eine Inventarliste ist das falsch, dort sollen alle Geräte auftauchen. Dafür gibt es den Outer Join. Ein LEFT JOIN behält alle Zeilen der linken Tabelle (die vor dem JOIN steht) und füllt die Spalten der rechten mit NULL, wenn es keinen Partner gibt:

SELECT g.inv_nr, m.nachname
FROM geraet g
LEFT JOIN mitarbeiter m ON g.pers_nr = m.pers_nr
ORDER BY g.inv_nr;

Jetzt erscheinen alle zwölf Geräte, bei DR-401, DR-402, MO-303, NB-104 und PC-203 steht als Nachname NULL.

INNER JOIN und LEFT JOIN im Vergleich: Der Inner Join liefert nur Geräte mit Benutzer, der Left Join alle Geräte und füllt fehlende Partner mit NULL

Dreh die Abfrage um, und du findest die Mitarbeiter ohne Gerät. Der Trick: Erst alle Mitarbeiter behalten, dann nur die Zeilen nehmen, bei denen auf der rechten Seite nichts gefunden wurde.

SELECT m.pers_nr, m.nachname
FROM mitarbeiter m
LEFT JOIN geraet g ON g.pers_nr = m.pers_nr
WHERE g.inv_nr IS NULL;

Ergebnis: 1006 Krüger und 1007 Hoffmann. Geprüft wird auf eine Spalte der rechten Tabelle, die normalerweise nie leer ist, am besten ihren Primärschlüssel.

Ein RIGHT JOIN macht dasselbe spiegelverkehrt und behält alle Zeilen der rechten Tabelle. geraet g RIGHT JOIN mitarbeiter m ist gleichbedeutend mit mitarbeiter m LEFT JOIN geraet g. In der Praxis schreiben die meisten nur LEFT JOIN und stellen die Tabellen passend um. Einen FULL OUTER JOIN, der beide Seiten vollständig behält, kennt SQL Server, MariaDB und MySQL aber nicht.

Unterabfragen

Eine Unterabfrage (Subselect, Subquery) ist ein vollständiges SELECT in runden Klammern, das innerhalb einer anderen Abfrage steht. Meist im WHERE. Das DBMS rechnet zuerst die innere Abfrage aus und setzt das Ergebnis dann in die äußere ein.

Unterabfrage mit genau einem Wert

Welche Geräte gehören zum Vertrieb? Wir kennen nur den Namen der Abteilung, in geraet steht aber die Nummer:

SELECT inv_nr, typ
FROM geraet
WHERE abt_nr = (SELECT abt_nr
                FROM abteilung
                WHERE name = 'Vertrieb');

Die innere Abfrage liefert 20, die äußere wird damit zu WHERE abt_nr = 20 und gibt NB-102, NB-103, PC-203, MO-302 und DR-402 zurück. Auch die Frage nach den Geräten der Vertriebsleitung lässt sich so lösen, mit WHERE pers_nr = (SELECT leiter FROM abteilung WHERE name = 'Vertrieb').

Wichtig: Mit =, <, > und Co. darf die Unterabfrage höchstens einen Wert liefern. Kommen mehrere zurück, bricht MariaDB mit „Subquery returns more than 1 row“ ab.

Unterabfrage mit Aggregatfunktion

Das ist der Fall, den Teil 1 offen gelassen hat. Welche Geräte waren teurer als der Durchschnitt aller Geräte? WHERE preis > AVG(preis) geht nicht, weil WHERE keine Aggregatfunktionen kennt. Mit einer Unterabfrage klappt es:

SELECT inv_nr, modell, preis
FROM geraet
WHERE preis > (SELECT AVG(preis) FROM geraet)
ORDER BY preis DESC;

Der Durchschnitt liegt bei 720,67 Euro. Darüber liegen sechs Geräte: die vier Notebooks und die beiden OptiPlex-Desktops für je 749 Euro. Diese Art Aufgabe lässt sich mit einem Join nicht sinnvoll lösen.

Ablauf einer Unterabfrage: Die innere Abfrage berechnet den Durchschnittspreis, die äußere vergleicht jede Zeile damit

Unterabfrage mit mehreren Werten: IN

Liefert die innere Abfrage eine ganze Liste, nimmst du IN. Welche Mitarbeiter nutzen ein Gerät, das mehr als 1000 Euro gekostet hat?

SELECT pers_nr, nachname
FROM mitarbeiter
WHERE pers_nr IN (SELECT pers_nr
                  FROM geraet
                  WHERE preis > 1000);

Die innere Abfrage liefert 1001, 1002 und NULL (das HP-Notebook NB-104 hat keinen Benutzer). Ergebnis: Kaya und Schulz. Die Vornamen-Aufgabe aus dem Self-Join-Abschnitt sieht als Unterabfrage so aus:

SELECT pers_nr, nachname, vorname
FROM mitarbeiter
WHERE abt_nr = 20
  AND vorname IN (SELECT vorname FROM mitarbeiter WHERE abt_nr = 30);

Unterabfragen lassen sich auch schachteln. Welche Geräte nutzen Mitarbeiter einer Abteilung, die von Personalnummer 1003 geleitet wird? Von innen nach außen gelesen: Abteilung von 1003 suchen, Mitarbeiter dieser Abteilung suchen, deren Geräte ausgeben.

SELECT inv_nr, modell
FROM geraet
WHERE pers_nr IN (SELECT pers_nr
                  FROM mitarbeiter
                  WHERE abt_nr IN (SELECT abt_nr
                                   FROM abteilung
                                   WHERE leiter = 1003));

Das ergibt NB-102, NB-103 und MO-302. Für die innerste Abfrage nehme ich IN statt =, obwohl eine Person heute nur eine Abteilung leitet. Leitet sie später zwei, läuft die Abfrage trotzdem.

Join oder Unterabfrage?

Viele Fragen lassen sich auf beide Arten beantworten. Diese Übersicht hilft bei der Entscheidung:

Situationbesser geeignetGrund
Ausgabe enthält Spalten aus mehreren TabellenJoinEine Unterabfrage im WHERE liefert keine Spalten für die Ausgabe.
Andere Tabelle dient nur als FilterbeidesUnterabfrage liest sich oft näher an der Frage.
Vergleich mit Durchschnitt, Maximum usw.UnterabfrageAggregate sind in WHERE nicht erlaubt.
Datensätze ohne Partner findenLEFT JOIN ... IS NULLNOT IN hat Probleme mit NULL (siehe unten).
Gleiche Werte innerhalb einer TabelleSelf Join oder INBeides üblich, Self Join braucht zwei Aliase.

Genau daraus ergibt sich, warum in der Prüfung bei Join und Subselect manchmal unterschiedliche Ausgabespalten verlangt werden. Für die Join-Lösung heißt es zum Beispiel „Personalnummer, Nachname, Abteilungsname“, für die Subselect-Lösung „Personalnummer, Nachname, Abteilungsnummer“. Den Abteilungsnamen kann die Unterabfrage nicht in die Ausgabe bringen, die Nummer steht dagegen in der äußeren Tabelle.

Bei der Geschwindigkeit nehmen sich beide Varianten auf aktuellen Datenbanksystemen meist wenig, weil der Optimierer Unterabfragen oft intern in Joins umwandelt. In der Prüfung zählt die Korrektheit.

Praxis: Datenqualität per PowerShell prüfen

Mit Outer Joins findest du Datensätze, deren Verweise ins Leere zeigen. In einer echten Inventardatenbank ist das ein häufiges Problem: Ein Mitarbeiter verlässt die Firma, sein Datensatz wird gelöscht, die Geräte verweisen aber weiter auf seine Personalnummer. Das folgende Skript führt mehrere Prüfabfragen gegen die XAMPP-Datenbank aus und meldet, wo etwas nicht stimmt.

# Prüfabfragen: Name der Prüfung und SQL, das die betroffenen Zeilen zählt
$mysql   = 'C:\xampp\mysql\bin\mysql.exe'
$pruefungen = [ordered]@{
    # Gerät verweist auf eine Personalnummer, die es nicht (mehr) gibt
    'Geräte mit unbekanntem Benutzer' = 'SELECT COUNT(*) FROM geraet g LEFT JOIN mitarbeiter m ON g.pers_nr = m.pers_nr WHERE g.pers_nr IS NOT NULL AND m.pers_nr IS NULL;'
    # Abteilungsleitung ist kein bekannter Mitarbeiter
    'Abteilungen ohne gültige Leitung' = 'SELECT COUNT(*) FROM abteilung a LEFT JOIN mitarbeiter m ON a.leiter = m.pers_nr WHERE m.pers_nr IS NULL;'
    # Mitarbeiter ohne Gerät, kein Fehler, aber gut zu wissen
    'Mitarbeiter ohne Gerät' = 'SELECT COUNT(*) FROM mitarbeiter m LEFT JOIN geraet g ON g.pers_nr = m.pers_nr WHERE g.inv_nr IS NULL;'
}

foreach ($name in $pruefungen.Keys) {
    # --skip-column-names liefert nur den Wert, ohne Kopfzeile
    $anzahl = [int](& $mysql --user=root --batch --skip-column-names --execute=$pruefungen[$name] inventar)
    $farbe  = if ($anzahl -eq 0) { 'Green' } else { 'Yellow' }
    Write-Host ('{0,-35} {1,3}' -f $name, $anzahl) -ForegroundColor $farbe
}

Auf unserer Übungsdatenbank melden die ersten beiden Prüfungen 0 und die dritte 2. Lösch zum Test mit DELETE FROM mitarbeiter WHERE pers_nr = 1004; den Datensatz von Lena Weber und lass das Skript noch einmal laufen. Dann zeigt die erste Prüfung 1, weil PC-201 jetzt auf eine nicht vorhandene Person verweist. Genau das verhindern Fremdschlüssel-Constraints, um die es in Teil 3 geht. Wie die Aufrufe von mysql.exe funktionieren, steht im Praxis-Abschnitt von Teil 1, die Grundlagen zu Hashtables und Schleifen in den PowerShell-Grundlagen.

Stolperfallen

Join-Bedingung vergessen. Zwei Tabellen hinter FROM oder ein JOIN ohne passendes ON erzeugen ein kartesisches Produkt. Die Abfrage läuft fehlerfrei und liefert trotzdem Unsinn. Zähl nach: n Tabellen brauchen mindestens n − 1 Verknüpfungen.

Falsche Spalten verknüpft. ON g.abt_nr = a.abt_nr statt ON g.pers_nr = a.leiter beantwortet eine ganz andere Frage. Überleg bei jeder Bedingung, ob links und rechts wirklich dieselbe Sache stehen.

Mehrdeutige Spaltennamen. Kommt eine Spalte in mehreren Tabellen vor, braucht sie ein Präfix. Gewöhn dir an, bei Joins jede Spalte mit Alias zu schreiben.

Alias vergeben, aber Tabellenname benutzt. Hast du FROM geraet g geschrieben, musst du auch g.inv_nr schreiben. geraet.inv_nr meldet MariaDB dann als unbekannte Spalte.

= vor einer Unterabfrage mit mehreren Ergebnissen. Liefert die innere Abfrage mehr als einen Wert, brauchst du IN. Im Zweifel IN nehmen, das funktioniert auch bei genau einem Wert.

NOT IN und NULL. WHERE pers_nr NOT IN (SELECT pers_nr FROM geraet) liefert in unserer Datenbank kein einziges Ergebnis, obwohl Krüger und Hoffmann kein Gerät haben. Der Grund ist das NULL in der Liste: Ob 1006 ungleich NULL ist, bleibt unbekannt, und damit ist die ganze Bedingung nie wahr. Entweder in der Unterabfrage WHERE pers_nr IS NOT NULL ergänzen oder gleich den LEFT JOIN mit IS NULL verwenden.

Filter auf die rechte Tabelle im WHERE eines LEFT JOIN. geraet g LEFT JOIN mitarbeiter m ON ... WHERE m.nachname LIKE 'K%' wirft alle Geräte ohne Benutzer wieder raus, weil NULL LIKE 'K%' nicht wahr ist. Damit hast du heimlich einen Inner Join. Soll die Bedingung nur die Partner einschränken, gehört sie mit AND in die ON-Klausel.

COUNT(*) nach einem LEFT JOIN. Zählst du Geräte pro Mitarbeiter mit COUNT(*), bekommen Krüger und Hoffmann eine 1, weil ihre Zeile mit lauter NULL ja existiert. Richtig ist COUNT(g.inv_nr), das ignoriert NULL und liefert 0. Das ist dieselbe Regel wie in Teil 1, nur mit größerer Wirkung.

NATURAL JOIN ohne Blick auf die Spalten. Er verknüpft über alle gleichnamigen Spalten, auch über solche, an die du nicht gedacht hast. Prüfe vorher, welche Spalten beide Tabellen gemeinsam haben.

Fazit

Ein Join braucht vor allem die richtige Verknüpfungsbedingung, der Rest ist dieselbe SELECT-Logik wie in Teil 1. Mit INNER JOIN bekommst du nur Paare, mit LEFT JOIN zusätzlich die Zeilen ohne Partner, und beim Self Join sorgen zwei Aliase dafür, dass das DBMS eine Tabelle wie zwei behandelt. Unterabfragen sind die erste Wahl, wenn die andere Tabelle nur filtert oder wenn du mit einem Aggregat vergleichen willst. Übe beide Varianten an derselben Frage und vergleiche die Ergebnisse in XAMPP, dann sitzt das auch auf Papier. In Teil 3 legen wir Tabellen selbst an, ändern Daten, sichern Beziehungen mit Fremdschlüsseln ab und vergeben Benutzerrechte.

Weiterlesen