WileCau's questions

我需要调用另一个数据库中的存储过程并检查返回值。其他数据库的名称可能会有所不同，因此我尝试使用 sp_executesql，但我无法找到如何从过程中获取返回值。

这是我所拥有的简化版本：

DECLARE @errorLogId INT
DECLARE @otherDbName NVARCHAR(MAX) = 'Foo' -- Get the database name from somewhere
DECLARE @sql NVARCHAR(MAX)

SET @sql = @otherDbName + '.dbo.SomeProc'

-- I want @errorLogId to be the return value from SomeProc, this didn't work.    
EXECUTE @errorLogId = sp_executesql @sql

IF @errorLogId <> 0
   RAISERROR('SomeProc failed, ErrorLogId = %d.', 16, 1, @errorLogId) WITH SETERROR

如果在 SomeProc 中发生错误，它会被捕获并将条目写入错误表（在另一个数据库中），然后 SomeProc 返回已写入记录的错误表 ID（身份）。否则 SomeProc 返回 0。

我知道 SomeProc 失败了，因为错误被写入另一个数据库中的错误日志，但在本地数据库中 @errorLogId 为 0 被视为成功。我认为返回值会“通过”sp_executesql，但我认为返回值实际上来自 sp_executesql 而不是 SomeProc（即无论 SomeProc 成功还是失败，sp_executesql 都可以成功）。

有没有办法从本地数据库中的 @otherDbName.dbo.SomeProc 访问返回值？

谢谢

不使用模式绑定似乎关闭了编译器警告——直到运行时你才发现你破坏了什么。

好处是模式绑定对象可以保护数据库免受意外或故意更改的影响，这些更改可能会在以后破坏依赖关系。

保护的代价是维护更加复杂，因为模式绑定对象有时需要以特定顺序更改多个对象以实现简单的局部更改。此成本是相对的，因为如果没有模式绑定，更改可能会悄无声息地破坏一些以后需要更多维护的东西。

我认为收益大于成本，特别是对于变化不大（变化少维护少）或您不知道依赖关系（不熟悉所以风险大）的已建立数据库。

是否存在不应使用模式绑定的情况？

在列上设置过滤索引是否会改进与过滤条件相反的 WHERE 子句的查询？

由于过滤索引指定了不返回的内容，它是否减少了要搜索的记录数？

例子：

CREATE TABLE MyTable
(
  ColumnA INT PRIMARY KEY CLUSTERED,
  ColumnB INT NULL
)

CREATE NONCLUSTERED INDEX IX_MyTable_Filtered_ColumnB
  ON MyTable (ColumnB)
  WHERE ColumnB IS NOT NULL

索引应该改进这个查询：

SELECT ColumnA
FROM MyTable
WHERE ColumnB IS NOT NULL

这对这个有什么影响吗？

SELECT ColumnA
FROM MyTable
WHERE ColumnB IS NULL

在上一个问题中，如何在不包含冗余行的情况下合并数据集？我询问了在导入期间过滤冗余历史数据的问题，但@DavidSpillett 正确地回答说我无法做我想做的事情。

我现在不想在导入期间过滤表，而是在表上创建一个视图，该视图仅返回价格发生变化的记录。

这是为了适应这个问题而改写的原始场景：

我们有一个物品的历史价格表。该表包含多个日期记录相同价格的行。我想在这个数据上创建一个视图，它只显示价格随时间的变化，所以如果价格从 A 变化到 BI 想要看到它，但如果它从 B 到 B “变化”，那么我不想看到它.

例子：如果昨天的价格是1美元，今天的价格是1美元，并且没有其他价格变化，那么今天的价格可以从昨天的价格推断出来，所以我只需要昨天的记录。

示例（http://sqlfiddle.com/#!3/c95ff/1）：

Table data:

Effective            Product  Kind  Price
2013-04-23T00:23:00  1234     1     1.00
2013-04-24T00:24:00  1234     1     1.00 -- redundant, implied by record 1
2013-04-25T00:25:00  1234     1     1.50
2013-04-26T00:26:00  1234     1     2.00
2013-04-27T00:27:00  1234     1     2.00 -- redundant, implied by record 4
2013-04-28T00:28:00  1234     1     1.00 -- not redundant, price changed back to 1.00

Expected view data:

Effective            Product  Kind  Price
2013-04-23T00:23:00  1234     1     1.00
2013-04-25T00:25:00  1234     1     1.50
2013-04-26T00:26:00  1234     1     2.00
2013-04-28T00:28:00  1234     1     1.00

我最初的尝试使用了 ROW_NUMBER：

SELECT
    Effective,
    Product,
    Kind,
    Price
FROM
(
    SELECT
        History.*,
        ROW_NUMBER() OVER
        (
            PARTITION BY
                Product,
                Kind,
                Price
            ORDER BY
                Effective ASC
        ) AS RowNumber
    FROM History
) H
WHERE RowNumber = 1
ORDER BY Effective

哪个返回：

Effective               Product  Kind  Price
2013-04-23T00:23:00     1234     1     1.00
                                             -- not 2013-04-24, good
2013-04-25T00:25:00     1234     1     1.50
2013-04-26T00:26:00     1234     1     2.00
                                             -- not 2013-04-27, good
                                             -- not 2013-04-28, bad

我尝试搜索类似的问题/答案，但很难弄清楚如何表达搜索，一个例子值得很多话。

任何建议表示赞赏。谢谢

我认为这一定是一件相当普遍的事情，但我找不到一个例子。它涉及合并涉及日期/时间（或更一般地说是任何顺序值）的数据，而不包括冗余记录。冗余是指可以被其他记录暗示的记录。

例如，如果昨天的价格是 1 美元，今天的价格是 1 美元，并且昨天和今天之间没有其他价格变化，那么可以从昨天的价格推断出今天的价格，而不需要存储两天的价格。

这是我要解决的方案。我们有一个物品的历史价格表。新价格会定期导入表中。导入文件可以包含任何时间的日期，我们不知道它们总是在历史表中的数据“之后”。

为避免数据膨胀，我只想在记录提供新信息时插入记录。因此，如果可以从旧记录中推断出新记录，那么我不想插入新记录，如果可以从新记录中推断出旧记录，那么我想删除旧记录并插入新记录。

一些具体的例子可能会有所帮助，这里有两个问题场景：

1. 传入记录可以从现有记录中推断出来，因此传入记录是冗余的。例如

   旧记录：2013-04-23 1.00

   新记录：2013-04-24 1.00 <--这是现有记录暗示的，不要插入

2. 现有记录可以从新记录中推断出来，因此现有记录是多余的。例如

   新纪录：2013-04-23 1.00

   旧记录：2013-04-24 1.00 <--这是新记录暗示的，删除它

3. 这只是显示一个值何时不是冗余的示例。例如

   旧记录：2013-04-23 1.00

   旧记录：2013-04-24 1.20

   新记录：2013-04-25 1.00 <-- 不是多余的，价格自上次 1.00 起发生了变化

这里有一个更详细的例子http://sqlfiddle.com/#!3/2ef87/2

目前，我倾向于采用以下多步骤方法：

1. 如果存在与较早日期具有相同价格的现有记录，则从收货中删除（上面的场景 1）。
2. 从现有中删除具有相同价格且较早日期的传入记录（上面的场景 2）。
3. 插入剩余的传入记录。

必须有更好的方法，也许使用 MERGE，但它正在努力解决如何做到这一点。

如何有效地“合并”现有记录和传入记录？谢谢

我们有几个独立的数据库，它们具有共同的数据和代码，不是在数据库之间访问数据的意义上，而是在每个数据库中数据的含义相同的意义上，代码做同样的事情。

例子是：

• 配置设置（例如错误代码 50xxx、公司名称的样板文本等）。
• 执行常见任务的过程和函数（例如，将 CSV 字符串转换为表格、记录错误、根据错误代码格式化错误消息）。
• 表结构（例如用于数据库版本历史的表、用于记录错误的表）。除了列、约束和触发器之外，还有一些常见的过程和函数可以读取/写入数据。
• 查找表（例如，包含 2000-2100 之间日期的日期查找表）。这些类似于表结构，但数据库中的数据通常是相同的。在日期表的情况下，开始日期和结束日期是配置设置，由函数读取，然后由过程生成日期数据。所有这些操作在数据库之间都是通用的。
• 用户定义的类型（例如用于将表传递给函数的类型）。

出于维护和支持的原因，我认为错误代码、过程、函数和类型之类的东西在所有数据库中都有一个“单一事实点”而不是每个数据库中的不同事实是有意义的。

目前，每个数据库都有自己的所有内容副本，包括源存储库，我们独立维护它们。这远非理想，因为在 A 中修复程序而忘记将其放入 B 中太容易了，或者在 A 中添加错误代码，在 B 中添加相同的错误代码，但它们的含义不同，等等。

数据库不会同时更新，它们不一定驻留在相同的硬件上。在某些情况下，它们可以相互读取数据（如果存在另一个）。

是否有一种标准方法可以为跨多个数据库使用的数据/代码提供单点真实性？

给定一个（简化的）存储过程，例如：

CREATE PROCEDURE WeeklyProc(@endDate DATE)
AS
BEGIN
  DECLARE @startDate DATE = DATEADD(DAY, -6, @endDate)
  SELECT
    -- Stuff
  FROM Sale
  WHERE SaleDate BETWEEN @startDate AND @endDate
END

如果Sale表很大，SELECT可能需要很长时间才能执行，显然是因为优化器由于局部变量而无法优化。我们测试了SELECT使用变量运行该部件，然后是硬编码日期，执行时间从约 9 分钟到约 1 秒。

我们有许多基于“固定”日期范围（周、月、8 周等）查询的存储过程，因此输入参数只是 @endDate 和 @startDate 在过程中计算。

问题是，在 WHERE 子句中避免使用变量以免损害优化器的最佳实践是什么？

我们提出的可能性如下所示。这些最佳实践中的任何一个，还是有其他方法？

使用包装程序将变量转换为参数。

参数不会像局部变量那样影响优化器。

CREATE PROCEDURE WeeklyProc(@endDate DATE)
AS
BEGIN
   DECLARE @startDate DATE = DATEADD(DAY, -6, @endDate)
   EXECUTE DateRangeProc @startDate, @endDate
END

CREATE PROCEDURE DateRangeProc(@startDate DATE, @endDate DATE)
AS
BEGIN
  SELECT
    -- Stuff
  FROM Sale
  WHERE SaleDate BETWEEN @startDate AND @endDate
END

使用参数化动态 SQL。

CREATE PROCEDURE WeeklyProc(@endDate DATE)
AS
BEGIN
  DECLARE @startDate DATE = DATEADD(DAY, -6, @endDate)
  DECLARE @sql NVARCHAR(4000) = N'
    SELECT
      -- Stuff
    FROM Sale
    WHERE SaleDate BETWEEN @startDate AND @endDate
  '
  DECLARE @param NVARCHAR(4000) = N'@startDate DATE, @endDate DATE'
  EXECUTE sp_executesql @sql, @param, @startDate = @startDate, @endDate = @endDate
END

使用“硬编码”动态 SQL。

CREATE PROCEDURE WeeklyProc(@endDate DATE)
AS
BEGIN
  DECLARE @startDate DATE = DATEADD(DAY, -6, @endDate)
  DECLARE @sql NVARCHAR(4000) = N'
    SELECT
      -- Stuff
    FROM Sale
    WHERE SaleDate BETWEEN @startDate AND @endDate
  '
  SET @sql = REPLACE(@sql, '@startDate', CONVERT(NCHAR(10), @startDate, 126))
  SET @sql = REPLACE(@sql, '@endDate', CONVERT(NCHAR(10), @endDate, 126))
  EXECUTE sp_executesql @sql
END

直接使用该DATEADD()功能。

我对此并不热衷，因为在 WHERE 中调用函数也会影响性能。

CREATE PROCEDURE WeeklyProc(@endDate DATE)
AS
BEGIN
  SELECT
    -- Stuff
  FROM Sale
  WHERE SaleDate BETWEEN DATEADD(DAY, -6, @endDate) AND @endDate
END

使用可选参数。

我不确定分配给参数是否与分配给变量有相同的问题，所以这可能不是一个选项。我真的不喜欢这个解决方案，但为了完整性而将其包括在内。

CREATE PROCEDURE WeeklyProc(@endDate DATE, @startDate DATE = NULL)
AS
BEGIN
  SET @startDate = DATEADD(DAY, -6, @endDate)
  SELECT
    -- Stuff
  FROM Sale
  WHERE SaleDate BETWEEN @startDate AND @endDate
END

- 更新 -

感谢您的建议和意见。阅读它们后，我使用各种方法进行了一些计时测试。我在这里添加结果作为参考。

运行 1 没有计划。运行 2 紧接在运行 1 之后，具有完全相同的参数，因此它将使用运行 1 中的计划。

NoProc 时间用于在存储过程之外的 SSMS 中手动运行 SELECT 查询。

TestProc1-7 是来自原始问题的查询。

TestProcA-B 基于Mikael Eriksson的建议。数据库中的列是 DATE，因此我尝试将参数作为 DATETIME 传递并使用隐式转换 (testProcA) 和显式转换 (testProcB) 运行。

TestProcC-D 基于Kenneth Fisher的建议。我们已经为其他事情使用了日期查找表，但我们没有一个针对每个期间范围的特定列。我尝试的变体仍然使用 BETWEEN，但在较小的查找表上使用它并连接到较大的表。我将进一步调查我们是否可以使用特定的查找表，尽管我们的周期是固定的，但有很多不同的。

    Sale 表中的总行数：136,424,366

                       运行 1（毫秒） 运行 2（毫秒）
    程序 CPU Elapsed CPU Elapsed 注释
    NoProc 常量 6567 62199 2870 719 手动查询常量
    NoProc 变量 9314 62424 3993 998 带变量的手动查询
    testProc1 6801 62919 2871 736 硬编码范围
    testProc2 8955 63190 3915 979 参数及变量范围
    testProc3 8985 63152 3932 987 带参数范围的包装程序
    testProc4 9142 63939 3931 977 参数化动态SQL
    testProc5 7269 62933 2933 728 硬编码动态SQL
    testProc6 9266 63421 3915 984 在 DATE 上使用 DATEADD
    testProc7 2044 13950 1092 1087 虚拟参数
    testProcA 12120 61493 5491 1875 在没有 CAST 的 DATETIME 上使用 DATEADD
    testProcB 8612 61949 3932 978 在 DATETIME 上使用 DATEADD 和 CAST
    testProcC 8861 61651 3917 993 使用查找表，先销售
    testProcD 8625 61740 3994 1031 使用查找表，最后销售

这是测试代码。

------ SETUP ------

IF OBJECT_ID(N'testDimDate', N'U') IS NOT NULL DROP TABLE testDimDate
IF OBJECT_ID(N'testProc1', N'P') IS NOT NULL DROP PROCEDURE testProc1
IF OBJECT_ID(N'testProc2', N'P') IS NOT NULL DROP PROCEDURE testProc2
IF OBJECT_ID(N'testProc3', N'P') IS NOT NULL DROP PROCEDURE testProc3
IF OBJECT_ID(N'testProc3a', N'P') IS NOT NULL DROP PROCEDURE testProc3a
IF OBJECT_ID(N'testProc4', N'P') IS NOT NULL DROP PROCEDURE testProc4
IF OBJECT_ID(N'testProc5', N'P') IS NOT NULL DROP PROCEDURE testProc5
IF OBJECT_ID(N'testProc6', N'P') IS NOT NULL DROP PROCEDURE testProc6
IF OBJECT_ID(N'testProc7', N'P') IS NOT NULL DROP PROCEDURE testProc7
IF OBJECT_ID(N'testProcA', N'P') IS NOT NULL DROP PROCEDURE testProcA
IF OBJECT_ID(N'testProcB', N'P') IS NOT NULL DROP PROCEDURE testProcB
IF OBJECT_ID(N'testProcC', N'P') IS NOT NULL DROP PROCEDURE testProcC
IF OBJECT_ID(N'testProcD', N'P') IS NOT NULL DROP PROCEDURE testProcD
GO

CREATE TABLE testDimDate
(
   DateKey DATE NOT NULL,
   CONSTRAINT PK_DimDate_DateKey UNIQUE NONCLUSTERED (DateKey ASC)
)
GO

DECLARE @dateTimeStart DATETIME = '2000-01-01'
DECLARE @dateTimeEnd DATETIME = '2100-01-01'
;WITH CTE AS
(
   --Anchor member defined
   SELECT @dateTimeStart FullDate
   UNION ALL
   --Recursive member defined referencing CTE
   SELECT FullDate + 1 FROM CTE WHERE FullDate + 1 <= @dateTimeEnd
)
SELECT
   CAST(FullDate AS DATE) AS DateKey
INTO #DimDate
FROM CTE
OPTION (MAXRECURSION 0)

INSERT INTO testDimDate (DateKey)
SELECT DateKey FROM #DimDate ORDER BY DateKey ASC

DROP TABLE #DimDate
GO

-- Hard coded date range.
CREATE PROCEDURE testProc1 AS
BEGIN
   SET NOCOUNT ON
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN '2012-12-09' AND '2012-12-10'
END
GO

-- Parameter and variable date range.
CREATE PROCEDURE testProc2(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate
END
GO

-- Parameter date range.
CREATE PROCEDURE testProc3a(@startDate DATE, @endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate
END
GO

-- Wrapper procedure.
CREATE PROCEDURE testProc3(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   EXEC testProc3a @startDate, @endDate
END
GO

-- Parameterized dynamic SQL.
CREATE PROCEDURE testProc4(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   DECLARE @sql NVARCHAR(4000) = N'SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate'
   DECLARE @param NVARCHAR(4000) = N'@startDate DATE, @endDate DATE'
   EXEC sp_executesql @sql, @param, @startDate = @startDate, @endDate = @endDate
END
GO

-- Hard coded dynamic SQL.
CREATE PROCEDURE testProc5(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   DECLARE @sql NVARCHAR(4000) = N'SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN ''@startDate'' AND ''@endDate'''
   SET @sql = REPLACE(@sql, '@startDate', CONVERT(NCHAR(10), @startDate, 126))
   SET @sql = REPLACE(@sql, '@endDate', CONVERT(NCHAR(10), @endDate, 126))
   EXEC sp_executesql @sql
END
GO

-- Explicitly use DATEADD on a DATE.
CREATE PROCEDURE testProc6(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN DATEADD(DAY, -1, @endDate) AND @endDate
END
GO

-- Dummy parameter.
CREATE PROCEDURE testProc7(@endDate DATE, @startDate DATE = NULL) AS
BEGIN
   SET NOCOUNT ON
   SET @startDate = DATEADD(DAY, -1, @endDate)
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate
END
GO

-- Explicitly use DATEADD on a DATETIME with implicit CAST for comparison with SaleDate.
-- Based on the answer from Mikael Eriksson.
CREATE PROCEDURE testProcA(@endDateTime DATETIME) AS
BEGIN
   SET NOCOUNT ON
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN DATEADD(DAY, -1, @endDateTime) AND @endDateTime
END
GO

-- Explicitly use DATEADD on a DATETIME but CAST to DATE for comparison with SaleDate.
-- Based on the answer from Mikael Eriksson.
CREATE PROCEDURE testProcB(@endDateTime DATETIME) AS
BEGIN
   SET NOCOUNT ON
   SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN CAST(DATEADD(DAY, -1, @endDateTime) AS DATE) AND CAST(@endDateTime AS DATE)
END
GO

-- Use a date lookup table, Sale first.
-- Based on the answer from Kenneth Fisher.
CREATE PROCEDURE testProcC(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   SELECT SUM(Value) FROM Sale J INNER JOIN testDimDate D ON D.DateKey = J.SaleDate WHERE D.DateKey BETWEEN @startDate AND @endDate
END
GO

-- Use a date lookup table, Sale last.
-- Based on the answer from Kenneth Fisher.
CREATE PROCEDURE testProcD(@endDate DATE) AS
BEGIN
   SET NOCOUNT ON
   DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)
   SELECT SUM(Value) FROM testDimDate D INNER JOIN Sale J ON J.SaleDate = D.DateKey WHERE D.DateKey BETWEEN @startDate AND @endDate
END
GO

------ TEST ------

SET STATISTICS TIME OFF

DECLARE @endDate DATE = '2012-12-10'
DECLARE @startDate DATE = DATEADD(DAY, -1, @endDate)

DBCC FREEPROCCACHE WITH NO_INFOMSGS
DBCC DROPCLEANBUFFERS WITH NO_INFOMSGS

RAISERROR('Run 1: NoProc with constants', 0, 0) WITH NOWAIT
SET STATISTICS TIME ON
SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN '2012-12-09' AND '2012-12-10'
SET STATISTICS TIME OFF

RAISERROR('Run 2: NoProc with constants', 0, 0) WITH NOWAIT
SET STATISTICS TIME ON
SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN '2012-12-09' AND '2012-12-10'
SET STATISTICS TIME OFF

DBCC FREEPROCCACHE WITH NO_INFOMSGS
DBCC DROPCLEANBUFFERS WITH NO_INFOMSGS

RAISERROR('Run 1: NoProc with variables', 0, 0) WITH NOWAIT
SET STATISTICS TIME ON
SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate
SET STATISTICS TIME OFF

RAISERROR('Run 2: NoProc with variables', 0, 0) WITH NOWAIT
SET STATISTICS TIME ON
SELECT SUM(Value) FROM Sale WHERE SaleDate BETWEEN @startDate AND @endDate
SET STATISTICS TIME OFF

DECLARE @sql NVARCHAR(4000)

DECLARE _cursor CURSOR LOCAL FAST_FORWARD FOR
   SELECT
      procedures.name,
      procedures.object_id
   FROM sys.procedures
   WHERE procedures.name LIKE 'testProc_'
   ORDER BY procedures.name ASC

OPEN _cursor

DECLARE @name SYSNAME
DECLARE @object_id INT

FETCH NEXT FROM _cursor INTO @name, @object_id
WHILE @@FETCH_STATUS = 0
BEGIN
   SET @sql = CASE (SELECT COUNT(*) FROM sys.parameters WHERE object_id = @object_id)
      WHEN 0 THEN @name
      WHEN 1 THEN @name + ' ''@endDate'''
      WHEN 2 THEN @name + ' ''@startDate'', ''@endDate'''
   END

   SET @sql = REPLACE(@sql, '@name', @name)
   SET @sql = REPLACE(@sql, '@startDate', CONVERT(NVARCHAR(10), @startDate, 126))
   SET @sql = REPLACE(@sql, '@endDate', CONVERT(NVARCHAR(10), @endDate, 126))

   DBCC FREEPROCCACHE WITH NO_INFOMSGS
   DBCC DROPCLEANBUFFERS WITH NO_INFOMSGS

   RAISERROR('Run 1: %s', 0, 0, @sql) WITH NOWAIT
   SET STATISTICS TIME ON
   EXEC sp_executesql @sql
   SET STATISTICS TIME OFF

   RAISERROR('Run 2: %s', 0, 0, @sql) WITH NOWAIT
   SET STATISTICS TIME ON
   EXEC sp_executesql @sql
   SET STATISTICS TIME OFF

   FETCH NEXT FROM _cursor INTO @name, @object_id
END

CLOSE _cursor
DEALLOCATE _cursor