Question

最终修改 - 已解决 - 解决方案

我无法相信我不知道这一点，但显然问题是表变量和真实表都有相同的名称：@CHECKERS和dbo.CHECKERS。触发器显然让两者混淆。我通过更改触发器中的插入和更新操作的顺序来发现这一点，以便在从表变量更新之后插入到真实表。突然间，更新开始没有问题。

当然，我只创建了dbo.CHECKERS来调试@CHECKERS，所以很明显存在一些原始问题，这启动了这一切;但无论如何，问题已经解决，触发器工作正常。我在下面发布，如果您愿意，请随时提供任何反馈。我不是一个专家（显然），我总是乐于接受建设性的反馈。

感谢大家的帮助和评论。我希望这篇文章可以帮助那些避免头痛的人...

查询 - 解决方案

ALTER TRIGGER CatchChange ON [dbo].[Orders]

-- Last Updated : 07 Oct 2014

AFTER UPDATE
NOT FOR REPLICATION
-- Trigger not fired by agent updates
AS
BEGIN

    IF UPDATE(UpdateRecordDate)
    -- Trigger fired only by user updates that include a timestamp.
    -- Does **NOT** fire from primary stored procedure (dictated by UpdateRecordDate).
    BEGIN

        -- Table variable for storing **multi-row updates**
        -- Using scalar variables will not work! Look it up.
        DECLARE @CHECKERS AS TABLE 
        (   OrderNum INT,
            Old_DCB INT,
            New_DCB INT,
            Old_MC INT,
            New_MC INT,
            Old_P2 NUMERIC(28,3),
            New_P2 NUMERIC(28,3),
            Old_PQ NUMERIC(28,3),
            New_PQ NUMERIC(28,3),
            Old_QT NUMERIC(28,3),
            New_QT NUMERIC(28,3)
        )

        -- Old & new values populated to table variable.
        -- We can add a table in the same format as the variable &
        -- then check what values were passed, if necessary.
        -- The INSERT for this scenario is commented out at the end.
        INSERT INTO @CHECKERS
        SELECT  I.OrderNo,
                D.DriverCB,
                I.DriverCB,
                D.MCode,
                I.MCode,
                D.Price2,
                I.Price2,
                D.PriceQuantity2,
                I.PriceQuantity2,
                D.Quantity1,
                I.Quantity1
        FROM Inserted I
        JOIN Deleted D ON I.Orderno = D.OrderNo
        -- These checks are crucial, as they cut down on reiteration.
        -- Without them, the program would fire the trigger redundantly.
        -- Here we check for changes to the relevant values &
        -- ensure that the update was a new one, not a repetitive one.
        WHERE I.OrderKind = 0
        AND isnull(D.UpdateRecordDate,convert(DATETIME,0)) <> isnull(I.UpdateRecordDate,convert(DATETIME,0))
        AND (D.DriverCB <> I.DriverCB
            OR D.MCode <> I.MCode
            OR D.Price2 <> I.Price2
            OR D.PriceQuantity2 <> I.PriceQuantity2
            OR D.Price3 <> I.Price3
            OR D.PriceQuantity3 <> I.PriceQuantity3
            OR D.Quantity1 <> I.Quantity1)

        -- Case conditions are preferable in this instance to IF conditions.
        -- All relevant values are checked here against dictating conditions &
        -- updated accordingly.
        UPDATE O
        SET     
        O.DriverCB =        CASE
                            WHEN C.New_DCB = 0
                            THEN NULL
                            ELSE O.DriverCB
                            END,
                            <...>,
        O.Quantity4 =       CASE 
                            WHEN C.New_QT > 0
                            THEN O.Quantity1
                            ELSE O.Quantity4
                            END 
        FROM Orders O
        INNER JOIN @CHECKERS C ON O.OrderNo = C.OrderNum

        -- This is the INSERT which populates the debug table, if you want.
        -- Naturally, the name here must match the name of the created table!
        -- And yes, DD, you need to create the ACTUAL TABLE outside of this trigger. :)
/*      INSERT INTO CheckMe
        SELECT  C.ID,
        C.OrderNum,
        C.Old_DriverCodeBizua,
        C.New_DriverCodeBizua,
        C.Old_MaslulCode1,
        C.New_MaslulCode1,
        C.Old_Price2,
        C.New_Price2,
        C.Old_PriceQuntity2,
        C.New_PriceQuntity2,
        C.Old_Quntity,
        C.New_Quntity
        FROM @CHECKERS C    */
    END
END
GO

结束查询 - 解决方案

--------开始原帖--------

我有一个客户需要我修补一堆执行各种功能的旧触发器。一般来说，我不赞成这一点，并认为他们的程序应该更新 - 但无论如何。

存在三个触发器，我只需要将它们组合成一个触发器，它可以更平滑地工作并具有更多条件。（目前，完全缺乏条件会使触发器在每次操作时都会运行，观察起来非常缓慢。）

简而言之，我创建了一个新的触发器，我在其中声明了一个表变量（下面的查询）。我这样做是为了让自己直接控制列名而不是简单地使用SELECT X INTO #temp。此后，我试图使用CASE检查来更新主表中的各个字段，具体取决于我的表变量中记录的更改。

问题是更新没有做任何事情。我没有错误，但主表中的值保持不变。为了确保表变量获取值并且它们可以使用，我向测试数据库添加了一个新表，并且在触发器的每次触发时，我将当前包含在表变量中的值插入到新表中，就像这样：

        DECLARE @CHECKERS AS TABLE
        (   OrderNum INT,
            Old_DCB INT,
            New_DCB INT,
            Old_MC INT,
            New_MC INT,
            Old_QT NUMERIC(28,3),
            New_QT NUMERIC(28,3)
        )

        INSERT INTO @CHECKERS
        SELECT  I.OrderNo,
                D.DriverCB,
                I.DriverCB,
                D.MCode,
                I.MCode,
                D.Quantity,
                I.Quantity
        FROM Inserted I
        JOIN Deleted D ON I.OrderNo = D.OrderNo
        WHERE I.OrderKind = 0
        AND (D.DriverCB <> I.DriverCB
            OR D.MCode1 <> I.MCode1
            OR D.Quantity <> I.Quantity)

        INSERT INTO CHECKERS
        SELECT  OrderNum,
            Old_DCB,
            New_DCB,
            Old_MC,
            New_MC,
            Old_QT,
            New_QT
        FROM @CHECKERS
        -- An actual table created to check functionality
        -- Works up until this point

        UPDATE Orders
        SET Quantity2 = CASE 
                WHEN New_QT > 0 THEN New_QT
                ELSE Quantity2
                END
        FROM @CHECKERS C
        WHERE OrderNo = C.OrderNum

当然，实际触发器中还有更多更新，但您明白了。

为什么订单更新未通过的任何想法？可能是一些小事，愚蠢和令人尴尬的东西 - 但我再说一遍;）谢谢。

--------结束原始帖子--------

- 编辑：

我也试过写这样的更新：

        UPDATE O
        SET Quantity2 = CASE 
                WHEN C.New_QT > 0 THEN C.New_QT
                ELSE Quantity2
                END
        FROM @CHECKERS C
        INNER JOIN Orders O on O.OrderNo = C.OrderNum

这种方法给出了相同的结果：没有错误消息（或任何其他消息），没有更新......

- 第二次编辑：

如果我使用实际的表CHECKERS而不是表变量@CHECKERS，则更新通过：

            UPDATE O
            SET Quantity2 = CASE 
                    WHEN C.New_QT > 0 THEN C.New_QT
                    ELSE Quantity2
                    END
            FROM CHECKERS C -- Actual table, not a table variable!
            INNER JOIN Orders O on O.OrderNo = C.OrderNum

无论JOIN中是否存在订单，这也都有效：

UPDATE Orders
            SET Quantity2 = CASE 
                    WHEN C.New_QT > 0 THEN C.New_QT
                    ELSE Quantity2
                    END
            FROM CHECKERS C -- Actual table, not a table variable!
            WHERE OrderNo = C.OrderNum

现在唯一的问题是，在客户的数据库中，我无法添加真正的CHECKERS表。我在测试数据库中添加它只是为了澄清值是否传递给表变量！这是我不熟悉的表变量的限制吗？我很难在在线文档中找到任何这样的限制......

Answer 1

您需要在FROM语句中添加Orders作为INNER JOIN。试试这个：

UPDATE O
SET Quantity2 = CASE 
        WHEN New_QT > 0 THEN New_QT
        ELSE Quantity2
        END
FROM @CHECKERS C
INNER JOIN Orders O on O.OrderNo = C.OrderNum

Answer 2

表变量（@CHECKERS）和实际表（dbo.CHECKERS）具有相同的名称。触发器在它们之间混淆了。通过改变触发器中操作的顺序，这变得显而易见。然后我改变了实际表格的名称，一切都开始顺利进行。

我对表变量一无所知，在搜索解决方案的几个小时内也没有在网上找到它。

一般信息：此触发器是在Microsoft SQL Server 2005中创建的。也许问题已经解决，或者这可能是一个侥幸。无论哪种方式，将dbo.CHECKERS的名称更改为dbo.CHECKME都为我解决了这个问题。

SQL Server从表变量更新

2 个答案: