SQL Natural Join

Den här artikeln ger en översikt över den naturliga kopplingen i SQL, samt några grundläggande exempel.

Vad är en Natural Join?

SQL natural join är en typ av equi-join som implicit kombinerar tabeller baserade på kolumner med samma namn och typ. Sammanfogningspredikatet uppstår implicit genom att jämföra alla kolumner i båda tabellerna som har samma kolumnnamn i de sammanfogade tabellerna.

Resultatuppsättningen innehåller endast en kolumn för varje par med lika namngivna kolumner. Om inga kolumner med samma namn hittas blir resultatet en korskoppling.

Syntax

En naturlig koppling kan appliceras på vilken INNER som helst , LEFT , RIGHT , eller FULL Ansluta sig. Du prefix helt enkelt kopplingstypen med NATURAL nyckelord.

Exempel på syntaxen som används på en inre koppling:

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

Ses som INNER är standardvärdet kan du också göra så här:

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

Den NATURAL sökord placerar en implicit USING klausul till sammanfogningsbegränsningarna. Den bildar en USING lista som består av alla kolumnnamn som visas i båda inmatningstabellerna. Detta gäller uppenbarligen bara DBMS som stöder USING klausul.

Inte alla DBMS stöder naturliga anslutningar, så kolla med din DBMS:s dokumentation.

När jag skriver detta stöds naturliga anslutningar i PostgreSQL, MySQL, MariaDB, SQLite och Oracle. Naturliga kopplingar stöds dock inte i SQL Server (2019).

Exempel

Här är några exempel att visa.

Exempeldata

Först, här är tabellerna vi ska använda för exemplen.

PetTypes tabell:

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

Pets tabell:

+---------+-------------+-----------+-----------+------------+
| 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 tabell:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | example@sqldat.com |
| 2         | Bart        | Pitt       | (231) 465-3497 | example@sqldat.com  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | example@sqldat.com |
+-----------+-------------+------------+----------------+-------------------+

Observera att:

• PetTypeId kolumnen i Pets tabellen är en främmande nyckel för PetTypeId av PetTypes tabell (som är den primära nyckeln för den tabellen).
• OwnerId kolumnen i Pets tabellen är en främmande nyckel för OwnerId kolumnen i Owners tabell.

Exempel 1 – Naturlig inre sammanfogning

Här är ett exempel på att utföra en naturlig inre koppling mot två av dessa tabeller.

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 det här exemplet sammanfogade den naturliga kopplingen implicit tabellerna på de två PetTypeId kolumner (dvs. Pets.PetTypeId kolumnen och PetTypes.PetTypeId kolumn).

Detta är ett implicit sätt att göra följande:

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

Vilket faktiskt gör följande.

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

Exempel 2 – Natural Right Join

Här är ett exempel på hur man utför en naturlig rättighetskoppling mot två av dessa tabeller. Den här gången måste vi ange typen av koppling, eftersom vi inte vill ha den (standard) inre kopplingen.

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 det här fallet är det samma sak som att göra följande:

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

Exempel 3 – Naturlig Full Join på 3 bord

Här är ett exempel på hur du utför en naturlig fullständig anslutning på alla tre borden.

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)

Den här gången har vi en husdjursägare som inte har ett husdjur, samt en husdjurstyp som inte är tilldelad ett husdjur.

Exempel 4 – Använda asterisken (* ) Jokertecken

Här är ett exempel som använder asterisk (*) jokertecken för att välja alla kolumner.

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)

Observera att pettypeid kolumn returneras bara en gång, även om det finns två kolumner med det namnet (en i varje tabell). Det är så naturliga sammanfogningar hanterar kolumner med samma namn över tabeller.