SQL Natural Join

Dit artikel geeft een overzicht van de natuurlijke samenvoeging in SQL, evenals enkele basisvoorbeelden.

Wat is een natuurlijke join?

De natuurlijke SQL-join is een soort equi-join die impliciet tabellen combineert op basis van kolommen met dezelfde naam en hetzelfde type. Het join-predikaat ontstaat impliciet door alle kolommen in beide tabellen met dezelfde kolomnaam in de samengevoegde tabellen te vergelijken.

De resultatenset bevat slechts één kolom voor elk paar gelijknamige kolommen. Als er geen kolommen met dezelfde namen worden gevonden, is het resultaat een cross join.

Syntaxis

Een natuurlijke join kan worden toegepast op elke INNER , LEFT , RIGHT , of FULL meedoen. U voegt het join-type eenvoudig toe aan de NATURAL zoekwoord.

Voorbeeld van de syntaxis die wordt gebruikt op een inner join:

SELECT *
FROM Table1 NATURAL INNER JOIN Table2 
ON Table1.Column = Table2.Column;

Zien als INNER is de standaardwaarde, je kunt het ook als volgt doen:

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

De NATURAL trefwoord plaatst een impliciete USING clausule voor de join-beperkingen. Het vormt een USING lijst bestaande uit alle kolomnamen die in beide invoertabellen voorkomen. Dit is uiteraard alleen van toepassing op DBMS'en die de USING . ondersteunen clausule.

Niet alle DBMS'en ondersteunen natuurlijke joins, dus raadpleeg de documentatie van uw DBMS.

Terwijl ik dit schrijf, worden natuurlijke joins ondersteund in PostgreSQL, MySQL, MariaDB, SQLite en Oracle. Natuurlijke joins worden echter niet ondersteund in SQL Server (2019).

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.

Voorbeeld 1 – Natuurlijke innerlijke verbinding

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

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Resultaat:

 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
(8 rows)

In dit voorbeeld voegde de natuurlijke join impliciet de tabellen op de twee PetTypeId . samen kolommen (d.w.z. de Pets.PetTypeId kolom, en de PetTypes.PetTypeId kolom).

Dit is een impliciete manier om het volgende te doen:

SELECT 
    PetName,
    PetType
FROM Pets
INNER JOIN PetTypes USING (PetTypeId);

Wat eigenlijk het volgende doet.

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

Voorbeeld 2 – Natuurlijke rechtse verbinding

Hier is een voorbeeld van het uitvoeren van een natural right join tegen twee van die tabellen. Deze keer moeten we het type join specificeren, aangezien we de (standaard) inner join niet willen.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
NATURAL RIGHT JOIN PetTypes pt;

Resultaat:

 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
         | Rabbit
(9 rows)

In dit geval is het hetzelfde als het volgende doen:

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

Voorbeeld 3 – Natural Full Join op 3 tafels

Hier is een voorbeeld van het uitvoeren van een natuurlijke volledige samenvoeging op alle drie de tafels.

SELECT 
    PetName,
    PetType,
    CONCAT(FirstName, ' ', LastName) AS PetOwner
FROM Owners NATURAL FULL JOIN Pets
NATURAL FULL JOIN PetTypes;

Resultaat:

 petname | pettype |    petowner    
---------+---------+----------------
 Fluffy  | Cat     | Nancy Simpson
 Fetch   | Dog     | Nancy Simpson
 Scratch | Cat     | Bart Pitt
 Wag     | Dog     | Nancy Simpson
 Tweet   | Bird    | Homer Connery
 Fluffy  | Dog     | Boris Trump
 Bark    | Dog     | Bart Pitt
 Meow    | Cat     | Boris Trump
         |         | Woody Eastwood
         | Rabbit  |  
(10 rows)

Deze keer hebben we een huisdiereigenaar die geen huisdier heeft, evenals een huisdiertype dat niet aan een huisdier is toegewezen.

Voorbeeld 4 – Gebruik van de asterisk (* ) Jokerteken

Hier is een voorbeeld waarbij het jokerteken asterisk (*) wordt gebruikt om alle kolommen te selecteren.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Resultaat:

 pettypeid | petid | ownerid | petname |    dob     | pettype 
-----------+-------+---------+---------+------------+---------
         2 |     1 |       3 | Fluffy  | 2020-11-20 | Cat
         3 |     2 |       3 | Fetch   | 2019-08-16 | Dog
         2 |     3 |       2 | Scratch | 2018-10-01 | Cat
         3 |     4 |       3 | Wag     | 2020-03-15 | Dog
         1 |     5 |       1 | Tweet   | 2020-11-28 | Bird
         3 |     6 |       4 | Fluffy  | 2020-09-17 | Dog
         3 |     7 |       2 | Bark    |            | Dog
         2 |     8 |       4 | Meow    |            | Cat
(8 rows)

Merk op dat de pettypeid kolom wordt slechts één keer geretourneerd, ook al zijn er twee kolommen met die naam (één in elke tabel). Dit is hoe natuurlijke joins omgaan met kolommen met dezelfde naam in tabellen.