SQL Full Join

Den här artikeln ger en översikt över FULL JOIN i SQL, samt några grundläggande exempel.

SQL FULL JOIN (eller FULL OUTER JOIN ) returnerar alla rader, så länge det finns matchande data i en av tabellerna.

Det är som att ha båda en vänster höger join i en join.

Syntax

Du anger en fullständig anslutning i FROM klausul. Du kan använda antingen FULL JOIN eller FULL OUTER JOIN syntax.

Använda FULL JOIN syntax:

SELECT *
FROM Table1 FULL JOIN Table2 
ON Table1.Column = Table2.Column;

Använda FULL OUTER JOIN syntax:

SELECT *
FROM Table1 FULL OUTER JOIN Table2 
ON Table1.Column = Table2.Column;

Båda dessa gör exakt samma sak. Det är bara att OUTER nyckelordet är valfritt.

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 | Fågel || 2 | Katt || 3 | Hund || 4 | Kanin |+-------------+------------+(4 rader påverkade)

Pets tabell:

+--------+-------------+------------+-------- -+------------+| PetId | PetTypeId | Ägar-ID | PetName | DOB ||--------+------------------------ +------------|| 1 | 2 | 3 | Fluffig | 2020-11-20 || 2 | 3 | 3 | Hämta | 2019-08-16 || 3 | 2 | 2 | Skrapa | 2018-10-01 || 4 | 3 | 3 | Wag | 2020-03-15 || 5 | 1 | 1 | Tweet | 2020-11-28 || 6 | 3 | 4 | Fluffig | 2020-09-17 || 7 | 3 | 2 | Bark | NULL || 8 | 2 | 4 | Mjau | NULL |+---------+------------------------ +------------+(8 rader påverkade)

Owners tabell:

+-------+-----------------+------- ----------+---------------------------+| Ägar-ID | Förnamn | Efternamn | Telefon | E-post ||----------------------------------------- ----+-------------------------|| 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 i Pets tabellen är en främmande nyckel för PetTypeId av PetTypes tabell (som är den primära nyckeln för den tabellen).
OwnerId kolumnen i Pets tabellen är en främmande nyckel för OwnerId kolumnen i Owners tabell.

Fullständiga anslutningsfrågan

Här är ett exempel på hur man utför en fullständig koppling mot två av dessa bord.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Resultat:

+-------+------------+| PetName | PetType ||-----------+--------|| Tweet | Fågel || Fluffig | Katt || Skrapa | Katt || Mjau | Katt || Hämta | Hund || Wag | Hund || Fluffig | Hund || Bark | Hund || NULL | Kanin |+-----------+-----------+(9 rader påverkade)

I det här exemplet får vi en PetType värde som inte överensstämmer med ett PetName . Detta beror på att det inte finns några kaniner som husdjur. Men den fullständiga kopplingen orsakar Rabbit ska returneras, även om det inte finns något husdjur i Pets bord av den typen. Detta resulterar i en NULL värde i PetName kolumn mot Rabbit .

Det här är samma resultat som vi skulle ha fått om vi hade använt en rätt join, eftersom PetTypes tabellen är till höger om JOIN nyckelord. Detta skulle inte ha hänt med en vänsterjoin, eftersom PetTypes tabellen är inte till vänster om JOIN nyckelord. Om vi ville återskapa den med en vänsterkoppling, måste vi ändra ordningen på tabellerna så att PetTypes tabellen var till vänster om JOIN nyckelord.

Det här är vad som händer om vi ändrar tabellordningen i vår fråga när vi använder en fullständig anslutning.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
FULL JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Resultat:

+-------+------------+| PetName | PetType ||-----------+--------|| Tweet | Fågel || Fluffig | Katt || Skrapa | Katt || Mjau | Katt || Hämta | Hund || Wag | Hund || Fluffig | Hund || Bark | Hund || NULL | Kanin |+-----------+-----------+(9 rader påverkade)

Vi får exakt samma resultat. Detta beror på att den fullständiga kopplingen returnerar alla rader, så länge det finns matchande data i en av tabellerna. Som nämnts är det som att ha en vänster och höger sammanfogning i en sammanfogning.

Fullständig gå med på 3 bord

Här är ett exempel på att utföra en fullständig anslutning på alla tre borden.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o FULL JOIN Pets p
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

Resultat:

+-------+------------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Tweet | Fågel | Homer Connery || Skrapa | Katt | Bart Pitt || Bark | Hund | Bart Pitt || Fluffig | Katt | Nancy Simpson || Hämta | Hund | Nancy Simpson || Wag | Hund | Nancy Simpson || Fluffig | Hund | Boris Trump || Mjau | Katt | Boris Trump || NULL | NULL | Woody Eastwood || NULL | Kanin | |+-----------+-----------+----------------+(10 rader påverkade) 
 Den här gången har vi en husdjursägare som inte har ett husdjur, samt en husdjurstyp som inte är tilldelad ett husdjur. 
 
 Om vi blandar ordningen på borden får vi samma resultat, även om raderna är listade i en annan ordning.
 SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt FULL JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
FULL JOIN Owners o 
    ON p.OwnerId = o.OwnerId; 
 
 Resultat:
 -----------+-----------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Tweet | Fågel | Homer Connery || Fluffig | Katt | Nancy Simpson || Skrapa | Katt | Bart Pitt || Mjau | Katt | Boris Trump || Hämta | Hund | Nancy Simpson || Wag | Hund | Nancy Simpson || Fluffig | Hund | Boris Trump || Bark | Hund | Bart Pitt || NULL | Kanin | || NULL | NULL | Woody Eastwood |+-----------+------------+----------------+(10 rader påverkade) 
 
 Och om vi blandar dem en gång till får vi fortfarande samma resultat.
 SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p FULL JOIN Owners o
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId; 
 
 Resultat:
 +-------+------------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Fluffig | Katt | Nancy Simpson || Hämta | Hund | Nancy Simpson || Skrapa | Katt | Bart Pitt || Wag | Hund | Nancy Simpson || Tweet | Fågel | Homer Connery || Fluffig | Hund | Boris Trump || Bark | Hund | Bart Pitt || Mjau | Katt | Boris Trump || NULL | NULL | Woody Eastwood || NULL | Kanin | |+-----------+-----------+----------------+(10 rader påverkade) 
 Om du undrar varför den senaste PetOwner är inte NULL (som sist PetName är), det beror på att det är ett resultat av en strängsammansättning. Jag använde T-SQL CONCAT() funktion för att sammanfoga ägarens för- och efternamn.