SQL juiste join

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

Ook bekend als de RIGHT OUTER JOIN , de RIGHT JOIN retourneert rijen met gegevens in de juiste tabel (rechts van de JOIN zoekwoord), zelfs als er geen overeenkomende rijen in de linkertabel zijn.

Syntaxis

Je specificeert een juiste join in de FROM clausule. U kunt ofwel de RIGHT JOIN of RIGHT OUTER JOIN syntaxis.

De RIGHT JOIN . gebruiken syntaxis:

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

Met behulp van de RIGHT OUTER JOIN syntaxis:

SELECT *
FROM Table1 RIGHT 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 juiste join-query

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

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
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 juiste join zorgt ervoor dat we een PetType . krijgen waarde die niet overeenkomt met een PetName . In het bijzonder zijn er geen konijnen als huisdier. Maar de juiste 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 was in de juiste tabel (d.w.z. rechts van de RIGHT JOIN trefwoorden).

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

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
RIGHT JOIN Pets p
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 linkerkant van de join.

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

Rechts deelnemen aan 3 tafels

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

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;

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 Pets p RIGHT JOIN Owners o 
    ON p.OwnerId = o.OwnerId
RIGHT JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId;

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.