Vollständiger SQL-Join

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 | example@sqldat.com || 2 | Bart | Pitt | (231) 465-3497 | example@sqldat.com || 3 | Nancy | Simpson | (489) 591-0408 | NULL || 4 | Boris | Trumpf | (349) 611-8908 | NULL || 5 | Holzig | Eastwood | (308) 555-0112 | example@sqldat.com |+-----------+---------------------+------------+---- -------------+-------------------+

Beachten Sie Folgendes:

• Die PetTypeId Spalte der Pets table ist ein Fremdschlüssel der PetTypeId der PetTypes Tabelle (das ist der Primärschlüssel dieser Tabelle).
• Die OwnerId Spalte der Pets table ist ein Fremdschlüssel der OwnerId Spalte der Owners 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 nicht NULL (wie zuletzt der PetName ist), weil es das Ergebnis einer Zeichenfolgenverkettung ist. Ich habe das T-SQL CONCAT() verwendet Funktion, um den Vor- und Nachnamen des Besitzers zu verketten.