计算SQL Server中的运行总计

想象一下下表（称为TestTable）：

id     somedate    somevalue
--     --------    ---------
45     01/Jan/09   3
23     08/Jan/09   5
12     02/Feb/09   0
77     14/Feb/09   7
39     20/Feb/09   34
33     02/Mar/09   6

我想要一个按日期顺序返回运行总计的查询，例如：

id     somedate    somevalue  runningtotal
--     --------    ---------  ------------
45     01/Jan/09   3          3
23     08/Jan/09   5          8
12     02/Feb/09   0          8
77     14/Feb/09   7          15  
39     20/Feb/09   34         49
33     02/Mar/09   6          55

我知道在SQL Server 2000/2005/2008中有多种方法可以做到这一点。

我对使用aggregating-set-statement技巧的这种方法特别感兴趣：

INSERT INTO @AnotherTbl(id, somedate, somevalue, runningtotal) 
   SELECT id, somedate, somevalue, null
   FROM TestTable
   ORDER BY somedate

DECLARE @RunningTotal int
SET @RunningTotal = 0

UPDATE @AnotherTbl
SET @RunningTotal = runningtotal = @RunningTotal + somevalue
FROM @AnotherTbl

...这非常有效，但是我听说周围存在问题，因为您不一定能保证该UPDATE语句将按正确的顺序处理行。也许我们可以获得有关该问题的明确答案。

但是，人们还有其他建议的方式吗？

编辑：现在使用带有上面的设置和“更新技巧”示例的SqlFiddle

更新，如果您正在运行SQL Server 2012，请参见：https : //stackoverflow.com/a/10309947

问题是Over子句的SQL Server实现受到一定的限制。

Oracle（和ANSI-SQL）允许您执行以下操作：

 SELECT somedate, somevalue,
  SUM(somevalue) OVER(ORDER BY somedate 
     ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) 
          AS RunningTotal
  FROM Table

SQL Server无法为您解决此问题。我的直觉告诉我，这是极少数情况下光标最快的情况之一，尽管我必须对大结果进行一些基准测试。

更新技巧很方便，但我觉得它相当脆弱。看来，如果要更新完整表，则它将按主键的顺序进行。因此，如果将日期设置为升序的主键，则将probably是安全的。但是您依赖于一个未记录的SQL Server实现细节（同样如果查询最终由两个proc执行，我想知道会发生什么，请参见：MAXDOP）：

完整的工作样本：

drop table #t 
create table #t ( ord int primary key, total int, running_total int)

insert #t(ord,total)  values (2,20)
-- notice the malicious re-ordering 
insert #t(ord,total) values (1,10)
insert #t(ord,total)  values (3,10)
insert #t(ord,total)  values (4,1)

declare @total int 
set @total = 0
update #t set running_total = @total, @total = @total + total 

select * from #t
order by ord 

ord         total       running_total
----------- ----------- -------------
1           10          10
2           20          30
3           10          40
4           1           41

您要求提供基准，这是最低点。

最快的SAFE方式是游标，它比交叉联接的相关子查询快一个数量级。

绝对最快的方法是UPDATE技巧。我唯一关心的是，我不确定在所有情况下更新都会以线性方式进行。查询中没有明确说明的内容。

底线，对于生产代码，我将使用光标。

测试数据：

create table #t ( ord int primary key, total int, running_total int)

set nocount on 
declare @i int
set @i = 0 
begin tran
while @i < 10000
begin
   insert #t (ord, total) values (@i,  rand() * 100) 
    set @i = @i +1
end
commit

测试1：

SELECT ord,total, 
    (SELECT SUM(total) 
        FROM #t b 
        WHERE b.ord <= a.ord) AS b 
FROM #t a

-- CPU 11731, Reads 154934, Duration 11135 

测试2：

SELECT a.ord, a.total, SUM(b.total) AS RunningTotal 
FROM #t a CROSS JOIN #t b 
WHERE (b.ord <= a.ord) 
GROUP BY a.ord,a.total 
ORDER BY a.ord

-- CPU 16053, Reads 154935, Duration 4647

测试3：

DECLARE @TotalTable table(ord int primary key, total int, running_total int)

DECLARE forward_cursor CURSOR FAST_FORWARD 
FOR 
SELECT ord, total
FROM #t 
ORDER BY ord


OPEN forward_cursor 

DECLARE @running_total int, 
    @ord int, 
    @total int
SET @running_total = 0

FETCH NEXT FROM forward_cursor INTO @ord, @total 
WHILE (@@FETCH_STATUS = 0)
BEGIN
     SET @running_total = @running_total + @total
     INSERT @TotalTable VALUES(@ord, @total, @running_total)
     FETCH NEXT FROM forward_cursor INTO @ord, @total 
END

CLOSE forward_cursor
DEALLOCATE forward_cursor

SELECT * FROM @TotalTable

-- CPU 359, Reads 30392, Duration 496

测试4：

declare @total int 
set @total = 0
update #t set running_total = @total, @total = @total + total 

select * from #t

-- CPU 0, Reads 58, Duration 139

在SQL Server 2012中，可以将SUM（）与OVER（）子句一起使用。

select id,
       somedate,
       somevalue,
       sum(somevalue) over(order by somedate rows unbounded preceding) as runningtotal
from TestTable

SQL小提琴

尽管Sam Saffron在此方面做了出色的工作，但他仍然没有为该问题提供递归的公用表表达式代码。对于使用SQL Server 2008 R2而不是Denali的我们来说，这仍然是最快的总运行方式，它比我的工作计算机上的游标快了10倍，处理了100000行，它也是内联查询。
因此，这里就是（我假设表中有一ord列，并且它是无间隙的连续数字，为了快速处理，对该数字也应该有唯一的约束）：

;with 
CTE_RunningTotal
as
(
    select T.ord, T.total, T.total as running_total
    from #t as T
    where T.ord = 0
    union all
    select T.ord, T.total, T.total + C.running_total as running_total
    from CTE_RunningTotal as C
        inner join #t as T on T.ord = C.ord + 1
)
select C.ord, C.total, C.running_total
from CTE_RunningTotal as C
option (maxrecursion 0)

-- CPU 140, Reads 110014, Duration 132

sql fiddle demo

更新 我也很好奇这个更新变量或古怪的更新。因此通常它可以正常工作，但是我们如何确定每次都能正常工作呢？好吧，这是一个小技巧（在此处找到它-http: //www.sqlservercentral.com/Forums/Topic802558-203-21.aspx#bm981258）-您只需检查当前和以前的内容，ord并使用1/0分配以防它们与其他内容不同您期望：

declare @total int, @ord int

select @total = 0, @ord = -1

update #t set
    @total = @total + total,
    @ord = case when ord <> @ord + 1 then 1/0 else ord end,
    ------------------------
    running_total = @total

select * from #t

-- CPU 0, Reads 58, Duration 139

从我所见，如果您的表上有正确的聚集索引/主键（在我们的情况下为index by ord_id），更新将一直以线性方式进行（从未遇到被零除）。就是说，由您决定是否要在生产代码中使用它：）

更新2我正在链接此答案，因为它包含一些有关古怪的更新的不可靠性的有用信息-nvarchar级联/索引/ nvarchar（max）莫名其妙的行为。

SQL 2005和更高版本中的APPLY运算符可用于此目的：

select
    t.id ,
    t.somedate ,
    t.somevalue ,
    rt.runningTotal
from TestTable t
 cross apply (select sum(somevalue) as runningTotal
                from TestTable
                where somedate <= t.somedate
            ) as rt
order by t.somedate

SELECT TOP 25   amount, 
    (SELECT SUM(amount) 
    FROM time_detail b 
    WHERE b.time_detail_id <= a.time_detail_id) AS Total FROM time_detail a

您还可以使用ROW_NUMBER（）函数和一个临时表来创建一个任意列，以用于内部SELECT语句的比较中。

使用相关的子查询。很简单，在这里您可以：

SELECT 
somedate, 
(SELECT SUM(somevalue) FROM TestTable t2 WHERE t2.somedate<=t1.somedate) AS running_total
FROM TestTable t1
GROUP BY somedate
ORDER BY somedate

该代码可能并不完全正确，但是我确定这个想法是正确的。

GROUP BY是为了防止日期多次出现，您只希望在结果集中看到一次。

如果您不介意看到重复的日期，或者想查看原始值和ID，则需要以下内容：

SELECT 
id,
somedate, 
somevalue,
(SELECT SUM(somevalue) FROM TestTable t2 WHERE t2.somedate<=t1.somedate) AS running_total
FROM TestTable t1
ORDER BY somedate

您还可以反规范化-将运行总计存储在同一表中：

http://sqlblog.com/blogs/alexander_kuznetsov/archive/2009/01/23/denormalizing-to-enforce-business-rules-running-totals.aspx

选择工作比任何其他解决方案都快得多，但修改速度可能较慢

假设窗口可以像在其他地方（我已经尝试过）一样在SQL Server 2008上运行，请尝试一下：

select testtable.*, sum(somevalue) over(order by somedate)
from testtable
order by somedate;

MSDN说它可以在SQL Server 2008中使用（也许也可以在2005中使用），但是我没有实例可以尝试。

编辑：好吧，显然，SQL Server不允许在不指定“ PARTITION BY”的情况下进行窗口指定（“ OVER（...）”）（将结果分成几组，但不能以GROUP BY的方式进行汇总）。烦人的-MSDN语法参考表明它是可选的，但目前我只有SqlServer 2000实例。

我提供的查询在Oracle 10.2.0.3.0和PostgreSQL 8.4-beta中均有效。所以告诉MS赶上;）

如果您使用的是上面的Sql Server 2008 R2。然后，这将是最短的方法。

Select id
    ,somedate
    ,somevalue,
LAG(runningtotal) OVER (ORDER BY somedate) + somevalue AS runningtotal
From TestTable 

LAG用于获取上一行的值。您可以通过google获取更多信息。

[1]：

我相信可以使用下面的简单INNER JOIN操作来实现运行总计。

SELECT
     ROW_NUMBER() OVER (ORDER BY SomeDate) AS OrderID
    ,rt.*
INTO
    #tmp
FROM
    (
        SELECT 45 AS ID, CAST('01-01-2009' AS DATETIME) AS SomeDate, 3 AS SomeValue
        UNION ALL
        SELECT 23, CAST('01-08-2009' AS DATETIME), 5
        UNION ALL
        SELECT 12, CAST('02-02-2009' AS DATETIME), 0
        UNION ALL
        SELECT 77, CAST('02-14-2009' AS DATETIME), 7
        UNION ALL
        SELECT 39, CAST('02-20-2009' AS DATETIME), 34
        UNION ALL
        SELECT 33, CAST('03-02-2009' AS DATETIME), 6
    ) rt

SELECT
     t1.ID
    ,t1.SomeDate
    ,t1.SomeValue
    ,SUM(t2.SomeValue) AS RunningTotal
FROM
    #tmp t1
    JOIN #tmp t2
        ON t2.OrderID <= t1.OrderID
GROUP BY
     t1.OrderID
    ,t1.ID
    ,t1.SomeDate
    ,t1.SomeValue
ORDER BY
    t1.OrderID

DROP TABLE #tmp

以下将产生所需的结果。

SELECT a.SomeDate,
       a.SomeValue,
       SUM(b.SomeValue) AS RunningTotal
FROM TestTable a
CROSS JOIN TestTable b
WHERE (b.SomeDate <= a.SomeDate) 
GROUP BY a.SomeDate,a.SomeValue
ORDER BY a.SomeDate,a.SomeValue

在SomeDate上具有聚集索引将大大提高性能。

使用联接另一个变体是使用联接。现在查询看起来像：

    SELECT a.id, a.value, SUM(b.Value)FROM   RunTotalTestData a,
    RunTotalTestData b
    WHERE b.id <= a.id
    GROUP BY a.id, a.value 
    ORDER BY a.id;

有关更多信息，您可以访问此链接 http://askme.indianyouth.info/details/calculating-simple-running-totals-in-sql-server-12

尽管最好的方法是使用window函数，但也可以使用简单的相关子查询来完成。

Select id, someday, somevalue, (select sum(somevalue) 
                                from testtable as t2
                                where t2.id = t1.id
                                and t2.someday <= t1.someday) as runningtotal
from testtable as t1
order by id,someday;

BEGIN TRAN
CREATE TABLE #Table (_Id INT IDENTITY(1,1) ,id INT ,    somedate VARCHAR(100) , somevalue INT)


INSERT INTO #Table ( id  ,    somedate  , somevalue  )
SELECT 45 , '01/Jan/09', 3 UNION ALL
SELECT 23 , '08/Jan/09', 5 UNION ALL
SELECT 12 , '02/Feb/09', 0 UNION ALL
SELECT 77 , '14/Feb/09', 7 UNION ALL
SELECT 39 , '20/Feb/09', 34 UNION ALL
SELECT 33 , '02/Mar/09', 6 

;WITH CTE ( _Id, id  ,  _somedate  , _somevalue ,_totvalue ) AS
(

 SELECT _Id , id  ,    somedate  , somevalue ,somevalue
 FROM #Table WHERE _id = 1
 UNION ALL
 SELECT #Table._Id , #Table.id  , somedate  , somevalue , somevalue + _totvalue
 FROM #Table,CTE 
 WHERE #Table._id > 1 AND CTE._Id = ( #Table._id-1 )
)

SELECT * FROM CTE

ROLLBACK TRAN

这里有2种简单的方法来计算运行总计：

方法1：如果您的DBMS支持分析功能，则可以用这种方式编写

SELECT     id
           ,somedate
           ,somevalue
           ,runningtotal = SUM(somevalue) OVER (ORDER BY somedate ASC)
FROM       TestTable

方法2：如果您的数据库版本/ DBMS本身不支持分析功能，则可以使用OUTER APPLY

SELECT     T.id
           ,T.somedate
           ,T.somevalue
           ,runningtotal = OA.runningtotal
FROM       TestTable T
           OUTER APPLY (
                           SELECT   runningtotal = SUM(TI.somevalue)
                           FROM     TestTable TI
                           WHERE    TI.somedate <= S.somedate
                       ) OA;

注意：-如果必须分别计算不同分区的运行总计，则可以按此处发布的操作进行：计算行之间的运行总计并按ID分组