Join in SQL: tutorial

SQL Server è un sistema di gestione di database relazionali. Uno dei principi chiave dei database relazionali è che i dati sono distribuiti su più tabelle.

Per estrarre i dati di cui abbiamo bisogno, dobbiamo essere in grado di unire le tabelle. Usiamo chiavi primary e foreign per unire le tabelle.

Chiave primaria

Una chiave primaria è una colonna che identifica in modo univoco ogni riga in una tabella. Questa unicità può essere ottenuta usando un intero sequenziale come colonna identity. Oppure, a volte, colonne esistenti contengono naturalmente valori unici e possono essere usate.

Nell'esempio qui sotto, possiamo vedere le prime righe della tabella artist. Ha due colonne, artist_id e name. La colonna artist_id funge da chiave primaria per questa tabella: è una colonna intera e ogni valore è diverso.

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

Ora diamo un'occhiata alla tabella album. Riesci a individuare la chiave primaria? Sì, è la colonna album_id. È comune che la chiave primaria si chiami "nome-tabella underscore id". Ma avrai notato che c'è anche una colonna artist_id. Anche questa è composta da interi e ha lo stesso nome della colonna artist_id nella tabella artist. Cosa significa?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Chiavi esterne

Dal risultato precedente è chiaro che l'artist_id nella tabella artist funge da Foreign_key per la tabella album. Il vincolo FOREIGN KEY viene usato per impedire azioni che distruggerebbero i collegamenti tra le tabelle.

• Tabella artist

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

• Tabella album

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Questo significa che quando l'artist_id nella tabella album corrisponde all'artist_id nella tabella artist, quelle righe possono essere collegate con un JOIN.

Unire Album e Artist

Le righe 1 e 4 della tabella artist hanno un artist_id pari a 1. L'artist_id 1 nella tabella artist corrisponde ad AC/DC. Quindi, quando uniamo le due tabelle, otteniamo i dettagli degli album dalla tabella album e i relativi dettagli dell'artista dalla tabella artist, uniti usando il campo artist_id, comune a entrambe le tabelle.

Questo è noto come inner join.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|

Abbiamo unito le tabelle album e artist facendo corrispondere l'artist_id della tabella artist con l'artist_id della tabella album.

Quando selezioni colonne con lo stesso nome da tabelle diverse, devi qualificare completamente il nome della colonna. In caso contrario, SQL Server non saprà da quale tabella SELECT la colonna.

Per qualificare completamente una colonna, devi anteporre il nome della tabella pertinente, seguito da un punto.

Sintassi dell'inner join

Ecco un esempio generico per ricordarti la sintassi. Selezioniamo le colonne pertinenti dalla tabella principale, in questo caso table_A, quindi selezioniamo qualsiasi colonna aggiuntiva a cui vogliamo unirci, in questo caso table_B. Poi specifichiamo la join usando le parole chiave INNER JOIN e ON, fornendo le colonne chiave necessarie per entrambe le tabelle.

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;

Senza usare una clausola WHERE

In questo esempio non specifichiamo una clausola WHERE, quindi otteniamo TUTTE le combinazioni di TUTTE le corrispondenze tra le tabelle artist e album, sempre in base alla colonna artist_id, comune a entrambe.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+

Inner join multipli

Puoi anche unire più di due tabelle usando gli INNER JOINS. Ti basta fornire un INNER JOIN aggiuntivo per ogni combinazione di tabelle. Nel codice qui sotto, uniamo le tabelle A e B, e anche B e C.

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;

Per saperne di più sull'unione delle tabelle, guarda questo video del nostro corso Introduzione a SQL Server.

Questo contenuto è tratto dal corso di DataCamp Introduzione a SQL Server di John MacKintosh.