Я смотрел на подобные проблемы и никогда не мог найти решение оконной функции, которое делает один проход по данным. Я не думаю, что это возможно. Оконные функции должны быть в состоянии применяться ко всем значениям в столбце. Это делает такие вычисления сброса очень сложными, потому что один сброс изменяет значение для всех следующих значений.
Один из способов решения проблемы заключается в том, что вы можете получить желаемый конечный результат, если вычисляете базовую промежуточную сумму, если вы можете вычесть промежуточную сумму из правильной предыдущей строки. Например, в ваших данных образца значение для id
4 являетсяrunning total of row 4 - the running total of row 3
. Значение id
6 - это running total of row 6 - the running total of row 3
потому что сброс еще не произошел. Значение для id
7 - это running total of row 7 - the running total of row 6
и так далее.
Я хотел бы подойти к этому с T-SQL в цикле. Я немного увлекся и думаю, что у меня есть полное решение. Для 3 миллионов строк и 500 групп код завершился за 24 секунды на моем рабочем столе. Я тестирую с SQL Server 2016 для разработчиков с 6 vCPU. Я использую преимущества параллельных вставок и параллельного выполнения в целом, поэтому вам может потребоваться изменить код, если вы используете более старую версию или имеете ограничения DOP.
Ниже код, который я использовал для генерации данных. Диапазоны на VAL
иRESET_VAL
должны быть аналогичны вашим образцам данных.
drop table if exists reset_runn_total;
create table reset_runn_total
(
id int identity(1,1),
val int,
reset_val int,
grp int
);
DECLARE
@group_num INT,
@row_num INT;
BEGIN
SET NOCOUNT ON;
BEGIN TRANSACTION;
SET @group_num = 1;
WHILE @group_num <= 50000
BEGIN
SET @row_num = 1;
WHILE @row_num <= 60
BEGIN
INSERT INTO reset_runn_total WITH (TABLOCK)
SELECT 1 + ABS(CHECKSUM(NewId())) % 10, 8 + ABS(CHECKSUM(NewId())) % 8, @group_num;
SET @row_num = @row_num + 1;
END;
SET @group_num = @group_num + 1;
END;
COMMIT TRANSACTION;
END;
Алгоритм выглядит следующим образом:
1) Начните с вставки всех строк со стандартным промежуточным итогом во временную таблицу.
2) В цикле:
2a) Для каждой группы вычислите первую строку с промежуточной суммой выше оставшегося в таблице значения reset_value и сохраните идентификатор, промежуточную сумму, которая была слишком большой, и предыдущую промежуточную сумму, которая была слишком большой, во временной таблице.
2b) Удалить строки из первой временной таблицы во временную таблицу результатов, которые имеют значение, ID
меньшее или равное ID
значению второй временной таблицы. Используйте другие столбцы для корректировки промежуточного итога по мере необходимости.
3) После удаления больше не обрабатываемых строк запускаются дополнительные DELETE OUTPUT
в таблицу результатов. Это для строк в конце группы, которые никогда не превышают значение сброса.
Я покажу пошаговую реализацию одного из описанных выше алгоритмов в T-SQL.
Начните с создания нескольких временных таблиц. #initial_results
содержит исходные данные со стандартным промежуточным итогом, #group_bookkeeping
обновляет каждый цикл, чтобы выяснить, какие строки могут быть перемещены, и #final_results
содержит результаты с промежуточным итогом, откорректированным для сброса.
CREATE TABLE #initial_results (
id int,
val int,
reset_val int,
grp int,
initial_running_total int
);
CREATE TABLE #group_bookkeeping (
grp int,
max_id_to_move int,
running_total_to_subtract_this_loop int,
running_total_to_subtract_next_loop int,
grp_done bit,
PRIMARY KEY (grp)
);
CREATE TABLE #final_results (
id int,
val int,
reset_val int,
grp int,
running_total int
);
INSERT INTO #initial_results WITH (TABLOCK)
SELECT ID, VAL, RESET_VAL, GRP, SUM(VAL) OVER (PARTITION BY GRP ORDER BY ID) RUNNING_TOTAL
FROM reset_runn_total;
CREATE CLUSTERED INDEX i1 ON #initial_results (grp, id);
INSERT INTO #group_bookkeeping WITH (TABLOCK)
SELECT DISTINCT GRP, 0, 0, 0, 0
FROM reset_runn_total;
Я создаю кластеризованный индекс для временной таблицы после этого, чтобы вставка и построение индекса могли выполняться параллельно. Сделал большую разницу на моей машине, но, возможно, не на вашей. Создание индекса для исходной таблицы, похоже, не помогло, но это могло бы помочь на вашем компьютере.
Приведенный ниже код запускается в цикле и обновляет таблицу учета. Для каждой группы нам нужно найти максимальное значение, ID
которое следует переместить в таблицу результатов. Нам нужна промежуточная сумма из этой строки, чтобы мы могли вычесть ее из начальной промежуточной суммы. grp_done
Столбец устанавливается в 1 , если не больше работы , чтобы сделать для grp
.
WITH UPD_CTE AS (
SELECT
#grp_bookkeeping.GRP
, MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN ID ELSE NULL END) max_id_to_update
, MIN(#group_bookkeeping.running_total_to_subtract_next_loop) running_total_to_subtract_this_loop
, MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN initial_running_total ELSE NULL END) additional_value_next_loop
, CASE WHEN MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN ID ELSE NULL END) IS NULL THEN 1 ELSE 0 END grp_done
FROM #group_bookkeeping
INNER JOIN #initial_results IR ON #group_bookkeeping.grp = ir.grp
WHERE #group_bookkeeping.grp_done = 0
GROUP BY #group_bookkeeping.GRP
)
UPDATE #group_bookkeeping
SET #group_bookkeeping.max_id_to_move = uv.max_id_to_update
, #group_bookkeeping.running_total_to_subtract_this_loop = uv.running_total_to_subtract_this_loop
, #group_bookkeeping.running_total_to_subtract_next_loop = uv.additional_value_next_loop
, #group_bookkeeping.grp_done = uv.grp_done
FROM UPD_CTE uv
WHERE uv.GRP = #group_bookkeeping.grp
OPTION (LOOP JOIN);
На самом деле не фанат LOOP JOIN
подсказки в целом, но это простой запрос, и это был самый быстрый способ получить то, что я хотел. Чтобы действительно оптимизировать время отклика, я хотел соединений с параллельными вложенными циклами вместо объединений DOP 1.
Приведенный ниже код выполняется в цикле и перемещает данные из исходной таблицы в таблицу окончательных результатов. Обратите внимание на корректировку начального промежуточного итога.
DELETE ir
OUTPUT DELETED.id,
DELETED.VAL,
DELETED.RESET_VAL,
DELETED.GRP ,
DELETED.initial_running_total - tb.running_total_to_subtract_this_loop
INTO #final_results
FROM #initial_results ir
INNER JOIN #group_bookkeeping tb ON ir.GRP = tb.GRP AND ir.ID <= tb.max_id_to_move
WHERE tb.grp_done = 0;
Для вашего удобства ниже приведен полный код:
DECLARE @RC INT;
BEGIN
SET NOCOUNT ON;
CREATE TABLE #initial_results (
id int,
val int,
reset_val int,
grp int,
initial_running_total int
);
CREATE TABLE #group_bookkeeping (
grp int,
max_id_to_move int,
running_total_to_subtract_this_loop int,
running_total_to_subtract_next_loop int,
grp_done bit,
PRIMARY KEY (grp)
);
CREATE TABLE #final_results (
id int,
val int,
reset_val int,
grp int,
running_total int
);
INSERT INTO #initial_results WITH (TABLOCK)
SELECT ID, VAL, RESET_VAL, GRP, SUM(VAL) OVER (PARTITION BY GRP ORDER BY ID) RUNNING_TOTAL
FROM reset_runn_total;
CREATE CLUSTERED INDEX i1 ON #initial_results (grp, id);
INSERT INTO #group_bookkeeping WITH (TABLOCK)
SELECT DISTINCT GRP, 0, 0, 0, 0
FROM reset_runn_total;
SET @RC = 1;
WHILE @RC > 0
BEGIN
WITH UPD_CTE AS (
SELECT
#group_bookkeeping.GRP
, MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN ID ELSE NULL END) max_id_to_move
, MIN(#group_bookkeeping.running_total_to_subtract_next_loop) running_total_to_subtract_this_loop
, MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN initial_running_total ELSE NULL END) additional_value_next_loop
, CASE WHEN MIN(CASE WHEN initial_running_total - #group_bookkeeping.running_total_to_subtract_next_loop > RESET_VAL THEN ID ELSE NULL END) IS NULL THEN 1 ELSE 0 END grp_done
FROM #group_bookkeeping
CROSS APPLY (SELECT ID, RESET_VAL, initial_running_total FROM #initial_results ir WHERE #group_bookkeeping.grp = ir.grp ) ir
WHERE #group_bookkeeping.grp_done = 0
GROUP BY #group_bookkeeping.GRP
)
UPDATE #group_bookkeeping
SET #group_bookkeeping.max_id_to_move = uv.max_id_to_move
, #group_bookkeeping.running_total_to_subtract_this_loop = uv.running_total_to_subtract_this_loop
, #group_bookkeeping.running_total_to_subtract_next_loop = uv.additional_value_next_loop
, #group_bookkeeping.grp_done = uv.grp_done
FROM UPD_CTE uv
WHERE uv.GRP = #group_bookkeeping.grp
OPTION (LOOP JOIN);
DELETE ir
OUTPUT DELETED.id,
DELETED.VAL,
DELETED.RESET_VAL,
DELETED.GRP ,
DELETED.initial_running_total - tb.running_total_to_subtract_this_loop
INTO #final_results
FROM #initial_results ir
INNER JOIN #group_bookkeeping tb ON ir.GRP = tb.GRP AND ir.ID <= tb.max_id_to_move
WHERE tb.grp_done = 0;
SET @RC = @@ROWCOUNT;
END;
DELETE ir
OUTPUT DELETED.id,
DELETED.VAL,
DELETED.RESET_VAL,
DELETED.GRP ,
DELETED.initial_running_total - tb.running_total_to_subtract_this_loop
INTO #final_results
FROM #initial_results ir
INNER JOIN #group_bookkeeping tb ON ir.GRP = tb.GRP;
CREATE CLUSTERED INDEX f1 ON #final_results (grp, id);
/* -- do something with the data
SELECT *
FROM #final_results
ORDER BY grp, id;
*/
DROP TABLE #final_results;
DROP TABLE #initial_results;
DROP TABLE #group_bookkeeping;
END;