Total cumulé. MISE À JOUR table temporaire 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;
Solution récursive prend 9 secondes :
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);
MISE À JOUR du tableau prend 0 seconde :
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;
Ces deux approches pourraient au moins vous donner un cadre sur lequel construire votre requête.
BTW dans SQL Server, contrairement à MySQL, l'ordre d'affectation des variables n'a pas d'importance. Ceci :
update @ReturnTable set
RunningTotal = @RunningTotal,
@RunningTotal = @RunningTotal + Qty;
Et les suivants :
update @ReturnTable set
@RunningTotal = @RunningTotal + Qty,
RunningTotal = @RunningTotal;
Ils s'exécutent tous les deux de la même manière, c'est-à-dire que les affectations de variables se produisent en premier, quelle que soit la position de l'affectation de variable dans l'instruction. Les deux requêtes ont le même résultat :
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
Sur votre tableau exact, détectez simplement Achat/Vente, vous pouvez soit le multiplier par 1 et -1 respectivement, soit simplement signer les champs, par ex. :
update @ReturnTable set
@RunningTotal = @RunningTotal +
CASE WHEN BuySell = 'Buy' THEN Qty ELSE -Qty END,
RunningTotal = @RunningTotal;
Si vous effectuez une mise à niveau vers SQL Server 2012, voici la mise en œuvre simple du total cumulé :
select OrderID, Qty, sum(Qty) over(order by OrderID) as RunningTotal
from Test
Sur votre problème exact :
select OrderID, Qty,
sum(CASE WHEN BuySell = 'Buy' THEN Qty ELSE -Qty END)
over(order by OrderID) as RunningTotal
from Test;
MISE À JOUR
Si vous vous sentez mal à l'aise avec mise à jour originale , vous pouvez mettre une clause de garde pour vérifier si l'ordre des lignes à mettre à jour correspond à l'ordre d'origine (aidé par 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;
Si UPDATE met vraiment à jour les lignes dans un ordre imprévisible (ou par hasard), le @RN_Check ne sera plus égal à RN (ordre d'identité), le code générera une erreur de division par zéro alors. En utilisant la clause de garde, l'ordre de mise à jour imprévisible échouera rapidement
; si cela se produit alors, il sera temps de signaler un bug pétition à Microsoft pour rendre la mise à jour bizarre moins bizarre :-)
La couverture de la clause de garde sur l'opération intrinsèquement impérative (affectation de variable) est vraiment séquentielle.
