SQL-Rechtsverknüpfung

Dieser Artikel gibt einen Überblick über den RIGHT JOIN in SQL sowie einige grundlegende Beispiele.

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.

Syntax

Sie geben einen rechten Join im FROM an Klausel. Sie können entweder den RIGHT JOIN verwenden oder RIGHT OUTER JOIN Syntax.

Mit dem RIGHT JOIN Syntax:

SELECT *
FROM Table1 RIGHT JOIN Table2 
ON Table1.Column = Table2.Column;

Verwenden des RIGHT OUTER JOIN Syntax:

SELECT *
FROM Table1 RIGHT 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   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Die Pets Tabelle:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

Die Owners Tabelle:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

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 Right-Join-Abfrage

Hier ist ein Beispiel für die Durchführung eines Right Joins für zwei dieser Tabellen.

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

Ergebnis:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

Der richtige Join bewirkt, dass wir einen PetType erhalten Wert, der keinem PetName entspricht . Insbesondere gibt es keine Kaninchen als Haustiere. Aber der richtige Join 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 geschah nur, weil Rabbit war in der rechten Tabelle (d. h. rechts vom RIGHT JOIN). Schlüsselwörter).

Folgendes passiert, wenn wir die Tabellenreihenfolge in unserer Abfrage ändern.

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

Ergebnis:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Dieses Mal Rabbits wurde nicht zurückgegeben. Das liegt daran, dass seine Tabelle (PetTypes ) befand sich auf der linken Seite des Joins.

Wir müssten es in einen linken Join oder einen vollständigen Join ändern, wenn wir Rabbits wollten mit dieser Tabellenreihenfolge zurückgegeben werden.

Right Join an 3 Tischen

Hier ist ein Beispiel für die Durchführung eines Right Joins für alle drei Tabellen.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p RIGHT JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
RIGHT JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Ergebnis:

+-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Tweet     | Bird      | Homer Connery  |
| Scratch   | Cat       | Bart Pitt      |
| Bark      | Dog       | Bart Pitt      |
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(9 rows affected)

Diesmal haben wir einen Haustierbesitzer, der kein Haustier hat.

Wir könnten die Reihenfolge der Tabellen erneut mischen und würden ein anderes Ergebnis erhalten.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p RIGHT JOIN Owners o 
    ON p.OwnerId = o.OwnerId
RIGHT JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId;

Ergebnis:

+-----------+-----------+---------------+
| PetName   | PetType   | PetOwner      |
|-----------+-----------+---------------|
| Tweet     | Bird      | Homer Connery |
| Fluffy    | Cat       | Nancy Simpson |
| Scratch   | Cat       | Bart Pitt     |
| Meow      | Cat       | Boris Trump   |
| Fetch     | Dog       | Nancy Simpson |
| Wag       | Dog       | Nancy Simpson |
| Fluffy    | Dog       | Boris Trump   |
| Bark      | Dog       | Bart Pitt     |
| NULL      | Rabbit    |               |
+-----------+-----------+---------------+
(9 rows affected)

Dieses Mal haben wir den zusätzlichen Haustiertyp (Rabbit). ), aber nicht der zusätzliche Eigentümer.

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.