【问题标题】:Bizarre performance issue: Common Table Expressions in inline User-Defined Function奇怪的性能问题:内联用户定义函数中的公用表表达式
【发布时间】:2011-01-06 09:57:12
【问题描述】:

这是 SQL 人员的脑筋急转弯 - 谁能想到为什么第一个函数执行良好,而第二个函数运行缓慢的原因?

函数 A - 通常在 ~5 毫秒内完成

CREATE FUNCTION dbo.GoodFunction
(
    @IDs UniqueIntTable READONLY
)
RETURNS TABLE
AS RETURN
    SELECT p.ID, p.Node, p.Name, p.Level
    FROM
    (
        SELECT DISTINCT a.Ancestor AS Node
        FROM Hierarchy h
        CROSS APPLY dbo.GetAncestors(h.Node.GetAncestor(1)) a
        WHERE h.ID IN (SELECT Value FROM @IDs)
    ) np
    INNER JOIN Hierarchy p
    ON p.Node = np.Node

功能 B - 运行速度极慢 - 5 分钟后我放弃了

CREATE FUNCTION dbo.BadFunction
(
    @IDs UniqueIntTable READONLY
)
RETURNS TABLE
AS RETURN
    WITH Ancestors_CTE AS
    (
        SELECT DISTINCT a.Ancestor AS Node
        FROM Hierarchy c
        CROSS APPLY dbo.GetAncestors(c.Node.GetAncestor(1)) a
        WHERE c.ID IN (SELECT Value FROM @IDs)
    )
    SELECT p.ID, p.Node, p.Name, p.Level
    FROM Ancestors_CTE ac
    INNER JOIN Hierarchy p
    ON p.Node = ac.Node

我将在下面解释这个函数的作用,但在我开始之前,我想指出我认为它并不重要,因为据我所知,这两个函数正是一样!唯一的区别是一个使用CTE,一个使用子查询; A 中的子查询内容与 B 中的 CTE 内容相同

如果有人决定这很重要:此函数的目的只是挑选出层次结构中任意数量位置的所有可能的祖先(父母、祖父母等)。 Node 列是 hierarchyiddbo.GetAncestors 是一个 CLR 函数,它只是沿着路径前进,它不进行任何数据访问。

UniqueIntTable 就是它的含义——它是一种用户定义的表类型,只有一列,Value int NOT NULL PRIMARY KEY。这里应该索引的所有内容都被索引 - 函数 A 的执行计划本质上只是两个索引搜索和一个哈希匹配,就像函数 B 一样。

这个奇怪问题的一些更奇怪的方面:

  • 我什至无法使用函数 B 获得一个简单查询的估计执行计划。看起来性能问题与这个简单的编译有关- 外观功能。

  • 1234563在 UDF 中,或者相反,仅在使用 CTE 的 UDF 中。
  • 当我尝试运行 B 时,测试机上一个内核的 CPU 使用率一路飙升至 100%。似乎没有太多 I/O。

我想将其视为 SQL Server 错误并使用版本 A,但我总是尽量牢记规则 #1 ("SELECT Ain't Broken"),并且我'我担心功能 A 的良好结果在某种程度上是本地化的侥幸,它会像 B 在不同的服务器上一样“失败”。

有什么想法吗?


更新 - 我现在包含一个完整的独立脚本来重现。

获取祖先函数

[SqlFunction(FillRowMethodName = "FillAncestor", 
    TableDefinition = "Ancestor hierarchyid", IsDeterministic = true,
    IsPrecise = true, DataAccess = DataAccessKind.None)]
public static IEnumerable GetAncestors(SqlHierarchyId h)
{
    while (!h.IsNull)
    {
        yield return h;
        h = h.GetAncestor(1);
    }
}

架构创建

BEGIN TRAN

CREATE TABLE Hierarchy
(
    ID int NOT NULL IDENTITY(1, 1)
        CONSTRAINT PK_Hierarchy PRIMARY KEY CLUSTERED,
    Node hierarchyid NOT NULL,
    [Level] as Node.GetLevel(),
    Name varchar(50) NOT NULL
)

CREATE INDEX IX_Hierarchy_Node
ON Hierarchy (Node)
INCLUDE (Name)

CREATE INDEX IX_Hierarchy_NodeBF
ON Hierarchy ([Level], Node)

GO

INSERT Hierarchy (Node, Name)
    SELECT CAST('/1/' AS hierarchyid), 'Alice' UNION ALL
    SELECT CAST('/1/1/' AS hierarchyid), 'Bob' UNION ALL
    SELECT CAST('/1/1/1/' AS hierarchyid), 'Charles' UNION ALL
    SELECT CAST('/1/1/2/' AS hierarchyid), 'Dave' UNION ALL
    SELECT CAST('/1/1/3/' AS hierarchyid), 'Ellen' UNION ALL
    SELECT CAST('/1/2/' AS hierarchyid), 'Fred' UNION ALL
    SELECT CAST('/1/3/' AS hierarchyid), 'Graham' UNION ALL
    SELECT CAST('/1/3/1/' AS hierarchyid), 'Harold' UNION ALL
    SELECT CAST('/1/3/2/' AS hierarchyid), 'Isabelle' UNION ALL
    SELECT CAST('/1/4/' AS hierarchyid), 'John' UNION ALL
    SELECT CAST('/2/' AS hierarchyid), 'Karen' UNION ALL
    SELECT CAST('/2/1/' AS hierarchyid), 'Liam' UNION ALL
    SELECT CAST('/2/2/' AS hierarchyid), 'Mary' UNION ALL
    SELECT CAST('/2/2/1/' AS hierarchyid), 'Nigel' UNION ALL
    SELECT CAST('/2/2/2/' AS hierarchyid), 'Oliver' UNION ALL
    SELECT CAST('/2/3/' AS hierarchyid), 'Peter' UNION ALL
    SELECT CAST('/2/3/1/' AS hierarchyid), 'Quinn'

GO

CREATE TYPE UniqueIntTable AS TABLE 
(
    Value int NOT NULL,
    PRIMARY KEY (Value)
)

GO

COMMIT

GO

以上代码/脚本可用于创建CLR函数/DB模式;在原始版本中使用相同的 GoodFunctionBadFunction 脚本。

【问题讨论】:

  • 我的错误。起初我没有注意到您使用的是 SQL 2008。评论撤回:)
  • 如果您还可以提供一个脚本来创建表格并填充一些数据,这样我们就可以进行一些测试,这将非常有帮助
  • BTW- 为什么您在第一个示例中使用 Node.GetAncestor 而在第二个示例中使用 ObjectNode.GetAncestor?或者这只是一个错字?
  • 当您说您“甚至无法获得函数 B 的估计执行计划”时,当您尝试在 SQL Server Management Studio 中获得一个时会发生什么?当你在等待它生成时,你能不能去另一个窗口执行一个 exec dbo.sp_who2,然后在这个页面上运行查询:sqlserverpedia.com/wiki/Misc_DMV_queries 报告等待查询的等待类型是什么,它'将显示阻碍执行计划的因素。
  • 好的,谁否决了这个问题?严重地!?一个问题可以更清晰和具体多少?

标签: sql-server performance sql-server-2008 user-defined-functions common-table-expression


【解决方案1】:

哈哈,试试这个:

IF OBJECT_ID('_HappyFunction' ) IS NOT NULL DROP FUNCTION _HappyFunction
IF OBJECT_ID('_SadFunction'   ) IS NOT NULL DROP FUNCTION _SadFunction
IF TYPE_ID  ('_UniqueIntTable') IS NOT NULL DROP TYPE _UniqueIntTable
GO

CREATE TYPE _UniqueIntTable AS TABLE (Value int NOT NULL PRIMARY KEY)
GO

CREATE FUNCTION _HappyFunction (@IDs _UniqueIntTable READONLY)
RETURNS TABLE AS RETURN
  SELECT Value FROM @IDs
GO

CREATE FUNCTION _SadFunction (@IDs _UniqueIntTable READONLY)
RETURNS TABLE AS RETURN 
  WITH CTE AS (SELECT Value FROM @IDs)
  SELECT Value FROM CTE
GO

-- this will return an empty record set
DECLARE @IDs _UniqueIntTable 
SELECT * FROM _HappyFunction(@IDs)
GO

-- this will hang
DECLARE @IDs _UniqueIntTable 
SELECT * FROM _SadFunction(@IDs)
GO

谁会猜到?

【讨论】:

  • 这太疯狂了!这里到底发生了什么?
  • 它现在正式在 MS Connect 上:connect.microsoft.com/SQLServer/feedback/…。我将此答案标记为已接受的答案,因为它消除了方程式中的几个变量(hierarchyidCROSS APPLY 和一般架构),它简化了重现步骤并使案例更容易提交。再次感谢!
【解决方案2】:

我已经重现了 SQL 2008 SP1 上的行为,用 SQL UDF 代替了 CLF UDF dbo.GetAncestors。我尝试了表值函数和内联函数;没有人有所作为。

我还不知道发生了什么,但为了他人的利益,我将在下面包含我的定义。

-- try a recursive inline UDF...
CREATE FUNCTION dbo.GetAncestors(@hierarchyid hierarchyid)
RETURNS TABLE AS RETURN (
WITH recurse AS (
    SELECT @hierarchyid AS Ancestor
    WHERE @hierarchyid IS NOT NULL
    UNION ALL
    SELECT Ancestor.GetAncestor(1) FROM recurse
    WHERE Ancestor.GetAncestor(1) IS NOT NULL
    )
SELECT * FROM recurse
)

-- ...or a table-valued UDF, it makes no difference
CREATE FUNCTION dbo.GetAncestors(@hierarchyid hierarchyid)
RETURNS @return TABLE (Ancestor hierarchyid) 
AS BEGIN
    WHILE @hierarchyid IS NOT NULL BEGIN
        INSERT @return (Ancestor)
        VALUES (@hierarchyid)
        SET @hierarchyid = @hierarchyid.GetAncestor(1)
    END             
    RETURN
END

选择上面的定义之一,然后运行它来观察它挂起:

DECLARE @IDs UniqueIntTable 
INSERT @IDs SELECT ID FROM Hierarchy
RAISERROR('we have inserted %i rows.',-1,-1,@@ROWCOUNT) WITH NOWAIT
SELECT * FROM dbo.GoodFunction(@IDs) a
RAISERROR('we have returned %i rows.',-1,-1,@@ROWCOUNT) WITH NOWAIT
GO

DECLARE @IDs UniqueIntTable 
INSERT @IDs SELECT ID FROM Hierarchy
RAISERROR('we have inserted %i rows.',-1,-1,@@ROWCOUNT) WITH NOWAIT
SELECT * FROM dbo.BadFunction(@IDs) a
RAISERROR('we have returned %i rows.',-1,-1,@@ROWCOUNT) WITH NOWAIT
GO

第二批甚至都没有开始。它通过了解析阶段,但似乎在绑定和优化之间迷失了方向。

两个函数的主体在函数包装器之外编译成完全相同的执行计划:

SET SHOWPLAN_TEXT ON
GO
DECLARE @IDs UniqueIntTable 
INSERT @IDs SELECT ID FROM Hierarchy
SELECT p.ID, p.Node, p.Name, p.[Level]
FROM
(
    SELECT DISTINCT a.Ancestor AS Node
    FROM Hierarchy c 
    CROSS APPLY dbo.GetAncestors_IF(c.Node.GetAncestor(1)) a
    WHERE c.ID IN (SELECT Value FROM @IDs)
) np
INNER JOIN Hierarchy p
ON p.Node = np.Node

;WITH Ancestors_CTE AS
(
    SELECT DISTINCT a.Ancestor AS Node
    FROM Hierarchy c
    CROSS APPLY dbo.GetAncestors_IF(c.Node.GetAncestor(1)) a
    WHERE c.ID IN (SELECT Value FROM @IDs)
)
SELECT p.ID, p.Node, p.Name, p.[Level]
FROM Ancestors_CTE ac
INNER JOIN Hierarchy p
ON p.Node = ac.Node


-- both return this:

    |--Nested Loops(Inner Join, OUTER REFERENCES:([p].[Node]))
         |--Compute Scalar(DEFINE:([p].[Level]=[Scratch].[dbo].[Hierarchy].[Level] as [p].[Level]))
         |    |--Compute Scalar(DEFINE:([p].[Level]=[Scratch].[dbo].[Hierarchy].[Node] as [p].[Node].GetLevel()))
         |         |--Index Scan(OBJECT:([Scratch].[dbo].[Hierarchy].[IX_Hierarchy_Node] AS [p]))
         |--Top(TOP EXPRESSION:((1)))
              |--Filter(WHERE:([Recr1005]=[Scratch].[dbo].[Hierarchy].[Node] as [p].[Node]))
                   |--Nested Loops(Inner Join, OUTER REFERENCES:([c].[Node]))
                        |--Nested Loops(Inner Join, OUTER REFERENCES:([Value]))
                        |    |--Clustered Index Scan(OBJECT:(@IDs))
                        |    |--Clustered Index Seek(OBJECT:([Scratch].[dbo].[Hierarchy].[PK_Hierarchy] AS [c]), SEEK:([c].[ID]=[Value]) ORDERED FORWARD)
                        |--Index Spool(WITH STACK)
                             |--Concatenation
                                  |--Compute Scalar(DEFINE:([Expr1011]=(0)))
                                  |    |--Constant Scan(VALUES:(([Scratch].[dbo].[Hierarchy].[Node] as [c].[Node].GetAncestor((1)))))
                                  |--Assert(WHERE:(CASE WHEN [Expr1013]>(100) THEN (0) ELSE NULL END))
                                       |--Nested Loops(Inner Join, OUTER REFERENCES:([Expr1013], [Recr1003]))
                                            |--Compute Scalar(DEFINE:([Expr1013]=[Expr1012]+(1)))
                                            |    |--Table Spool(WITH STACK)
                                            |--Compute Scalar(DEFINE:([Expr1004]=[Recr1003].GetAncestor((1))))
                                                 |--Filter(WHERE:(STARTUP EXPR([Recr1003].GetAncestor((1)) IS NOT NULL)))
                                                      |--Constant Scan

非常有趣。在 Microsoft Connect 提交错误报告,让他们告诉您发生了什么。

【讨论】:

  • 有趣的是,它在没有 CLR 功能的情况下是可重现的,如果涉及到这个问题,这将使提交错误报告变得容易得多。感谢您耐心地处理这个问题,并确认这不仅仅是优化器放弃的情况。
【解决方案3】:

这是一个猜测,只是一个猜测,但也许它与优化器如何对最佳执行计划做出很好的猜测有关,但并未对最佳执行计划进行详尽的搜索。

所以,查询执行是这样的:

解析->绑定->优化->执行

您的两个查询的解析树肯定会有所不同。绑定树可能不同。我对绑定阶段知之甚少,无法得出结论,但假设绑定树 不同,那么可能需要不同数量的转换才能使 A 和 B 绑定树相同执行计划。

如果需要两次额外的转换才能使查询 B 达到约 5 毫秒的计划,优化器可能会在发现它之前说“足够好”。而对于查询 A,约 5 毫秒的计划可能刚好在搜索成本阈值之内。

【讨论】:

  • 我认为这是除了 MS 之外的任何人都能给出的最佳答案。如果优化失败,它仍然可以执行,因为绑定阶段生成的解析树可执行的。但是 1) 性能很糟糕,因为它没有经过优化,2) 它对语法和顺序敏感,因为它是优化器来处理的,以及 3) is no i> true query plan,因为 QP 包括成本计算并且优化器也这样做。请注意,所有这三种症状在 OP 问题中都很明显。
  • 正如我现在在一些问题 cmets 中提到的,它不能简单地选择一个低效的计划,因为估计的计划永远不会回来,而且这个问题在非常小桌子,即使是三次笛卡尔积也需要不到一秒钟的时间。正如我所希望的那样,“惰性优化器”的解释似乎站不住脚。
  • 所选择的方案并非低效。 NO 计划被选择并且必须使用原始分析树。 (见我对你的问题的cmets,上面)
【解决方案4】:

在第一条语句中,你的加入是

np INNER JOIN Hierarchy p
    ON p.Node = np.Node

你的第二个陈述是

Ancestors_CTE a
INNER JOIN Hierarchy p
ON p.Node = a.Node

但是,a 也用作 CT 中 dbo.GetAncestor(c.Node.GetAncestor(1)) 的别名。尝试用例如交换Ancestors_CTE a Ancestor_CTE acte,以确保优化器不会与双重使用 a 作为别名混淆。

也就是说,我不确定 SQL 服务器在创建 CTE 时应用正确索引的能力如何。我以前遇到过这个问题,并且使用表变量取得了巨大的成功。

【讨论】:

  • 不幸的是,事实并非如此 - SQL Server 解决它没有问题,但是请注意,我已经更新了问题以明确这一点。
【解决方案5】:

据我了解,在批量使用 CTE 时,您必须以“;”结束语句。它与 WITH 子句的解释有关。试试这个:

IF OBJECT_ID('_HappyFunction' ) IS NOT NULL DROP FUNCTION _HappyFunction  
IF OBJECT_ID('_NowHappyFunction') IS NOT NULL DROP FUNCTION _NowHappyFunction  
IF TYPE_ID  ('_UniqueIntTable') IS NOT NULL DROP TYPE _UniqueIntTable  
GO  

CREATE TYPE _UniqueIntTable AS TABLE (Value int NOT NULL PRIMARY KEY)  
GO  

CREATE FUNCTION _HappyFunction (@IDs _UniqueIntTable READONLY)  
RETURNS TABLE AS RETURN  
  SELECT Value FROM @IDs  
GO  

CREATE FUNCTION _NowHappyFunction (@IDs _UniqueIntTable READONLY)  
RETURNS @Table TABLE
(
Value INT
)
BEGIN
  ;WITH CTE AS (SELECT Value FROM @IDs)
  INSERT INTO @Table
  SELECT Value FROM CTE
  RETURN
END
GO

-- this will return an empty record set  
DECLARE @IDs _UniqueIntTable   
SELECT * FROM _HappyFunction(@IDs)  
GO  

-- this will no longer hang and will also return an empty record set 
DECLARE @IDs _UniqueIntTable   
SELECT * FROM _NowHappyFunction(@IDs)  
GO 

【讨论】:

  • 这不会执行。这 ;在 WITH 语句前面会导致错误,阻止您创建函数。
  • 更正了语法并将内联函数更改为多行语句函数。立即编译。
猜你喜欢
  • 2011-01-02
  • 2018-07-11
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2013-10-07
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多