Guida alle join in MySQL: padroneggia le join con esempi

Se hai mai provato a estrarre dati da più tabelle MySQL e ti sei sentito perso, non sei il solo. Le join sono uno di quei concetti che all'inizio sembrano intimidatori, ma che diventano incredibilmente potenti una volta che ci prendi la mano.

Pensa alle join come a un modo per dire a MySQL “ehi, voglio prendere i dati da questa tabella E da quella tabella, ma solo dove certe condizioni corrispondono.” Una volta capiti gli schemi di base, combinerai dati come un professionista.

🔖 Riferimento rapido: Ti serve una consultazione veloce? Dai un'occhiata al nostro cheat sheet sulle JOIN SQL con tutti i tipi di JOIN, diagrammi visivi ed esempi di codice in un unico posto.

L'albero genealogico delle join

In sostanza, una join ti permette di combinare righe di tabelle diverse quando hanno qualcosa in comune. È come presentare due gruppi di amici che hanno conoscenze in comune.

Ecco i tipi di join che vedremo:

• INNER JOIN - Mostrami solo i record presenti in entrambe le tabelle
• LEFT JOIN - Mostrami tutto dalla tabella di sinistra, più le corrispondenze da quella di destra
• RIGHT JOIN - L'opposto della LEFT JOIN (anche se, sinceramente, quasi tutti preferiscono invertire le tabelle)
• FULL JOIN - Tutto da entrambe le tabelle (MySQL ci fa faticare un po' per questa)
• CROSS JOIN - Ogni combinazione possibile (usala con cautela!)
• SELF JOIN - Quando una tabella deve parlare con se stessa

INNER JOIN - La perfezionista

La INNER JOIN è esigente. Ti restituisce solo le righe in cui entrambe le tabelle hanno dati corrispondenti. Pensala come l'intersezione in un diagramma di Venn.

Esempio:

Usiamo due semplici tabelle, employees e departments:

-- Employees Table
+----+----------+-------------+
| id | name     | department_id|
+----+----------+-------------+
| 1  | Alice    | 1           |
| 2  | Bob      | 2           |
| 3  | Charlie  | NULL        |
+----+----------+-------------+

-- Departments Table
+----+-------------+
| id | department  |
+----+-------------+
| 1  | HR          |
| 2  | IT          |
+----+-------------+

Query INNER JOIN:

SELECT employees.name, departments.department
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

Risultato:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

LEFT JOIN - L'inclusiva

La LEFT JOIN è più generosa della INNER JOIN. Dice “voglio tutto dalla tabella di sinistra e, se c'è qualcosa di corrispondente nella tabella di destra, ottimo! Altrimenti, ci metto NULL.”

Nota come questa volta compare anche Charlie, pur non avendo un reparto:

Query LEFT JOIN:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id;

Risultato:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

RIGHT JOIN - Il rovescio della medaglia

La RIGHT JOIN è semplicemente una LEFT JOIN con le tabelle invertite. La maggior parte degli sviluppatori la evita e riorganizza invece la clausola FROM: così è meno confusionario.

Query RIGHT JOIN:

SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Risultato:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

FULL JOIN - L'approccio “metti dentro tutto”

Qui MySQL diventa un po' fastidioso: non ha una FULL JOIN integrata. Ma possiamo simularla con un trucco basato su UNION:

Simulazione di FULL JOIN:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id
UNION
SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Risultato:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

CROSS JOIN - La creatrice di caos

La CROSS JOIN è come quell'amico che a una festa vuole presentare tutti a tutti. Abbina ogni singola riga della prima tabella con ogni singola riga della seconda. Con 3 dipendenti e 2 reparti, otteniamo 6 combinazioni:

Query CROSS JOIN:

SELECT employees.name, departments.department
FROM employees
CROSS JOIN departments;

Risultato:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Alice | IT         |
| Bob   | HR         |
| Bob   | IT         |
| Charlie | HR       |
| Charlie | IT       |
+-------+------------+

SELF JOIN - L'introspettiva

Le self join si usano quando una tabella fa riferimento a se stessa. L'esempio classico è una tabella dei dipendenti in cui alcuni dipendenti gestiscono altri dipendenti.

Esempio:

Ecco una tabella managers in cui mgr_id punta a un'altra riga della stessa tabella:

-- Managers Table
+----+----------+--------+
| id | name     | mgr_id |
+----+----------+--------+
| 1  | Tom      | NULL   |
| 2  | Jerry    | 1      |
| 3  | Spike    | 1      |
+----+----------+--------+

Query SELF JOIN:

SELECT m1.name AS manager, m2.name AS employee
FROM managers m1
LEFT JOIN managers m2 ON m1.id = m2.mgr_id;

Risultato:

+---------+----------+
| manager | employee |
+---------+----------+
| Tom     | Jerry    |
| Tom     | Spike    |
| Jerry   | NULL     |
| Spike   | NULL     |
+---------+----------+

In conclusione

All'inizio le join possono sembrare travolgenti, ma in realtà sono solo modi diversi per dire “mostrami i dati di più tabelle secondo queste regole.” Inizia con INNER e LEFT join: copriranno il 90% di ciò che ti serve.

Il modo migliore per prendere confidenza con le join è fare pratica con i tuoi dati. Crea qualche tabella di prova, inserisci dei dati di esempio e inizia a sperimentare. In poco tempo farai join a destra e a sinistra (gioco di parole voluto).

E ricorda: se la tua join restituisce molte più righe del previsto, probabilmente hai fatto una CROSS JOIN per sbaglio. Ci siamo passati tutti!