SQL Natural-Join

Dieser Artikel bietet einen Überblick über die natürliche Verknüpfung in SQL sowie einige grundlegende Beispiele.

Was ist ein natürlicher Join?

Der natürliche SQL-Join ist eine Art Equi-Join, der implizit Tabellen basierend auf Spalten mit demselben Namen und Typ kombiniert. Das Join-Prädikat entsteht implizit durch Vergleich aller Spalten in beiden Tabellen, die in den verknüpften Tabellen denselben Spaltennamen haben.

Die Ergebnismenge enthält nur eine Spalte für jedes Paar gleichnamiger Spalten. Wenn keine Spalten mit demselben Namen gefunden werden, ist das Ergebnis ein Cross Join.

Syntax

Ein natürlicher Join kann auf jedes INNER angewendet werden , LEFT , RIGHT , oder FULL beitreten. Sie stellen dem Join-Typ einfach den NATURAL voran Schlüsselwort.

Beispiel für die bei einem Inner Join verwendete Syntax:

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

Als INNER zu sehen der Standardwert ist, können Sie es auch so machen:

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

Das NATURAL Schlüsselwort platziert ein implizites USING -Klausel zu den Join-Einschränkungen. Es bildet ein USING Liste bestehend aus allen Spaltennamen, die in beiden Eingabetabellen vorkommen. Dies gilt natürlich nur für DBMS, die USING unterstützen Klausel.

Nicht alle DBMS unterstützen natürliche Verknüpfungen, sehen Sie also in der Dokumentation Ihres DBMS nach.

Während ich dies schreibe, werden natürliche Verknüpfungen in PostgreSQL, MySQL, MariaDB, SQLite und Oracle unterstützt. Natürliche Verknüpfungen werden jedoch in SQL Server (2019) nicht unterstützt.

Beispiele

Hier sind einige Beispiele zur Veranschaulichung.

Beispieldaten

Hier sind zunächst die Tabellen, die wir für die Beispiele verwenden werden.

Die PetTypes Tabelle:

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

Die Pets Tabelle:

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

Die Owners Tabelle:

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

Beachten Sie Folgendes:

• Die PetTypeId Spalte der Pets table ist ein Fremdschlüssel der PetTypeId der PetTypes Tabelle (das ist der Primärschlüssel dieser Tabelle).
• Die OwnerId Spalte der Pets table ist ein Fremdschlüssel der OwnerId Spalte der Owners Tabelle.

Beispiel 1 – Natürlicher innerer Join

Hier ist ein Beispiel für die Durchführung eines natürlichen Inner Joins für zwei dieser Tabellen.

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Ergebnis:

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

In diesem Beispiel hat die natürliche Verknüpfung die Tabellen auf den beiden PetTypeId implizit verknüpft Spalten (d. h. die Pets.PetTypeId Spalte und die PetTypes.PetTypeId Spalte).

Dies ist eine implizite Möglichkeit, Folgendes zu tun:

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

Was tatsächlich Folgendes bewirkt.

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

Beispiel 2 – Natural Right Join

Hier ist ein Beispiel für die Durchführung einer natürlichen Rechtsverknüpfung mit zwei dieser Tabellen. Diesmal müssen wir den Join-Typ angeben, da wir den (Standard-)Inner Join nicht wollen.

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

Ergebnis:

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

In diesem Fall ist es dasselbe wie das Folgende:

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

Beispiel 3 – Natural Full Join an 3 Tischen

Hier ist ein Beispiel für die Durchführung eines natürlichen vollständigen Joins für alle drei Tabellen.

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

Ergebnis:

 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)

Diesmal haben wir einen Haustierbesitzer, der kein Haustier hat, sowie einen Haustiertyp, der keinem Haustier zugeordnet ist.

Beispiel 4 – Verwendung des Asterisk (* ) Platzhalterzeichen

Hier ist ein Beispiel, das das Platzhalterzeichen Sternchen (*) verwendet, um alle Spalten auszuwählen.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Ergebnis:

 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)

Beachten Sie, dass die pettypeid Spalte wird nur einmal zurückgegeben, obwohl es zwei Spalten mit diesem Namen gibt (eine in jeder Tabelle). So behandeln natürliche Joins tabellenübergreifend Spalten mit demselben Namen.