SQL Natural Join

Questo articolo fornisce una panoramica del join naturale in SQL, nonché alcuni esempi di base.

Cos'è un Natural Join?

Il natural join SQL è un tipo di equi-join che combina implicitamente tabelle basate su colonne con lo stesso nome e tipo. Il predicato join nasce implicitamente dal confronto di tutte le colonne in entrambe le tabelle che hanno gli stessi nomi di colonna nelle tabelle unite.

Il set di risultati contiene solo una colonna per ogni coppia di colonne con lo stesso nome. Se non vengono trovate colonne con lo stesso nome, il risultato sarà un cross join.

Sintassi

Un join naturale può essere applicato a qualsiasi INNER , LEFT , RIGHT o FULL giuntura. Devi semplicemente anteporre al tipo di unione il NATURAL parola chiave.

Esempio della sintassi utilizzata su un inner join:

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

Visto come INNER è il valore predefinito, puoi anche farlo in questo modo:

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

Il NATURAL la parola chiave inserisce un USING implicito clausola ai vincoli di join. Forma un USING elenco composto da tutti i nomi di colonna che appaiono in entrambe le tabelle di input. Questo ovviamente si applica solo ai DBMS che supportano USING clausola.

Non tutti i DBMS supportano i natural join, quindi controlla con la documentazione del tuo DBMS.

Mentre scrivo, i join naturali sono supportati in PostgreSQL, MySQL, MariaDB, SQLite e Oracle. Tuttavia, i join naturali non sono supportati in SQL Server (2019).

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.

Esempio 1:unione interna naturale

Ecco un esempio di esecuzione di un inner join naturale su due di queste tabelle.

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Risultato:

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

In questo esempio, il join naturale ha unito implicitamente le tabelle sui due PetTypeId colonne (cioè il Pets.PetTypeId colonna e il PetTypes.PetTypeId colonna).

Questo è un modo implicito per eseguire le seguenti operazioni:

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

Che in realtà fa quanto segue.

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

Esempio 2 – Partecipazione per diritto naturale

Ecco un esempio di esecuzione di un join destro naturale su due di quei tavoli. Questa volta dobbiamo specificare il tipo di join, visto che non vogliamo il join interno (predefinito).

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

Risultato:

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

In questo caso, è come fare quanto segue:

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

Esempio 3 – Join naturale completo su 3 tabelle

Ecco un esempio di esecuzione di un full join naturale su tutti e tre i tavoli.

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

Risultato:

 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)

Questa volta abbiamo un proprietario di un animale domestico che non ha un animale domestico, così come un tipo di animale domestico che non è assegnato a un animale domestico.

Esempio 4:utilizzo dell'asterisco (* ) Carattere jolly

Ecco un esempio che utilizza il carattere jolly asterisco (*) per selezionare tutte le colonne.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Risultato:

 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)

Nota che il pettypeid colonna viene restituita solo una volta, anche se sono presenti due colonne con quel nome (una in ogni tabella). Questo è il modo in cui i join naturali gestiscono le colonne con lo stesso nome nelle tabelle.