连接顺序如何影响查询性能

Question

我在查询中遇到了时间性能的巨大差异，并且查询中连接（内部和左外部）发生的顺序似乎造成了所有的差异。 是否有一些“基本规则”，应按什么顺序加入？

它们都是更大查询的一部分。 它们之间的区别在于左连接在更快的查询中放在最后。

慢速查询：（>10分钟）

SELECT [t0].[Ref], [t1].[Key], [t1].[Name],  
    (CASE 
        WHEN [t3].[test] IS NULL THEN CONVERT(NVarChar(250),@p0)
        ELSE CONVERT(NVarChar(250),[t3].[Key])
     END) AS [value], 
    (CASE 
        WHEN 0 = 1 THEN CONVERT(NVarChar(250),@p1)
        ELSE CONVERT(NVarChar(250),[t4].[Key])
     END) AS [value2]

FROM [dbo].[tblA] AS [t0]
INNER JOIN [dbo].[tblB] AS [t1] ON [t0].[RefB] = [t1].[Ref]

LEFT OUTER JOIN (
    SELECT 1 AS [test], [t2].[Ref], [t2].[Key]
    FROM [dbo].[tblC] AS [t2]
    ) AS [t3] ON [t0].[RefC] = ([t3].[Ref])

INNER JOIN [dbo].[tblD] AS [t4] ON [t0].[RefD] = ([t4].[Ref])

较快查询：（~30秒）

SELECT [t0].[Ref], [t1].[Key], [t1].[Name],  
    (CASE 
        WHEN [t3].[test] IS NULL THEN CONVERT(NVarChar(250),@p0)
        ELSE CONVERT(NVarChar(250),[t3].[Key])
     END) AS [value], 
    (CASE 
        WHEN 0 = 1 THEN CONVERT(NVarChar(250),@p1)
        ELSE CONVERT(NVarChar(250),[t4].[Key])
     END) AS [value2]

FROM [dbo].[tblA] AS [t0]
INNER JOIN [dbo].[tblB] AS [t1] ON [t0].[RefB] = [t1].[Ref]

INNER JOIN [dbo].[tblD] AS [t4] ON [t0].[RefD] = ([t4].[Ref])

LEFT OUTER JOIN (
    SELECT 1 AS [test], [t2].[Ref], [t2].[Key]
    FROM [dbo].[tblC] AS [t2]
    ) AS [t3] ON [t0].[RefC] = ([t3].[Ref])

Answer 1

一般来说，INNER JOIN 顺序并不重要，因为内连接是可交换的和关联的。在这两种情况下，您仍然有 t0 内部联接 t4，因此应该没有区别。

换句话来说，SQL 是声明性的：你说“你想要什么”，而不是“如何”。优化器会“如何”工作，并根据需要重新排序 JOIN，在实践中也会查找 WHERE 等。

在复杂的查询中，基于成本的查询优化器不会耗尽所有排列，因此它有时可能很重要。

因此，我会检查这些：

• 您说这些是更大查询的一部分，因此这一部分不太重要，因为整个查询很重要。
• 如果任何表实际上是视图，也可以使用视图隐藏复杂性
• ，无论代码以什么顺序运行，这是否可重复？
• 查询计划有何差异？

请参阅其他一些问题：

• 如何最好组织 Inner Joins in (select) 语句
• SQL Server 2005 - 内部联接的顺序

Answer 2

如果你有超过 2 个表，那么排序表连接就很重要。它可以产生很大的差异。第一个表应该得到一个主要提示。第一个表是具有最多选择性行的对象。例如：如果您有一个包含 1.000.000 人的成员表，并且您只想选择女性，并且它是第一个表，那么您只需将 500.000 条记录连接到下一个表。如果该表位于连接顺序的末尾（可能是表 4,5 或 6），则将连接每条记录（最坏情况为 1.000.000）。这包括内部连接和外部连接。

规则：从最具选择性的表开始，然后加入下一个逻辑上最具选择性的表。

功能转换和美化应该放在最后。有时最好
将完整的 SQL 捆绑在括号中，并在外部选择语句中使用表达式和函数。

Answer 3

在左连接的情况下，它会对性能产生很大影响。我在选择查询中遇到了这样的问题：

select distinct count(p0_.id) over ()        as col_0_0_,
       p0_.id                       as col_1_0_,
       p0_.lp           as col_2_0_,
       0
                                          as col_3_0_,
       max(coalesce(i6_.cft, i7_.rfo,
                    ''))                  as col_4_0_,
       p0_.pdv              as col_5_0_,
       (s8_.qer)
                                          as col_6_0_,
       cf1_.ests as col_7_0_
from Produit p0_
         left outer join CF cf1_ on p0_.fk_cf = cf1_.id
         left outer join CA c2_ on cf1_.fk_ca = c2_.id
         left outer join ml mt on c2_.fk_m = mt.id
         left outer join sk s8_ on p0_.id = s8_.fk_p
         left outer join rf r5_ on
        rp4_.fk_r = r5_.id
         left outer join
     in i6_ on r5_.fk_ireftc = i6_.id
         left outer join r_p_r rp4_ on p0_.id = rp4_.fk_p
         left outer join
     ir i7_ on r5_.fk_if = i7_.id
      left outer join re_p_g gc9_ on p0_.id = gc9_.fk_p
         left outer join gc g10_ on gc9_.fk_g = g10_.id
where
  and (p0_.lC is null or p0_.lS = 'E')
  and g10_.id is null or g10_.id
  and r5_.fk_i is null
group by col_1_0_, col_2_0_, col_3_0_, col_5_0_, col_6_0_, col_7_0_
order by col_2_0_ asc, p0_.id
limit 10;

查询需要 13 到 15 秒才能执行，当我更改顺序时，它需要 1 到 2 秒。

select distinct count(p0_.id) over ()        as col_0_0_,
       p0_.id                       as col_1_0_,
       p0_.lp           as col_2_0_,
       0
                                          as col_3_0_,
       max(coalesce(i6_.cft, i7_.rfo,
                    ''))                  as col_4_0_,
       p0_.pdv              as col_5_0_,
       (s8_.qer)
                                          as col_6_0_,
       cf1_.ests as col_7_0_
from Produit p0_
         left outer join CF cf1_ on p0_.fk_cf = cf1_.id
         left outer join sk s8_ on p0_.id = s8_.fk_p
         left outer join r_p_r rp4_ on p0_.id = rp4_.fk_p
         left outer join re_p_g gc9_ on p0_.id = gc9_.fk_p
         left outer join CA c2_ on cf1_.fk_ca = c2_.id
         left outer join ml mt on c2_.fk_m = mt.id
         left outer join rf r5_ on
        rp4_.fk_r = r5_.id
         left outer join
     in i6_ on r5_.fk_ireftc = i6_.id
         left outer join
     ir i7_ on r5_.fk_if = i7_.id
         left outer join gc g10_ on gc9_.fk_g = g10_.id
where
  and (p0_.lC is null or p0_.lS = 'E')
  and(g10_.id is null
  and r5_.fk_i is null
group by col_1_0_, col_2_0_, col_3_0_, col_5_0_, col_6_0_, col_7_0_
order by col_2_0_ asc, p0_.id
limit 10;

就我而言，我更改顺序，以防当我加载表时，我使用在后面的联接中使用该表的所有联接，而不是将其加载到另一个块中。就像在我的 p0_ 表中一样，我在前 4 行中进行了所有左连接，这与第一个代码中不同。

PS：为了测试我在 postgre 中的性能，我使用这个网站： http://tatiyants.com/pev /#/计划/新

Answer 4

至少在 SQLite 中，我发现它有很大的不同。实际上，不需要非常复杂的查询就能显示出差异。然而，我的 JOIN 语句位于嵌入子句内。

基本上，正如克里斯蒂安所指出的，您应该首先从最具体的限制开始。