Vaccano's questions

背景

这是一个与我正在使用的相似的示例：

CREATE TABLE sandboxTesting.TemporalTest (    
    GroupNumber VARCHAR(25) NOT NULL,
    StartEffectiveWhen DATE NOT NULL,
    EndEffectiveWhen DATE NULL,
    ModifiedWhen DATETIME NULL,
    IsReady BIT NOT NULL DEFAULT 0,
    RowValidFrom DATETIME2 GENERATED ALWAYS AS ROW START NOT NULL,
    RowValidTo DATETIME2 GENERATED ALWAYS AS ROW END NOT NULL,
    PERIOD FOR SYSTEM_TIME (RowValidFrom, RowValidTo),
    CONSTRAINT PK_TemporalTest PRIMARY KEY CLUSTERED  
    (
        GroupNumber, StartEffectiveWhen
    )
) WITH (SYSTEM_VERSIONING=ON (HISTORY_TABLE=sandboxTesting.TemporalTestHistory))
GO 

CREATE TRIGGER sandboxTesting.OnModify ON sandboxTesting.TemporalTest AFTER UPDATE AS
BEGIN
    
    UPDATE  temporalTst
    SET     temporalTst.IsReady = 0,
            temporalTst.ModifiedWhen = GETDATE()
    FROM    sandboxTesting.TemporalTest temporalTst
            JOIN deleted del
                ON del.GroupNumber = temporalTst.GroupNumber
                AND del.StartEffectiveWhen = temporalTst.StartEffectiveWhen
    WHERE   -- All business columns go here with OR statements in between them.
            -- The idea is that if anything changes except the IsReady flag, then we 
            -- set the IsReady back to false.  (IsReady has to be set by itself)
            del.EndEffectiveWhen <> temporalTst.EndEffectiveWhen 
            OR (del.EndEffectiveWhen IS NULL AND temporalTst.EndEffectiveWhen IS NOT NULL)
            OR (del.EndEffectiveWhen IS NOT NULL AND temporalTst.EndEffectiveWhen IS NULL)
END
GO

-- Insert new test
INSERT INTO [sandboxTesting].[TemporalTest] ([GroupNumber], [StartEffectiveWhen], [EndEffectiveWhen],  [ModifiedWhen])
VALUES ('12345', '2024-01-1', NULL, NULL)
GO

-- Set is as ready 
UPDATE  sandboxTesting.TemporalTest
SET     IsReady = 1
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
GO 

-- Change the End date
UPDATE  sandboxTesting.TemporalTest
SET     EndEffectiveWhen = '2024-09-02'
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
        
-- Set the new end date as ready for billing.
UPDATE  sandboxTesting.TemporalTest
SET     IsReady = 1
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
GO 


-- Select the Data
SELECT * FROM sandboxTesting.TemporalTest for SYSTEM_TIME ALL 
ORDER BY GroupNumber, StartEffectiveWhen desc, RowValidFrom DESC, RowValidTo DESC, ModifiedWhen desc

-- Select the Raw Data (for comparison)
SELECT * FROM sandboxTesting.TemporalTest
UNION ALL 
SELECT * FROM sandboxTesting.TemporalTestHistory
ORDER BY GroupNumber, StartEffectiveWhen desc, RowValidFrom DESC, RowValidTo DESC, ModifiedWhen desc

当我运行它时，这是第一个结果：

第二组输出如下：

这是不同的，因为第一个查询结果使用了for SYSTEM_TIME ALL子句，而第二个查询结果只是查询原始数据。

不同之处在于，在第一个数据集中，第二个数据集的第二行和第三行已被过滤掉。它们被删除是因为第二行和第三行的开始日期和结束日期相同。（基本上说这些行从未真正生效。）

问题

我需要知道的是，对于通过触发器更新的数据，我是否可以依赖这个“零时间差” AFTER？（如果不是这种情况，我需要编写一些查询，这些查询将会失败。）

我的意思是：如果我的服务器被数千个查询所困扰，这些查询都进行着大量的 IO 和计算，那么第二个数据集的第二行和第三行的RowValidFrom和RowValidTo值的差是否仍然为 0？

换句话说，这些值是否因为事务逻辑而相同？还是因为我的服务器速度很快并且目前没有任何压力，所以它们相同？

这是我的问题的 SQL Fiddle： https://sqlfiddle.com/sql-server/online-compiler? id=ab1634d7-fec7-4918-ac1c-3f4fcac8dc92

我有以下示例数据：

DROP TABLE IF EXISTS #Price
CREATE TABLE #Price (DataId INT IDENTITY(1,1), NameOfWidget VARCHAR(50), Price MONEY, PriceScheduleId INT, 
                     StartEffectiveWhen DATE, EndEffectiveWhen DATE)

INSERT INTO #Price (NameOfWidget, Price, PriceScheduleId, StartEffectiveWhen, EndEffectiveWhen)
VALUES
    ('CoolWidget', 3.51, 1, '2015-1-1', '2021-12-31'),
    ('CoolWidget', 2.00, 2, '2017-1-1', '2022-12-31'),
    ('CoolWidget', 4.23, 1, '2021-1-1', '2100-12-31'),
    ('CoolWidget', 2.00, 2, '2021-1-1', '2100-12-31'),
    ('OtherWidget', 13.24, 1, '2014-1-1', '2100-12-31')

我现在需要将此数据转换为以下格式：

NameOfWidget    StartEffectiveWhen  EndEffectiveWhen
CoolWidget      2015-01-01          2016-12-31
CoolWidget      2017-01-01          2021-12-31
CoolWidget      2021-01-01          2022-12-31
CoolWidget      2023-01-01          2100-12-31
OtherWidget     2015-01-01          2100-12-31

这遵循以下逻辑，按 分组NameOfWidget：

1. 找到最低的StartEffectiveWhen.
2. 查找下一个最低值StartEffectiveWhen或EndEffectiveWhen。该日期成为下一个日期EndEffectiveWhen。但如果它是EndEffectiveWhen，那么我们从中减去一天。
3. 然后，它会重复上述步骤，但排除已使用的数据。

目标是每个时间范围“窗口”都有一行。

下面的代码满足我的需要，但它使用循环来完成。

和往常一样，我的真实数据要复杂得多。它还具有 5600 万行。（下面的代码在我的真实数据上运行需要3个小时）

我希望有一种方法可以完成下面的操作而无需循环。

我的（缓慢的、基于循环的）代码

DROP TABLE IF EXISTS #EffectiveRange
CREATE TABLE #EffectiveRange (EffectiveDateId INT IDENTITY(1,1), StartEffectiveWhen DATE, EndEffectiveWhen DATE, EndWhenOfRowsThatMatchStartDate DATE, SecondStartWhen DATE, NameOfWidget VARCHAR(50), CalculationRound INT)

DECLARE @CalculationRound INT = 1

-- This is < 15 in my real code
WHILE (@CalculationRound < 5)
BEGIN

    -- Find the first/next range in source price table.
    INSERT INTO  #EffectiveRange(StartEffectiveWhen, EndWhenOfRowsThatMatchStartDate, SecondStartWhen, NameOfWidget, CalculationRound)
    SELECT  MIN(price.StartEffectiveWhen) StartWhen, NULL, NULL, price.NameOfWidget, @CalculationRound
    FROM    #Price price            
    WHERE   price.StartEffectiveWhen > 
            (SELECT MAX(maxValue.StartWhen) 
             FROM 
                (SELECT MAX(rangesSub.StartEffectiveWhen) AS StartWhen
                 FROM   #EffectiveRange AS rangesSub
                 WHERE  rangesSub.NameOfWidget = price.NameOfWidget
                 UNION ALL
                 SELECT CAST('1/1/1900' AS DATE) AS StartWhen) AS maxValue)
    GROUP BY price.NameOfWidget 

    -- Find the end date for the rows that match the start date we just found.
    UPDATE  #EffectiveRange SET
       EndWhenOfRowsThatMatchStartDate = calc.EndWhenOfRowsThatMatchStartDateCalc
    FROM 
        (
            SELECT  MIN(price.EndEffectiveWhen) AS EndWhenOfRowsThatMatchStartDateCalc, price.NameOfWidget
            FROM    #Price price
                    JOIN #EffectiveRange ranges
                        ON ranges.NameOfWidget = price.NameOfWidget
                        AND ranges.CalculationRound = @CalculationRound
            WHERE   price.StartEffectiveWhen = ranges.StartEffectiveWhen
            GROUP BY price.NameOfWidget
        ) AS calc
        JOIN #EffectiveRange ranges
            ON ranges.NameOfWidget = calc.NameOfWidget
            AND ranges.CalculationRound = @CalculationRound

    -- Find the next largest start date for the calculation round.        
    UPDATE  #EffectiveRange SET
        SecondStartWhen = calc.SecondStartWhen
    FROM 
        (
            SELECT  MIN(price.StartEffectiveWhen) SecondStartWhen, price.NameOfWidget
            FROM    #Price price
                    JOIN #EffectiveRange ranges
                        ON ranges.NameOfWidget = price.NameOfWidget
                        AND ranges.CalculationRound = @CalculationRound
            WHERE   price.StartEffectiveWhen > ranges.StartEffectiveWhen
            GROUP BY price.NameOfWidget
        ) AS calc
        JOIN #EffectiveRange ranges
            ON ranges.NameOfWidget = calc.NameOfWidget
            AND ranges.CalculationRound = @CalculationRound

    -- Send the EndWhen to be the lesser of EndWhenOfRowsThatMatchStartDate and secondStartDate.  
    -- This will define our window of effectiveness for this round of the test. (once we have all of the windows (aka each time a change was made),
    -- we will caclulate the price for each window.
    UPDATE #EffectiveRange SET
        EndEffectiveWhen = IIF((EndWhenOfRowsThatMatchStartDate < SecondStartWhen) OR SecondStartWhen IS NULL, EndWhenOfRowsThatMatchStartDate, DATEADD(DAY, -1, SecondStartWhen))
    WHERE   CalculationRound = @CalculationRound

    SET @CalculationRound = @CalculationRound + 1
END

-- Show the final result
SELECT  ranges.NameOfWidget, ranges.StartEffectiveWhen, ranges.EndEffectiveWhen
FROM    #EffectiveRange ranges
ORDER BY ranges.NameOfWidget, ranges.StartEffectiveWhen


DROP TABLE IF EXISTS #EffectiveRange
DROP TABLE IF EXISTS #Price

更新

这个 SQL Fiddle 显示了我最终做了什么：

https://sqlfiddle.com/sql-server/online-compiler?id=b0d81632-b14d-4374-a80e-0835750f48bc

@Akina 让我朝着正确的方向思考我的问题。（谢谢@Akina！）

以防万一，这是我最终使用的查询：

DROP TABLE IF EXISTS #Price
CREATE TABLE #Price (DataId INT IDENTITY(1,1), NameOfWidget VARCHAR(50), Price MONEY, PriceScheduleId INT, StartEffectiveWhen DATE, EndEffectiveWhen DATE)

INSERT INTO #Price (NameOfWidget, Price, PriceScheduleId, StartEffectiveWhen, EndEffectiveWhen)
VALUES
    ('CoolWidget', 3.51, 1, '2015-1-1', '2021-12-31'),
    ('CoolWidget', 2.00, 2, '2017-1-1', '2022-12-31'),
    ('CoolWidget', 4.23, 1, '2021-1-1', '2100-12-31'),
    ('CoolWidget', 2.00, 2, '2021-1-1', '2100-12-31'),
    ('OtherWidget', 13.24, 1, '2014-1-1', '2018-5-4'),
    ('OtherWidget', 13.24, 1, '2018-5-6', '2019-12-31'),
    ('OtherWidget', 13.24, 1, '2020-1-1', '2100-12-31')

;WITH OrderedDates AS 
(
    SELECT  priceStart.NameOfWidget, priceStart.StartEffectiveWhen AS DateWhen, 1 AS IsStartDate, 0 AS IsEndDate
    FROM    #Price priceStart

    UNION 

    SELECT  priceStart.NameOfWidget, priceStart.EndEffectiveWhen AS DateWhen, 0 AS IsStartDate, 1 AS IsEndDate
    FROM    #Price priceStart
    
)
SELECT  OrderedDates.NameOfWidget,
        CASE 
            WHEN LAG(OrderedDates.DateWhen) OVER (PARTITION BY OrderedDates.NameOfWidget ORDER BY OrderedDates.DateWhen) IS NULL THEN '1900-1-1'
            WHEN LAG(OrderedDates.IsStartDate ) OVER (PARTITION BY OrderedDates.NameOfWidget ORDER BY OrderedDates.DateWhen) = 1 
                THEN  LAG(OrderedDates.DateWhen) OVER (PARTITION BY OrderedDates.NameOfWidget ORDER BY OrderedDates.DateWhen)
            ELSE DATEADD(DAY, 1, LAG(OrderedDates.DateWhen) OVER (PARTITION BY OrderedDates.NameOfWidget ORDER BY OrderedDates.DateWhen))
        END AS StartEffectiveWhen, 
        
        CASE
            WHEN OrderedDates.IsEndDate = 1 THEN OrderedDates.DateWhen
            ELSE DATEADD(DAY, -1, OrderedDates.DateWhen)
        END AS EndEffectiveWhen
FROM    OrderedDates
ORDER BY OrderedDates.NameOfWidget

据我了解，当您在表上定义列时，您定义了它的精度。此精度占用 1 个字节并存储在列级别。如果您使用 5 或更高的精度，则 DateTime2 列将占用每行 8 个字节。（精度不存储在行级别。）

但是，当您将相同的 DateTime2 转换为 VarBinary 时，它将占用 9 个字节。那是因为它需要存储在列级别的精度字节。

我很好奇这与 DateTime2 存储在内存中时有何关系。假设我在内存中有 1,000,000 个 DateTime2s（每个的精度为 5 或更高）。这会占用 8,000,000 字节的内存，还是 9,000,000 字节的内存？

基本上，我想知道默认精度 DateTime2 是否会比正常的 DateTime 对 Page Life Expectancy 造成更大的压力？

背景

我有一个具有以下权限的 SQL 用户：

GRANT CREATE SEQUENCE ON SCHEMA::seq TO SequenceCreator  
GO

我希望能够让这个用户创建一个它拥有的序列。但是当我运行以下命令时：

EXECUTE AS USER = 'SequenceCreator'
CREATE SEQUENCE seq.Testing START WITH 1 INCREMENT BY 1 NO CACHE 
REVERT

所有者是dbo，继承自架构。如以下查询所示：

;with objects_cte as
(    select o.name, o.type_desc,
            case
                when o.principal_id is null then s.principal_id
                else o.principal_id
            end as principal_id
    from    sys.objects o
            INNER join sys.schemas s
                ON o.schema_id = s.schema_id )
select cte.name, dp.name AS owner
from    objects_cte cte
        JOIN sys.database_principals dp
            ON cte.principal_id = dp.principal_id
WHERE  cte.name = 'Testing'

结果：

name            name
Testing         dbo

但是当我（as dbo）运行这个时：

ALTER AUTHORIZATION ON seq.[Test--Things] TO SequenceCreator

然后该查询的结果变为：

name      owner
Testing   SequenceCreator

但是如果我放弃序列并运行它：

EXECUTE AS USER = 'SequenceCreator'
CREATE SEQUENCE seq.Testing START WITH 1 INCREMENT BY 1 NO CACHE 
ALTER AUTHORIZATION ON seq.[Testing] TO SequenceCreator
REVERT

我收到以下错误：

Cannot find the object 'Testing', because it does not exist or you do not have permission.

这是意料之中的，因为用户SequenceCreator没有看到更少alter序列的权限。

但似乎，既然用户正在创建它，它也应该能够设置谁拥有它。（类似于CREATE SCHEMA seq AUTHORIZATION dbo通话）

问题

如何让创建用户 ( SequenceCreator) 拥有它创建的序列，而无需更高级别的用户转移所有权？

我们的一张表上有一个 After Insert 和 Update 触发器。触发器基本上生成一个 json 有效负载并将其排入 RabbitMQ 系统。

今天在表上运行了一个大型插入脚本（超过 50,000 个插入）。这种情况尚未经过测试或考虑，现在我们在该数据库上遇到了性能问题。

我们注意到 RabbitMQ 的记录在很长一段时间内缓慢流入。即使数据已经存在了一段时间（因为它是 After Trigger）。

似乎 After 触发器已以某种方式排队，并且正在非常缓慢地通过系统工作。

After Trigger 事件如何跟踪执行？他们在某个地方排队吗？有什么办法可以清除它们吗？

我有一个看起来与此类似的视图：

CREATE VIEW Shipment.Shipment AS

    SELECT  CASE 
                WHEN shipmentOld.SHIPMENT_ID = 0 OR shipmentOld.SHIPMENT_ID = -1 THEN NULL
                ELSE shipmentOld.SHIPMENT_ID
            END AS ShipmentId, 

            OtherValue, SomeOtherValue, OtherStuff
    FROM    dbo.tblShipment_Old shipmentOld
GO

然后如果我做这样的查询：

SELECT * FROM Shipment.Shipment WHERE ShipmentId = 18140

我得到了完整的索引扫描。原因是它在表中的所有行上运行 ShipmentId 的 case 表达式，并将结果与​​我的 ShipmentId (18140) 进行比较。非 sargable 的定义。

我正在使用这个视图来规范化遗留数据，这样我就可以在它之上编写一个新的应用程序。 我只希望 case 表达式在输出时运行。

我猜这是不可能的，但我想在我追求更极端的选择之前我会问。所以这是我的问题：

是否仍然可以让我的 ShipmentId 输出通过 case 表达式，但在where子句中使用 ShipmentId 时也可以进行可搜索查询？

我们在应用程序中遇到以下异常：

执行超时已过期。在操作完成之前超时期限已过，或者服务器没有响应。

所以，我查看了查询，果然花了很长时间。所以我把它调到不到一秒钟。

但我仍然超时。

因此，我为 Attention 事件设置了一个扩展事件会话以捕获超时并查看发生了什么（使用此页面作为指南）。

结果令人困惑。我在列表中看到了我的查询，但跟踪中记录的持续时间不到一秒！

以下是我在超时持续时间列中获得的一些示例值：

我很困惑。 当持续时间平均显示半秒时，为什么我会收到 SQL Server 超时错误？

注意：扩展事件的输出显示一些行超过 30 秒。在我看来，这些是合法的超时，我正在努力解决这些问题。（我只是指出这一点以表明Attention扩展事件似乎对这些查询有效。）

我认为它可能会阻塞，所以我设置了一个Blocked Process Report扩展事件来查看（遵循本指南）。虽然服务器上发生了阻塞，但它们不在我的查询所针对的数据库上。

该应用程序使用称为 Dapper 的 API（我听说这是一种相当流行的 Micro ORM，用于运行 Stack Exchange）。我想它有不错的连接管理。但即使他们滥用其连接，据我所知，这也会导致资源泄漏，而不是 SQL 超时。

应用程序中的查询超时设置为 120 秒。这应该有足够的时间让我看到的大多数查询报告为超时。

我有一个这样的查询：

SELECT  ordIdent.Identifier, ord.OrderId
FROM    OrderIdentifier ordIdent
        JOIN [order] ord
            ON ordIdent.OrderId = ord.OrderId
WHERE   ordIdent.Identifier = '29584'
        OR ord.ClientOrderId = '29584'

这个想法是我们正在使用值'29584'进行搜索，但我们真的不知道它是 aClientOrderId还是 an Identifier，所以我们想同时搜索两者。

这给出了非常糟糕的性能。它提取了数百万行（12.5 万行来自另一个，2000 万行来自另一个）

但是这个查询：

SELECT  ordIdent.Identifier, ord.OrderId
FROM    OrderIdentifier ordIdent
        JOIN [order] ord
            ON ordIdent.OrderId = ord.OrderId
WHERE   ord.ClientOrderId = '01193504' 

UNION

SELECT  ordIdent.Identifier, ord.OrderId
FROM    OrderIdentifier ordIdent
        JOIN [order] ord
            ON ordIdent.OrderId = ord.OrderId
WHERE   ordIdent.Identifier = '01193504'

有很好的表现。通常我会这样做并收工。

但是我的实际查询非常大，我宁愿不调用它两次（尽管它仍然比使用“或”更好。）所以在我将它设置为被调用两次之前，我想我会四处询问看看如果我有其他选择。

看来我应该做某种左连接来完成这项工作。但我似乎无法绕过它。

有没有办法在一个有左连接而不是“OR”的查询中做到这一点？ （或者其他类型的选择？）

更新：
好的，我开始考虑它，我意识到我可以将 OR 分解为使用union的 CTE，然后将 CTE 用于实际查询。

如果有更好的方法来处理它，我将保持打开状态，但 CTE 解决了我的问题。

这是一个静态查询，它显示了我要获取的位置

declare @Airbill VARCHAR(50) = '12345678912'
select stuff(stuff(@Airbill, 4, 0, '-'), 9, 0, '-')

但我需要让它变得更加可变。我有以下变量：

DECLARE @AirbillMask VARCHAR(50) = '999-9999-9999'

哪个可以（并且确实）改变。它始终是“9”和“-”。但是它们的位置发生了变化。

• 如果@AirbillMask是999-99-99-9999我想要的结果将是123-45-67-8912。
• 如果@AirbillMask是 999-9999-9999我想要的结果将是123-4567-8912。

我正在运行dbo.FindPatternLocation(@AirbillMask, '-')返回破折号位置表。

我正计划找到一种方法将STUFF的部分@Airbill放入相应的位置以生成 的计算字段FormattedAirbill，但我在尝试迭代STUFF调用时遇到了困难。

有没有办法一遍又一遍地打电话给STUFF另一个STUFF电话，直到我不在行？

我觉得递归 CTE 或交叉应用可以实现这一点，但我似乎无法理解它。

注意：如果可能的话，我更愿意在不循环的情况下执行此操作。

我正在编写INSTEAD OF INSERT触发器并在此代码上遇到错误：

CASE 
   WHEN Inserted.KeyId IS NOT NULL THEN Inserted.KeyId
   ELSE NEXT VALUE FOR SomeSchema.NextKeyId
END

错误是：

NEXT VALUE FOR 函数不能在 CASE、CHOOSE、COALESCE、IIF、ISNULL 和 NULLIF 中使用。

阅读表明这是一个相当硬的限制，我想我可以接受，但我想知道为什么会有这个限制。

对我来说似乎很奇怪，它不能只为与 case 语句的该分支匹配的集合部分调用该方法。

有人可以解释为什么CASE声明不允许NEXT VALUE FOR吗？

我刚刚获得了一个 Sql Server 2016 可用性组设置（一个主节点、一个同步辅助节点和一个异步辅助节点）。我在服务器上有五个数据库。

我设置了一个应用程序来对服务器运行查询（使用带有“故障转移伙伴”连接字符串的实体框架。）

当我尝试通过重新启动主服务器来测试故障转移时，出现以下错误：

服务器 MySecondaryServer，没有为数据库镜像配置数据库主服务器。

像这样镜像系统数据库似乎很奇怪，因此我们没有将其设置为“可用性数据库”之一。

所以，这是我的问题：我是否应该将主数据库添加到“可用性数据库”列表中，如果我这样做会导致问题吗？

我是一名尝试使用新的 Sql Server 2016 Always On 集群的开发人员。

在阅读文档时，我得到了相互矛盾的信息。

1. 一些文档告诉我，我只需要将“failover partner=MySecondaryServer”添加到我的连接字符串中。
2. 其他站点谈论使用“侦听器”。在 SSMS 2016 的 Always On 部分中，有一个 Availability Group Listeners 部分。

这些选项之间有什么区别？

这些相互竞争的选择（意味着你只选择一个）还是一起工作？

备注：我试过“故障转移伙伴”，但收效甚微。当主服务器重新启动时，我必须在它“故障转移”到辅助服务器之前重新启动我的实体框架服务。我正在考虑设置一个监听器，看看它是否会更动态地工作。

我有以下查询

SELECT Ice.IceId, Ice.Code, Box.Ice, LEN(Box.Ice) AS IceCharLength,
       DATALENGTH(Box.Ice) AS DataLength, Box.Ice, ASCII(Box.Ice) AS ASCII, 
       CAST(Box.ice AS VARBINARY) AS VarBinary
FROM dbo.tblESPShipBox Box
LEFT JOIN ReferenceManual.IceType Ice
       ON Ice.Code = CASE
                        WHEN Box.ICE IS NULL THEN 'N'
                        WHEN RTRIM(Box.ICE) = '' THEN 'N'
                        WHEN Box.Ice IN ('', ' ', '/') THEN 'N'
                        ELSE Box.ICE
                      END
WHERE BOX_SEQ_NUM = '000023' AND BOX_TYPE_ID = 0

它返回以下结果：

IceId       Code Ice  IceCharLength DataLength  Ice  ASCII       VarBinary
----------- ---- ---- ------------- ----------- ---- ----------- -------------
2           N         0             1                32          0x20
NULL        NULL      1             1                0           0x00

奇怪的是，Box.ICE第一行是 ' '（单个空格字符串）。第二行似乎是 '' （无空格字符串）。（我看到的方式是将单元格复制出来并粘贴到其他文本中，看看它是否有空格。）

该Box.ICE列是一个char(1)，所以我真的不明白 '' （无空格字符串）是如何进入其中的。

但奇怪的是，我的 case 语句仍应匹配 ''（无空格）字符。但显然不是。

我怎样才能弄清楚该字段中的真实内容并使其与我的案例陈述相匹配？

我尝试过的事情：

• 使用SSMSBoost 将包含特殊字符的单元格副本复制到NotePad++ 中（打开显示所有字符）。我这样做是为了确保没有无法播放的 unicode 字符。

假设我有一个如下所示的索引视图：

ALTER VIEW dbo.MyIndexedView WITH SCHEMABINDING
AS 
    SELECT ord.SomeColumn, COUNT_BIG(*) AS Count
    FROM dbo.Ordered ord
    WHERE ord.CreatedWhen >  CONVERT(DATETIME, '2014-11-01', 121)
    GROUP BY ord.SomeColumn
GO

CREATE UNIQUE CLUSTERED INDEX [CIX_MyIndexedView] ON dbo.MyIndexedView (SomeColumn)
GO

如果我更改此视图中的日期时间值（例如“2014-11-01”），则需要重新生成聚簇索引。

有没有办法让现有的视图和索引保持有效，直到新视图和索引完全构建，然后让它们交换？ 如同Online=On

我有一个 Web 服务，可以触发订单的一系列事件。当它收到一条消息告诉它（每秒最多约 2 次）时，它会执行此操作。

我遇到的问题是我有多个 Web 服务实例，有时订单的不同部分可以同时到达每个实例。这会导致事件链针对订单多次触发（错误）。

所以，我在想，我可以做一个表，它只是订单的 ID 和一个标志，说明“事件链”是否已经被触发。

然后我可以在我的代码中开始交易。是这样的：

mySqlConnection.BeginTransaction(); // C# Code

我可以像这样为有问题的订单选择行：

SET TRANSACTION ISOLATION LEVEL READ COMMITTED

SELECT  OrderId, IsChainFired
FROM    OrderedChainFlag WITH ( ROWLOCK, XLOCK, HOLDLOCK )
WHERE   OrderId = 123456

然后，如果 IsChainFired 为假，则触发“事件链”。然后我会运行：

UPDATE  OrderedChainFlag 
SET     IsChainFired = 1
WHERE   OrderId = 123456

然后运行（即使 IsChainFired 为真）：

myConnection.CommitTransaction(); // C# Code

这将防止多个服务实例读取链可以同时自由运行。

我的担心（也是我的问题）是锁升级。如果这保持在行锁上，那么它将是解决我的问题的绝佳方法。但是，如果锁定升级到页面或表，那么我就会在我的系统中造成瓶颈。

那么，我能做些什么来确保它保持在行锁级别吗？ （或者像这样将数据库锁定系统用作信号量是个好主意吗？）

注意：OrderId 将是表的主键、聚簇索引和分区索引。

我的产品“Microsoft SQL Server 2012 (SP1) - 11.0.3128.0 (X64)”显示出奇怪的缓冲区和页面预期寿命 (PLE) 症状。

我每分钟都在我的服务器上运行这个（以跟踪这个问题）：

SELECT @ple = CAST([cntr_value] AS VARCHAR(20))
FROM sys.dm_os_performance_counters
WHERE [object_name] LIKE '%Manager%'
AND [counter_name] = 'Page life expectancy'

SELECT @usedBufferPages = CAST(COUNT(*) /128 AS VARCHAR(20)) 
FROM sys.dm_os_buffer_descriptors

DECLARE @StartDate VARCHAR(8) = Convert(VARCHAR(8), GETDATE(), 14)
RAISERROR ('%s. PLE at %s and Used Buffers at %s at %s ', 0, 
            1,@runCountString ,@ple, @usedBufferPages, @StartDate) WITH NOWAIT  

这是一些示例输出：

16. 858 的 PLE 和 7290 的已用缓冲区 09:51:42
17. 918 处的 PLE 和 7342 处的已用缓冲区 09:52:42
18. 978 处的 PLE 和 7408 处的已用缓冲区 09:53:43
19. PLE 为 1039，使用缓冲区为 7547，时间为 09:54:43
20. PLE 为 1100，使用缓冲区为 7697，时间为 09:55:44
21. 1160 处的 PLE 和 7901 处的已用缓冲区 09:56:45
22. 1221 处的 PLE 和 7961 处的已用缓冲区 09:57:46
23. 1282 处的 PLE 和 8012 处的已用缓冲区 09:58:46
24. 11 点的 PLE 和 313 点的已用缓冲区 09:59:46
25. PLE 在 31 和 Used Buffers 在 966 在 10:00:46
26. PLE 为 90，使用缓冲区为 1580，时间为 10:01:47
27. 151 处的 PLE 和 3072 处的已用缓冲区 10:02:47
28. 211 处的 PLE 和 3152 处的已用缓冲区 10:03:47
29. 271 处的 PLE 和 3729 处的已用缓冲区 10:04:47  

在第 24 项，SQL Server 报告 PLE 从1,282 变为 11。SQL Server 还报告使用的缓冲区从8,012 变为 313。

首先，我寻找运行不佳的查询，并找到了一些已修复的查询（对问题没有影响）。但是，我没有发现任何与我遇到 PLE/缓冲区问题的时间相关的问题查询。此外，如果它是一个运行不佳的查询，那么我认为缓冲区将充满该查询的数据，而不是空的/丢失的/错误的。

接下来我认为发生这种情况时虚拟机的内存受到限制。但我问过我的系统管理员，他向我保证内存不是动态的，也不是以任何方式共享的。（它一直被分配什么，它就得到什么。）另外，我每 10 分钟运行一次这个脚本，当 PLE 报告少于 50 时：

  SELECT * FROM sys.dm_os_sys_memory

当 PLE/缓冲区高和低时，它会报告相同/相似的值。为了完整起见，下面是上面#24 之前和之后的值示例：

total_physical_memory_kb available_physical_memory_kb total_page_file_kb available_page_file_kb system_cache_kb kernel_paged_pool_kb kernel_nonpaged_pool_kb system_high_memory_signal_state system_low_memory_signal_state system_memory_state_desc
20970996 4758672 24378868 7929404 4844160 686076 182752 1 0 可用物理内存高
20970996 4743468 24378868 7892632 4845000 686580 182688 1 0 可用物理内存高

我检查了系统健康会话，但没有显示任何相关内容。（它所具有的只是模拟错误，它们的时间与 PLE/Buffers 显示问题的时间无关。

我已经跟踪了这种情况发生的频率，但我看不到模式或将其与任何工作或计划的活动联系起来。

下图显示了 21 小时内的 PLE 和缓冲区：

所以我很难过。我认为问题的核心是缓冲区而不是 PLE。（我认为 PLE 得到了低的错误报告，因为所有缓冲区都以某种方式消失了。）

但我想不出任何可能发生的方式。或者下一步该做什么。

我很乐意提供有关其他要检查的内容的建议或有关此问题可能是什么的建议。

评论中问题的更新：

那么，给服务器分配多少内存呢？VM 有 20 GB 的内存。
什么是最大服务器内存？

名称 值 value_in_use 描述
max server memory (MB) 13000 13000 服务器内存的最大大小 (MB)
min server memory (MB) 0 16 服务器内存的最小大小 (MB)

注意：我刚刚对此做了一些阅读，看来这些设置对我的服务器来说是错误的。

数据库有多大？该服务器上运行着两个事务数据库（我正在让服务器隔离它们。）它们的大小分别为 383 GB 和 378 GB。

该服务器上还运行着哪些其他应用程序和服务？该服务器托管我的应用程序的数据。没有其他东西打它。（我有一个用于报告等的复制操作数据存储。

什么是VM技术VM Ware。
此 VM 是否在仅托管具有类似资源分配的 VM 的主机上运行？我们公司有很多虚拟机。都是大小不一的。这是最大的之一。

您能否确认您的系统管理员告诉您的有关内存分配的内容，而不必相信他？ 我不能。我无权使用这些工具。

（根据我的经验，系统管理员会说很多话来推卸责任并责怪应用程序或其他任何人，如果这意味着他们不必做任何事情的话。） 我完全理解这种情绪。

我同意，这种模式看起来确实像是严重的内存压力。我希望找到一些东西来证明 SQL 感受到了内存压力。所以我可以将它发回给系统管理员进行更多研究。

等待时间统计

WaitType Wait_S Resource_S Signal_S WaitCount 百分比 AvgWait_S AvgRes_S AvgSig_S
---------------------- ---------- ---------- ------ --- ------------ ------------ ------------ -------- ------ ---
PAGEIOLATCH_SH 16250.10 16219.14 30.96 2171649 29.59 0.0075 0.0075 0.0000   
CXPACKET 14214.03 13238.56 975.47 1187935 25.88 0.0120 0.0111 0.0008   
PAGEIOLATCH_EX 6814.59 6806.21 8.38 638725 12.41 0.0107 0.0107 0.0000   
写日志 5157.42 4873.44 283.98 3588476 9.39 0.0014 0.0014 0.0001   
备份 2569.51 2538.12 31.39 1704119 4.68 0.0015 0.0015 0.0000   
LCK_M_IX 2477.15 2477.10 0.05 113 4.51 21.9217 21.9213 0.0004   
ASYNC_IO_COMPLETION 2079.99 2079.66 0.33 836 3.79 2.4880 2.4876 0.0004   
备份缓冲区 1807.75 1759.11 48.64 380189 3.29 0.0048 0.0046 0.0001   
IO_COMPLETION 986.23 985.84 0.39 116112 1.80 0.0085 0.0085 0.0000   

我有一个生产数据库，该数据库遇到页面预期寿命 (PLE) 问题的剧烈波动。（它会随机崩溃为零。）

我一直在研究 PLE 问题，发现一些似乎指向 VMWare 问题的东西，但我不确定我是否正确使用了数据。好像我正在丢失缓冲区/缓存页面。

我正在使用这个查询：

SELECT  COUNT(*) AS cached_pages_count, 
        CASE database_id
            WHEN 32767 THEN 'ResourceDb'
            ELSE DB_NAME(database_id)
        END AS database_name
FROM    sys.dm_os_buffer_descriptors
GROUP BY DB_NAME(database_id), database_id
ORDER BY cached_pages_count DESC;

（在这里找到）

我正在汇总我的 PLE 崩溃前后的结果（计数）。一个例子是之前的 1,097,820 和之后的 131,394。所以我似乎“丢失”了 966,426 页。

我的猜测是所有虚拟机的硬件都处于压力之下，所以它会在一段时间内随机从服务器换出一些内存。（这只是一个猜测。）当这种情况发生时，所有页面都丢失了，所以 PLE 直线下降。

那么，我sys.dm_os_buffer_descriptors是否正确使用了视图？ 从我阅读的内容来看，它总是显示使用过的缓冲区/缓存页面。因此，如果它是空的（或显着减少），我要么不再有内存，要么它是空的。（我很想用一种方法来证实这个结论。）

或者还有其他解释为什么计数下降这么多？

该行下方的信息是从 OP 的评论中添加的

我们的系统管理员管理虚拟机。我希望在我带着这些数据去找他们之前了解我的查询。从数据库的角度来看，PLE 崩溃的时间似乎是随机的。（在 PLE 崩溃期间不会发生重新索引或其他高性能的事情）

我做了很多工作，看看它是否与工作量有关。虽然有一个性能不佳的查询，但用完所有缓存是不够的。当缓冲区计数下降时，服务器上没有重建或其他非常规用户活动。即使是这样，我会不会在上面的查询中看到它被使用？（意思是如果它是一个 SQL Server 操作，计数不会保持不变，只是使用不同的东西吗？）

我无权访问 VMWare 设置。我希望在让那些这样做的人参与之前更好地理解我的发现。这个问题的重点是确保我首先正确使用视图。

在评论链的末尾：

我想说的是 PLE 问题导致我丢失了 Buffer Pages 问题。我用来获取 PLE 的查询将显示低 PLE，因为页面丢失了。所以他们里面的东西都没有了。这是一个错误的读数，因为内存量减少了。

这是我的@@版本：

Microsoft SQL Server 2012 (SP1) - 11.0.3128.0 (X64) 
    Dec 28 2012 20:23:12 
    Copyright (c) Microsoft Corporation
    Enterprise Edition (64-bit) on Windows NT 6.2 <X64> (Build 9200: ) (Hypervisor)

我已经读过，在 SQL Server 2000 之后，删除了“取消标识”标识列的能力。这是“按设计”（不仅仅是缺少的功能）。

这是我在博客上找到的一个例子。它涉及更新系统表。（并且该功能在 SQL Server 2000 之后被删除。）我知道通过系统表执行此操作不是一个好主意。我只是想知道为什么不存在以另一种方式执行此操作的功能。

解决这个问题将导致我做大量的工作。（在不容忍停机的环境中将数亿行复制到新表中。）

所以我想我会问“为什么”。

Sql Server 2005 及更高版本中的哪些变化使这成为一件坏事？还是它总是很糟糕，只是没有被锁定？

将标识列再次设为普通列会违反什么“最佳实践”（或类似原则）？

--

更新以回答“我为什么这样做”的请求：
这是一个非常高级的摘要：我将开始向我的表添加分区。（这样我就可以存档/清除旧数据。）这很容易。但是我偶尔需要将记录移动到不同的分区，这样它就不会被删除（当一个分区出现以进行归档/删除时）。（我的分区列增加了 2，以便始终有空间将行移动到不同的分区。）

但是如果分区列是标识列，那么我必须删除并重新插入该值（没有办法更新标识列的值）。这会导致复制问题。

所以我想使用序列而不是标识列。但是这种切换在大型数据库上非常非常困难。

我有几个大表需要复制到事务数据库的分区副本中。

我担心这会对我的生产应用程序的性能造成影响。

为了缓解这种情况，我正在研究 Resource Governor。我将设置我的脚本以使用限制为最多 5% CPU 和内存的资源池。

我唯一不确定的部分是对 PLE 的影响。

据我了解，表中的选择会将值读入缓存。这将强制清除缓存中的其他内容。（PLE的基本概念。）但是“强制退出”的项目是否会限制在我指定的5%以内？

意思是在我使用了 5% 的内存之后，它是否只会强制取出相同 5% 的缓存项？（其余 95% 不受影响。）

另一种提问方式是：5% 的内存限制是否与 5% 的高速缓存限制相同？

我正在比较两个表。他们是：

CREATE TABLE Table1(
    Column1 [bigint] NOT NULL,
    Column2 [VARBINARY](max) NULL,
    Column3 [int] NULL,
    Column4 [DATETIME] NULL,
    Column5 [INT] NULL,
    Column6 [DATETIME] NULL,
    [RowVersionId] [timestamp] NOT NULL,
 CONSTRAINT [PK_BagImage] PRIMARY KEY CLUSTERED (Column1 ASC)
)

这是第二张表：

CREATE TABLE Table2(
    Column1 [bigint] IDENTITY(1,1) NOT FOR REPLICATION NOT NULL,
    Column2 [BIGINT] NULL,
    Column3 [VARCHAR](1) NOT NULL,
    Column4 [int] NOT NULL,
    Column5 [varchar](11) NOT NULL,
    Column6 [varchar](13) NOT NULL,
    Column7 [datetime] NOT NULL,
    Column8 [bigint] NULL,
    Column9 [bit] NOT NULL,
    Column10 [uniqueidentifier] NOT NULL,
    [RowVersionId] [timestamp] NOT NULL,
 CONSTRAINT [PK_Table2] PRIMARY KEY CLUSTERED ( Column1 ASC)
) 

它们都没有任何非聚集索引。他们每个人都有一个外键，但是查找它们的查询计划非常快！（需要 00:00:00 的聚集索引查找）。

当我将 55K 行复制到第一行时，需要 45 分钟。当我将 770 万行复制到第二个时，需要 7 分钟。

这一切对我来说似乎都有意义。（复制图像应该需要更长的时间，对吧？）

但是我想为这个操作计算一个粗略的IO。所以我dbcc showcontig在这些桌子上跑了。

表 MinimumRecordSize MaximumRecordSize AverageRecordSize  
表 1 75 123 81.733
表 2 101 101 101

所以这就是我感到困惑的地方。 如果包含图像的表的平均记录大小少 20，那么为什么插入数据要花这么长时间？ 特别是当我在第二个表中插入700 万行时。