SQL Natural Join

Denne artikel giver et overblik over den naturlige joinforbindelse i SQL, samt nogle grundlæggende eksempler.

Hvad er en Natural Join?

Den naturlige SQL-join er en type equi-join, der implicit kombinerer tabeller baseret på kolonner med samme navn og type. Sammenføjningsprædikatet opstår implicit ved at sammenligne alle kolonner i begge tabeller, der har de samme kolonnenavne i de sammenføjede tabeller.

Resultatsættet indeholder kun én kolonne for hvert par af samme navngivne kolonner. Hvis ingen kolonner med de samme navne findes, vil resultatet være en krydssammenføjning.

Syntaks

En naturlig joinforbindelse kan anvendes på enhver INNER , LEFT , RIGHT , eller FULL tilslutte. Du skal blot præfikse jointypen med NATURAL søgeord.

Eksempel på syntaks brugt på en indre joinforbindelse:

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

Ses som INNER er standardværdien, kan du også gøre det sådan her:

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

Den NATURAL søgeord placerer en implicit USING klausul til join-begrænsningerne. Det danner en USING liste bestående af alle kolonnenavne, der vises i begge inputtabeller. Dette gælder naturligvis kun for DBMS'er, der understøtter USING klausul.

Ikke alle DBMS'er understøtter naturlige joinforbindelser, så tjek dit DBMS's dokumentation.

Mens jeg skriver dette, understøttes naturlige joinforbindelser i PostgreSQL, MySQL, MariaDB, SQLite og Oracle. Naturlige joinforbindelser understøttes dog ikke i SQL Server (2019).

Eksempler

Her er nogle eksempler til demonstration.

Eksempel på data

For det første er her de tabeller, vi skal bruge til eksemplerne.

PetTypes tabel:

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

Pets tabel:

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

Owners tabel:

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

Bemærk at:

• PetTypeId kolonne i Pets tabel er en fremmednøgle til PetTypeId af PetTypes tabel (som er den primære nøgle til den pågældende tabel).
• OwnerId kolonne i Pets tabel er en fremmednøgle til OwnerId kolonne i Owners tabel.

Eksempel 1 – Naturlig indre forbindelse

Her er et eksempel på at udføre en naturlig indre joinforbindelse mod to af disse borde.

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Resultat:

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

I dette eksempel forenede den naturlige join implicit tabellerne på de to PetTypeId kolonner (dvs. Pets.PetTypeId kolonnen og PetTypes.PetTypeId kolonne).

Dette er en implicit måde at gøre følgende på:

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

Hvilket faktisk gør følgende.

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

Eksempel 2 – Natural Right Join

Her er et eksempel på at udføre en naturlig right join mod to af disse tabeller. Denne gang skal vi angive sammenføjningstypen, da vi ikke ønsker den (standard) indre sammenføjning.

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

Resultat:

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

I dette tilfælde er det det samme som at gøre følgende:

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

Eksempel 3 – Naturlig fuld tilslutning på 3 borde

Her er et eksempel på at udføre en naturlig fuld join på alle tre borde.

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

Resultat:

 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)

Denne gang har vi en kæledyrsejer, der ikke har et kæledyr, samt en kæledyrstype, der ikke er tildelt et kæledyr.

Eksempel 4 – Brug af stjernen (* ) Jokertegn

Her er et eksempel, der bruger jokertegnet stjerne (*) til at vælge alle kolonner.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Resultat:

 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)

Bemærk, at pettypeid kolonne returneres kun én gang, selvom der er to kolonner med det navn (en i hver tabel). Sådan håndterer naturlige sammenføjninger kolonner af samme navn på tværs af tabeller.