Eu tenho 2 tabelas 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 com ambas as tabelas
INNER JOIN se preocupa com as duas tabelas, portanto, você só terá uma linha se ambas as tabelas tiverem uma. Se houver mais de um par correspondente, você obtém várias linhas.
> 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 |
+------+------+------+------+------+
Não faz diferença para INNER JOIN se você reverter a ordem, porque se importa com as duas tabelas:
> 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 |
+------+------+------+------+------+
Você obtém as mesmas linhas, mas as colunas estão em uma ordem diferente porque mencionamos as tabelas em uma ordem diferente.
LEFT JOIN se preocupa apenas com a primeira mesa
LEFT JOIN se preocupa com a primeira tabela que você fornece e não se importa muito com a segunda; portanto, você sempre obtém as linhas da primeira tabela, mesmo se não houver uma linha correspondente na 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 |
+------+------+------+------+------+
Acima, você pode ver todas as linhas da tabela_a, mesmo que algumas não correspondam a nada na tabela b, mas nem todas as linhas da tabela_b - somente aquelas que correspondem a algo na tabela_a.
Se revertermos a ordem das tabelas, LEFT JOIN se comportará de maneira 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 |
+------+------+------+------+------+
Agora temos todas as linhas de table_b, mas apenas as linhas correspondentes de table_a.
RIGHT JOIN se preocupa apenas com a segunda mesa
a RIGHT JOIN bfornece exatamente as mesmas linhas que b LEFT JOIN a. A única diferença é a ordem padrão das colunas.
> 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 |
+------+------+------+------+------+
São as mesmas linhas table_b LEFT JOIN table_aque vimos na seção LEFT JOIN.
Similarmente:
> 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 |
+------+------+------+------+------+
São as mesmas linhas que table_a LEFT JOIN table_b.
Nenhuma junção oferece cópias de tudo
Cláusula No Join: Se você escrever suas tabelas sem nenhuma cláusula JOIN, apenas separadas por vírgulas, todas as linhas da primeira tabela serão escritas ao lado de todas as linhas da segunda tabela, em todas as combinações possíveis:
> 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 |
+------+------+------+------+------+
(Isto é da minha postagem no blog. Exemplos de tipos de junção SQL )
