MySQL: Classificação rápida dos tipos de junções

Eu gostaria de uma rápida descrição dos tipos de junções do MySQL. Eu sei disso, o resto não tenho certeza do que eles significam.

• separado por vírgula (o que exatamente significa isso?):SELECT * FROM a, b WHERE b.id = a.beeId AND ...
• mostre as informações de a, mesmo que não haja correspondências em b: SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...

Eu já vi outras junções, mas quero saber o que as torna diferentes, o que é INNER/ OUTER, adicionando LEFTcoisas de mudança.

Eu já sei como as junções funcionam, só quero saber se existem outros tipos de junções ou se são apenas maneiras diferentes de obter o mesmo resultado.

(c) Encontrado no G + "Visualização de dados"

ou consulte os seguintes links para uma boa visão geral:

http://www.khankennels.com/blog/index.php/archives/2007/04/20/getting-joins/

http://www.codinghorror.com/blog/2007/10/a-visual-explanation-of-sql-joins.html

Com base no seu comentário, as definições simples de cada uma são encontradas melhor no W3Schools. A primeira linha de cada tipo fornece uma breve explicação do tipo de associação.

• JOIN: retorna linhas quando houver pelo menos uma correspondência nas duas tabelas
• LEFT JOIN: Retorna todas as linhas da tabela esquerda, mesmo se não houver correspondências na tabela direita
• RIGHT JOIN: Retorna todas as linhas da tabela direita, mesmo se não houver correspondências na tabela esquerda
• JUNÇÃO COMPLETA: Retornar linhas quando houver uma correspondência em uma das tabelas

EDIT FIM

Em poucas palavras, o exemplo separado por vírgula que você deu

SELECT * FROM a, b WHERE b.id = a.beeId AND ...

está selecionando todos os registros das tabelas aeb com as vírgulas separando as tabelas, isso também pode ser usado em colunas como

SELECT a.beeName,b.* FROM a, b WHERE b.id = a.beeId AND ...

Em seguida, ele obtém as informações instruídas na linha em que a coluna b.id e a.beeId têm correspondência no seu exemplo. Portanto, no seu exemplo, ele obterá todas as informações das tabelas aeb, onde b.id é igual a a.beeId. No meu exemplo, ele obterá todas as informações da tabela be apenas as informações da coluna a.beeName quando o b.id for igual ao a.beeId. Observe que também há uma cláusula AND, isso ajudará a refinar seus resultados.

Para alguns tutoriais simples e explicações sobre as junções esquerda e esquerda do mySQL, veja os tutoriais mySQL da Tizag. Você também pode conferir o site de Keith J. Brown para obter mais informações sobre junções, o que também é bastante bom.

Espero que isso ajude você

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 )

A junção externa completa não existe no mysql; talvez você precise usar uma combinação de junção esquerda e direita.