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 | 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 | +-----------+-------------+------------+----------------+-------------------+
Beachten Sie Folgendes:
- Die
PetTypeIdSpalte derPetstable ist ein Fremdschlüssel derPetTypeIdderPetTypesTabelle (das ist der Primärschlüssel dieser Tabelle). - Die
OwnerIdSpalte derPetstable ist ein Fremdschlüssel derOwnerIdSpalte derOwnersTabelle.
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.
