Inner Join Vs Outer Join: Innan vi utforskar skillnaderna mellan Inner Join och Outer Join
För att utforska skillnaderna mellan Inner Join Vs Outer Join, låt oss först se vad är en SQL JOIN?
En join-klausul används för att kombinera poster eller för att manipulera poster från två eller flera tabeller genom ett joinvillkor. Joinvillkoret anger hur kolumner från varje tabell matchas mot varandra.
Join baseras på en relaterad kolumn mellan dessa tabeller. Det vanligaste exemplet är en sammanfogning mellan två tabeller genom primärnyckelkolumnen och kolumnen för den främmande nyckeln.
Antag att vi har en tabell som innehåller den anställdes lön och att det finns en annan tabell som innehåller uppgifter om den anställde.
I det här fallet kommer det att finnas en gemensam kolumn, t.ex. anställdas ID, som kommer att sammanfoga de här två tabellerna. Denna kolumn Employee ID skulle vara primärnyckeln i tabellerna med anställningsdetaljer och en främmande nyckel i lönetabellen.
Det är mycket viktigt att ha en gemensam nyckel mellan de två enheterna. Du kan tänka på en tabell som en enhet och nyckeln som en gemensam länk mellan de två tabellerna som används vid sammanfogning.
Det finns två typer av sammanfogning i SQL, dvs. inre sammanfogning och yttre sammanfogning. Outer Join delas vidare in i tre typer, nämligen Left Outer Join, Right Outer Join och Full Outer Join.
I den här artikeln kommer vi att se skillnaden mellan Inner Join och Outer Join i detalj. Vi kommer att hålla Cross Joins och Unequal Joins utanför denna artikel.
Vad är Inner Join?
En Inner Join returnerar endast de rader som har matchande värden i båda tabellerna (vi anser här att joinen görs mellan de två tabellerna).
Vad är Outer Join?
Outer Join inkluderar de matchande raderna samt några av de icke matchande raderna mellan de två tabellerna. En Outer Join skiljer sig i princip från en Inner Join genom hur den hanterar falska matchningar.
Det finns tre typer av Outer Join:
- Left Outer Join:
- : Returnerar alla rader från tabellen LEFT och matchande poster mellan de båda tabellerna.
- : Right Outer Join:
- Full Outer Join: Återger alla rader från tabellen RIGHT och matchande poster mellan de båda tabellerna:
Skillnaden mellan inre och yttre sammanfogning
Som framgår av diagrammet ovan finns det två enheter, dvs. tabell 1 och tabell 2, och båda tabellerna har vissa gemensamma data.
En Inner Join returnerar det gemensamma området mellan dessa tabeller (det grönskuggade området i diagrammet ovan), dvs. alla poster som är gemensamma för tabell 1 och tabell 2.
En Left Outer Join returnerar alla rader från tabell 1 och endast de rader från tabell 2 som är gemensamma för tabell 1 också. En Right Outer Join gör precis tvärtom. Den kommer att ge alla poster från tabell 2 och endast de motsvarande matchande posterna från tabell 1.
För övrigt kommer en Full Outer Join att ge oss alla poster från tabell 1 och tabell 2.
Låt oss börja med ett exempel för att göra detta tydligare.
Antag att vi har två tabeller: EmpDetails och EmpSalary.
Tabell EmpDetails:
EmployeeID | EmployeeName | 1 | John |
2 | Samantha | 3 | Hakuna | 4 | Silky |
5 | Ram | 6 | Arpit | 7 | Lily |
8 | Sita |
9 | Farah | 10 | Jerry |
EmpLönetabell:
EmployeeID | EmployeeName | EmployeeSalary | 1 | John | 50000 |
---|---|---|
2 | Samantha | 120000 | 3 | Hakuna | 75000 | 4 | Silky | 25000 | 5 | Ram | 150000 | 6 | Arpit | 80000 | 11 | Rose | 90000 | 12 | Sakshi | 45000 | 13 | Jack | 250000 |
Låt oss göra en inre sammanfogning av dessa två tabeller och observera resultatet:
Förfrågan:
SELECT EmpDetails. EmployeeID, EmpDetails. EmployeeName, EmpSalary. EmployeeSalaryFROM EmpDetails INNER JOIN EmpSalaryON EmpDetails. EmployeeID = EmpSalary. EmployeeID;
Resultat:
EmployeeID | EmployeeName | EmployeeSalary | 1 | John | 50000 | 2 | Samantha | 120000 | 3 | Hakuna | 75000 | 4 | Silky | 25000 | 5 | 5 | Ram | 150000 | 6 | Arpit | 80000 |
---|
I ovanstående resultat, kan du se att Inner Join har returnerat de första 6 posterna som fanns i både EmpDetails och EmpSalary och som har en matchande nyckel i.e. EmployeeID. Om A och B är två enheter kommer Inner Join alltså att återge en resultatuppsättning som är lika med ”Records in A and B”, baserat på den matchande nyckeln.
Vi ska nu se vad en Left Outer Join gör.
Förfrågan:
SELECT EmpDetails. EmployeeID, EmpDetails. EmployeeName, EmpSalary. EmployeeSalaryFROM EmpDetails LEFT JOIN EmpSalaryON EmpDetails. EmployeeID = EmpSalary. EmployeeID;
Resultat:
EmployeeID | EmployeeName | EmployeeSalary |
---|---|---|
1 | John | 50000 |
2 | Samantha | 120000 | 3 | Hakuna | 75000 | 4 | Silky | 25000 |
5 | Ram | 150000 |
6 | Arpit | 80000 |
7 | Lily | NULL | 8 | Sita | NULL | 9 | Farah | NULL | 10 | Jerry | NULL |
I ovanstående resultat, kan du se att den vänstra yttre sammanfogningen har returnerat alla 10 poster från den vänstra tabellen i.e. EmpDetails tabellen och eftersom de första 6 posterna är matchande har den returnerat lönen för dessa matchande poster.
Eftersom resten av posterna inte har en matchande nyckel i RIGHT tabellen, dvs. EmpSalary tabellen, har den returnerat NULL motsvarande dessa. Eftersom Lily, Sita, Farah och Jerry inte har något matchande anställnings-ID i tabellen EmpSalary visas deras lön som NULL i resultatmängden.
Så, om A och B är två enheter, kommer Left Outer Join att returnera resultatmängden som kommer att vara lika med ”Records in A NOT B”, baserat på den matchande nyckeln.
Nu ska vi se vad Right Outer Join gör.
Förfrågan:
SELECT EmpDetails. EmployeeID, EmpDetails. EmployeeName, EmpSalary. EmployeeSalaryFROM EmpDetails RIGHT join EmpSalaryON EmpDetails. EmployeeID = EmpSalary. EmployeeID;
Resultat:
EmployeeID | EmployeeName | EmployeeSalary |
---|---|---|
1 | John | 50000 |
2 | Samantha | 120000 |
3 | Hakuna | 75000 |
4 | Silky | 25000 |
5 | Ram | 150000 | 6 | Arpit | 80000 |
NULL | NULL | 90000 |
NULL | NULL | 250000 | NULL | NULL | 250000 |
I ovanstående resultatmängd, kan du se att Right Outer Join har gjort precis motsatsen till Left Join. Den har returnerat alla löner från den högra tabellen, dvs. tabellen EmpSalary.
Men eftersom Rose, Sakshi och Jack inte har något matchande anställnings-ID i den vänstra tabellen, dvs. tabellen EmpDetails, har vi fått deras anställnings-ID och EmployeeName som NULL från den vänstra tabellen.
Så, om A och B är två enheter, kommer den högra yttre sammanfogningen att återge en resultatuppsättning som är lika med ”Records in B NOT A”, baserat på den matchande nyckeln.
Låt oss också se hur resultatuppsättningen kommer att se ut om vi gör en select-operation på alla kolumnerna i de båda tabellerna.
Förfrågan:
SELECT *FROM EmpDetails RIGHT JOIN EmpSalaryON EmpDetails. EmployeeID = EmpSalary. EmployeeID;
Resultat:
EmployeeID | EmployeeName | EmployeeID | EmployeeName | EmployeeSalary | 1 | John | 1 | John | 50000 |
---|---|---|---|---|
2 | Samantha | 2 | Samantha | 120000 | 3 | Hakuna | 3 | Hakuna | 75000 | 4 | Silky | 4 | Silky | 25000 | 5 | Ram | 5 | Ram | 150000 | 6 | Arpit | 6 | Arpit | 80000 | NULL | NULL | NULL | 11 | Rose | 90000 | NULL | NULL | 12 | Sakshi | 250000 | NULL | NULL | 13 | Jack | 250000 |
Nu, låt oss gå över till den fullständiga anslutningen.
En full outer join görs när vi vill ha alla data från båda tabellerna oavsett om det finns en matchning eller inte. Om jag vill ha alla anställda även om jag inte hittar någon matchande nyckel, kör jag alltså en fråga som visas nedan.
Query:
SELECT *FROM EmpDetails FULL JOIN EmpSalaryON EmpDetails. EmployeeID = EmpSalary. EmployeeID;
Resultat:
EmployeeID | EmployeeName | EmployeeID | EmployeeName | EmployeeSalary |
---|---|---|---|---|
1 | John | 1 | John | 50000 | 2 | Samantha | 2 | Samantha | 120000 | 3 | Hakuna | 3 | Hakuna | 75000 | 4 | Silky | 4 | Silky | 25000 | 5 | Ram | 5 | Ram | 150000 | 6 | Arpit | 6 | Arpit | 80000 |
7 | Lily | NULL | NULL | NULL | 8 | Sita | NULL | NULL | NULL | NULL |
9 | Farah | NULL | NULL | NULL | 10 | Jerry | NULL | NULL | NULL | NULL | NULL | NULL | 11 | Rose | 90000 |
NULL | NULL | 12 | Sakshi | 250000 |
NULL | NULL | 13 | Jack | 250000 |
Det framgår av ovanstående resultat att de första sex posterna matchar i båda tabellerna, har vi fått alla data utan någon NULL. Nästa fyra poster finns i den vänstra tabellen men inte i den högra, vilket innebär att motsvarande data i den högra tabellen är NULL.
De tre sista posterna finns i den högra tabellen men inte i den vänstra, vilket innebär att vi har NULL i motsvarande data från den vänstra tabellen. Så om A och B är två enheter kommer den fullständiga yttre sammanfogningen att återge en resultatuppsättning som är lika med ”Records in A AND B”, oavsett den matchande nyckeln.
Teoretiskt sett är det en kombination av Left Join och Right Join.
Performance
Låtsas oss jämföra en Inner Join med en Left Outer Join i SQL-servern. När vi talar om hastigheten på operationen är en left outer JOIN uppenbarligen inte snabbare än en inner join.
Enligt definitionen måste en outer join, oavsett om den är vänster eller höger, utföra allt arbete som en inner join utför tillsammans med det extra arbetet noll- förlängning av resultaten. En outer join förväntas returnera ett större antal poster vilket ytterligare ökar den totala exekveringstiden bara på grund av den större resultatmängden.
En outer join är alltså långsammare än en inner join.
Det kan dessutom finnas vissa specifika situationer där Left join är snabbare än Inner join, men vi kan inte fortsätta att ersätta dem med varandra eftersom en Left outer join inte är funktionellt likvärdig med en Inner join.
Låt oss diskutera ett exempel där Left join kan vara snabbare än Inner join. Om de tabeller som är involverade i join-operationen är för små, till exempel om de har mindre än 10 poster och tabellerna inte har tillräckliga index för att täcka frågan, är Left Join generellt sett snabbare än Inner Join.
Låt oss skapa de två nedanstående tabellerna och göra en INNER JOIN och en LEFT OUTER JOIN mellan dem som ett exempel:
CREATE TABLE #Table1(ID int NOT NULL PRIMARY KEY,Name varchar(50) NOT NULL)INSERT #Table1 (ID, Name) VALUES (1, 'A')INSERT #Table1 (ID, Name) VALUES (2, 'B')INSERT #Table1 (ID, Name) VALUES (3, 'C')INSERT #Table1 (ID, Name) VALUES (4, 'D')INSERT #Table1 (ID, Name) VALUES (5, 'E')CREATE TABLE #Table2(ID int NOT NULL PRIMARY KEY,Name varchar(50) NOT NULL)INSERT #Table2 (ID, Name) VALUES (1, 'A')INSERT #Table2 (ID, Name) VALUES (2, 'B')INSERT #Table2 (ID, Name) VALUES (3, 'C')INSERT #Table2 (ID, Name) VALUES (4, 'D')INSERT #Table2 (ID, Name) VALUES (5, 'E')SELECT *FROM #Table1 t1INNER JOIN #Table2 t2ON t2.Name = t1.Name
ID | Namn | ID | Namn | ||
---|---|---|---|---|---|
1 | 1 | A | 1 | A | |
2 | 2 | B | 2 | 2 | B | 3 | 3 | C | 3 | C | 4 | 4 | D | D | 4 | D |
5 | 5 | E | 5 | E |
SELECT * FROM (SELECT 38 AS bah) AS foo JOIN (SELECT 35 AS bah) AS barON (55=55);
ID | Namn | ID | Namn | ||
---|---|---|---|---|---|
1 | 1 | A | 1 | A | 2 | 2 | B | 2 | B |
3 | 3 | C | 3 | C | |
4 | 4 | D | 4 | 4 | D | 5 | 5 | E | 5 | E |
Som ni kan se ovan, har båda frågorna gett samma resultat. Om du tittar på exekveringsplanen för båda frågorna kommer du att se att den inre sammanfogningen har kostat mer än den yttre sammanfogningen. Detta beror på att SQL-servern gör en hashmatchning för en inner join medan den gör nested loops för left join.
En hashmatchning är normalt sett snabbare än nested loops. Men i det här fallet, eftersom antalet rader är så litet och det inte finns något index att använda (eftersom vi gör en sammanfogning på namnkolumnen), har hashoperationen visat sig vara den dyraste inre sammanfogningsfrågan.
Men om du ändrar matchningsnyckeln i sammanfogningsfrågan från Namn till ID och om det finns ett stort antal rader i tabellen, kommer du att märka att inre sammanfogningen kommer att vara snabbare än den vänstra yttre sammanfogningen.
MS Access Inner och Outer Join
När du använder flera datakällor i en MS Access-fråga tillämpar du JOINs för att styra vilka poster du vill se, beroende på hur datakällorna är länkade med varandra.
I en inner join kombineras endast de relaterade från båda tabellerna i en enda resultatuppsättning. Detta är en standardfogning i Access och den mest använda också. Om du tillämpar en sammanfogning men inte uttryckligen anger vilken typ av sammanfogning det är, antar Access att det är en inre sammanfogning.
I yttre sammanfogningar kombineras alla relaterade data från båda tabellerna på rätt sätt, plus alla återstående rader från en tabell. I fullständiga outer joins kombineras alla data så långt det är möjligt.
Left Join vs Left Outer Join
I SQL server är nyckelordet outer valfritt när du tillämpar left outer join. Det spelar alltså ingen roll om du antingen skriver ”LEFT OUTER JOIN” eller ”LEFT JOIN” eftersom båda kommer att ge samma resultat.
A LEFT JOIN B är en likvärdig syntax till A LEFT OUTER JOIN B.
Nedan följer en lista över likvärdiga syntaxer i SQL server:
Left Outer Join vs Right Outer Join
Vi har redan sett denna skillnad i den här artikeln. Du kan hänvisa till Left Outer Join och Right Outer Join-frågorna och resultatuppsättningen för att se skillnaden.
Den huvudsakliga skillnaden mellan Left Join och Right Join ligger i inkluderandet av icke matchade rader. Left outer join inkluderar de icke-matchade raderna från den tabell som står till vänster om join-klausulen medan Right outer join inkluderar de icke-matchade raderna från den tabell som står till höger om join-klausulen.
Människor frågar sig vad som är bäst att använda, dvs. Left join eller Right join? I grund och botten är det samma typ av operationer förutom att argumenten är omvända. När du frågar vilken sammanfogning du ska använda frågar du alltså egentligen om du ska skriva a<b eller b>a. Det är bara en fråga om preferens.
Generellt föredrar folk att använda Left join i sina SQL-förfrågningar. Jag föreslår att du bör vara konsekvent i ditt sätt att skriva frågan för att undvika förvirring vid tolkningen av frågan.
Vi har hittills sett allt om Inner join och alla typer av Outer joins. Låt oss snabbt sammanfatta skillnaden mellan Inner Join och Outer Join.
Skillnaden mellan Inner Join och Outer Join i tabellformat
Inner Join | Outer Join |
---|---|
Returnerar endast de rader som har matchande värden i båda tabellerna. | Inkluderar de matchande raderna samt några av de icke-matchande raderna mellan de två tabellerna. |
Om det finns ett stort antal rader i tabellerna och det finns ett index som ska användas är INNER JOIN generellt sett snabbare än OUTER JOIN. | Generellt sett är en OUTER JOIN långsammare än en INNER JOIN eftersom den behöver returnera ett större antal poster jämfört med INNER JOIN. Det kan dock finnas vissa specifika scenarier där OUTER JOIN är snabbare. |
När en matchning inte hittas returneras ingenting. | När en matchning inte hittas placeras en NULL i det returnerade kolumnvärdet. |
Använd INNER JOIN när du vill söka detaljerad information om en specifik kolumn. | Använd OUTER JOIN när du vill visa en lista över all information i de två tabellerna. |
INNER JOIN fungerar som ett filter. Det måste finnas en matchning i båda tabellerna för att en inre sammanfogning ska ge data. | De fungerar som data-add ons. |
Den implicita sammanfogningsnoteringen finns för inre sammanfogning där tabellerna som ska sammanfogas är kommaseparerade i FROM-klausulen. Exempel: Det finns ingen implicit notering för yttre sammanfogning. |
|
Nedan visas en visualisering av en inre fogning: |
Nedan visas en visualisering av en outer join |
Inner and Outer Join vs Union
I vissa fall förväxlar vi Join och Union, och det här är också en av de vanligaste frågorna i SQL-intervjuer. Vi har redan sett skillnaden mellan inner join och outer join . Nu ska vi se hur en JOIN skiljer sig från en UNION.
UNION placerar en rad frågor efter varandra, medan join skapar en kartesisk produkt och delar upp den. UNION och JOIN är alltså helt olika operationer.
Låt oss köra nedanstående två frågor i MySQL och se deras resultat.
UNION Förfrågan:
SELECT 28 AS bahUNIONSELECT 35 AS bah;
Resultat:
Bah | 1 | 28 |
---|---|
2 | 35 |
JOIN Förfrågan:
SELECT * FROM(SELECT 38 AS bah) AS fooJOIN(SELECT 35 AS bah) AS barON (55=55);
Resultat:
foo | Bar | 1 | 38 | 35 |
---|
En UNION-operation placerar resultatet av två eller flera frågor i en enda resultatuppsättning. Denna resultatuppsättning innehåller alla poster som returneras genom alla de frågor som ingår i UNION. En UNION kombinerar alltså i princip de två resultatuppsättningarna tillsammans.
En join-operation hämtar data från två eller flera tabeller baserat på de logiska relationerna mellan dessa tabeller, dvs. baserat på join-villkoret. I en join-fråga används data från en tabell för att välja poster från en annan tabell. Det gör det möjligt att koppla ihop liknande data som finns i olika tabeller.
För att förstå det mycket enkelt kan man säga att en UNION kombinerar rader från två tabeller medan en join kombinerar kolumner från två eller flera tabeller. Båda används alltså för att kombinera data från n tabeller, men skillnaden ligger i hur data kombineras.
Nedan finns bildrepresentationer av UNION och JOIN.
Ovanstående är en bildlig representation av en Join-operation som visar att varje post i resultatmängden innehåller kolumner från båda tabellerna, dvs. tabell A och tabell B. Detta resultat returneras baserat på det Join-villkor som tillämpas i frågan.
En sammanfogning är i allmänhet resultatet av denormalisering (motsatsen till normalisering) och använder den främmande nyckeln i en tabell för att söka upp kolumnvärdena genom att använda primärnyckeln i en annan tabell.
Ovanstående är en bildlig representation av en UNION-operation som visar att varje post i resultatmängden är en rad från någon av de två tabellerna. Resultatet av UNION har alltså kombinerat raderna från tabell A och tabell B.
Fortsatt läsning =>> MySQL UNION förklaras med exempel
Slutsats
I den här artikeln har vi sett de stora skillnaderna mellan Inner Join och Outer Join i SQL. Vi har också sett klassificeringen av en Outer Join, dvs. Left join, Right join och Full join. Vi har sett hur var och en av dessa join-typer fungerar och hur de skiljer sig från varandra.
Vi har också gjort en jämförelse av prestanda mellan dessa join-typer. Vi har också diskuterat hur en join skiljer sig från en union.
Och läs =>> MySQL Join Types
Hoppar att den här artikeln har hjälpt dig att reda ut dina tvivel om skillnaderna mellan de olika join-typerna. Vi är säkra på att detta verkligen kommer att få dig att bestämma vilken join-typ du ska välja utifrån den önskade resultatuppsättningen.