SQL Inner Join

Denne artikel giver et overblik over INNER JOIN i SQL, samt nogle grundlæggende eksempler.

SQL INNER JOIN returnerer rækker, når der er mindst én række i begge tabeller, der matcher join-betingelsen. Den kasserer umatchede rækker fra begge tabeller. Dette er standard jointype.

Syntaks

Der er to måder at angive en indre joinforbindelse:i FROM klausul (ved hjælp af INNER JOIN syntaks), eller ved at bruge WHERE klausul.

For at angive en indre joinforbindelse i FROM klausul:

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

For at angive en indre joinforbindelse i WHERE klausul:

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

Nedenfor er eksempler på hver.

Eksempler

Her har vi eksempler for hver metode til at specificere en indre joinforbindelse.

Eksempel på data

For det første er her de tabeller, vi skal bruge til eksemplerne.

PetTypes tabel:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Pets tabel:

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

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

Bemærk at:

• PetTypeId kolonne i Pets tabel er en fremmednøgle til PetTypeId af PetTypes tabel (som er den primære nøgle til den pågældende tabel).
• OwnerId kolonne i Pets tabel er en fremmednøgle til OwnerId kolonne i Owners tabel.

Eksempel på brug af INNER JOIN-syntaksen

Her er et grundlæggende eksempel på at specificere en indre joinforbindelse ved hjælp af INNER JOIN syntaks.

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)

For at angive en indre joinforbindelse i FROM klausul, bruger vi INNER JOIN . Vi bruger også ON nøgleord for at definere prædikatet, der skal evalueres for hvert par af sammenføjede rækker.

Uanset jointype kvalificerer vi vores kolonnenavne med tabelnavnene. Grunden til, at vi gør dette, er for at undgå uklarhed med hensyn til kolonnenavnene mellem tabellerne. Begge tabeller kunne have kolonner med samme navn (som i vores eksempel), og i sådanne tilfælde ved DBMS ikke, hvilken kolonne du henviser til. Ved at præfikse kolonnenavnene med deres tabelnavne sikrer du, at du refererer til den højre kolonne, og forhindrer fejl, der kan skyldes uklarhed om, hvilken kolonne du henviser til.

I dette eksempel har begge tabeller et PetTypeId kolonne. Pets.PetTypeId kolonnen er en fremmednøgle til PetTypes.PetTypeId kolonne, som er den primære nøgle til den pågældende tabel.

I dette eksempel kan vi se, at alle kæledyr returneres, men ikke alle kæledyrstyper returneres. Der er ingen kaniner i Pets tabellen, og så Rabbits kæledyrstype returneres ikke.

Årsagen til Rabbits type ikke returneres, fordi INNER JOIN returnerer kun rækker, når der er mindst én række i begge tabeller, der matcher join-betingelsen. I dette tilfælde Rabbits er kun i én tabel (PetTypes tabel).

Deltagelsestype er valgfri

Bemærk, at jointypen er valgfri. Derfor tillader de fleste (hvis ikke alle) DBMS'er dig at udelade INNER søgeord. Når du udelader dette (dvs. kun specificer JOIN). ), antages det at være en indre sammenføjning.

Derfor kunne vi omskrive ovenstående eksempel til dette:

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

Formattering

Som med enhver SQL-sætning kan du bruge mellemrum og indrykning osv. til at formatere dine forespørgsler.

For eksempel FROM klausul kan være på en hel linje, hvis du foretrækker:

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

Når du skriver større tabeller, der forbinder flere tabeller, kan indrykning hjælpe meget.

Eksempel på brug af WHERE-klausulen

Ovenstående joinforbindelse kan også omtales som en equi-join . En equi-join er en join, der kun indeholder lighedssammenligninger i join-prædikatet.

Her er et eksempel på specificering af en indre joinforbindelse ved hjælp af 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)

Dette gav det samme resultat som det forrige eksempel.

Her har vi blot givet en kommasepareret liste over tabellerne og derefter en WHERE tilstand. Hvis vi havde udeladt WHERE betingelse, ville vi have endt med en CROSS JOIN .

Mange begyndere finder ovenstående syntaks meget lettere at forstå end INNER JOIN syntaks. Du er velkommen til at bruge denne syntaks, hvis du foretrækker det, men vær opmærksom på, at de fleste SQL-professionelle foretrækker at bruge INNER JOIN syntaks fra det forrige eksempel..

Indre deltagelse på 3 borde

Her er et eksempel på at udføre en indre joinforbindelse på 3 borde.

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 dette eksempel bragte vi Owners tabel ind i blandingen, fordi vi havde brug for denne forespørgsel for at returnere oplysninger om ejeren.

For at bruge en tredje tabel, var det eneste, vi gjorde, at tilføje endnu en INNER JOIN... ON argument sammen med de relevante tabel-/kolonnedetaljer.

I dette tilfælde brugte jeg T-SQL's CONCAT() funktion til at sammenkæde to kolonner, men dette er irrelevant for sammenføjningen.