SQL Left Join

Dit artikel geeft een overzicht van de LEFT JOIN in SQL, evenals enkele basisvoorbeelden.

De LEFT JOIN , of LEFT OUTER JOIN , retourneert rijen met gegevens in de linkertabel (links van de JOIN zoekwoord), zelfs als er geen overeenkomende rijen in de juiste tabel staan.

Syntaxis

Je specificeert een left join in de FROM clausule. U kunt de LEFT JOIN . gebruiken of LEFT OUTER JOIN syntaxis.

Met behulp van de LEFT JOIN syntaxis:

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

Met behulp van de LEFT OUTER JOIN syntaxis:

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

Beide doen precies hetzelfde. Het is alleen dat de OUTER zoekwoord is optioneel.

Voorbeelden

Hier zijn enkele voorbeelden om te demonstreren.

Voorbeeldgegevens

Ten eerste zijn hier de tabellen die we voor de voorbeelden zullen gebruiken.

De PetTypes tafel:

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

De Pets tafel:

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

De Owners tafel:

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

Merk op dat:

• De PetTypeId kolom van de Pets tabel is een externe sleutel van de PetTypeId van de PetTypes tabel (wat de primaire sleutel van die tabel is).
• De OwnerId kolom van de Pets tabel is een externe sleutel van de OwnerId kolom van de Owners tafel.

De linker join-query

Hier is een voorbeeld van het uitvoeren van een left join tegen twee van die tafels.

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

Resultaat:

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

De linker join zorgt ervoor dat we een PetType . krijgen waarde die niet overeenkomt met een PetName . Er zijn geen konijnen als huisdier. Maar de linker join veroorzaakt Rabbit te retourneren, ook al is er geen huisdier in de Pets tafel van dat type. Dit resulteert in een NULL waarde in de PetName kolom tegen Rabbit .

Dit gebeurde alleen omdat Rabbit stond in de linkertabel (d.w.z. links van de LEFT JOIN trefwoorden). OK, mijn opmaak maakt het meer "boven" dan "links", maar je krijgt de afbeelding.

Dit is wat er gebeurt als we de tabelvolgorde in onze zoekopdracht wijzigen.

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

Resultaat:

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

Deze keer Rabbits werd niet teruggestuurd. Dat komt omdat de tabel (PetTypes ) bevond zich aan de rechterkant van de join.

We zouden het moeten veranderen in een right join of een full join als we Rabbits . wilden te retourneren met behulp van deze tafelvolgorde.

Links deelnemen aan 3 tafels

Hier is een voorbeeld van het uitvoeren van een left join op alle drie de tafels.

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;

Resultaat:

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

Deze keer hebben we een huisdiereigenaar die geen huisdier heeft.

We zouden de volgorde van de tafels opnieuw kunnen schudden en we zouden een andere uitkomst krijgen.

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;

Resultaat:

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

Deze keer kregen we het extra huisdiertype (Rabbit ), maar niet de extra eigenaar.

Als je je afvraagt ​​waarom de laatste PetOwner is niet NULL (zoals de laatste PetName is), is dat omdat het het resultaat is van een aaneenschakeling van tekenreeksen. Ik gebruikte de T-SQL CONCAT() functie om de voor- en achternaam van de eigenaar samen te voegen.