SQL Right Join

Questo articolo fornisce una panoramica del RIGHT JOIN in SQL, oltre ad alcuni esempi di base.

Conosciuto anche come RIGHT OUTER JOIN , il RIGHT JOIN restituisce righe che contengono dati nella tabella di destra (a destra di JOIN parola chiave), anche se non ci sono righe corrispondenti nella tabella di sinistra.

Sintassi

Specificare un diritto di join nel FROM clausola. Puoi usare sia il RIGHT JOIN o RIGHT OUTER JOIN sintassi.

Usando il RIGHT JOIN sintassi:

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

Usando il RIGHT OUTER JOIN sintassi:

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

Entrambi fanno esattamente la stessa cosa. È solo che il OUTER la parola chiave è facoltativa.

Esempi

Ecco alcuni esempi da dimostrare.

Dati di esempio

Innanzitutto, ecco le tabelle che useremo per gli esempi.

I PetTypes tabella:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Gli Pets tabella:

+---------+-------------+-----------+-----------+------------+
| 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)

I Owners tabella:

+-----------+-------------+------------+----------------+-------------------+
| 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] |
+-----------+-------------+------------+----------------+-------------------+

Nota che:

• Il PetTypeId colonna del Pets table è una chiave esterna di PetTypeId dei PetTypes table (che è la chiave primaria di quella tabella).
• Il OwnerId colonna del Pets table è una chiave esterna di OwnerId colonna dei Owners tabella.

La giusta query di unione

Ecco un esempio di esecuzione di un join destro su due di queste tabelle.

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

Risultato:

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

Il giusto join ci fa ottenere un PetType valore che non corrisponde a un PetName . Nello specifico, non ci sono conigli come animali da compagnia. Ma il giusto join provoca Rabbit da restituire, anche se non ci sono animali nel Pets tabella di quel tipo. Ciò risulta in un NULL valore nel PetName colonna contro Rabbit .

Questo è successo solo perché Rabbit era nella tabella di destra (cioè a destra del RIGHT JOIN parole chiave).

Ecco cosa succede se cambiamo l'ordine delle tabelle nella nostra query.

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

Risultato:

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

Questa volta Rabbits non è stato restituito. Questo perché la sua tabella (PetTypes ) era sul lato sinistro del join.

Dovremmo cambiarlo in un join sinistro o in un join completo se volessimo Rabbits da restituire utilizzando questo ordine di tabella.

Unisciti a destra su 3 tavoli

Ecco un esempio di esecuzione di un join corretto su tutti e tre i tavoli.

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;

Risultato:

+-----------+-----------+----------------+
| 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)

Questa volta abbiamo un proprietario di un animale domestico che non ha un animale domestico.

Potremmo ancora una volta mischiare l'ordine dei tavoli e otterremmo un risultato diverso.

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;

Risultato:

+-----------+-----------+---------------+
| 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)

Questa volta abbiamo ottenuto il tipo di animale domestico extra (Rabbit ), ma non il proprietario aggiuntivo.

Se ti stai chiedendo perché l'ultimo PetOwner non è NULL (come ultimo il PetName is), è perché è il risultato di una concatenazione di stringhe. Ho usato T-SQL CONCAT() funzione per concatenare il nome e il cognome del proprietario.