Lernprogramm für SQL-Joins

Der Equi-Join

Der obige Join kann auch als Equi-Join bezeichnet werden . Ein Equi-Join ist ein Join, der nur Gleichheitsvergleiche im Join-Prädikat enthält.

Eine andere Art, den obigen Join zu schreiben, ist wie folgt:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Katze || Holen | Hund || Kratzer | Katze || Wackeln | Hund || Twittern | Vogel || Flauschig | Hund || Rinde | Hund || Miau | Katze |+-----------+-----------+

Dies ist ein Beispiel für die Angabe eines inneren Joins in WHERE Klausel. Wir haben einfach eine durch Kommas getrennte Liste der Tabellen bereitgestellt und dann ein WHERE Zustand. Wenn wir WHERE weggelassen hätten Bedingung, hätten wir am Ende einen CROSS JOIN erhalten .

Viele Anfänger finden die obige Syntax viel einfacher zu verstehen als den INNER JOIN Syntax. Fühlen Sie sich frei, diese Syntax zu verwenden, wenn Sie dies vorziehen, beachten Sie jedoch, dass die meisten SQL-Profis den INNER JOIN bevorzugen Syntax aus dem vorherigen Beispiel.

Weitere Beispiele finden Sie unter SQL Inner Join, einschließlich eines Inner Join, der 3 Tabellen verbindet.

Die richtige Verbindung

Auch als RIGHT OUTER JOIN bekannt , der RIGHT JOIN gibt Zeilen zurück, die Daten in der rechten Tabelle enthalten (rechts vom JOIN). Schlüsselwort), auch wenn es keine übereinstimmenden Zeilen in der linken Tabelle gibt.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Twittern | Vogel || Flauschig | Katze || Kratzer | Katze || Miau | Katze || Holen | Hund || Wackeln | Hund || Flauschig | Hund || Rinde | Hund || NULL | Hase |+-----------+-----------+(9 Zeilen betroffen)

In diesem Fall haben wir einen zusätzlichen PetType Wert – Rabbits – obwohl es kein Haustier in den Pets gibt Tabelle dieser Art. Dies führt zu einem NULL Wert im PetName Spalte gegen Rabbit .

Weitere Beispiele finden Sie unter SQL Right Join, einschließlich eines Right Join, der 3 Tabellen verbindet.

Die linke Verbindung

Auch als LEFT OUTER JOIN bekannt , der SQL LEFT JOIN gibt Zeilen zurück, die Daten in der linken Tabelle enthalten (links vom JOIN). Schlüsselwort), auch wenn es keine übereinstimmenden Zeilen in der rechten Tabelle gibt.

Dies ist das Gegenteil von RIGHT JOIN .

Wenn wir das vorherige Beispiel ändern, um einen linken Join zu verwenden, erhalten wir das folgende Ergebnis.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Katze || Holen | Hund || Kratzer | Katze || Wackeln | Hund || Twittern | Vogel || Flauschig | Hund || Rinde | Hund || Miau | Katze |+-----------+-----------+(8 Zeilen betroffen)

In diesem speziellen Fall sind unsere Ergebnisse die gleichen wie beim Inner Join.

Wenn wir jedoch die Tabellenreihenfolge in unserem FROM vertauschen -Klausel erhalten wir ein ähnliches Ergebnis wie beim rechten Join im vorherigen Beispiel.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Twittern | Vogel || Flauschig | Katze || Kratzer | Katze || Miau | Katze || Holen | Hund || Wackeln | Hund || Flauschig | Hund || Rinde | Hund || NULL | Hase |+-----------+-----------+(9 Zeilen betroffen)

Sie können also sehen, dass jeder resultierende Unterschied zwischen den Links- und Rechtsverknüpfungen ausschließlich davon abhängt, wie Sie die Spalten in FROM anordnen Klausel.

Weitere Beispiele finden Sie unter SQL Left Join, einschließlich eines Left Join, der 3 Tabellen verbindet.

Der vollständige Beitritt

Der SQL-FULL JOIN (oder FULL OUTER JOIN ) gibt alle Zeilen zurück, solange in einer der Tabellen übereinstimmende Daten vorhanden sind.

Mit anderen Worten, es ist, als hätte man sowohl einen linken als auch einen rechten Join in einem Join.

Hier ist ein Beispiel für einen vollständigen Join.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Katze || Holen | Hund || Kratzer | Katze || Wackeln | Hund || Twittern | Vogel || Flauschig | Hund || Rinde | Hund || Miau | Katze || NULL | Hase |+-----------+-----------+(9 Zeilen betroffen)

Dies gibt das gleiche Ergebnis zurück, das wir mit dem rechten Join erhalten haben, aber es hätte ein anderes Ergebnis zurückgegeben, wenn es eine Zeile in der linken Tabelle gegeben hätte, die keinen entsprechenden Wert in der rechten Tabelle hätte.

Lassen Sie uns die Tabellennamen vertauschen und es erneut ausführen.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
FULL JOIN Pets p
ON p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Twittern | Vogel || Flauschig | Katze || Kratzer | Katze || Miau | Katze || Holen | Hund || Wackeln | Hund || Flauschig | Hund || Rinde | Hund || NULL | Hase |+-----------+-----------+(9 Zeilen betroffen)

Gleiches Ergebnis.

Weitere Beispiele finden Sie unter Vollständiger SQL-Join, einschließlich eines vollständigen Joins, der 3 Tabellen verbindet.

Die Kreuzverbindung

Der SQL-CROSS JOIN gibt Zeilen zurück, die jede Zeile aus der ersten Tabelle mit jeder Zeile aus der zweiten Tabelle kombinieren.

Mit anderen Worten, es gibt das kartesische Produkt von Zeilen aus Tabellen im Join zurück.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Vogel || Holen | Vogel || Kratzer | Vogel || Wackeln | Vogel || Twittern | Vogel || Flauschig | Vogel || Rinde | Vogel || Miau | Vogel || Flauschig | Katze || Holen | Katze || Kratzer | Katze || Wackeln | Katze || Twittern | Katze || Flauschig | Katze || Rinde | Katze || Miau | Katze || Flauschig | Hund || Holen | Hund || Kratzer | Hund || Wackeln | Hund || Twittern | Hund || Flauschig | Hund || Rinde | Hund || Miau | Hund || Flauschig | Kaninchen || Holen | Kaninchen || Kratzer | Kaninchen || Wackeln | Kaninchen || Twittern | Kaninchen || Flauschig | Kaninchen || Rinde | Kaninchen || Miau | Kaninchen |+-----------+-----------+(32 Zeilen betroffen)

Wie Sie sich wahrscheinlich vorstellen können, könnte dies sehr gefährlich sein, wenn Sie es gegen die falschen Tische laufen lassen.

Es ist dasselbe wie dies:

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p, PetTypes pt; 

Sie können ein WHERE hinzufügen -Klausel zu einem Cross-Join, wodurch sie in einen Inner-Join umgewandelt wird.

So:

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId; 

Ergebnis:

+-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Katze || Holen | Hund || Kratzer | Katze || Wackeln | Hund || Twittern | Vogel || Flauschig | Hund || Rinde | Hund || Miau | Katze |+-----------+-----------+(8 Zeilen betroffen)

Weitere Beispiele finden Sie unter SQL Cross Join.

Die natürliche Verbindung

Der SQL-NATURAL JOIN ist eine Art Equi-Join, bei dem das Join-Prädikat implizit entsteht, indem alle Spalten in beiden Tabellen verglichen werden, die in den verknüpften Tabellen dieselben Spaltennamen haben.

Die Ergebnismenge enthält nur eine Spalte für jedes Paar gleichnamiger Spalten. Wenn keine Spalten mit demselben Namen gefunden werden, ist das Ergebnis ein Cross Join.

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets NATURAL JOIN PetTypes; 

Ergebnis:

Hausname | pettype ---------+--------- Fluffy | Katze holen | Hund kratzen | Katze wedelt | Hund twittern | Vogel flauschig | Hund bellen | Hund Miau | Katze (8 Reihen)

Tatsächlich ist der natürliche Join kein Join-Typ im Sinne des ANSI-Standards. Es ist ein Schlüsselwort, das Sie optional einfügen können, um den Join zu einem natürlichen Join zu machen.

Daher könnten wir das obige Beispiel in NATURAL INNER JOIN ändern wenn wir wollten:

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets NATURAL INNER JOIN PetTypes; 

Wie bereits erwähnt, sind innere Joins der Standard-Join-Typ, wenn Sie also den Join-Typ weglassen (z. B. INNER , LEFT , RIGHT usw.), dann wird es als innerer Join behandelt.

Wenn die Formatierung dieser Ergebnisse anders aussieht als die vorherigen Ergebnisse, liegt das daran, dass ich zu PostgreSQL wechseln musste, um diese Abfrage auszuführen. Ich habe die vorherigen Beispiele in SQL Server ausgeführt, aber SQL Server unterstützt die natürliche Verknüpfung nicht.

Siehe SQL Natural Join für weitere Beispiele, einschließlich eines natürlichen Joins, der 3 Tabellen verbindet.

Der Selbstbeitritt

Der SQL-SELF JOIN verbindet eine Tabelle mit sich selbst.

Ein klassisches Beispiel für einen Self-Join ist eine Employees-Tabelle. In einer solchen Tabelle kann ein Mitarbeiter einem anderen Mitarbeiter unterstellt sein. Daher könnten Sie einen Self-Join verwenden, um die Tabelle in der Spalte "Mitarbeiter-ID" und "Manager-ID" zu verknüpfen.

Angenommen, wir haben die folgende Tabelle:

+--------------+------------+------------+---- ---------+| MitarbeiterID | Vorname | Nachname | BerichteAn ||--------------+------------+------------+----- --------|| 1 | Homer | Conner | NULL || 2 | Bart | Pitt | 1 || 3 | Maggie | Greif | 1 || 4 | Peter | Farnworth | 2 || 5 | Marge | Morrison | NULL || 6 | Lisa | Stapel | 5 || 7 | David | Zuckerberg | 6 || 8 | Vlad | Koch | 7 |+--------------+------------+------------+----- --------+

Wir können an dieser Tabelle eine Selbstverknüpfung durchführen, um alle Mitarbeiter und ihre Manager zurückzugeben.

SELECT
    CONCAT(e1.FirstName, ' ', e1.LastName) AS Employee,
    CONCAT(e2.FirstName, ' ', e2.LastName) AS Manager
FROM Employees e1
LEFT JOIN Employees e2 
ON e1.ReportsTo = e2.EmployeeId; 

Ergebnis:

+------------------+-----------------+| Mitarbeiter | Manager ||-----------------+-----------------|| Homer Connery | || Bart Pitt | Homer Connery || Maggie Griffin | Homer Connery || Peter Farnsworth | Bart Pitt || Marge Morrison | || Lisa-Batch | Marge Morrison || David Zuckerberg | Lisa-Batch || Vlad Koch | Dave Zuckerberg |+-----------------+----------------+

Weitere Beispiele finden Sie unter SQL Self Join.