Naturalne połączenie SQL

Ten artykuł zawiera przegląd naturalnego łączenia w SQL, a także kilka podstawowych przykładów.

Co to jest naturalne połączenie?

Naturalne sprzężenie SQL jest rodzajem sprzężenia ekwiwalentnego, które niejawnie łączy tabele oparte na kolumnach o tej samej nazwie i typie. Predykat łączenia powstaje niejawnie przez porównanie wszystkich kolumn w obu tabelach, które mają takie same nazwy kolumn w połączonych tabelach.

Zestaw wyników zawiera tylko jedną kolumnę dla każdej pary kolumn o tej samej nazwie. Jeśli nie zostaną znalezione żadne kolumny o tych samych nazwach, wynikiem będzie sprzężenie krzyżowe.

Składnia

Złączenie naturalne można zastosować do dowolnego INNER , LEFT , RIGHT lub FULL Przystąp. Po prostu poprzedź typ połączenia przedrostkiem NATURAL słowo kluczowe.

Przykład składni używanej w sprzężeniu wewnętrznym:

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

Widząc jako INNER jest wartością domyślną, możesz to również zrobić w ten sposób:

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

NATURAL słowo kluczowe umieszcza niejawne USING klauzula do ograniczeń sprzężenia. Tworzy USING lista składająca się ze wszystkich nazw kolumn, które pojawiają się w obu tabelach wejściowych. Dotyczy to oczywiście tylko DBMS, które obsługują USING klauzula.

Nie wszystkie DBMS obsługują naturalne łączenia, więc sprawdź w dokumentacji DBMS.

Kiedy to piszę, naturalne złączenia są obsługiwane w PostgreSQL, MySQL, MariaDB, SQLite i Oracle. Jednak sprzężenia naturalne nie są obsługiwane w programie SQL Server (2019).

Przykłady

Oto kilka przykładów do zademonstrowania.

Przykładowe dane

Najpierw oto tabele, których użyjemy w przykładach.

PetTypes tabela:

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

Pets tabela:

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

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

Pamiętaj, że:

• PetTypeId kolumna Pets tabela jest kluczem obcym PetTypeId PetTypes tabela (która jest kluczem podstawowym tej tabeli).
• OwnerId kolumna Pets tabela jest kluczem obcym OwnerId kolumna Owners stół.

Przykład 1 – Naturalne połączenie wewnętrzne

Oto przykład wykonania naturalnego sprzężenia wewnętrznego przeciwko dwóm z tych tabel.

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Wynik:

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

W tym przykładzie sprzężenie naturalne niejawnie połączyło tabele w dwóch PetTypeId kolumny (np. Pets.PetTypeId kolumna i PetTypes.PetTypeId kolumna).

Jest to domyślny sposób na wykonanie następujących czynności:

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

Który faktycznie wykonuje następujące czynności.

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

Przykład 2 – Prawidłowe łączenie

Oto przykład wykonania sprzężenia z prawem naturalnym dla dwóch z tych tabel. Tym razem musimy określić typ połączenia, ponieważ nie chcemy (domyślnego) połączenia wewnętrznego.

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

Wynik:

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

W tym przypadku wygląda to tak samo, jak wykonanie następujących czynności:

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

Przykład 3 – Naturalne pełne łączenie na 3 stołach

Oto przykład wykonania naturalnego pełnego sprzężenia na wszystkich trzech stołach.

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

Wynik:

 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)

Tym razem mamy właściciela zwierzaka, który nie ma zwierzaka, a także rodzaj zwierzaka, który nie jest przypisany do zwierzaka.

Przykład 4 – Korzystanie z gwiazdki (* ) Znak wieloznaczny

Oto przykład, w którym do zaznaczenia wszystkich kolumn użyto gwiazdki (*) znaku wieloznacznego.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Wynik:

 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)

Zauważ, że pettypeid kolumna jest zwracana tylko raz, mimo że istnieją dwie kolumny o tej nazwie (po jednej w każdej tabeli). W ten sposób naturalne złączenia radzą sobie z kolumnami o tej samej nazwie w tabelach.