Compare essas 2 consultas. É mais rápido colocar o filtro nos critérios de junção ou na WHEREcláusula. Sempre achei que é mais rápido nos critérios de junção porque reduz o conjunto de resultados o mais rápido possível, mas não sei ao certo.
Vou construir alguns testes para ver, mas também gostaria de obter opiniões sobre quais seriam mais claras de ler também.
Consulta 1
SELECT *
FROM TableA a
INNER JOIN TableXRef x
ON a.ID = x.TableAID
INNER JOIN TableB b
ON x.TableBID = b.ID
WHERE a.ID = 1 /* <-- Filter here? */Consulta 2
SELECT *
FROM TableA a
INNER JOIN TableXRef x
ON a.ID = x.TableAID
AND a.ID = 1 /* <-- Or filter here? */
INNER JOIN TableB b
ON x.TableBID = b.IDEDITAR
Fiz alguns testes e os resultados mostram que está muito próximo, mas a WHEREcláusula é um pouco mais rápida! =)
Eu concordo totalmente que faz mais sentido aplicar o filtro na WHEREcláusula, eu estava apenas curioso para saber as implicações de desempenho.
TEMPO REALIZADO ONDE CRITÉRIOS: 143016 ms
CRITÉRIOS DE REGISTRO DE TEMPO REALIZADO : 143256 ms
TESTE
SET NOCOUNT ON;
DECLARE @num INT,
@iter INT
SELECT @num = 1000, -- Number of records in TableA and TableB, the cross table is populated with a CROSS JOIN from A to B
@iter = 1000 -- Number of select iterations to perform
DECLARE @a TABLE (
id INT
)
DECLARE @b TABLE (
id INT
)
DECLARE @x TABLE (
aid INT,
bid INT
)
DECLARE @num_curr INT
SELECT @num_curr = 1
WHILE (@num_curr <= @num)
BEGIN
INSERT @a (id) SELECT @num_curr
INSERT @b (id) SELECT @num_curr
SELECT @num_curr = @num_curr + 1
END
INSERT @x (aid, bid)
SELECT a.id,
b.id
FROM @a a
CROSS JOIN @b b
/*
TEST
*/
DECLARE @begin_where DATETIME,
@end_where DATETIME,
@count_where INT,
@begin_join DATETIME,
@end_join DATETIME,
@count_join INT,
@curr INT,
@aid INT
DECLARE @temp TABLE (
curr INT,
aid INT,
bid INT
)
DELETE FROM @temp
SELECT @curr = 0,
@aid = 50
SELECT @begin_where = CURRENT_TIMESTAMP
WHILE (@curr < @iter)
BEGIN
INSERT @temp (curr, aid, bid)
SELECT @curr,
aid,
bid
FROM @a a
INNER JOIN @x x
ON a.id = x.aid
INNER JOIN @b b
ON x.bid = b.id
WHERE a.id = @aid
SELECT @curr = @curr + 1
END
SELECT @end_where = CURRENT_TIMESTAMP
SELECT @count_where = COUNT(1) FROM @temp
DELETE FROM @temp
SELECT @curr = 0
SELECT @begin_join = CURRENT_TIMESTAMP
WHILE (@curr < @iter)
BEGIN
INSERT @temp (curr, aid, bid)
SELECT @curr,
aid,
bid
FROM @a a
INNER JOIN @x x
ON a.id = x.aid
AND a.id = @aid
INNER JOIN @b b
ON x.bid = b.id
SELECT @curr = @curr + 1
END
SELECT @end_join = CURRENT_TIMESTAMP
SELECT @count_join = COUNT(1) FROM @temp
DELETE FROM @temp
SELECT @count_where AS count_where,
@count_join AS count_join,
DATEDIFF(millisecond, @begin_where, @end_where) AS elapsed_where,
DATEDIFF(millisecond, @begin_join, @end_join) AS elapsed_join
9
Dependendo dos dados, os critérios WHERE vs JOIN podem retornar conjuntos de resultados diferentes.
—
Pôneis OMG
@OMG Pôneis muito verdadeiros, mas muitas vezes também não.
—
Jon Erickson
Eu não chamaria a diferença abaixo de 5% como uma diferença - eles são iguais. Se você deseja significância para uma diferença de 2 %%, é melhor executar os testes 1000 vezes para garantir que não seja apenas aleatório.
—
TomTom de
A vantagem é filtrar os dados antes de ingressar, então se fosse x.ID, você teria mais chances de ver melhorias do que com um a.ID
—
MikeT
possível duplicação dos critérios do Filtro SQL nos critérios de junção ou cláusula where que é mais eficiente
—
azulado