누적 합계를 얻는 방법

declare  @t table
    (
        id int,
        SomeNumt int
    )

insert into @t
select 1,10
union
select 2,12
union
select 3,3
union
select 4,15
union
select 5,23


select * from @t

위의 선택은 다음을 반환합니다.

id  SomeNumt
1   10
2   12
3   3
4   15
5   23

다음을 어떻게 얻습니까?

id  srome   CumSrome
1   10  10
2   12  22
3   3   25
4   15  40
5   23  63

select t1.id, t1.SomeNumt, SUM(t2.SomeNumt) as sum
from @t t1
inner join @t t2 on t1.id >= t2.id
group by t1.id, t1.SomeNumt
order by t1.id

SQL 피들 예제

산출

| ID | SOMENUMT | SUM |
-----------------------
|  1 |       10 |  10 |
|  2 |       12 |  22 |
|  3 |        3 |  25 |
|  4 |       15 |  40 |
|  5 |       23 |  63 |

편집 : 이것은 대부분의 DB 플랫폼에서 작동하는 일반화 된 솔루션입니다. 특정 플랫폼 (예 : gareth)에 적합한 솔루션이 더 있으면 사용하십시오!

최신 버전의 SQL Server (2012)는 다음을 허용합니다.

SELECT 
    RowID, 
    Col1,
    SUM(Col1) OVER(ORDER BY RowId ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS Col2
FROM tablehh
ORDER BY RowId

또는

SELECT 
    GroupID, 
    RowID, 
    Col1,
    SUM(Col1) OVER(PARTITION BY GroupID ORDER BY RowId ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS Col2
FROM tablehh
ORDER BY RowId

이것은 더 빠릅니다. 분할 된 버전은 5 백만 행이 넘는 34 초 만에 완료됩니다.

다른 답변에서 언급 된 SQL 팀 스레드에 대해 언급 한 Peso에게 감사드립니다.

SQL Server 2012 이후로는 쉬울 수 있습니다.

SELECT id, SomeNumt, sum(SomeNumt) OVER (ORDER BY id) as CumSrome FROM @t

때문에 ORDER BY대한 절 SUM기본적으로 수단 RANGE UNBOUNDED PRECEDING AND CURRENT ROW창 프레임은 (에서 "일반 비고" https://msdn.microsoft.com/en-us/library/ms189461.aspx )

재미를위한 CTE 버전 :

;
WITH  abcd
        AS ( SELECT id
                   ,SomeNumt
                   ,SomeNumt AS MySum
             FROM   @t
             WHERE  id = 1
             UNION ALL
             SELECT t.id
                   ,t.SomeNumt
                   ,t.SomeNumt + a.MySum AS MySum
             FROM   @t AS t
                    JOIN abcd AS a ON a.id = t.id - 1
           )
  SELECT  *  FROM    abcd
OPTION  ( MAXRECURSION 1000 ) -- limit recursion here, or 0 for no limit.

보고:

id          SomeNumt    MySum
----------- ----------- -----------
1           10          10
2           12          22
3           3           25
4           15          40
5           23          63

먼저 더미 데이터가 포함 된 테이블을 생성합니다->

Create Table CUMULATIVESUM (id tinyint , SomeValue tinyint)

**Now let put some data in the table**

Insert Into CUMULATIVESUM

Select 1, 10 union 
Select 2, 2  union
Select 3, 6  union
Select 4, 10 

여기 나는 같은 테이블에 합류하고있다 (SELF Joining)

Select c1.ID, c1.SomeValue, c2.SomeValue
From CumulativeSum c1,  CumulativeSum c2
Where c1.id >= c2.ID
Order By c1.id Asc

결과 :

ID  SomeValue   SomeValue
1   10          10
2   2           10
2   2            2
3   6           10
3   6            2
3   6            6
4   10          10
4   10           2
4   10           6
4   10          10

여기서 우리는 이제 t2의 Somevalue를 합하면 ans를 얻습니다.

Select c1.ID, c1.SomeValue, Sum(c2.SomeValue) CumulativeSumValue
From CumulativeSum c1,  CumulativeSum c2
Where c1.id >= c2.ID
Group By c1.ID, c1.SomeValue
Order By c1.id Asc

FOR SQL SERVER 2012 이상 (훨씬 더 나은 성능)

Select c1.ID, c1.SomeValue, 
SUM (SomeValue) OVER (ORDER BY c1.ID )
From CumulativeSum c1
Order By c1.id Asc

원하는 결과

ID  SomeValue   CumlativeSumValue
1   10          10
2   2           12
3   6           18
4   10          28

Drop Table CumulativeSum

더미 테이블을 지우십시오

답변이 늦었지만 한 가지 가능성이 더 있습니다 ...

CROSS APPLY논리 를 통해 누적 합계 생성을보다 최적화 할 수 있습니다 .

실제 쿼리 계획을 분석 할 때 INNER JOIN& 보다 우수합니다 OVER Clause...

/* Create table & populate data */
IF OBJECT_ID('tempdb..#TMP') IS NOT NULL
DROP TABLE #TMP 

SELECT * INTO #TMP 
FROM (
SELECT 1 AS id
UNION 
SELECT 2 AS id
UNION 
SELECT 3 AS id
UNION 
SELECT 4 AS id
UNION 
SELECT 5 AS id
) Tab


/* Using CROSS APPLY 
Query cost relative to the batch 17%
*/    
SELECT   T1.id, 
         T2.CumSum 
FROM     #TMP T1 
         CROSS APPLY ( 
         SELECT   SUM(T2.id) AS CumSum 
         FROM     #TMP T2 
         WHERE    T1.id >= T2.id
         ) T2

/* Using INNER JOIN 
Query cost relative to the batch 46%
*/
SELECT   T1.id, 
         SUM(T2.id) CumSum
FROM     #TMP T1
         INNER JOIN #TMP T2
                 ON T1.id > = T2.id
GROUP BY T1.id

/* Using OVER clause
Query cost relative to the batch 37%
*/
SELECT   T1.id, 
         SUM(T1.id) OVER( PARTITION BY id)
FROM     #TMP T1

Output:-
  id       CumSum
-------   ------- 
   1         1
   2         3
   3         6
   4         10
   5         15

Select *, (Select SUM(SOMENUMT) From @t S Where S.id <= M.id) From @t M

이 우수한 게시물에서 사용 가능한 훨씬 빠른 CTE 구현이 있습니다. http://weblogs.sqlteam.com/mladenp/archive/2009/07/28/SQL-Server-2005-Fast-Running-Totals.aspx

이 스레드의 문제는 다음과 같이 표현 될 수 있습니다.

    DECLARE @RT INT
    SELECT @RT = 0

    ;
    WITH  abcd
            AS ( SELECT TOP 100 percent
                        id
                       ,SomeNumt
                       ,MySum
                       order by id
               )
      update abcd
      set @RT = MySum = @RT + SomeNumt
      output inserted.*

점진적 계산에이 간단한 쿼리를 사용할 수 있습니다.

select 
   id
  ,SomeNumt
  ,sum(SomeNumt) over(order by id ROWS between UNBOUNDED PRECEDING and CURRENT ROW) as CumSrome
from @t

테이블이 생성되면-

select 
    A.id, A.SomeNumt, SUM(B.SomeNumt) as sum
    from @t A, @t B where A.id >= B.id
    group by A.id, A.SomeNumt

order by A.id

위의 (SQL12 이전) 우리는 다음과 같은 예제를 보았습니다.

SELECT
    T1.id, SUM(T2.id) AS CumSum
FROM 
    #TMP T1
    JOIN #TMP T2 ON T2.id < = T1.id
GROUP BY
    T1.id

더 효율적인 ...

SELECT
    T1.id, SUM(T2.id) + T1.id AS CumSum
FROM 
    #TMP T1
    JOIN #TMP T2 ON T2.id < T1.id
GROUP BY
    T1.id

이 시도

select 
    t.id,
    t.SomeNumt, 
    sum(t.SomeNumt) Over (Order by t.id asc Rows Between Unbounded Preceding and Current Row) as cum
from 
    @t t 
group by
    t.id,
    t.SomeNumt
order by
    t.id asc;

이 시도:

CREATE TABLE #t(
 [name] varchar NULL,
 [val] [int] NULL,
 [ID] [int] NULL
) ON [PRIMARY]

insert into #t (id,name,val) values
 (1,'A',10), (2,'B',20), (3,'C',30)

select t1.id, t1.val, SUM(t2.val) as cumSum
 from #t t1 inner join #t t2 on t1.id >= t2.id
 group by t1.id, t1.val order by t1.id

SQL 솔루션은 "바인딩되지 않은 선행 및 현재 행 사이의 행"과 "SUM"이 내가 원하는 것을 정확히 수행했습니다. 정말 고맙습니다!

그것이 누군가를 도울 수 있다면, 여기 내 사건이 있습니다. 메이커가 "일부 메이커"(예)로 표시 될 때마다 열에서 +1을 누적하고 싶었습니다. 그렇지 않으면 증분이없고 이전 증분 결과가 표시됩니다.

따라서이 SQL 조각 :

SUM( CASE [rmaker] WHEN 'Some Maker' THEN  1 ELSE 0 END) 
OVER 
(PARTITION BY UserID ORDER BY UserID,[rrank] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS Cumul_CNT

다음과 같은 것을 얻을 수있었습니다.

User 1  Rank1   MakerA      0  
User 1  Rank2   MakerB      0  
User 1  Rank3   Some Maker  1  
User 1  Rank4   Some Maker  2  
User 1  Rank5   MakerC      2
User 1  Rank6   Some Maker  3  
User 2  Rank1   MakerA      0  
User 2  Rank2   SomeMaker   1  

위의 설명 : 0으로 「일부 메이커」의 카운트를 개시 해, 일부 메이커가 발견되어 +1합니다. 사용자 1의 경우 MakerC가 발견되어 +1하지 않지만 대신 일부 행의 세로 개수는 다음 행까지 2에 고정됩니다. 파티셔닝은 사용자 별이므로 사용자를 변경하면 누적 횟수가 0으로 돌아갑니다.

나는 일하고 있습니다.이 답변에 대한 공로를 원하지 않습니다. 누군가가 같은 상황에 처한 경우에 대비하여 감사하고 내 예를 보여주십시오. SUM과 PARTITION을 결합하려고했지만 놀라운 구문 "바꾸지 않은 선행 및 현재 행 사이의 행"이 작업을 완료했습니다.

감사! 그루 커

다음 쿼리를 사용하여 인출하는 사람에 대해 모든 유형의 JOIN 누적 급여를 사용하지 않는 경우 :

SELECT * , (
  SELECT SUM( salary ) 
  FROM  `abc` AS table1
  WHERE table1.ID <=  `abc`.ID
    AND table1.name =  `abc`.Name
) AS cum
FROM  `abc` 
ORDER BY Name

예 : 열이 두 개인 테이블이있는 경우 하나는 ID이고 두 번째는 숫자이며 누적 합계를 찾으려고합니다.

SELECT ID,Number,SUM(Number)OVER(ORDER BY ID) FROM T