SQL Inner Join

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

SQL INNER JOIN returnerar rader när det finns minst en rad i båda tabellerna som matchar kopplingsvillkoret. Den kasserar omatchade rader från båda tabellerna. Detta är standardanslutningstypen.

Syntax

Det finns två sätt att ange en inre koppling:i FROM klausul (med hjälp av INNER JOIN syntax), eller med WHERE klausul.

För att ange en inre koppling i FROM klausul:

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

För att ange en inre koppling i WHERE klausul:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

Nedan finns exempel på var och en.

Exempel

Här har vi exempel för varje metod för att specificera en inre koppling.

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              |
+-----------+-------------+------------+----------------+-------------------+

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.

Exempel på att använda INNER JOIN-syntaxen

Här är ett grundläggande exempel på hur du anger en inre koppling med INNER JOIN syntax.

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

Resultat:

-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

För att ange en inre koppling i FROM klausul använder vi INNER JOIN . Vi använder också ON nyckelord för att definiera predikatet som ska utvärderas för varje par sammanfogade rader.

Oavsett kopplingstyp kvalificerar vi våra kolumnnamn med tabellnamnen. Anledningen till att vi gör detta är för att undvika oklarheter angående kolumnnamnen mellan tabellerna. Båda tabellerna kan ha kolumner med samma namn (som i vårt exempel), och i sådana fall kommer DBMS inte att veta vilken kolumn du hänvisar till. Att prefixa kolumnnamnen med deras tabellnamn säkerställer att du hänvisar till höger kolumn och förhindrar eventuella fel som kan uppstå på grund av oklarheter om vilken kolumn du hänvisar till.

I det här exemplet har båda tabellerna ett PetTypeId kolumn. Pets.PetTypeId kolumnen är en främmande nyckel till PetTypes.PetTypeId kolumn, som är den primära nyckeln för den tabellen.

I det här exemplet kan vi se att alla husdjur returneras, men inte alla husdjurstyper returneras. Det finns inga kaniner i Pets tabellen, och så Rabbits husdjurstyp returneras inte.

Anledningen till Rabbits typ inte returneras beror på att INNER JOIN returnerar endast rader när det finns minst en rad i båda tabellerna som matchar kopplingsvillkoret. I det här fallet, Rabbits finns bara i en tabell (PetTypes tabell).

Anslutningstyp är valfri

Observera att anslutningstypen är valfri. Därför tillåter de flesta (om inte alla) DBMS dig att utelämna INNER nyckelord. När du utelämnar detta (dvs. anger bara JOIN ), antas det vara en inre sammanfogning.

Därför skulle vi kunna skriva om exemplet ovan till detta:

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

Formatera

Som med alla SQL-satser kan du använda blanksteg och indrag etc för att formatera dina frågor.

Till exempel, FROM klausul kan vara på en hel rad om du föredrar:

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

När du skriver större tabeller som sammanfogar flera tabeller kan indrag hjälpa mycket.

Exempel med WHERE-klausulen

Ovanstående koppling kan också hänvisas till som en equi-join . En equi-join är en join som endast innehåller likhetsjämförelser i join-predikatet.

Här är ett exempel på hur du anger en inre koppling med WHERE klausul:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

Resultat:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Detta gav samma resultat som föregående exempel.

Här gav vi helt enkelt en kommaseparerad lista över tabellerna och sedan en WHERE tillstånd. Om vi hade utelämnat WHERE villkor, skulle vi ha slutat med en CROSS JOIN .

Många nybörjare tycker att ovanstående syntax är mycket lättare att förstå än INNER JOIN syntax. Använd gärna denna syntax om du föredrar det, men tänk på att de flesta SQL-proffs föredrar att använda INNER JOIN syntax från föregående exempel...

Inre gå med på 3 bord

Här är ett exempel på hur man utför en inre koppling på 3 bord.

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

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   |
+-----------+-----------+---------------+
(8 rows affected)

I det här exemplet tog vi med oss Owners tabellen in i mixen eftersom vi behövde den här frågan för att returnera information om ägaren.

För att använda en tredje tabell var allt vi gjorde att lägga till ytterligare en INNER JOIN... ON argument tillsammans med relevant tabell/kolumninformation.

I det här fallet använde jag T-SQL:s CONCAT() funktion för att sammanfoga två kolumner, men detta är irrelevant för sammanfogningen.