Kirk Saunders's questions

Distributor问：服务器使用 1publication到 2subscribers或使用 2且每台publications相同articles的服务器更便宜/更高效subscriber？

细节：

我们最近遇到了一个问题，即我们Transactional Replication的DistributortoSubscriber进程将停止并且不会优雅地恢复。这几乎就像一些事务被跳过或被乱序应用。从历史上看，我们刚刚解决了这个问题reinitializing并publication继续前进。

我们已将其缩小到Distributor服务器上的资源利用问题。大多数情况下，我们可以通过重新启动服务器来解决，Azure但较大的服务器publications并不总是自行恢复。

我们articles需要将所有内容交付到两台不同的服务器（一台用于 IT 部门拥有的报告功能，另一台用于数据分析师团队拥有的报告功能）。我们将把各种文章分成几组，每组得到 2 篇，然后将它们发送到我们接受两者publications的单独服务器。一个连接到 IT 服务器，另一个连接到 Data Analyst 服务器。如下所示：DistributorPublicationspublication

资源利用问题的部分原因是数据分析服务器上对命令blocking应用的昂贵查询。replication我们正在与该团队合作以改进查询，但我也想看看我们是否可以进行架构调整以提供帮助。

我正在寻找是否有任何理由可以降低Distributor发送 1publication到 2subscribers而不是使用 2publications到单个的成本subscriber。如下所示：

有没有人对这种潜在的实施有任何经验？

今天早些时候，我正在研究一个Stored Procedure表现不佳的报告。我能够通过将包含variable十个或更少字符的字符串的静态变量从 更改为VARCHAR(MAX)来解决这个问题VARCHAR(10)。 我希望了解为什么会有所作为。

如有需要，可提供其他详细信息

原始查询比需要查看的要大得多，但我看到发生了以下事情，当将基础连接table到 a时，Key-Value Pair table我们返回的rows结果比实际需要的要多得多（在某些情况下，最终输出超过 140 亿行~60,000 行）并且我们有一些额外的操作（尤其是Lazy Table Spool）。该部分查询计划的图像如下：

我可以看到执行计划中一个奇怪的部分是如何@ProgramID variable处理的。此变量用作表[Column] = @ProgramID的一部分，并且是Column表的一部分。但是我们仍然在做一个而不是一个。Non-Clustered IndexVarChar(10)Inequality SearchEquality Search

parameter/variable将其从修改VarChar(Max)为 后VarChar(10)。execution time从几个小时下降到大约 30 秒，该计划的结构非常不同。从执行计划中查看类似的片段，我们没有返回几乎那么多的行，我们没有额外的操作并且我们正在执行equality searchon [Column] = @ProgramID（再次Column是表的一部分Non-Clustered Index并且是 a VarChar(10)）。

下面是一个简化的查询，它显示了一些这种行为（我们没有得到所有额外的步骤，但是 Seek Predicate 的区别仍然存在）：（粘贴计划）

DECLARE @CompanyID VarChar(10) = 'RxCRoads'
        ,@ClientID VarCHar(10) = 'Amgen'
        ,@ProgramID VarChar(MAX) = 'Foundation'
        ,@StartDate DATETIME = '2020-01-01'
        ,@EndDate DATETIME = '2020-12-07'
        ,@RxOnly INT = 9

SELECT PC.CompanyID,
PC.ClientID,
PC.ProgramID,
PC.PatientID,
PC.CaseID,
RxOnly.[Value] AS RxOnly
FROM PATIENTCASES PC
    LEFT OUTER JOIN PatientCaseDetail RxOnly
        ON RxOnly.CompanyId = PC.CompanyID
        AND RxOnly.ClientId = PC.ClientID
        AND RxOnly.ProgramId = PC.ProgramID
        AND RxOnly.PatientID = PC.PatientID
        AND RxOnly.CaseID = PC.CaseID
        AND RxOnly.PatientCaseAdditionalElementId = @RxOnly
WHERE PC.CompanyID = @CompanyID
AND PC.ClientID = @ClientID
AND PC.ProgramID = @ProgramID
AND PC.CaseCreateDateTime >= @StartDate
AND PC.CaseCreateDateTime < @EndDate

只需将 更改为@ProgramID VarChar(MAX) = 'Foundation')即可@ProgramID VarChar(10) = 'Foundation'返回更精简的计划和更好的性能（即使在此特定查询中并不明显）。（粘贴计划）

数据类型大小的这种变化会导致执行计划的变化有什么特别的原因吗？@ProgarmId VarChar(8000)使用而不是@Program VarChar(10)运行 相同的查询与@Program VarChar(10). （粘贴计划）

我的猜测是，VarChar(MAX)由于它的大小，它有不同的比较规则，这只是一种状态VarChar(MAX)。但我不知道是否有人比我有更好/更具技术性的答案，所以我可以在未来更好地应用这一课。

免责声明

不久前我有一个桌子设计的想法，当时对我来说很有意义。在最近的历史中，我意识到我有“过度设计”或花费太多时间试图“过度优化”解决方案的习惯。我假设这是我过度思考解决方案并且会产生额外开销而几乎没有实际收益的情况之一。

问题

假设一个对象（Shipment table例如 a）有某种NOTE varchar(MAX)我们想要跟踪的数据元素。NOTE column有机会将数据推入溢出并显着增加大小（row从而限制rows可以保存在 上的数量page）。据我了解，这会对整个表上各种操作的执行时间产生负面影响。

有没有一个例子，我们应该把它推column到一个单独的独立设备上，ShipmentNote table而不是把它column放在Shipment table. 理论是，如果我们将其推NOTE column入一个单独table的位置，它会保存pageson，Shipment table这使得所有操作都Shipment table可以更好地执行。因为row尺寸更小，现在您可以rows在相同的尺寸上安装更多page。

（请参见下面的架构示例）：

这可能是一个好主意的主要用例是：

• Note column通常超过 8000 个字符（我认为这是我们开始使用额外分页的时候）
• 操作中Note column唯一返回的，SELECT很少或从不用作JOINor的一部分WHERE
• 其余columns的Shipment将被Note定期独立查询（即：我们的大部分操作，不会使用Note，JOIN或者WHERE其他发生columns在“装运”中的情况）

我看到的缺点（除此之外，在使用列Shipment外的表格时可能实际上并没有明显的改进Note）：

• 现在变得不可能（或至少需要 atrigger或其他东西）确保总是有某种价值NOTE（即：因为它现在是单独的child table，我们无法确保它NOTE适用于NOT NULL每个rowShipment
• 现在使用任何操作NOTE都需要额外的努力，因为需要做一个JOIN以确保我们正在使用正确的记录

问题

当从多个关系树创建“子”或“孙子”表时，确保维护“祖父”或“曾祖父”表中的键的最佳实践是什么。

详细信息，因为该问题可能没有意义

我正在尝试建立一个数据库来跟踪我们环境中运行的自动化进程的执行状态。

一般来说，我们有一个“作业”，它触发一个或多个“可执行文件”，这些“可执行文件”可以为一个或多个客户运行任务。然后我们将有 2 个记录表，一个跟踪“作业”何时启动，另一个记录每个“ExecutableCustomer”实例的成功与失败状态。

计划的简化模式如下：

当我们将记录正确到 时JobExecutableCustomerExecutionLog，我想确保与Job.IDvalue 关联的值与与关联的JobExecutionLog.ID值匹配。Job.IDJobExecutableCustomer.ID

通常我会用 aForeign Key但是因为Job.ID不存储在JobExecutableCustomer,JobExecutableCustomerExecutionLog也不JobExecutionLog. 关系是间接的。

例子：

我有 2 个工作，“发送电子邮件”和“发送短信”。“发送电子邮件”启动属于 1 个客户的单个可执行文件。“发送文本消息”有 2 个可执行文件（两者都为同一个客户执行）。我想确保当记录被写入JobExecutableCustomerExecutionLog“发送电子邮件”时，Job.ID关联JobExecutableCustomerExecutionLog.JobExecutableCustomerID和JobExecutableCustomerExecutionLog.JobExecutionLogID（在关系上升之后）实际上属于Job.ID“发送电子邮件”而不是“发送短信”。

正如我所看到的，我有两个选择：

1. 将值从Job.ID所有子表中推入，并使其成为Foreign Key
2. 让另一个过程（Trigger或Indexed View）为我确保关系

我个人不喜欢Job.ID在所有其他子表上推送值的想法，所以我倾向于使用 aTrigger或其他东西来处理它。我不知道这是否是我仅有的两个选择，或者我是否有能力配置“正常”Foreign Key来遍历关系。在某种Cascade或别的什么。

设置

最近，我对返回患者最近使用的处方产品的 SQL 查询进行了优化。原始查询通过 3 个嵌套CTE的 's 处理此问题，并且在迁移到新服务器后性能非常差。我们没有尝试使原始版本与服务器调整或索引更改一起工作，而是使用ROW_NUMBER()分区修改了查询。这使最终输出中大约 215,000 行的查询执行时间从大约 10 分钟缩短到大约 6 秒。

问题

我正在寻找是否有比我重写它的方式更好的方法，因为在我看来，这几乎像是一个 hack。我只是想看看这是否仅仅因为我们的数据集的大小而运作良好，或者这是否真的是一个很好的解决方案。我假设我们宁愿使用某种类型的解决方案，该解决方案利用几个不同JOIN的 s 来找到这种信息，而不是使用ROW_NUMBER()and a CTE。

额外细节

为了这个问题，我将在我们的数据库中省略某些不太理想的细节（复合主键，使用VarChar(1)而不是 aBIT等），以便更好地解决问题的根源。

我们在范围内有 4 个表：

• Patient- 我们只打算从这个表中返回标识列
• OrderHeader- 保存有关包裹的信息，例如它要去的地址。并且是 的父记录OrderDetail。Patient该表通过列绑定PatientID。
• OrderDetail- 建立关系，OrderHeader并Product指明哪些产品在发货时放入实际包装盒中
• Product- 持有产品清单

我们需要一个查询，它为每个患者返回顶部OrderDetail记录，顶部OrderHeader记录，其中Product记录与记录绑定OrderDetail= Product.IsRx1。

不幸的是，我们不能只获得where = 1的MAX值，因为它可能不属于. 我们也不能依赖value ，因为它不能保证有记录，也不能保证那里的任何记录都有 a = 1OrderDetail.IDProduct.IsRxOrderDetail.IDMAXOrderHeader.IDMAXOrderHeader.IDOrderDetailProduct.IsRx

我通过以下查询解决了这个问题：

WITH CTE
(
    PatientID,
    OrderHeaderID,
    OrderDetaillID,
    ProductNDCCode,
    ProductNDCDescription,
    RowNumber
)
AS
(
    SELECT P.ID AS 'PatientID',
    H.ID AS 'OrderHeaderID',
    D.ID AS 'OrderDetaillID',
    P.NDCCode AS 'ProductNDCCode',
    P.NDCDescription AS 'ProductNDCDescription',
    ROW_NUMBER() 
    OVER
    (
    PARTITION BY P.ID
    ORDER BY 
        P.ID ASC, --This part in the ORDER BY may not be needed, I apologize if it is unnecessary
        SH.OrderHdrID DESC, 
        SD.OrderDtlID DESC
    ) AS 'RowNumber'
    FROM Patient P
        INNER JOIN OrderHeader H
            ON P.ID = H.PatientID
        INNER JOIN OrderDetail D
            ON H.ID = D.OrderHeaderID
        INNER JOIN Product PR
            ON PR.ID = D.ProductID
    WHERE PR.IsRx = 1
)
SELECT PatientID,
OrderHeaderID,
OrderDetaillID,
ProductNDCCode,
ProductNDCDescription
FROM CTE
WHERE RowNumber = 1

我可以获得的指导或专业知识将非常有帮助。

我想我已经找到了答案，但我希望能得到一些额外的观点。

假设我们将JOIN两个表放在一个共享列上，然后每个表都有一个不同的表，column我们将对其进行Constant搜索。当我们构建一个index支持查询的时候，对于每个表，我们是想把JOINing放在第column一个还是第Constant column一个？我现在想这是第Constant column一个。当我查看提示此问题的不同查询的查询计划时，它似乎尝试创建每个表的子集，然后将JOIN它们一起创建。而不是JOIN将两个表放在一起并从那里过滤。

EX：在发货且客户处于活动状态的情况下将发货加入客户

SELECT [Columns]
FROM Shipment S
   INNER JOIN Customer C
      ON S.CustomerID = C.CustomerID
WHERE S.IsShipped = 1
AND C.IsActive = 1

我认为要使用的两个最佳索引如下。因为Query Optimizer他们宁愿先扫描第一个，Constant然后再扫描JOIN第二个column，而不是JOIN将两者tables放在一起，然后再过滤constant。

CREATE NONCLUSTERED INDEX [IX_IsActive-CustomerID] ON [dbo].[Customer]
(
    [IsActive] ASC,
    [CustomerID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

CREATE NONCLUSTERED INDEX [IX_IsShipped-CustomerID] ON [dbo].[Shipment]
(
    [IsShipped] ASC,
    [CustomerID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

代替：

CREATE NONCLUSTERED INDEX [IX_CustomerID-IsActive] ON [dbo].[Customer]
(
    [CustomerID] ASC,
    [IsActive] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

CREATE NONCLUSTERED INDEX [IX_CustomerID-IsShipped] ON [dbo].[Shipment]
(
    [CustomerID] ASC,
    [IsShipped] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

那正确吗？

我们有一种情况，不同的客户实际上要求相同的报告，但他们：

1. 不想要所有的列
2. 希望列的顺序与我们自然拥有的顺序不同
3. 希望它们被称为不同于我们存储方式的名称（例如“客户编号”与“客户编号”）

目的是减轻适应这些定制请求所需的工作量。我们目前处于这些基本相同报告的数百个实例的位置（不包括这些表面差异）。我想看看我是否需要Dynamic每组这些基本查询的一个实例，Parameter或者我是否可以parameter通过 1 处理所有可能的集合Stored Procedure。希望也不必拥有一堆特定SSRS RDL文件或SSIS DTSX包的特定实例来处理这些更改。数据将来自Stored Procedure我们需要显示/呈现的数据。

让我们假设我构建了一个Dynamic SQL Command输出看起来像这样的地方：

SELECT
Col1 AS 'Alias1',
Col2 AS 'Alias2',
Col3 AS 'Alias3'
FROM View
WHERE DateCol >= @StartDate
AND DateCol < @EndDate

它是由几个不同的部分使用几个表构建的。下面的表结构是更多的伪代码来理解这些想法，所以请忽略诸如没有声明主键之类的东西......

CREATE TABLE [report].[ReportTemplate]
(
    ID INT NOT NULL, --(Primary Key)
    ReportName VarChar(100) NOT NULL,
    ReportTypeID INT NOT NULL --(FK To report.ReportTemplateType.ID)
)

CREATE TABLE [report].[ReportTemplateType]
(
    ID INT NOT NULL, --(Primary Key)
    Name VarChar(50), --(Unique Constraint)
    BaseCommand VarChar(2000), --Holds FROM and JOIN clauses
    WhereCommand VarChar(2000), --Holds WHERE Clause
    WhereCommandParameters VarChar(2000), --Holds declaration of the parameters
)

CREATE TABLE [report].[ReportTemplateColumnDetails]
(
    ID INT NOT NULL, --(Primary Key)
    ReportTemplateID INT NOT NULL, --(FK to report.ReportTemplate.ID)
    ColumnName VarChar(256) NOT NULL,
    ColumnAlias VarChar(256) NULL, --Have logic handle blank vs NULL values
    ColumnOrder SmallInt NOT NULL
)

+----+-------------------+--------------+
| ID |    ReportName     | ReportTypeID |
+----+-------------------+--------------+
|  1 | Customer 1 Status |            1 |
|  2 | Customer 1 Sales  |            2 |
+----+-------------------+--------------+


+----+--------+-----------------+------------------------------------------------------------------------------+-------------------------------------------------------------------+
| ID |  Name  |   BaseCommand   |                                WhereCondition                                |                     WhereConditionParameters                      |
+----+--------+-----------------+------------------------------------------------------------------------------+-------------------------------------------------------------------+
|  1 | Status | FROM StatusView | WHERE DateCol >= @StartDate AND DateCol < @EndDate                           | @StartDate DATEIME, @EndDate DateTime                             |
|  2 | Sales  | FROM SalesView  | WHERE DateCol >= @StartDate AND DateCol < @EndDate AND Col4 = @TypeParameter | @StartDate DATEIME, @EndDate DateTime, @TypeParameter VarChar(20) |
+----+--------+-----------------+------------------------------------------------------------------------------+-------------------------------------------------------------------+

+----+------------------+------------+-------------+-------------+
| ID | ReportTemplateID | ColumnName | ColumnAlias | ColumnOrder |
+----+------------------+------------+-------------+-------------+
|  1 |                1 | Col1       | Alias1      |           1 |
|  2 |                1 | Col2       | Alias2      |           2 |
|  3 |                1 | Col3       | Alias3      |           3 |
|  4 |                2 | Col4       | Alias1      |           1 |
|  5 |                2 | Col5       | Alias2      |           2 |
|  6 |                2 | Col6       | Alias3      |           3 |
+----+------------------+------------+-------------+-------------+

该命令是使用以下代码构建的：

CREATE PROCEDURE [report].[ExecuteReportTemplate] (@ReportName VarChar(50))
AS
BEGIN
    DECLARE @SQLCommand VarChar(MAX) = 'SELECT ',
            @FirstColumnAdded BIT = 0,
            @BaseCommand VarChar(2000),
            @WhereCondition VarChar(2000),
            @WhereConditionParameters VarChar(2000)

    SELECT @BaseCommand = RTT.BaseCommand,
    @WhereCondition = RTT.WhereCommand, 
    @WhereConditionParameters = RTT.WhereCommandParameters 
    FROM [report].[ReportTemplateType] RTT
        INNER JOIN [report].[ReportTemplate] RT
            ON RTT.ID = RT.ReportTypeID
    WHERE RT.Name = @ReportName

    DECLARE @ColumnName VarChar(256),
            @ColumnAlias VarChar(256)

    DECLARE ColumnCursor CURSOR FOR
    SELECT ColumnName,
    ColumnAlias
    FROM [report].[ReportTemplateColumnDetails]
    ORDER BY ColumnOrder

    FETCH NEXT FROM ColumnCursor INTO @ColumnName, @ColumnAlias

    WHILE (@@FETCH_STATUS = 0)
    BEGIN
        --Add a comma inbetween columns, does not happen on the first one
        IF(@FirstColumnAdded = 1)
        BEGIN
            SET @SQLCommand = @SQLCommand + ', '
        END
        ELSE
        BEGIN
            SET @FirstColumnAdded = 1
        END

        --Adds the column into the list
        SET @SQLCommand = @SQLCommand + @ColumnName

        --If we have been provided an alias, set the alias
        IF(@ColumnAlias IS NULL OR LTRIM(RTRIM(@ColumnAlias)) = '')
        BEGIN
            @SQLCommand = @SQLCommand + 'AS ''' + @ColumnAlias + ''' '
        END
    END

    CLOSE ColumnCursor
    DEALLOCATE ColumnCursor

    --Now Add The Base Command
    SELECT @SQLCommand = @SQLCommand + ' ' + @BaseCommand + ' ' + @WhereCommand

    EXECUTE sp_executesql @sqlCommand, @WhereConditionParameters
        @StartDate = '2019-01-01', 
        @EndDate = GETDATE()
END

有没有办法动态更改配置和传入的参数而无需构建单独的命令？

我希望能够用不同的and填充[report].[ReportTemplateType].[WhereCondition]and 。例如在类似的东西中添加第三个。我知道解决这个问题的唯一方法是创建一个不同的地方，其中所有内容都与上述相同，但我们会将最后一块更改为：[report].[ReportTemplateType].[WhereCondition]WHEREParameterscolumnWHERE conditionCol4 = @TypeParameterStored ProcedureStored Procedure

EXECUTE sp_executesql @sqlCommand, @WhereConditionParameters
        @StartDate = '2019-01-01', 
        @EndDate = GETDATE(),
        @TypeParameter = 'SomeStringValue'

有没有办法动态更改配置和传入的参数而无需构建单独的命令？

问题

我有一个查询，它输出一个column，通过一系列CASE语句创建。这同样column被用作同一语句中CASE第二个逻辑的一部分。columnSELECT

如果我要构建一个CTE应用了内部逻辑的 a，那么当我以后必须将其用作决策时，我可以参考内部逻辑。总体额外开销是多少？

据我了解，并没有增加任何真正的开销。（下面是我使用的一些研究和一个简单的测试用例）。是否有文章谈论这一点或情况并非如此？

研究和简单的测试用例

我发现有几篇文章没有指出这个特定问题，而是将我发送到没有增加运营开销的方向。

• https://www.scarydba.com/2016/07/18/common-table-expression-just-a-name/
• https://www.sqlshack.com/why-is-my-cte-so-slow/

我针对我们现有的一个数据库写了一个小查询来测试这个理论。结果和执行时间相同，以及 Thestatistics和Query Execution Plan.

Code，Execution Plan对于Statistics非CTE版本：

SELECT PC.CompanyID,
PC.ClientID,
PC.ProgramID,
PC.PatientID,
PC.CaseID,
CASE
    WHEN PFH.FulFilHdrCreateDateTime IS NULL
        THEN PC.CaseCreateDateTime
    ELSE
        PFH.FulFilHdrCreateDateTime
    END AS [ImportantDate],
DATEDIFF(Day, CASE WHEN PFH.FulFilHdrCreateDateTime IS NULL THEN PC.CaseCreateDateTime ELSE PFH.FulFilHdrCreateDateTime END, GETDATE())
FROM PATIENTCASES PC
    LEFT OUTER JOIN PATFULFILLMENTHEADER PFH
        ON PFH.CompanyID = PC.CompanyID
        AND PFH.ClientID = PC.ClientID
        AND PFH.ProgramID = PC.ProgramID
        AND PFH.PatientID = PC.PatientID
        AND PFH.CaseID = PC.CaseID
        AND PFH.FulFilHdrID = (SELECT TOP(1) temp.FulFilHdrID
                                FROM PATFULFILLMENTHEADER temp
                                WHERE temp.CompanyID = PC.CompanyID
                                AND temp.ClientID = PC.ClientID
                                AND temp.ProgramID = PC.ProgramID
                                AND temp.PatientID = PC.PatientID
                                AND temp.CaseID = PC.CaseID
                                ORDER BY temp.FulFilHdrID
                            )
WHERE PC.CompanyID = 'RxCRoads'

+---------------------------------------------------------+----------+
| Query Profile Statistics                                |          |
|   Number of INSERT, DELETE and UPDATE statements        | 0        |
|   Rows affected by INSERT, DELETE, or UPDATE statements | 0        |
|   Number of SELECT statements                           | 2        |
|   Rows returned by SELECT statements                    | 2880384  |
|   Number of transactions                                | 0        |
| Network Statistics                                      |          |
|   Number of server roundtrips                           | 3        |
|   TDS packets sent from client                          | 3        |
|   TDS packets received from server                      | 38523    |
|   Bytes sent from client                                | 2128     |
|   Bytes received from server                            | 157781300|
| Time Statistics                                         |          |
|   Client processing time                                | 10158    |
|   Total execution time                                  | 10158    |
|   Wait time on server replies                           | 0        |
+---------------------------------------------------------+----------+

Code，对于Execution PlanCTEStatistics版本：

WITH CTE (CompanyID, ClientID, ProgramID, PatientID, CaseID, ImportantDate)
AS
(
    SELECT PC.CompanyID,
    PC.ClientID,
    PC.ProgramID,
    PC.PatientID,
    PC.CaseID,
    CASE
        WHEN PFH.FulFilHdrCreateDateTime IS NULL
            THEN PC.CaseCreateDateTime
        ELSE
            PFH.FulFilHdrCreateDateTime
        END AS [ImportantDate]
    FROM PATIENTCASES PC
        LEFT OUTER JOIN PATFULFILLMENTHEADER PFH
            ON PFH.CompanyID = PC.CompanyID
            AND PFH.ClientID = PC.ClientID
            AND PFH.ProgramID = PC.ProgramID
            AND PFH.PatientID = PC.PatientID
            AND PFH.CaseID = PC.CaseID
            AND PFH.FulFilHdrID = (SELECT TOP(1) temp.FulFilHdrID
                                    FROM PATFULFILLMENTHEADER temp
                                    WHERE temp.CompanyID = PC.CompanyID
                                    AND temp.ClientID = PC.ClientID
                                    AND temp.ProgramID = PC.ProgramID
                                    AND temp.PatientID = PC.PatientID
                                    AND temp.CaseID = PC.CaseID
                                    ORDER BY temp.FulFilHdrID
                                )
)
SELECT CompanyID, 
ClientID, 
ProgramID, 
PatientID, 
CaseID, 
ImportantDate,
DATEDIFF(Day, [ImportantDate], GETDATE())
FROM CTE
WHERE CompanyID = 'RxCRoads'

+---------------------------------------------------------+-----------+
| Query Profile Statistics                                |           |
|   Number of INSERT, DELETE and UPDATE statements        |         0 |
|   Rows affected by INSERT, DELETE, or UPDATE statements |         0 |
|   Number of SELECT statements                           |         2 |
|   Rows returned by SELECT statements                    |   2880383 |
|   Number of transactions                                |         0 |
| Network Statistics                                      |           |
|   Number of server roundtrips                           |         3 |
|   TDS packets sent from client                          |         3 |
|   TDS packets received from server                      |     38523 |
|   Bytes sent from client                                |      2348 |
|   Bytes received from server                            | 157781800 |
| Time Statistics                                         |           |
|   Client processing time                                |      9985 |
|   Total execution time                                  |      9985 |
|   Wait time on server replies                           |         0 |
+---------------------------------------------------------+-----------+

我们正在为新应用程序构建数据库。我从架构师那里得到了一些反馈，他在某处读到，首先将所有不可为空的列放在一个表中，然后是所有可空的列，这对内存利用率有好处。如果在不可空列之间存在可空列，则某种内存或存储优势将被丧失，因为这些可空列位于不可空列之间。

这些列的排序有点模糊，但一般来说，它优先用于更有可能首先使用的列。

我的印象是 SSMS 按其自己的逻辑而不是它们在表上创建的特定顺序对页面文件上的列进行排序。我将列放在表中的顺序完全独立于数据在页面文件中的存储方式。

是否有任何文件可以支持这一发现/理解？

编辑：

围绕弄清楚这个想法的来源进行了更多的对话。该请求过度简化了具有高密度数据或表中最常用的列SELECT或JOIN操作的列，以防止它们移动到页面文件的溢出部分。

分配给表的列的顺序与将数据添加到页面文件的顺序相同。对于给定的行，数据按照列在表中设置的顺序存储在页面文件中。如果该行包含的数据多于页面文件允许的数据（假设我们没有使用任何会进入 LOBIMAGE或VARCHAR(MAX)类似的东西），那么剩余部分将被放入溢出文件。如果需要该溢出数据，则需要花费额外的精力和时间来查找该溢出文件。这可能会对高行环境中的性能产生显着影响（10 或 100 的数百万行 +）。因此，我们希望按照我们认为该列将被访问的频率来确定列顺序的优先级，不一定是是否访问NULL。

这种理解/分析听起来对吗？

这个问题是我之前问过的一个问题的延伸。 使用联合时表锁定

对于我们正在使用的相同查询，导致阻塞了这些UNIONSCTE 查询中使用的各种查询。

例如：

CREATE TABLE #TempTable (
    [Columns]
)

WITH CTE1 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE2 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE3 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE4 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE5 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE6 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
),
CTE7 (Columns)
(
    Select [Columns] FROM [Tables] WHERE [WHERE-Condition]
)

INSERT INTO #TempTable
SELECT * FROM CTE1
UNION
SELECT * FROM CTE2
UNION
SELECT * FROM CTE3
UNION
SELECT * FROM CTE4
UNION
SELECT * FROM CTE5
UNION
SELECT * FROM CTE6 WHERE [Where-Condition]
UNION
SELECT * FROM CTE7

假设这个特定场景（并且我们没有声明任何显式事务）物理表锁定结构是否会改变，因为我们正在使用 CTE 查询？

当SELECTfor CTE1 作为 的一部分完成时UNION，物理表是否仍处于锁定状态或是否仍处于释放状态？

根据我上一个问题的答案，我的印象是，在各种语句中的一个完成UNION时，表被释放。那是不正确的吗？SELECTSELECT

我们没有修改此事务的隔离级别。据我了解，这意味着我们正在使用READ_COMMITTED. 这个问题仍然适用，只有 2 个SELECT陈述。我试图了解此功能的工作原理。我正在使用的特定查询使用 7，这是我指定 7 的唯一原因。

当在 a 中使用多个选择时，是单独处理UNION/UNION ALL每个单独SELECT语句的表锁，还是持有所有表锁直到所有SELECT语句完成？

例如，100 个单独的 select 语句通过 连接在一起UNION/UNION ALL。（假设它们是按顺序解析的）如果事务中的第一个SELECT事务已完成，而不同会话中的另一个事务试图访问相同的数据，数据是否仍被锁定UNION？

我只是想了解在UNIONs物理表仍在执行时它们的行为方式。

UNION对于提示此问题的查询， (Not UNION ALL)中有 7 个不同的语句。对于这个特定的问题，我只是想了解其UNION/UNION ALL工作原理的后端架构。提示这个问题的查询会导致很多阻塞，但只运行了大约一分钟，所以我试图了解是整个查询导致了它还是只是几个单独的部分。

我在这里添加了一个后续问题：Backend Table/Row Locking Structure using CTE Queries

我们希望使用 SQL Server 2012 中的 SQL MERGE 语句来处理数据仓库的数据复制，我们可以从我们用于数据输入的第 3 方应用程序的制造商处访问该数据仓库。

数据仓库的来源是 Oracle 环境，我们使用 SQL 连接器在我们的环境中引用 Oracle 数据库作为链接服务器。数据在每晚一次的转储中加载/更新到 Oracle 数据源中。

由于我们在事务和快照复制中看到的不可靠性/不稳定性，我们正在查看 MERGE 语句。

下面是进行合并的表结构：

    CREATE TABLE [dbo].[FACT_WIP_2](
    [WIP_KEY] [float] NOT NULL,
    [PATIENT_KEY] [float] NULL,
    [PHARMACY_KEY] [float] NULL,
    [LINE_PHARM_KEY] [float] NULL,
    [DELIVERY_ADDRESS_KEY] [float] NULL,
    [INVENTORY_TYPE_KEY] [float] NULL,
    [PHYSICIAN_LOCATION_KEY] [float] NULL,
    [PRIMARY_ORIGINAL_INS_PLAN_KEY] [float] NULL,
    [PRIMARY_INSURANCE_PLAN_KEY] [float] NULL,
    [REFERRAL_PRIORITY_KEY] [float] NULL,
    [REIMBURSEMENT_STATUS_REF_KEY] [float] NULL,
    [REIMBURSEMENT_STATUS_STAGE_KEY] [float] NULL,
    [REFERRAL_SOURCE_TYPE_KEY] [float] NULL,
    [REFERRAL_START_DATE_KEY] [float] NULL,
    [STAGE_START_DATE_KEY] [float] NULL,
    [STAGE_END_DATE_KEY] [float] NULL,
    [ASSIGNED_EMPLOYEE_KEY] [float] NULL,
    [REFERRAL_COMPLETION_DATE_KEY] [float] NULL,
    [REFERRAL_CYCLE_KEY] [float] NULL,
    [SHIP_DATE_KEY] [float] NULL,
    [SHIP_MODE_KEY] [float] NULL,
    [PLACE_OF_SERVICE_KEY] [float] NULL,
    [REF_BUSINESS_DRIVERS_KEY] [float] NULL,
    [REF_OUTCOME_STATUS_KEY] [float] NULL,
    [STAGE_OUTCOME_STATUS_KEY] [float] NULL,
    [REF_REFERENCE_CATEGORY_KEY] [float] NULL,
    [THERAPY_GROUP_KEY] [float] NULL,
    [FORWARD_REASON_KEY] [float] NULL,
    [FORWARDED_TO_PHARMACY_KEY] [float] NULL,
    [IMAGE_RECEIPT_DATE_KEY] [float] NULL,
    [DATA_SOURCE_KEY] [float] NULL,
    [ORDER_START_DATE_KEY] [float] NULL,
    [DRUG_KEY] [float] NULL,
    [WORK_STAGE_KEY] [float] NULL,
    [REFERRAL_NEED_DATE_KEY] [float] NULL,
    [ORDER_NEED_DATE_KEY] [float] NULL,
    [WIP_TYPE] [varchar](1) NULL,
    [REFERRAL_ID] [varchar](32) NULL,
    [REFERRAL_LINE_NUM] [float] NULL,
    [ORDER_ID] [varchar](150) NULL,
    [ORDER_LINE_NUM] [float] NULL,
    [DIAGNOSIS_CODE] [varchar](10) NULL,
    [DIAGNOSIS_DESCRIPTION] [varchar](40) NULL,
    [QTY_WRITTEN] [float] NULL,
    [METRIC_QTY] [float] NULL,
    [DELETED_VOID_INDICATOR] [varchar](1) NULL,
    [DAY_SUPPLY] [float] NULL,
    [PROFILED_RX_INDICATOR] [numeric](1, 0) NULL,
    [PAT_PRIMARY_INS_CARDHOLDER_ID] [varchar](20) NULL,
    [PAT_PRIMARY_INS_EMPLOYER] [varchar](30) NULL,
    [PAT_PRIMARY_INS_GROUP_NUMBER] [varchar](30) NULL,
    [RX_NUMBER] [float] NULL,
    [REFILL_NUMBER] [float] NULL,
    [REFERRAL_START_TIMESTAMP] [datetime] NULL,
    [STAGE_START_TIMESTAMP] [datetime] NULL,
    [STAGE_END_TIMESTAMP] [datetime] NULL,
    [WORK_STAGE_ASSIGN_STATUS] [varchar](10) NULL,
    [REFERRAL_COMPLETION_TIMESTAMP] [datetime] NULL,
    [ORDER_START_TIMESTAMP] [datetime] NULL,
    [PRIOR_AUTH_APPEAL_INDICATOR] [varchar](20) NULL,
    [BV_MISSING_INFO_INDICATOR] [numeric](1, 0) NULL,
    [ORDER_COMPLETION_TIMESTAMP] [datetime] NULL,
    [SUPPLY_ITEM_INDICATOR] [numeric](1, 0) NULL,
    [FORWARDED_REFERRAL_INDICATOR] [numeric](1, 0) NULL,
    [NOGO_INDICATOR] [numeric](1, 0) NULL,
    [CREATE_UPDATE_DATE] [datetime] NULL,
    [ORDER_STATUS] [varchar](50) NULL,
    [REFERRAL_STATUS] [varchar](50) NULL,
    [VIRTUAL_STAGE_OUTCOME] [varchar](40) NULL,
    [VIRTUAL_STAGE_OUTCOME_REASON] [varchar](40) NULL,
    [UNIQUE_ID] [varchar](250) NULL,
    [STAGED_DATE_TIMESTAMP] [datetime] NULL,
    [REWORK_COUNT] [float] NULL,
 CONSTRAINT [MSHREPL_290_PK_2] PRIMARY KEY CLUSTERED 
    (
        [WIP_KEY] ASC
    )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
    ) ON [PRIMARY]

这是我们用来完成合并的查询：

MERGE FACT_WIP_2 AS S
USING RXCSMAP..SMA.FACT_WIP AS O
ON (S.WIP_KEY = O.WIP_KEY)
WHEN MATCHED
AND O.CREATE_UPDATE_DATE > @DateToStartLooking
AND O.CREATE_UPDATE_DATE <> S.CREATE_UPDATE_DATE
THEN
UPDATE 
SET 
S.PATIENT_KEY = O.PATIENT_KEY,
S.PHARMACY_KEY = O.PHARMACY_KEY,
S.LINE_PHARM_KEY = O.LINE_PHARM_KEY,
S.DELIVERY_ADDRESS_KEY = O.DELIVERY_ADDRESS_KEY,
S.INVENTORY_TYPE_KEY = O.INVENTORY_TYPE_KEY,
S.PHYSICIAN_LOCATION_KEY = O.PHYSICIAN_LOCATION_KEY,
S.PRIMARY_ORIGINAL_INS_PLAN_KEY = O.PRIMARY_ORIGINAL_INS_PLAN_KEY,
S.PRIMARY_INSURANCE_PLAN_KEY = O.PRIMARY_INSURANCE_PLAN_KEY,
S.REFERRAL_PRIORITY_KEY = O.REFERRAL_PRIORITY_KEY,
S.REIMBURSEMENT_STATUS_REF_KEY = O.REIMBURSEMENT_STATUS_REF_KEY,
S.REIMBURSEMENT_STATUS_STAGE_KEY = O.REIMBURSEMENT_STATUS_STAGE_KEY,
S.REFERRAL_SOURCE_TYPE_KEY = O.REFERRAL_SOURCE_TYPE_KEY,
S.REFERRAL_START_DATE_KEY = O.REFERRAL_START_DATE_KEY,
S.STAGE_START_DATE_KEY = O.STAGE_START_DATE_KEY,
S.STAGE_END_DATE_KEY = O.STAGE_END_DATE_KEY,
S.ASSIGNED_EMPLOYEE_KEY = O.ASSIGNED_EMPLOYEE_KEY,
S.REFERRAL_COMPLETION_DATE_KEY = O.REFERRAL_COMPLETION_DATE_KEY,
S.REFERRAL_CYCLE_KEY = O.REFERRAL_CYCLE_KEY,
S.SHIP_DATE_KEY = O.SHIP_DATE_KEY,
S.SHIP_MODE_KEY = O.SHIP_MODE_KEY,
S.PLACE_OF_SERVICE_KEY = O.PLACE_OF_SERVICE_KEY,
S.REF_BUSINESS_DRIVERS_KEY = O.REF_BUSINESS_DRIVERS_KEY,
S.REF_OUTCOME_STATUS_KEY = O.REF_OUTCOME_STATUS_KEY,
S.STAGE_OUTCOME_STATUS_KEY = O.STAGE_OUTCOME_STATUS_KEY,
S.REF_REFERENCE_CATEGORY_KEY = O.REF_REFERENCE_CATEGORY_KEY,
S.THERAPY_GROUP_KEY = O.THERAPY_GROUP_KEY,
S.FORWARD_REASON_KEY = O.FORWARD_REASON_KEY,
S.FORWARDED_TO_PHARMACY_KEY = O.FORWARDED_TO_PHARMACY_KEY,
S.IMAGE_RECEIPT_DATE_KEY = O.IMAGE_RECEIPT_DATE_KEY,
S.DATA_SOURCE_KEY = O.DATA_SOURCE_KEY,
S.ORDER_START_DATE_KEY = O.ORDER_START_DATE_KEY,
S.DRUG_KEY = O.DRUG_KEY,
S.WORK_STAGE_KEY = O.WORK_STAGE_KEY,
S.REFERRAL_NEED_DATE_KEY = O.REFERRAL_NEED_DATE_KEY,
S.ORDER_NEED_DATE_KEY = O.ORDER_NEED_DATE_KEY,
S.WIP_TYPE = O.WIP_TYPE,
S.REFERRAL_ID = O.REFERRAL_ID,
S.REFERRAL_LINE_NUM = O.REFERRAL_LINE_NUM,
S.ORDER_ID = O.ORDER_ID,
S.ORDER_LINE_NUM = O.ORDER_LINE_NUM,
S.DIAGNOSIS_CODE = O.DIAGNOSIS_CODE,
S.DIAGNOSIS_DESCRIPTION = O.DIAGNOSIS_DESCRIPTION,
S.QTY_WRITTEN = O.QTY_WRITTEN,
S.METRIC_QTY = O.METRIC_QTY,
S.DELETED_VOID_INDICATOR = O.DELETED_VOID_INDICATOR,
S.DAY_SUPPLY = O.DAY_SUPPLY,
S.PROFILED_RX_INDICATOR = O.PROFILED_RX_INDICATOR,
S.PAT_PRIMARY_INS_CARDHOLDER_ID = O.PAT_PRIMARY_INS_CARDHOLDER_ID,
S.PAT_PRIMARY_INS_EMPLOYER = O.PAT_PRIMARY_INS_EMPLOYER,
S.PAT_PRIMARY_INS_GROUP_NUMBER = O.PAT_PRIMARY_INS_GROUP_NUMBER,
S.RX_NUMBER = O.RX_NUMBER,
S.REFILL_NUMBER = O.REFILL_NUMBER,
S.REFERRAL_START_TIMESTAMP = O.REFERRAL_START_TIMESTAMP,
S.STAGE_START_TIMESTAMP = O.STAGE_START_TIMESTAMP,
S.STAGE_END_TIMESTAMP = O.STAGE_END_TIMESTAMP,
S.WORK_STAGE_ASSIGN_STATUS = O.WORK_STAGE_ASSIGN_STATUS,
S.REFERRAL_COMPLETION_TIMESTAMP = O.REFERRAL_COMPLETION_TIMESTAMP,
S.ORDER_START_TIMESTAMP = O.ORDER_START_TIMESTAMP,
S.PRIOR_AUTH_APPEAL_INDICATOR = O.PRIOR_AUTH_APPEAL_INDICATOR,
S.BV_MISSING_INFO_INDICATOR = O.BV_MISSING_INFO_INDICATOR,
S.ORDER_COMPLETION_TIMESTAMP = O.ORDER_COMPLETION_TIMESTAMP,
S.SUPPLY_ITEM_INDICATOR = O.SUPPLY_ITEM_INDICATOR,
S.FORWARDED_REFERRAL_INDICATOR = O.FORWARDED_REFERRAL_INDICATOR,
S.NOGO_INDICATOR = O.NOGO_INDICATOR,
S.CREATE_UPDATE_DATE = O.CREATE_UPDATE_DATE,
S.ORDER_STATUS = O.ORDER_STATUS,
S.REFERRAL_STATUS = O.REFERRAL_STATUS,
S.VIRTUAL_STAGE_OUTCOME = O.VIRTUAL_STAGE_OUTCOME,
S.VIRTUAL_STAGE_OUTCOME_REASON = O.VIRTUAL_STAGE_OUTCOME_REASON,
S.UNIQUE_ID = O.UNIQUE_ID,
S.STAGED_DATE_TIMESTAMP = O.STAGED_DATE_TIMESTAMP,
S.REWORK_COUNT = O.REWORK_COUNT
--When no records are matched, insert
--the incoming records from Oracle Table
--to our SQL environment table
WHEN NOT MATCHED BY TARGET THEN
INSERT 
(
    WIP_KEY,
    PATIENT_KEY,
    PHARMACY_KEY,
    LINE_PHARM_KEY,
    DELIVERY_ADDRESS_KEY,
    INVENTORY_TYPE_KEY,
    PHYSICIAN_LOCATION_KEY,
    PRIMARY_ORIGINAL_INS_PLAN_KEY,
    PRIMARY_INSURANCE_PLAN_KEY,
    REFERRAL_PRIORITY_KEY,
    REIMBURSEMENT_STATUS_REF_KEY,
    REIMBURSEMENT_STATUS_STAGE_KEY,
    REFERRAL_SOURCE_TYPE_KEY,
    REFERRAL_START_DATE_KEY,
    STAGE_START_DATE_KEY,
    STAGE_END_DATE_KEY,
    ASSIGNED_EMPLOYEE_KEY,
    REFERRAL_COMPLETION_DATE_KEY,
    REFERRAL_CYCLE_KEY,
    SHIP_DATE_KEY,
    SHIP_MODE_KEY,
    PLACE_OF_SERVICE_KEY,
    REF_BUSINESS_DRIVERS_KEY,
    REF_OUTCOME_STATUS_KEY,
    STAGE_OUTCOME_STATUS_KEY,
    REF_REFERENCE_CATEGORY_KEY,
    THERAPY_GROUP_KEY,
    FORWARD_REASON_KEY,
    FORWARDED_TO_PHARMACY_KEY,
    IMAGE_RECEIPT_DATE_KEY,
    DATA_SOURCE_KEY,
    ORDER_START_DATE_KEY,
    DRUG_KEY,
    WORK_STAGE_KEY,
    REFERRAL_NEED_DATE_KEY,
    ORDER_NEED_DATE_KEY,
    WIP_TYPE,
    REFERRAL_ID,
    REFERRAL_LINE_NUM,
    ORDER_ID,
    ORDER_LINE_NUM,
    DIAGNOSIS_CODE,
    DIAGNOSIS_DESCRIPTION,
    QTY_WRITTEN,
    METRIC_QTY,
    DELETED_VOID_INDICATOR,
    DAY_SUPPLY,
    PROFILED_RX_INDICATOR,
    PAT_PRIMARY_INS_CARDHOLDER_ID,
    PAT_PRIMARY_INS_EMPLOYER,
    PAT_PRIMARY_INS_GROUP_NUMBER,
    RX_NUMBER,
    REFILL_NUMBER,
    REFERRAL_START_TIMESTAMP,
    STAGE_START_TIMESTAMP,
    STAGE_END_TIMESTAMP,
    WORK_STAGE_ASSIGN_STATUS,
    REFERRAL_COMPLETION_TIMESTAMP,
    ORDER_START_TIMESTAMP,
    PRIOR_AUTH_APPEAL_INDICATOR,
    BV_MISSING_INFO_INDICATOR,
    ORDER_COMPLETION_TIMESTAMP,
    SUPPLY_ITEM_INDICATOR,
    FORWARDED_REFERRAL_INDICATOR,
    NOGO_INDICATOR,
    CREATE_UPDATE_DATE,
    ORDER_STATUS,
    REFERRAL_STATUS,
    VIRTUAL_STAGE_OUTCOME,
    VIRTUAL_STAGE_OUTCOME_REASON,
    UNIQUE_ID,
    STAGED_DATE_TIMESTAMP,
    REWORK_COUNT
)
VALUES
(
    O.WIP_KEY,
    O.PATIENT_KEY,
    O.PHARMACY_KEY,
    O.LINE_PHARM_KEY,
    O.DELIVERY_ADDRESS_KEY,
    O.INVENTORY_TYPE_KEY,
    O.PHYSICIAN_LOCATION_KEY,
    O.PRIMARY_ORIGINAL_INS_PLAN_KEY,
    O.PRIMARY_INSURANCE_PLAN_KEY,
    O.REFERRAL_PRIORITY_KEY,
    O.REIMBURSEMENT_STATUS_REF_KEY,
    O.REIMBURSEMENT_STATUS_STAGE_KEY,
    O.REFERRAL_SOURCE_TYPE_KEY,
    O.REFERRAL_START_DATE_KEY,
    O.STAGE_START_DATE_KEY,
    O.STAGE_END_DATE_KEY,
    O.ASSIGNED_EMPLOYEE_KEY,
    O.REFERRAL_COMPLETION_DATE_KEY,
    O.REFERRAL_CYCLE_KEY,
    O.SHIP_DATE_KEY,
    O.SHIP_MODE_KEY,
    O.PLACE_OF_SERVICE_KEY,
    O.REF_BUSINESS_DRIVERS_KEY,
    O.REF_OUTCOME_STATUS_KEY,
    O.STAGE_OUTCOME_STATUS_KEY,
    O.REF_REFERENCE_CATEGORY_KEY,
    O.THERAPY_GROUP_KEY,
    O.FORWARD_REASON_KEY,
    O.FORWARDED_TO_PHARMACY_KEY,
    O.IMAGE_RECEIPT_DATE_KEY,
    O.DATA_SOURCE_KEY,
    O.ORDER_START_DATE_KEY,
    O.DRUG_KEY,
    O.WORK_STAGE_KEY,
    O.REFERRAL_NEED_DATE_KEY,
    O.ORDER_NEED_DATE_KEY,
    O.WIP_TYPE,
    O.REFERRAL_ID,
    O.REFERRAL_LINE_NUM,
    O.ORDER_ID,
    O.ORDER_LINE_NUM,
    O.DIAGNOSIS_CODE,
    O.DIAGNOSIS_DESCRIPTION,
    O.QTY_WRITTEN,
    O.METRIC_QTY,
    O.DELETED_VOID_INDICATOR,
    O.DAY_SUPPLY,
    O.PROFILED_RX_INDICATOR,
    O.PAT_PRIMARY_INS_CARDHOLDER_ID,
    O.PAT_PRIMARY_INS_EMPLOYER,
    O.PAT_PRIMARY_INS_GROUP_NUMBER,
    O.RX_NUMBER,
    O.REFILL_NUMBER,
    O.REFERRAL_START_TIMESTAMP,
    O.STAGE_START_TIMESTAMP,
    O.STAGE_END_TIMESTAMP,
    O.WORK_STAGE_ASSIGN_STATUS,
    O.REFERRAL_COMPLETION_TIMESTAMP,
    O.ORDER_START_TIMESTAMP,
    O.PRIOR_AUTH_APPEAL_INDICATOR,
    O.BV_MISSING_INFO_INDICATOR,
    O.ORDER_COMPLETION_TIMESTAMP,
    O.SUPPLY_ITEM_INDICATOR,
    O.FORWARDED_REFERRAL_INDICATOR,
    O.NOGO_INDICATOR,
    O.CREATE_UPDATE_DATE,
    O.ORDER_STATUS,
    O.REFERRAL_STATUS,
    O.VIRTUAL_STAGE_OUTCOME,
    O.VIRTUAL_STAGE_OUTCOME_REASON,
    O.UNIQUE_ID,
    O.STAGED_DATE_TIMESTAMP,
    O.REWORK_COUNT
)
--When there is a row that exists in our SQL table and
--same record does not exist in Oracle table
--then delete this record from our SQL table
WHEN NOT MATCHED BY SOURCE
THEN
DELETE;

这是执行计划：

我们可以为查询配置或表结构（索引、统计信息等）做出哪些选择来尝试优化此过程？