SQL Inner Join

Dit artikel geeft een overzicht van de INNER JOIN in SQL, evenals enkele basisvoorbeelden.

De SQL INNER JOIN retourneert rijen wanneer er in beide tabellen ten minste één rij is die overeenkomt met de join-voorwaarde. Het verwijdert ongeëvenaarde rijen van beide tabellen. Dit is het standaard join-type.

Syntaxis

Er zijn twee manieren om een ​​inner join op te geven:in de FROM clausule (met behulp van de INNER JOIN syntaxis), of met behulp van de WHERE clausule.

Een inner join specificeren in de FROM clausule:

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

Een inner join specificeren in de WHERE clausule:

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

Hieronder staan ​​voorbeelden van elk.

Voorbeelden

Hier hebben we voorbeelden voor elke methode om een ​​inner join op te geven.

Voorbeeldgegevens

Ten eerste zijn hier de tabellen die we voor de voorbeelden zullen gebruiken.

De PetTypes tafel:

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

De Pets tafel:

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

De Owners tafel:

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

Merk op dat:

• De PetTypeId kolom van de Pets tabel is een externe sleutel van de PetTypeId van de PetTypes tabel (wat de primaire sleutel van die tabel is).
• De OwnerId kolom van de Pets tabel is een externe sleutel van de OwnerId kolom van de Owners tafel.

Voorbeeld met de INNER JOIN-syntaxis

Hier is een eenvoudig voorbeeld van het specificeren van een inner join met behulp van de INNER JOIN syntaxis.

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

Resultaat:

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

Een inner join specificeren in de FROM clausule gebruiken we INNER JOIN . We gebruiken ook de ON trefwoord om het predikaat te definiëren dat moet worden geëvalueerd voor elk paar samengevoegde rijen.

Ongeacht het type join, kwalificeren we onze kolomnamen met de tabelnamen. De reden dat we dit doen is om onduidelijkheid over de kolomnamen tussen de tabellen te voorkomen. Beide tabellen kunnen kolommen met dezelfde naam hebben (zoals in ons voorbeeld), en in dergelijke gevallen weet het DBMS niet naar welke kolom u verwijst. Door de kolomnamen vooraf te laten gaan door hun tabelnamen zorgt u ervoor dat u naar de juiste kolom verwijst en voorkomt u fouten die zouden kunnen voortvloeien uit onduidelijkheid over de kolom waarnaar u verwijst.

In dit voorbeeld hebben beide tabellen een PetTypeId kolom. De Pets.PetTypeId kolom is een refererende sleutel voor de PetTypes.PetTypeId kolom, wat de primaire sleutel is voor die tabel.

In dit voorbeeld kunnen we zien dat alle huisdieren worden geretourneerd, maar niet alle soorten huisdieren. Er zijn geen konijnen in de Pets tabel, en dus de Rabbits huisdiertype wordt niet geretourneerd.

De reden waarom de Rabbits type niet wordt geretourneerd, is omdat de INNER JOIN retourneert alleen rijen als er in beide tabellen ten minste één rij is die overeenkomt met de join-voorwaarde. In dit geval, Rabbits staat slechts in één tabel (de PetTypes tafel).

Aanmeldtype is optioneel

Houd er rekening mee dat het join-type optioneel is. Daarom kunt u bij de meeste (zo niet alle) DBMS'en de INNER . weglaten trefwoord. Wanneer u dit weglaat (d.w.z. alleen JOIN specificeren) ), wordt aangenomen dat het een inner join is.

Daarom zouden we het bovenstaande voorbeeld hiernaar kunnen herschrijven:

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

Opmaak

Zoals bij elke SQL-instructie, kunt u spaties en inspringingen, enz. gebruiken om uw query's op te maken.

Bijvoorbeeld de FROM clausule kan op één hele regel staan ​​als je dat liever hebt:

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

Wanneer u grotere tabellen schrijft die aan meerdere tabellen zijn gekoppeld, kan inspringen veel helpen.

Voorbeeld met de WHERE-clausule

De bovenstaande join kan ook worden aangeduid als een equi-join . Een equi-join is een join die alleen gelijkheidsvergelijkingen bevat in het join-predikaat.

Hier is een voorbeeld van het specificeren van een inner join met behulp van de WHERE clausule:

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

Resultaat:

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

Dit gaf hetzelfde resultaat als het vorige voorbeeld.

Hier hebben we eenvoudig een door komma's gescheiden lijst van de tabellen gegeven en vervolgens een WHERE voorwaarde. Als we de WHERE . hadden weggelaten voorwaarde, zouden we zijn geëindigd met een CROSS JOIN .

Veel beginners vinden de bovenstaande syntaxis veel gemakkelijker te begrijpen dan de INNER JOIN syntaxis. Voel je vrij om deze syntaxis te gebruiken als je dat liever hebt, maar houd er rekening mee dat de meeste SQL-professionals de voorkeur geven aan de INNER JOIN syntaxis van het vorige voorbeeld..

Inner Join op 3 Tafels

Hier is een voorbeeld van het uitvoeren van een inner join op 3 tafels.

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;

Resultaat:

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

In dit voorbeeld hebben we de Owners tabel in de mix omdat we deze zoekopdracht nodig hadden om informatie over de eigenaar te retourneren.

Om een ​​derde tabel te gebruiken, hebben we alleen nog een INNER JOIN... ON . toegevoegd argument samen met de relevante tabel-/kolomdetails.

In dit geval gebruikte ik T-SQL's CONCAT() functie om twee kolommen samen te voegen, maar dit is niet relevant voor de join.