Database
 sql >> Database >  >> RDS >> Database

Join sinistro SQL

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 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 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.