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 | [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] | +-----------+-------------+------------+----------------+-------------------+
Observera att:
PetTypeId
kolumnen iPets
tabellen är en främmande nyckel förPetTypeId
avPetTypes
tabell (som är den primära nyckeln för den tabellen).OwnerId
kolumnen iPets
tabellen är en främmande nyckel förOwnerId
kolumnen iOwners
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.