Ho 2 tavoli come questo:
> SELECT * FROM table_a;
+------+------+
| id | name |
+------+------+
| 1 | row1 |
| 2 | row2 |
+------+------+
> SELECT * FROM table_b;
+------+------+------+
| id | name | aid |
+------+------+------+
| 3 | row3 | 1 |
| 4 | row4 | 1 |
| 5 | row5 | NULL |
+------+------+------+
INNER JOIN si prende cura di entrambi i tavoli
INNER JOIN si prende cura di entrambi i tavoli, quindi otterrai una riga solo se entrambi i tavoli ne hanno uno. Se esiste più di una coppia corrispondente, si ottengono più righe.
> SELECT * FROM table_a a INNER JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
+------+------+------+------+------+
INNER JOIN non fa differenza se inverti l'ordine, perché si preoccupa per entrambe le tabelle:
> SELECT * FROM table_b b INNER JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
+------+------+------+------+------+
Ottieni le stesse righe, ma le colonne sono in un ordine diverso perché abbiamo menzionato le tabelle in un ordine diverso.
LEFT JOIN si preoccupa solo del primo tavolo
LEFT JOIN si prende cura della prima tabella che gli dai, e non importa molto della seconda, quindi ottieni sempre le righe dalla prima tabella, anche se non c'è una riga corrispondente nella seconda:
> SELECT * FROM table_a a LEFT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
| 2 | row2 | NULL | NULL | NULL |
+------+------+------+------+------+
Sopra puoi vedere tutte le righe di table_a anche se alcune di esse non corrispondono a nulla nella tabella b, ma non tutte le righe di table_b - solo quelle che corrispondono a qualcosa in table_a.
Se invertiamo l'ordine delle tabelle, LEFT JOIN si comporta diversamente:
> SELECT * FROM table_b b LEFT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
| 5 | row5 | NULL | NULL | NULL |
+------+------+------+------+------+
Ora otteniamo tutte le righe di table_b, ma solo le righe corrispondenti di table_a.
RIGHT JOIN si preoccupa solo del secondo tavolo
a RIGHT JOIN bti dà esattamente le stesse file di b LEFT JOIN a. L'unica differenza è l'ordine predefinito delle colonne.
> SELECT * FROM table_a a RIGHT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
| NULL | NULL | 5 | row5 | NULL |
+------+------+------+------+------+
Queste sono le stesse righe table_b LEFT JOIN table_ache abbiamo visto nella sezione LEFT JOIN.
Allo stesso modo:
> SELECT * FROM table_b b RIGHT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
| NULL | NULL | NULL | 2 | row2 |
+------+------+------+------+------+
Ha le stesse righe di table_a LEFT JOIN table_b.
Nessuna partecipazione ti dà copie di tutto
Clausola No Join: se scrivi le tue tabelle senza alcuna clausola JOIN, separate solo da virgole, otterrai ogni riga della prima tabella scritta accanto a ogni riga della seconda tabella, in ogni possibile combinazione:
> SELECT * FROM table_b, table_a;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 3 | row3 | 1 | 2 | row2 |
| 4 | row4 | 1 | 1 | row1 |
| 4 | row4 | 1 | 2 | row2 |
| 5 | row5 | NULL | 1 | row1 |
| 5 | row5 | NULL | 2 | row2 |
+------+------+------+------+------+
(Questo è dal mio post sul blog Esempi di tipi di join SQL )
