Traditionellt hämtar du data från två eller flera tabeller med en WHERE klausul i en fråga. Men i ett relationsdatabassystem (RDBMS) kan detta uppnås med en enda SELECT fråga. Detta är den sanna kraften i relationsdatabassystem. I den här guiden lär du dig om SQL Joins, ett kraftfullt sätt att jämföra och välja rader och tabeller.
Vad är en SQL Join?
I SQL, en join sats utökar möjligheten att jämföra och välja rader från tabeller. Den använder en algebraisk process för att kombinera rader från två eller flera tabeller baserat på en relaterad kolumn i dessa tabeller. Enligt ANSI-standarden SQL-definition finns det fem typer av Joins –Cross Joins , Inre kopplingar , vänster (yttre) går med , Höger (yttre) sammanfogningar och Fullständiga (yttre) anslutningar . Dessa kopplingar implementeras i alla relationsdatabassystem och behandlas i avsnitten nedan.
Obs Joins kan utföras på valfritt antal tabeller i en given fråga. För enkelhetens skull och tydligheten diskuterar den här guiden kopplingar som tillämpas på två tabeller.
Den här guiden använder två tabeller, Employees och Address , respektive för att demonstrera SQL Joins. Var och en av dessa tabeller innehåller följande kolumndefinitioner och data:
-
Tabell för anställda
Anställd-ID Anställdsnamn 1 John 2 Mary 3 Robert -
Adresstabell
Id Tillstånd 1 New York 2 New Jersey 3 Idaho 4 Hawaii
Obs Om inget annat nämns fungerar alla kommandon i den här guiden bra på båda MySQL och PostgreSQL databaser.
SQL Cross Joins
Även känd som en Cartesian Join , Cross Joins uppstår när du anger flera tabeller som källa för din SELECT kolumnlistan. I det här fallet utelämnar du WHERE sats join-uttryck för att matcha rader på. Resultatuppsättningen innehåller en rad för varje kombination av rader mellan tabellerna. I ett scenario med två tabeller paras varje rad i en tabell med varje rad i den andra tabellen. Den resulterande produkten är känd som den kartesiska produkten av de två borden. Syntaxen för en Cross Join är följande:
(# Rows in Table A) TIMES (# of Rows in Table B)
ObsI mängdteorin är den kartesiska produkten en multiplikationsoperation som genererar alla ordnade par av de givna mängderna. Överväg till exempel set
Amed elementen{a,b}och ställ inBmed elementen{1,2,3}. Den kartesiska produkten avAochBbetecknas medAxBoch resultatet är följande:AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}
SQL-syntaxen för en Cross Join är följande:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM [Table_1]
CROSS JOIN [Table_2]
Från ovanstående syntax, Column_1 , Column_2 , Column_N representerar kolumnerna i en tabell och CROSS JOIN sats tjänar till att kombinera de två tabellerna, Table_1 och Table_2 . Från exempeltabellerna ovan, om du behöver utföra en Cross Join på Employees och Address tabeller, använd följande SQL-kod:
SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address
Utdata från ovanstående SQL-kod liknar följande:
+--------------+--------------+
| 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 Inner Join
En Inner Join returnerar rader som har matchande värden i båda tabellerna. Om det inte finns några matchande poster returneras inga rader i resultaten.
SQL-syntaxen för Inner Join är följande:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;
I exemplet ovan, key är respektive nyckel för tabellerna. Om du behöver utföra en inre anslutning på Employees och Address tabeller, använd följande SQL-kod:
SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id
Utdata från ovanstående SQL-kod liknar följande:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
+------------+----------------+SQL vänster (yttre) gå med
En Left Join returnerar en komplett uppsättning rader från den vänstra tabellen tillsammans med de matchande raderna från den högra tabellen. Om det inte finns några matchande poster, NULL värden returneras från den högra tabellen.
Obs Vissa relationsdatabasimplementeringar använder nyckelorden "Left Outer Join", i motsats till "Left Join", men de är funktionellt likvärdiga.
SQL-syntaxen för Left Join är följande:
SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key
I exemplet ovan, key är respektive nyckel för tabellerna. Om du behöver utföra en vänsteranslutning på Employees och Address tabeller, använd följande SQL-kod:
SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id
Utdata från ovanstående SQL-kod är som följer:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
+------------+----------------+SQL höger (yttre) gå med
En Right Join returnerar en komplett uppsättning rader från den högra tabellen och de matchande raderna från den vänstra tabellen. Detta är också känt som en Right Outer Join. Om det inte finns några matchande poster, NULL värden returneras från den högra tabellen, för de berörda raderna i den vänstra tabellen.
Obs Vissa relationsdatabasimplementeringar använder nyckelorden "Right Outer Join", i motsats till "Right Join", men de är funktionellt likvärdiga.
SQL-syntaxen för en Right Join är följande:
SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key
Från koden ovan, key är respektive nyckel för tabellerna. Om du behöver utföra en rätt att gå med på Employees och Address tabeller, använd följande SQL-kod:
SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id
Utdata från ovanstående SQL-kod är följande:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+SQL Full (yttre) gå med
En Full Join returnerar alla rader från den vänstra tabellen, alla rader från den högra tabellen. Detta är också känt som en Full Outer Join. En Full Join returnerar också alla matchande poster från båda borden där de är tillgängliga. Om det inte finns några matchande poster, NULL värden returneras från den vänstra tabellen. Den returnerar också NULL värden från den högra tabellen.
Obs Vissa relationsdatabasimplementeringar använder nyckelorden "Full Outer Join", i motsats till "Full Join", men de är funktionellt likvärdiga.
SQL-syntaxen för Full Join är följande:
SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key
I koden ovan, key är respektive nyckel för tabellerna. Om du behöver utföra en fullständig anslutning på Employees och Address tabeller, använd följande SQL-kod:
SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id
Utdata från ovanstående SQL-kod är följande:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+Obs Under Join-beräkningar, om du jämför tabelldata medNULLvärden matchar de inte varandra. DärförNULLvärden returneras endast som en del av Join-resultat och ignoreras under Join-beräkningar.
Prestandajämförelse av SQL-joins
Med tanke på ovanstående exempeltabeller är Inner Join vanligtvis den snabbaste av de fem Join-klausulerna när det gäller databasprestanda. Left Join och Right Join är näst snabbast beroende på storleken på de två borden. Full Join är vanligtvis långsammare än Left Join eller Right Join. Cross Join, som är beroende av den kartesiska produkten av de två tabellerna, är vanligtvis den långsammaste när det gäller databasprestanda. Den angivna prestandahierarkin kan skilja sig beroende på tabellens kolumnlängd, kolumndatatyp och nyckeldefinitioner.
Slutsats
Användningen av SQL Joins utökar funktionaliteten för att kunna jämföra tabellrader, över traditionella WHERE klausulfrågor. Joins är en värdefull mekanism för att tillämpa algebraisk logik på två eller flera tabeller.