J'ai 2 tables comme celle-ci:
> 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 se soucie des deux tables
INNER JOIN se soucie des deux tables, donc vous n'obtenez une ligne que si les deux tables en ont une. S'il y a plus d'une paire correspondante, vous obtenez plusieurs lignes.
> 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 |
+------+------+------+------+------+
Cela ne fait aucune différence pour INNER JOIN si vous inversez l'ordre, car il se soucie des deux tables:
> 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 |
+------+------+------+------+------+
Vous obtenez les mêmes lignes, mais les colonnes sont dans un ordre différent car nous avons mentionné les tables dans un ordre différent.
LEFT JOIN ne se soucie que de la première table
LEFT JOIN se soucie de la première table que vous lui donnez, et ne se soucie pas beaucoup de la seconde, donc vous obtenez toujours les lignes de la première table, même s'il n'y a pas de ligne correspondante dans la seconde:
> 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 |
+------+------+------+------+------+
Ci-dessus, vous pouvez voir toutes les lignes de table_a même si certaines d'entre elles ne correspondent à rien de la table b, mais pas toutes les lignes de table_b - seulement celles qui correspondent à quelque chose dans table_a.
Si nous inversons l'ordre des tables, LEFT JOIN se comporte différemment:
> 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 |
+------+------+------+------+------+
Nous obtenons maintenant toutes les lignes de table_b, mais uniquement les lignes correspondantes de table_a.
RIGHT JOIN ne se soucie que de la deuxième table
a RIGHT JOIN bvous donne exactement les mêmes lignes que b LEFT JOIN a. La seule différence est l'ordre par défaut des colonnes.
> 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 |
+------+------+------+------+------+
Il s'agit des mêmes lignes que celles table_b LEFT JOIN table_aque nous avons vues dans la section LEFT JOIN.
De même:
> 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 |
+------+------+------+------+------+
Est les mêmes lignes que table_a LEFT JOIN table_b.
Aucune jointure du tout vous donne des copies de tout
Clause No Join: Si vous écrivez vos tables sans aucune clause JOIN, juste séparées par des virgules, vous obtenez chaque ligne de la première table écrite à côté de chaque ligne de la deuxième table, dans toutes les combinaisons possibles:
> 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 |
+------+------+------+------+------+
(Ceci est tiré de mon article de blog Exemples de types de jointures SQL )
