查找与最小值/最大值关联的行，没有内部循环

Question

我有一个关于 T-SQL 和 SQL Server 的问题。

假设我有一个包含 2 列的表 Orders：

• ProductId int
• CustomerId int
• 日期日期时间

我想要每个产品的第一个订单的日期，所以我执行这种类型的查询：

SELECT ProductId, MIN(Date) AS FirstOrder 
FROM Orders
GROUP BY ProductId

我在ProductId 上有一个索引，包括CustomerId 和Date 列以加快查询速度(IX_Orders)。查询计划看起来像是对IX_Orders 的非聚集索引扫描，然后是流聚合（由于索引没有排序）。

现在我的问题是我还想检索与每个产品的第一个订单关联的CustomerId（产品 26 是在 25 日星期二由客户 12 首次订购的）。棘手的部分是我不希望在执行计划中有任何内部循环，因为这意味着表中每个ProductId 的额外读取，效率非常低。

这应该可以使用相同的非聚集索引扫描，然后是流聚合，但是我似乎找不到可以做到这一点的查询。有什么想法吗？

谢谢

Answer 1

这将处理具有重复日期的产品：

DECLARE @Orders table (ProductId int
                      ,CustomerId int
                      ,Date datetime
                      )

INSERT INTO @Orders VALUES (1,1,'20090701')
INSERT INTO @Orders VALUES (2,1,'20090703')
INSERT INTO @Orders VALUES (3,1,'20090702')
INSERT INTO @Orders VALUES (1,2,'20090704')
INSERT INTO @Orders VALUES (4,2,'20090701')
INSERT INTO @Orders VALUES (1,3,'20090706')
INSERT INTO @Orders VALUES (2,3,'20090704')
INSERT INTO @Orders VALUES (4,3,'20090702')
INSERT INTO @Orders VALUES (5,5,'20090703')  --duplicate dates for product #5
INSERT INTO @Orders VALUES (5,1,'20090703')  --duplicate dates for product #5
INSERT INTO @Orders VALUES (5,5,'20090703')  --duplicate dates for product #5

;WITH MinOrders AS
(SELECT
     o.ProductId, o.CustomerId, o.Date
         ,row_number() over(partition by o.ProductId order by o.ProductId,o.CustomerId) AS RankValue
     FROM @Orders o
     INNER JOIN (SELECT
                     ProductId
                         ,MIN(Date) MinDate 
                     FROM @Orders 
                     GROUP BY ProductId
                ) dt ON o.ProductId=dt.ProductId AND o.Date=dt.MinDate
 )
SELECT
    m.ProductId, m.CustomerId, m.Date
    FROM MinOrders  m
    WHERE m.RankValue=1
    ORDER BY m.ProductId, m.CustomerId

这将返回相同的结果，只需使用与上述代码相同的声明和插入：

;WITH MinOrders AS
(SELECT
     o.ProductId, o.CustomerId, o.Date
         ,row_number() over(partition by o.ProductId order by o.ProductId,o.CustomerId) AS RankValue
     FROM @Orders o
 )
SELECT
    m.ProductId, m.CustomerId, m.Date
    FROM MinOrders  m
    WHERE m.RankValue=1
    ORDER BY m.ProductId, m.CustomerId

您可以尝试每个版本，看看哪个版本运行得更快...

Answer 2

declare @Orders table (
    ProductId int,
    CustomerId int,
    Date datetime
)

insert into @Orders values (1,1,'20090701')
insert into @Orders values (2,1,'20090703')
insert into @Orders values (3,1,'20090702')
insert into @Orders values (1,2,'20090704')
insert into @Orders values (4,2,'20090701')
insert into @Orders values (1,3,'20090706')
insert into @Orders values (2,3,'20090704')
insert into @Orders values (4,3,'20090702')
insert into @Orders values (5,5,'20090703')

select O.* from @Orders O inner join 
(
    select ProductId,
    MIN(Date) MinDate 
    from @Orders 
    group by ProductId
) FO
on FO.ProductId = O.ProductId and FO.MinDate = O.Date

估计的查询计划没有用，因为我用表变量来模拟它，但是匿名内部连接应该在子选择上进行优化。

Answer 3

在SQL Server 2005+:

SELECT  oo.*
FROM    (
        SELECT  DISTINCT ProductId
        FROM    Orders
        ) od
CROSS APPLY
        (
        SELECT  TOP 1 ProductID, Date, CustomerID
        FROM    Orders oi
        WHERE   oi.ProductID = od.ProductID
        ORDER BY
                Date DESC
        ) oo

名义上，查询计划包含Nested Loops。

但是，外部循环将使用Index Scan 和Stream Aggregate，而内部循环将包含Index Seek 用于ProductID 和Top。

事实上，第二个操作几乎是免费的，因为在内循环中使用的索引页很可能会驻留在缓存中，因为它刚刚用于外循环。

这是1,000,000 行的测试结果（带有100 DISTINCT ProductID's）：

SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 1 ms.

(строк обработано: 100)
Table 'Orders'. Scan count 103, logical reads 6020, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

SQL Server Execution Times:
   CPU time = 234 ms,  elapsed time = 125 ms.

，虽然这只是 SELECT DISTINCT 查询的结果：

SELECT  od.*
FROM    (
        SELECT  DISTINCT ProductId
        FROM    Orders
        ) od

还有统计数据：

SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 1 ms.

(строк обработано: 100)
Table 'Orders'. Scan count 3, logical reads 5648, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

SQL Server Execution Times:
   CPU time = 250 ms,  elapsed time = 125 ms.

正如我们所看到的，性能是相同的，CROSS APPLY 只需要400 额外的logical reads（很可能永远不会是physical）。

看不到如何改进这个查询了。

此查询的另一个好处是它可以很好地并行化。您可能会注意到CPU 的时间是elapsed time 的两倍：这是由于我的旧Core Duo 上的并行化。

4-coreCPU 将在一半的时间内完成此查询。

使用窗口函数的解决方案不并行化：

SELECT  od.*
FROM    (
        SELECT  ProductId, Date, CustomerID, ROW_NUMBER() OVER (PARTITION BY ProductID ORDER BY Date DESC) AS rn
        FROM    Orders
        ) od
WHERE   rn = 1

，以下是统计数据：

SQL Server Execution Times:
   CPU time = 0 ms,  elapsed time = 1 ms.

(строк обработано: 100)
Table 'Orders'. Scan count 1, logical reads 5123, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

SQL Server Execution Times:
   CPU time = 406 ms,  elapsed time = 415 ms.

Answer 4

如果不执行子查询或窗口函数（例如 row_number、rank），我看不出有什么方法可以很好地做到这一点，因为 max 只显示在一列中。

但是你不能很好地做到这一点。

SELECT
    productid, 
    min(date), 
cast(
    substring( 
        min(convert(varchar(23),date,21) + cast(customerid as varchar(20)))
              , 24, 44)
    as int) customerid
from 
    orders
group by
    productid 

这仅适用于您的客户 ID 少于 20 位数字。

编辑： 添加了 group by 子句

Answer 5

SELECT
    o1.productid, 
    o1.date, 
    o1.customerid
FROM
    Orders o1
JOIN
    (select productid, min(date) as orderDate
     from Orders
     group by productid
    ) firstOrder
ON o1.productid = firstOrder.productid

这是我能想到的最好的方法，但老实说，我不知道这个查询的性能特征是什么。如果不好，我可能会建议运行两个查询来获取您想要的信息。

Answer 6

IX_Orders 是按 ProductId，然后是 CutomerId，然后是 Date，还是按 ProductId，然后是 Date，然后是 CustomerId？如果是前者，就换成后者。

换句话说，不要使用这个：

create index IX_Orders on Orders (ProductId, CustomerId, Date) 

改用这个：

create index IX_Orders on Orders (ProductId, Date, CustomerId)

如果你这样做：

SELECT o1.* 
FROM [Order] o1
JOIN
    (
        SELECT ProductID, Min(Date) as Date
        FROM [Order]
        GROUP BY ProductID
    ) o2
    ON o1.ProductID = o2.ProductID AND o1.Date = o2.Date
ORDER BY ProductID

您最终只对 IX_Orders 进行了一次索引扫描，但是如果两个客户可以同时订购相同的产品，您可以获得每个产品的多行。您可以使用以下查询来解决这个问题，但它的效率低于第一个：

WITH cte AS
(
    SELECT ProductID, CustomerID, Date, 
        ROW_NUMBER() OVER(PARTITION BY ProductID ORDER BY Date ASC) AS row
    FROM [Order]
)
SELECT ProductID, CustomerId, Date
FROM cte
WHERE row = 1
ORDER BY ProductID