Traditionelt trækker du data fra to eller flere tabeller ved hjælp af en WHERE
klausul i en forespørgsel. Men i et relationsdatabasesystem (RDBMS) kan dette opnås ved hjælp af en enkelt SELECT
forespørgsel. Dette er den sande kraft af relationelle databasesystemer. I denne guide lærer du om SQL Joins, en effektiv måde at sammenligne og vælge rækker og tabeller på.
Hvad er en SQL Join?
I SQL, en join
klausul udvider muligheden for at sammenligne og vælge rækker fra tabeller. Den bruger en algebraisk proces til at kombinere rækker fra to eller flere tabeller baseret på en relateret kolonne i disse tabeller. I henhold til ANSI-standarden SQL-definition er der fem typer joins –Cross Joins , Indre sammenføjninger , venstre (ydre) joinforbindelser , Højre (ydre) sammenføjninger , og Fuld (ydre) tilslutning . Disse Joins er implementeret på tværs af alle relationelle databasesystemer og er dækket i sektionerne nedenfor.
Bemærk Joins kan udføres på et vilkårligt antal tabeller i en given forespørgsel. For kortheds skyld og klarhed diskuterer denne vejledning Joins anvendt på to tabeller.
Denne vejledning bruger to tabeller, Employees
og Address
, henholdsvis for at demonstrere SQL Joins. Hver af disse tabeller indeholder følgende kolonnedefinitioner og data:
-
Tabel med medarbejdere
Medarbejder-id Medarbejdernavn 1 John 2 Mary 3 Robert -
Adressetabel
Id State 1 New York 2 New Jersey 3 Idaho 4 Hawaii
Bemærk Medmindre andet er nævnt, fungerer alle kommandoerne i denne guide godt på både MySQL og PostgreSQL databaser.
SQL Cross Joins
Også kendt som en Cartesian Join , Cross Joins opstår, når du angiver flere tabeller som en kilde til din SELECT
kolonneliste. I dette tilfælde udelader du WHERE
klausul join-udtryk for at matche rækker på. Resultatsættet indeholder en række for hver kombination af rækker mellem tabellerne. I et scenarie med to tabeller er hver række i den ene tabel parret med hver række i den anden tabel. Det resulterende produkt er kendt som det kartesiske produkt af de to borde. Syntaksen for en Cross Join er følgende:
(# Rows in Table A) TIMES (# of Rows in Table B)
BemærkI mængdeteori er det kartesiske produkt en multiplikationsoperation, der genererer alle ordnede par af de givne sæt. Overvej f.eks. sæt
A
med elementerne{a,b}
og indstilB
med elementerne{1,2,3}
. Det kartesiske produkt afA
ogB
er angivet medAxB
og resultatet er følgende:AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}
SQL-syntaksen for en Cross Join er som følger:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM [Table_1]
CROSS JOIN [Table_2]
Fra ovenstående syntaks, Column_1
, Column_2
, Column_N
repræsentere kolonnerne i en tabel og CROSS JOIN
klausul tjener til at kombinere de to tabeller, Table_1
og Table_2
. Fra eksempeltabellerne ovenfor, hvis du har brug for at udføre en Cross Join på Employees
og Address
tabeller, skal du bruge følgende SQL-kode:
SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address
Outputtet af ovenstående SQL-kode ligner følgende:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| John | New Jersey |
| John | Idaho |
| John | Hawaii |
| John | New York |
| Mary | New York |
| Mary | New Jersey |
| Mary | Idaho |
| Mary | Hawaii |
| Robert | New York |
| Robert | New Jersey |
| Robert | Idaho |
| Robert | Hawaii |
+------------+----------------+
SQL Indre Join
En indre forbindelse returnerer rækker, der har matchende værdier i begge tabeller. Hvis der ikke er nogen matchende poster, returneres ingen rækker i resultaterne.
SQL-syntaksen for Inner Join er som følger:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;
I eksemplet ovenfor, key
er den respektive nøgle i tabellerne. Hvis du skal udføre en indre tilslutning på Employees
og Address
tabeller, skal du bruge følgende SQL-kode:
SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id
Outputtet af ovenstående SQL-kode ligner følgende:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
+------------+----------------+
SQL venstre (ydre) join
En Left Join returnerer et komplet sæt rækker fra den venstre tabel sammen med de matchende rækker fra den højre tabel. Hvis der ikke er nogen matchende poster, så NULL
værdier returneres fra den højre tabel.
Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Left Outer Join", i modsætning til "Left Join", men de er funktionelt ækvivalente.
SQL-syntaksen for Left Join er som følger:
SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key
I eksemplet ovenfor, key
er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en venstre-tilmelding på Employees
og Address
tabeller, skal du bruge følgende SQL-kode:
SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id
Outputtet af ovenstående SQL-kode er som følger:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
+------------+----------------+
SQL højre (ydre) join
En Right Join returnerer et komplet sæt rækker fra den højre tabel og de matchende rækker fra den venstre tabel. Dette er også kendt som en Right Outer Join. Hvis der ikke er nogen matchende poster, så NULL
værdier returneres fra den højre tabel for de berørte rækker i den venstre tabel.
Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Right Outer Join", i modsætning til "Right Join", men de er funktionelt ækvivalente.
SQL-syntaksen for en Right Join er som følger:
SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key
Fra ovenstående kode, key
er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en ret tilmelding på Employees
og Address
tabeller, skal du bruge følgende SQL-kode:
SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id
Outputtet af ovenstående SQL-kode er følgende:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+
SQL fuld (ydre) deltagelse
En Full Join returnerer alle rækker fra venstre tabel, alle rækker fra højre tabel. Dette er også kendt som også kendt som en Full Outer Join. A Full Join returnerer også alle matchende poster fra begge borde, hvor de er tilgængelige. Hvis der ikke er nogen matchende poster, så NULL
værdier returneres fra den venstre tabel. Det returnerer også NULL
værdier fra den højre tabel.
Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Full Outer Join", i modsætning til "Full Join", men de er funktionelt ækvivalente.
SQL-syntaksen for Full Join er som følger:
SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key
I ovenstående kode, key
er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en fuld tilslutning på Employees
og Address
tabeller, skal du bruge følgende SQL-kode:
SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id
Outputtet af ovenstående SQL-kode er følgende:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+
Bemærk Under Join-beregninger, hvis du sammenligner tabeldata medNULL
værdier, matcher de ikke hinanden. DerforNULL
værdier returneres kun som en del af Join-resultater og ignoreres under Join-beregninger.
Sammenligning af ydeevne af SQL-joins
I betragtning af ovenstående eksempeltabeller er Inner Join typisk den hurtigste af de fem Join-klausuler med hensyn til databaseydelse. Left Join og Right Join er de næsthurtigste afhængigt af størrelsen på de to borde. Full Join er typisk langsommere end Left Join eller Right Join. Cross Join, der er afhængig af det kartesiske produkt af de to tabeller, er typisk den langsomste med hensyn til databaseydelse. Det angivne ydeevnehierarki kan variere afhængigt af tabelkolonnelængden, kolonnedatatypen og nøgledefinitionerne.
Konklusion
Brugen af SQL Joins udvider funktionaliteten ved at være i stand til at sammenligne tabelrækker over traditionelle WHERE
klausul forespørgsler. Joins er en værdifuld mekanisme til at anvende algebraisk logik på to eller flere tabeller.