Tengo 2 tablas como esta:
> 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 preocupa por ambas tablas
INNER JOIN se preocupa por ambas tablas, por lo que solo obtendrá una fila si ambas tablas tienen una. Si hay más de un par coincidente, obtendrá varias filas.
> 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 no hace ninguna diferencia si invierte el orden, porque se preocupa por ambas tablas:
> 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 |
+------+------+------+------+------+
Obtiene las mismas filas, pero las columnas están en un orden diferente porque mencionamos las tablas en un orden diferente.
IZQUIERDA UNIRSE solo se preocupa por la primera mesa
LEFT JOIN se preocupa por la primera tabla que le da, y no le importa mucho la segunda, por lo que siempre obtiene las filas de la primera tabla, incluso si no hay una fila correspondiente en la segunda:
> 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 |
+------+------+------+------+------+
Arriba puede ver todas las filas de la tabla_a a pesar de que algunas de ellas no coinciden con nada en la tabla b, pero no todas las filas de la tabla_b, solo las que coinciden con algo en la tabla_a.
Si invertimos el orden de las tablas, LEFT JOIN se comporta de manera diferente:
> 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 |
+------+------+------+------+------+
Ahora obtenemos todas las filas de table_b, pero solo las filas coincidentes de table_a.
A DERECHA ÚNICA solo le importa la segunda mesa
a RIGHT JOIN bte da exactamente las mismas filas que b LEFT JOIN a. La única diferencia es el orden predeterminado de las columnas.
> 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 |
+------+------+------+------+------+
Estas son las mismas filas table_b LEFT JOIN table_aque las que vimos en la sección LEFT JOIN.
Similar:
> 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 |
+------+------+------+------+------+
Es las mismas filas que table_a LEFT JOIN table_b.
No unirse en absoluto te da copias de todo
Cláusula No Join: si escribe sus tablas sin ninguna cláusula JOIN, solo separadas por comas, obtendrá cada fila de la primera tabla escrita junto a cada fila de la segunda tabla, en todas las combinaciones posibles:
> 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 |
+------+------+------+------+------+
(Esto es de mi publicación de blog Ejemplos de tipos de unión SQL )
