Questo articolo fornisce una panoramica di LEFT JOIN
in SQL, oltre ad alcuni esempi di base.
Il LEFT JOIN
o LEFT OUTER JOIN
, restituisce le righe che contengono dati nella tabella di sinistra (a sinistra di JOIN
parola chiave), anche se non ci sono righe corrispondenti nella tabella di destra.
Sintassi
Specifica un join sinistro nel FROM
clausola. Puoi usare sia il LEFT JOIN
o LEFT OUTER JOIN
sintassi.
Usando il LEFT JOIN
sintassi:
SELECT *
FROM Table1 LEFT JOIN Table2
ON Table1.Column = Table2.Column;
Usando il LEFT OUTER JOIN
sintassi:
SELECT *
FROM Table1 LEFT 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 delPets
table è una chiave esterna diPetTypeId
deiPetTypes
table (che è la chiave primaria di quella tabella). - Il
OwnerId
colonna delPets
table è una chiave esterna diOwnerId
colonna deiOwners
tabella.
La query di unione a sinistra
Ecco un esempio di esecuzione di un join sinistro su due di queste tabelle.
SELECT
p.PetName,
pt.PetType
FROM PetTypes pt
LEFT JOIN Pets p
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 join sinistro ci fa ottenere un PetType
valore che non corrisponde a un PetName
. Non ci sono conigli come animali domestici. Ma il join sinistro 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 sinistra (cioè a sinistra di LEFT JOIN
parole chiave). OK, la mia formattazione lo rende più "sopra" che "sinistra", ma ottieni l'immagine.
Ecco cosa succede se cambiamo l'ordine delle tabelle nella nostra query.
SELECT
p.PetName,
pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
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 destro del join.
Dovremmo cambiarlo in un join corretto o in un join completo se volessimo Rabbits
da restituire utilizzando questo ordine di tabella.
Partecipa a sinistra su 3 tavoli
Ecco un esempio di esecuzione di un join sinistro su tutte e tre le tabelle.
SELECT
p.PetName,
pt.PetType,
CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o LEFT JOIN Pets p
ON p.OwnerId = o.OwnerId
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;
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 PetTypes pt LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId
LEFT JOIN Owners o
ON p.OwnerId = o.OwnerId;
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.