Database
 sql >> Database >  >> RDS >> Database

Join interno SQL

Questo articolo fornisce una panoramica di INNER JOIN in SQL, oltre ad alcuni esempi di base.

Il INNER JOIN di SQL restituisce righe quando è presente almeno una riga in entrambe le tabelle che soddisfano la condizione di unione. Elimina le righe non corrispondenti da entrambe le tabelle. Questo è il tipo di unione predefinito.

Sintassi

Ci sono due modi per specificare un inner join:nel FROM clausola (usando la INNER JOIN sintassi), o usando il WHERE clausola.

Per specificare un inner join nel FROM clausola:

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

Per specificare un inner join in WHERE clausola:

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

Di seguito sono riportati esempi di ciascuno.

Esempi

Qui abbiamo esempi per ogni metodo per specificare un inner join.

Dati di esempio

Innanzitutto, ecco le tabelle che useremo per gli esempi.

I PetTypes tabella:

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

Gli Pets tabella:

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

I Owners tabella:

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

Nota che:

  • Il PetTypeId colonna del Pets table è una chiave esterna di PetTypeId dei PetTypes table (che è la chiave primaria di quella tabella).
  • Il OwnerId colonna del Pets table è una chiave esterna di OwnerId colonna dei Owners tabella.

Esempio di utilizzo della sintassi INNER JOIN

Ecco un esempio di base di come specificare un inner join utilizzando INNER JOIN sintassi.

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

Risultato:

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

Per specificare un inner join nel FROM clausola, utilizziamo INNER JOIN . Usiamo anche il ON parola chiave per definire il predicato da valutare per ogni coppia di righe unite.

Indipendentemente dal tipo di join, qualifichiamo i nomi delle nostre colonne con i nomi delle tabelle. Il motivo per cui lo facciamo è evitare qualsiasi ambiguità riguardo ai nomi delle colonne tra le tabelle. Entrambe le tabelle potrebbero avere colonne con lo stesso nome (come nel nostro esempio) e in questi casi il DBMS non saprà a quale colonna ti riferisci. Prefissare i nomi delle colonne con i nomi delle tabelle assicura che stai facendo riferimento alla colonna giusta e previene eventuali errori che potrebbero derivare da qualsiasi ambiguità sulla colonna a cui ti riferisci.

In questo esempio, entrambe le tabelle hanno un PetTypeId colonna. Il Pets.PetTypeId column è una chiave esterna per PetTypes.PetTypeId colonna, che è la chiave primaria per quella tabella.

In questo esempio, possiamo vedere che tutti gli animali domestici vengono restituiti, ma non tutti i tipi di animali domestici vengono restituiti. Non ci sono conigli nel Pets tabella, e così i Rabbits il tipo di animale domestico non viene restituito.

Il motivo per i Rabbits il tipo non viene restituito è perché INNER JOIN restituisce righe solo quando è presente almeno una riga in entrambe le tabelle che soddisfano la condizione di unione. In questo caso, Rabbits è solo in una tabella (il PetTypes tabella).

Il tipo di iscrizione è facoltativo

Si noti che il tipo di unione è facoltativo. Pertanto, la maggior parte (se non tutti) i DBMS ti consentono di omettere il INNER parola chiave. Quando lo ometti (es. specifica solo JOIN ), si presume che sia un inner join.

Pertanto, potremmo riscrivere l'esempio sopra in questo:

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

Formattazione

Come con qualsiasi istruzione SQL, puoi utilizzare spazi bianchi e rientri, ecc. Per formattare le tue query.

Ad esempio, il FROM la clausola può essere su un'intera riga se preferisci:

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

Quando scrivi tabelle più grandi che uniscono più tabelle, il rientro può aiutare molto.

Esempio utilizzando la clausola WHERE

L'unione di cui sopra può anche essere definita equi-join . Un equi-join è un join che contiene solo confronti di uguaglianza nel predicato di join.

Ecco un esempio di come specificare un inner join usando WHERE clausola:

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

Risultato:

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

Ciò ha restituito lo stesso risultato dell'esempio precedente.

Qui, abbiamo semplicemente fornito un elenco separato da virgole delle tabelle, quindi un WHERE condizione. Se avessimo omesso il WHERE condizione, avremmo finito con un CROSS JOIN .

Molti principianti trovano la sintassi di cui sopra molto più facile da capire rispetto a INNER JOIN sintassi. Sentiti libero di usare questa sintassi se preferisci, tuttavia, tieni presente che la maggior parte dei professionisti SQL preferisce utilizzare il INNER JOIN sintassi dell'esempio precedente..

Inner Join su 3 tavoli

Ecco un esempio di esecuzione di un inner join su 3 tabelle.

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;

Risultato:

+-----------+-----------+---------------+
| 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 questo esempio, abbiamo portato i Owners table nel mix perché avevamo bisogno di questa query per restituire informazioni sul proprietario.

Per utilizzare una terza tabella, tutto ciò che abbiamo fatto è stato aggiungere un altro INNER JOIN... ON argomento insieme ai dettagli relativi alla tabella/colonna.

In questo caso, ho usato CONCAT() di T-SQL funzione per concatenare due colonne, ma questo è irrilevante per il join.