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 delPets
table è una chiave esterna diPetTypeId
deiPetTypes
table (che è la chiave primaria di quella tabella). - Il
OwnerId
colonna delPets
table è una chiave esterna diOwnerId
colonna deiOwners
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.