查询性能：CTE 使用 ROW_NUMBER() 到 select 第一行

Question

We have three environments and when I run my SQL query in two of them just takes 30 or 38 seconds to run but in the other environment running is not completed and I should cancel it. Query is based on two parts, a CTE and a very simple select from a table, in both CTE and select I'm using the same table.

Could you please tell me why it takes so long time? how can I improve the query?

ALTER VIEW [fact].[vPurchase] 
AS
    WITH VKPL AS 
    (
        SELECT * 
        FROM
            (SELECT 
                 iv.[Delivery_FK],
                 1 AS column2,
                 ROW_NUMBER() OVER(PARTITION BY [Delivery_FK] ORDER BY iv.UpdateDate) AS rk     
             FROM 
                 [fact].[KRMFact] iv   
             LEFT JOIN 
                 [dimension].[Product] pr ON iv.Product_FK =pr.Product_SK
             LEFT JOIN 
                 [dimension].[Delivery] le ON le.Delivery_FK = iv.Delivery_FK 
             WHERE 
                 pr.Product_Key = '740') X
        WHERE 
            rk = 1
    )
    SELECT 
         -- ....  here are some columns
         Delivery_FK,
         Product_FK,
         CAST(column2 AS VARCHAR) AS column2,
         f.[UpdateDate] AS [Update date]
     FROM 
         [fact].[KRMFact] f
     LEFT JOIN 
         VKPL v ON f.Delivery_FK = v.Delivery_FK

Answer 1

This is guesswork.

1. I guess the environment where this query is slow is the one with lots of production data in it.

2. I guess some index on your KRMFact table will, maybe, help you. Here's how to figure out what you need: SQL Server Management Studio (SSMS) has a feature to show you a query's execution plan. Put your query ( not simplified, please, the actual query ) into SSMS, right click and choose "Include Actual Execution Plan." Then run the query. The execution plan display may recommend an index for you to create to get this query to run faster.

3. I guess you're trying to find rows with the earliest values of UpdateDate .

Your subquery

SELECT * 
  FROM
      (SELECT 
              iv.[Delivery_FK],
              1 AS column2,
              ROW_NUMBER() OVER(PARTITION BY [Delivery_FK] ORDER BY iv.UpdateDate) AS rk     
        FROM 
              [fact].[KRMFact] iv   
        LEFT JOIN 
             [dimension].[Product] pr ON iv.Product_FK =pr.Product_SK
        LEFT JOIN 
             [dimension].[Delivery] le ON le.Delivery_FK = iv.Delivery_FK 
       WHERE 
             pr.Product_Key = '740') X
 WHERE 
       rk = 1

looks like it picks out the row with the earliest KRMFact.UpdateDate for each value of KRMFact.Delivery_FK . That's what the ROW_NUMBER() OVER... WHERE rk=1 language does.

If my guess about that is correct you can do that a different way, which may be more efficient.

SELECT * 
  FROM
      (SELECT 
              iv.[Delivery_FK],
              1 AS column2,
              1 AS rk
        FROM 
              [fact].[KRMFact] iv   
        JOIN (   SELECT Delivery_FK, MIN(UpdateDate) first_update
                   FROM [fact].[KRMFact]
                 GROUP BY Delivery_FK
             ) first_update ON iv.UpdateDate = first_update.first_update
        LEFT JOIN 
             [dimension].[Product] pr ON iv.Product_FK =pr.Product_SK
        LEFT JOIN 
             [dimension].[Delivery] le ON le.Delivery_FK = iv.Delivery_FK 
       WHERE 
             pr.Product_Key = '740') X
 WHERE 
       rk = 1

You should probably try out the old and new versions of the subquery to determine whether they will yield the same results.

If you use this subquery query I suggest, this index will help make it run faster by optimizing the new sub-sub-query's MIN()... GROUP BY operation.

CREATE INDEX x_KRMFact_Product_Update 
          ON [fact].[KRMFact]
             ([Product_FK],[UpdateDate])

By the way, WHERE pr.Product_Key = '740' turns your LEFT JOIN [dimension].[Product] operation into an ordinary inner JOIN.