Dieser Artikel gibt einen Überblick über den FULL JOIN
in SQL sowie einige grundlegende Beispiele.
Der SQL-FULL JOIN
(oder FULL OUTER JOIN
) gibt alle Zeilen zurück, solange in einer der Tabellen übereinstimmende Daten vorhanden sind.
Es ist, als hätte man einen Left-Right-Join in einem Join.
Syntax
Sie geben einen vollständigen Join im FROM
an Klausel. Sie können entweder den FULL JOIN
verwenden oder FULL OUTER JOIN
Syntax.
Verwenden des FULL JOIN
Syntax:
SELECT *
FROM Table1 FULL JOIN Table2
ON Table1.Column = Table2.Column;
Verwenden des FULL OUTER JOIN
Syntax:
SELECT *
FROM Table1 FULL OUTER JOIN Table2
ON Table1.Column = Table2.Column;
Beide machen genau dasselbe. Es ist nur das OUTER
Schlüsselwort ist optional.
Beispiele
Hier sind einige Beispiele zur Veranschaulichung.
Beispieldaten
Hier sind zunächst die Tabellen, die wir für die Beispiele verwenden werden.
Die PetTypes
Tabelle:
+-------------+-----------+| PetTypeId | Haustiertyp ||-------------+-----------|| 1 | Vogel || 2 | Katze || 3 | Hund || 4 | Hase |+-------------+-----------+(4 Zeilen betroffen)
Die Pets
Tabelle:
+---------+------------+-----------+---------- -+------------+| Haustier-ID | PetTypeId | Eigentümer-ID | Haustiername | Geburtsdatum ||---------+------------+-----------+----------- +------------|| 1 | 2 | 3 | Flauschig | 2020-11-20 || 2 | 3 | 3 | Holen | 2019-08-16 || 3 | 2 | 2 | Kratzer | 01.10.2018 || 4 | 3 | 3 | Wackeln | 2020-03-15 || 5 | 1 | 1 | Twittern | 2020-11-28 || 6 | 3 | 4 | Flauschig | 2020-09-17 || 7 | 3 | 2 | Rinde | NULL || 8 | 2 | 4 | Miau | NULL |+---------+------------+-----------+----------- +------------+(8 Zeilen betroffen)
Die Owners
Tabelle:
+-----------+------------+-----------+------- ---------+-------------------+| Eigentümer-ID | Vorname | Nachname | Telefon | E-Mail ||-----------+-------------+------------+-------- --------+-------------------|| 1 | Homer | Conner | (308) 555-0100 | [email protected] || 2 | Bart | Pitt | (231) 465-3497 | [email protected] || 3 | Nancy | Simpson | (489) 591-0408 | NULL || 4 | Boris | Trumpf | (349) 611-8908 | NULL || 5 | Holzig | Eastwood | (308) 555-0112 | [email protected] |+-----------+---------------------+------------+---- -------------+-------------------+
Beachten Sie Folgendes:
- Die
PetTypeId
Spalte derPets
table ist ein Fremdschlüssel derPetTypeId
derPetTypes
Tabelle (das ist der Primärschlüssel dieser Tabelle). - Die
OwnerId
Spalte derPets
table ist ein Fremdschlüssel derOwnerId
Spalte derOwners
Tabelle.
Die Full-Join-Abfrage
Hier ist ein Beispiel für die Durchführung eines vollständigen Joins für zwei dieser Tabellen.
SELECT
p.PetName,
pt.PetType
FROM Pets p
FULL 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 Beispiel erhalten wir einen PetType
Wert, der keinem PetName
entspricht . Dies liegt daran, dass es keine Kaninchen als Haustiere gibt. Aber die vollständige Verknüpfung verursacht Rabbit
zurückgegeben werden, obwohl in den Pets
kein Haustier enthalten ist Tabelle dieser Art. Dies führt zu einem NULL
Wert in PetName
Spalte gegen Rabbit
.
Dies ist das gleiche Ergebnis, das wir erhalten hätten, wenn wir einen rechten Join verwendet hätten, da die PetTypes
Die Tabelle befindet sich rechts neben JOIN
Stichwort. Mit einem Left Join wäre das nicht passiert, weil PetTypes
Tabelle befindet sich nicht links vom JOIN
Stichwort. Wollten wir es mit einem Left Join nachbauen, müssten wir die Reihenfolge der Tabellen umstellen, sodass die PetTypes
Tabelle war auf der linken Seite des JOIN
Stichwort.
Folgendes passiert, wenn wir die Tabellenreihenfolge in unserer Abfrage ändern, wenn wir einen vollständigen Join verwenden.
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)
Wir erhalten genau das gleiche Ergebnis. Dies liegt daran, dass der vollständige Join alle Zeilen zurückgibt, solange übereinstimmende Daten in einer der Tabellen vorhanden sind. Wie bereits erwähnt, ist es so, als hätte man einen linken und einen rechten Join in einem Join.
Vollständiger Beitritt an 3 Tischen
Hier ist ein Beispiel für die Durchführung eines vollständigen Joins für alle drei Tabellen.
SELECT
p.PetName,
pt.PetType,
CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o FULL JOIN Pets p
ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;
Ergebnis:
+-----------+-----------+----------------+| Haustiername | Haustiertyp | Haustierbesitzer ||-----------+-----------+----------------|| Twittern | Vogel | Homer Connery || Kratzer | Katze | Bart Pitt || Rinde | Hund | Bart Pitt || Flauschig | Katze | Nancy Simpson || Holen | Hund | Nancy Simpson || Wackeln | Hund | Nancy Simpson || Flauschig | Hund | Boris Trumpf || Miau | Katze | Boris Trumpf || NULL | NULL | Woody Eastwood || NULL | Kaninchen | |+-----------+-----------+----------------+(10 Zeilen betroffen)Diesmal haben wir einen Haustierbesitzer, der kein Haustier hat, sowie einen Haustiertyp, der keinem Haustier zugeordnet ist.
Wenn wir die Reihenfolge der Tabellen umstellen, erhalten wir das gleiche Ergebnis, obwohl die Zeilen in einer anderen Reihenfolge aufgelistet sind.
SELECT p.PetName, pt.PetType, CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner FROM PetTypes pt FULL JOIN Pets p ON p.PetTypeId = pt.PetTypeId FULL JOIN Owners o ON p.OwnerId = o.OwnerId;
Ergebnis:
-----------+-----------+----------------+| Haustiername | Haustiertyp | Haustierbesitzer ||-----------+-----------+----------------|| Twittern | Vogel | Homer Connery || Flauschig | Katze | Nancy Simpson || Kratzer | Katze | Bart Pitt || Miau | Katze | Boris Trumpf || Holen | Hund | Nancy Simpson || Wackeln | Hund | Nancy Simpson || Flauschig | Hund | Boris Trumpf || Rinde | Hund | Bart Pitt || NULL | Kaninchen | || NULL | NULL | Woody Eastwood |+-----------+-----------+----------------+(10 Zeilen betroffen)
Und wenn wir sie noch einmal mischen, erhalten wir immer noch das gleiche Ergebnis.
SELECT
p.PetName,
pt.PetType,
CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p FULL JOIN Owners o
ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;
Ergebnis:
+-----------+-----------+----------------+| Haustiername | Haustiertyp | Haustierbesitzer ||-----------+-----------+----------------|| Flauschig | Katze | Nancy Simpson || Holen | Hund | Nancy Simpson || Kratzer | Katze | Bart Pitt || Wackeln | Hund | Nancy Simpson || Twittern | Vogel | Homer Connery || Flauschig | Hund | Boris Trumpf || Rinde | Hund | Bart Pitt || Miau | Katze | Boris Trumpf || NULL | NULL | Woody Eastwood || NULL | Kaninchen | |+-----------+-----------+----------------+(10 Zeilen betroffen)Falls Sie sich fragen, warum der letzte
PetOwner
ist nichtNULL
(wie zuletzt derPetName
ist), weil es das Ergebnis einer Zeichenfolgenverkettung ist. Ich habe das T-SQLCONCAT()
verwendet Funktion, um den Vor- und Nachnamen des Besitzers zu verketten.