sql-server - sumas - sumar resultados de una consulta sql

Cómo obtener la suma acumulada

Question

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

la selección de arriba me devuelve lo siguiente.

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

¿Cómo obtengo lo siguiente?

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

Answer 1

Última respuesta pero mostrando una posibilidad más ...

La generación suma acumulativa puede optimizarse con la lógica CROSS APPLY .

Funciona mejor que la OVER Clause INNER JOIN & OVER Clause cuando se analiza el plan de consulta real ...

/* 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

Answer 2

Arriba (Pre-SQL12) vemos ejemplos como este:

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

Más eficiente...

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

Answer 3

Hay una implementación de CTE mucho más rápida disponible en esta excelente publicación: http://weblogs.sqlteam.com/mladenp/archive/2009/07/28/SQL-Server-2005-Fast-Running-Totals.aspx

El problema en este hilo se puede expresar así:

    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.*

Answer 4

La última versión de SQL Server (2012) permite lo siguiente.

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

o

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

Esto es incluso más rápido. La versión particionada completa en 34 segundos más de 5 millones de filas para mí.

Gracias a Peso, quien comentó sobre el hilo del Equipo SQL mencionado en otra respuesta.

Answer 5

La solución SQL que combina "FILAS ENTRE SIN PRECEDENTES Y FILA ACTUAL" y "SUMA" hizo exactamente lo que yo quería lograr. Muchas gracias!

Si puede ayudar a alguien, aquí estaba mi caso. Quería acumular +1 en una columna cada vez que un fabricante se encuentra como "Some Maker" (ejemplo). Si no, no hay incremento, pero muestra el resultado del incremento anterior.

Entonces esta pieza de 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

Me permitió obtener algo como esto:

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  

Explicación de lo anterior: inicia el recuento de "algún fabricante" con 0, se encuentra Some Maker y hacemos +1. Para el usuario 1, se encuentra MakerC, por lo que no hacemos +1, sino que el recuento vertical de Some Maker queda bloqueado en 2 hasta la siguiente fila. La partición es por Usuario, por lo tanto, cuando cambiamos de usuario, el conteo acumulativo regresa a cero.

Estoy en el trabajo, no quiero ningún mérito en esta respuesta, solo agradezco y demuestro mi ejemplo en caso de que alguien esté en la misma situación. Intenté combinar SUM y PARTITION, pero la sintaxis asombrosa "FILAS ENTRE SIN PRECEDENTES Y FILA ACTUAL" completó la tarea.

¡Gracias! Groaker

Answer 6

Para SQL Server 2012 en adelante, podría ser fácil:

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

porque la cláusula ORDER BY para SUM por defecto significa RANGE UNBOUNDED PRECEDING AND CURRENT ROW para window frame ("Observaciones generales" en https://msdn.microsoft.com/en-us/library/ms189461.aspx )

Answer 7

Prueba esto

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;

Answer 8

Prueba esto:

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

Answer 9

Sin utilizar ningún tipo de salario acumulativo JOIN para una persona a buscar usando la siguiente consulta:

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

Answer 10

Una versión CTE, solo por diversión:

;
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.

Devoluciones:

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

Answer 11

Una vez que se crea la tabla,

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

Answer 12

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

Answer 13

Primero crea una tabla con datos ficticios ->

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 

aquí me estoy uniendo a la misma mesa (SELF Joining)

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

RESULTADO:

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

aquí vamos ahora solo sumamos el Somevalue de t2 y obtendremos la 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

PARA SQL SERVER 2012 y superior (mucho mejor rendimiento)

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

Resultado deseado

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

Drop Table CumulativeSum

Borrar la tabla dummy

Answer 14

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

Ejemplo de SQL Fiddle

Salida

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

Editar: esta es una solución generalizada que funcionará en la mayoría de las plataformas de db. Cuando haya una mejor solución disponible para su plataforma específica (p. Ej., La de Gareth), úselo.