Associações explícitas x implícitas

Existe alguma diferença de eficiência em uma junção interna explícita vs implícita? Por exemplo:

SELECT * FROM
table a INNER JOIN table b
ON a.id = b.id;

vs.

SELECT a.*, b.*
FROM table a, table b
WHERE a.id = b.id;

Em termos de desempenho, eles são exatamente os mesmos (pelo menos no SQL Server).

PS: Lembre-se de que a IMPLICIT OUTER JOINsintaxe está obsoleta desde o SQL Server 2005. (A IMPLICIT INNER JOINsintaxe usada na pergunta ainda é suportada)

Descontinuação do "estilo antigo" Sintaxe JOIN: apenas uma coisa parcial

Pessoalmente, prefiro a sintaxe de junção, pois torna mais claro que as tabelas são unidas e como elas são unidas. Tente comparar consultas SQL maiores em que você seleciona 8 tabelas diferentes e há muita filtragem no local. Usando a sintaxe de junção, você separa as partes em que as tabelas estão unidas e a parte em que você está filtrando as linhas.

No MySQL 5.1.51, ambas as consultas têm planos de execução idênticos:

mysql> explain select * from table1 a inner join table2 b on a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.02 sec)

mysql> explain select * from table1 a, table2 b where a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.00 sec)

table1tem 166208 linhas; table2tem cerca de 1000 linhas.

Este é um caso muito simples; de forma alguma prova que o otimizador de consultas não ficaria confuso e geraria planos diferentes em um caso mais complicado.

A segunda sintaxe tem a possibilidade indesejada de uma junção cruzada: você pode adicionar tabelas à parte FROM sem a cláusula WHERE correspondente. Isso é considerado prejudicial.

A primeira resposta que você deu usa o que é conhecido como sintaxe de junção ANSI, a outra é válida e funcionará em qualquer banco de dados relacional.

Concordo com o grom que você deve usar a sintaxe de junção ANSI. Como eles disseram, a principal razão é a clareza. Em vez de ter uma cláusula where com muitos predicados, alguns dos quais associam tabelas e outros restringem as linhas retornadas com a sintaxe de associação ANSI, você deixa claro que condições estão sendo usadas para ingressar em suas tabelas e quais estão sendo usadas para restringir o resultados.

Em termos de desempenho, eles são exatamente os mesmos (pelo menos no SQL Server), mas lembre-se de que estão obsoletos nessa sintaxe de junção e não são suportados pelo sql server2005 imediatamente.

Eu acho que você está pensando nos operadores obsoletos * = e = * vs. "junção externa".

Acabei de testar os dois formatos fornecidos e eles funcionam corretamente em um banco de dados do SQL Server 2008. No meu caso, eles produziram planos de execução idênticos, mas eu não podia dizer com segurança que isso sempre seria verdade.

@lomaxx: Apenas para esclarecer, tenho certeza de que as duas sintaxes acima são suportadas pelo SQL Serv 2005. A sintaxe abaixo NÃO é suportada no entanto

select a.*, b.*  
from table a, table b  
where a.id *= b.id;

Especificamente, a junção externa (* =) não é suportada.

Em alguns bancos de dados (principalmente Oracle), a ordem das junções pode fazer uma enorme diferença para consultar o desempenho (se houver mais de duas tabelas). Em um aplicativo, tivemos literalmente duas ordens de diferença de magnitude em alguns casos. O uso da sintaxe de junção interna fornece controle sobre isso - se você usar a sintaxe correta das dicas.

Você não especificou qual banco de dados está usando, mas a probabilidade sugere o SQL Server ou o MySQL onde não faz diferença real.

Como Leigh Caldwell afirmou, o otimizador de consulta pode produzir diferentes planos de consulta com base no que funcionalmente se parece com a mesma instrução SQL. Para ler mais sobre isso, dê uma olhada nas duas postagens a seguir:

Uma postagem da equipe do Oracle Optimizer

Outra postagem do blog "Structured Data"

Espero que você ache isso interessante.

Em termos de desempenho, não deve fazer diferença. A sintaxe de junção explícita me parece mais clara, pois define claramente os relacionamentos entre as tabelas na cláusula from e não desordena a cláusula where.

Basicamente, a diferença entre os dois é que um é escrito da maneira antiga, enquanto o outro é escrito da maneira moderna. Pessoalmente, prefiro o script moderno usando as definições interna, esquerda, externa e direita, porque elas são mais explicativas e tornam o código mais legível.

Ao lidar com junções internas, também não há diferença real na legibilidade; no entanto, pode ser complicado lidar com junções esquerda e direita, pois no método mais antigo, você obteria algo assim:

SELECT * 
FROM table a, table b
WHERE a.id = b.id (+);

A descrição acima é a maneira antiga de como uma junção esquerda é escrita, em oposição ao seguinte:

SELECT * 
FROM table a 
LEFT JOIN table b ON a.id = b.id;

Como você pode ver visualmente, a maneira moderna de como o script é escrito torna a consulta mais legível. (A propósito, o mesmo vale para as junções direitas e um pouco mais complicado para as junções externas).

Voltando à placa da caldeira, não faz diferença para o compilador SQL a maneira como a consulta é escrita, pois lida com eles da mesma maneira. Eu já vi uma mistura de ambos nos bancos de dados Oracle, que tiveram muitas pessoas escrevendo nele, tanto as mais antigas quanto as mais novas. Novamente, tudo se resume a quão legível é o script e a equipe com a qual você está desenvolvendo.

Na minha experiência, o uso da sintaxe de junção cruzada com um local onde geralmente produz um plano de execução danificado, especialmente se você estiver usando um produto Microsoft SQL. A maneira como o SQL Server tenta estimar a contagem de linhas da tabela, por exemplo, é terrivelmente horrível. O uso da sintaxe de junção interna fornece controle sobre como a consulta é executada. Portanto, do ponto de vista prático, dada a natureza atávica da atual tecnologia de banco de dados, você precisa seguir a junção interna.