Totale parziale. UPDATE tabella temporanea vs CTE
create table Test(
OrderID int primary key,
Qty int not null
);
declare @i int = 1;
while @i <= 5000 begin
insert into Test(OrderID, Qty) values (@i * 2,rand() * 10);
set @i = @i + 1;
end;
Soluzione ricorsiva impiega 9 secondi:
with T AS
(
select ROW_NUMBER() over(order by OrderID) as rn, * from test
)
,R(Rn, OrderId, Qty, RunningTotal) as
(
select Rn, OrderID, Qty, Qty
from t
where rn = 1
union all
select t.Rn, t.OrderId, t.Qty, p.RunningTotal + t.Qty
from t t
join r p on t.rn = p.rn + 1
)
select R.OrderId, R.Qty, R.RunningTotal from r
option(maxrecursion 0);
UPDATE tabella impiega 0 secondi:
create function TestRunningTotal()
returns @ReturnTable table(
OrderId int, Qty int, RunningTotal int
)
as begin
insert into @ReturnTable(OrderID, Qty, RunningTotal)
select OrderID, Qty, 0 from Test
order by OrderID;
declare @RunningTotal int = 0;
update @ReturnTable set
RunningTotal = @RunningTotal,
@RunningTotal = @RunningTotal + Qty;
return;
end;
Questi due approcci potrebbero almeno darti un framework su cui costruire la tua query.
A proposito, in SQL Server, a differenza di MySQL, l'ordine di assegnazione delle variabili non ha importanza. Questo:
update @ReturnTable set
RunningTotal = @RunningTotal,
@RunningTotal = @RunningTotal + Qty;
E quanto segue:
update @ReturnTable set
@RunningTotal = @RunningTotal + Qty,
RunningTotal = @RunningTotal;
Entrambi vengono eseguiti allo stesso modo, ovvero le assegnazioni delle variabili avvengono per prime, indipendentemente dalla posizione dell'assegnazione delle variabili nell'istruzione. Entrambe le query hanno lo stesso output:
OrderId Qty RunningTotal
----------- ----------- ------------
2 4 4
4 8 12
6 4 16
8 5 21
10 3 24
12 8 32
14 2 34
16 9 43
18 1 44
20 2 46
22 0 46
24 2 48
26 6 54
Sulla tua tabella esatta, rileva semplicemente Compra/Vendi, puoi moltiplicarlo rispettivamente per 1 e -1, o semplicemente firmare i campi, ad es. :
update @ReturnTable set
@RunningTotal = @RunningTotal +
CASE WHEN BuySell = 'Buy' THEN Qty ELSE -Qty END,
RunningTotal = @RunningTotal;
Se ti capita di eseguire l'aggiornamento a SQL Server 2012, ecco la semplice implementazione del totale parziale:
select OrderID, Qty, sum(Qty) over(order by OrderID) as RunningTotal
from Test
Sul tuo problema esatto:
select OrderID, Qty,
sum(CASE WHEN BuySell = 'Buy' THEN Qty ELSE -Qty END)
over(order by OrderID) as RunningTotal
from Test;
AGGIORNAMENTO
Se ti senti a disagio con aggiornamento stravagante , puoi inserire una clausola di guardia per verificare se l'ordine delle righe da aggiornare corrisponde all'ordine originale (aiutato da identity(1,1)):
create function TestRunningTotalGuarded()
returns @ReturnTable table(
OrderId int, Qty int,
RunningTotal int not null,
RN int identity(1,1) not null
)
as begin
insert into @ReturnTable(OrderID, Qty, RunningTotal)
select OrderID, Qty, 0 from Test
order by OrderID;
declare @RunningTotal int = 0;
declare @RN_check INT = 0;
update @ReturnTable set
@RN_check = @RN_check + 1,
@RunningTotal =
(case when RN = @RN_check then @RunningTotal + Qty else 1/0 end),
RunningTotal = @RunningTotal;
return;
end;
Se UPDATE aggiorna davvero le righe in un ordine imprevedibile (o per caso lo farà), @RN_Check non sarà più uguale a RN(identity order), il codice genererà un errore di divisione per zero poi. Utilizzando la clausola di protezione, l'ordine di aggiornamento imprevedibile fallirà rapidamente
; in tal caso, sarà il momento di presentare un bug petizione a Microsoft per rendere il bizzarro aggiornamento non così bizzarro :-)
La protezione della clausola di guardia sull'operazione intrinsecamente imperativa (assegnazione variabile) è davvero sequenziale.
