Обчисліть загальний обсяг роботи в 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 існують різні способи .

Мене особливо цікавить такий метод, який використовує трюк агрегування-встановлення оператора:

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 (також якщо запит виконується двома документами, мені цікаво, що буде, див. 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

Ви попросили орієнтир, це низький рівень.

Найшвидший БЕЗПЕЧНИЙ спосіб зробити це курсор, це на порядок швидше, ніж корельований підзапит на перехресне з'єднання.

Абсолютний найшвидший спосіб - трюк 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 Fiddle

Хоча Сем Сафрон зробив велику роботу над цим, він все ще не надав рекурсивний загальний код вираження таблиці для цієї проблеми. А для нас, хто працює з SQL Server 2008 R2, а не Деналі, це все-таки найшвидший спосіб отримати загальний запуск, це приблизно в 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

З того, що я бачив, якщо у вас на столі належним кластеризований індекс / первинний ключ (у нашому випадку це буде індексувати ord_id), оновлення триватиме лінійним шляхом весь час (ніколи не зустрічалося ділення на нуль). З цього приводу вирішувати, чи бажаєте ви використовувати його у виробничому коді, вирішувати :)

оновлення 2 Я пов'язую цю відповідь, тому що вона містить корисну інформацію про ненадійність вигадливого оновлення - nvarchar concatenation / index / nvarchar (max) незрозумілою поведінкою .

Оператор APPLY у SQL 2005 та новіших версіях працює для цього:

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 - якщо дата з’являється більше одного разу, ви хочете побачити її лише один раз у наборі результатів.

Якщо ви не проти бачити повторювані дати або хочете побачити оригінальне значення та ідентифікатор, то вам потрібно:

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 році?), Але я не маю примірника для того, щоб спробувати це.

EDIT: ну, мабуть, SQL Server не дозволяє специфікувати вікно ("OVER (...)") без вказівки "PARTITION BY" (поділ результату на групи, але не агрегуючий так, як це робить GROUP BY). Дратівливо - посилання на синтаксис MSDN говорить про те, що його необов'язково, але в даний момент у мене є лише екземпляри SqlServer 2000.

Запит, який я дав, працює як в Oracle 10.2.0.3.0, так і в PostgreSQL 8.4-beta. Тому скажіть МС наздогнати;)

Якщо ви використовуєте сервер Sql 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

Хоча найкращим способом зробити це буде використання віконної функції, це також можна зробити за допомогою простого співвіднесеного підзапиту .

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

Ось два простих способи розрахунку загальної кількості запущених даних:

Підхід 1 : Це можна записати так, якщо ваші СУБД підтримують аналітичні функції

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

Підхід 2 : Ви можете скористатися 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;

Примітка: - Якщо вам доведеться окремо обчислити загальну кількість запуску для різних розділів, це можна зробити так, як розміщено тут: Обчислення загальної кількості за рядками та групування за ідентифікатором