मैंने इसी तरह की समस्याओं को देखा है और कभी भी एक विंडो फ़ंक्शन समाधान खोजने में सक्षम नहीं हुआ है जो डेटा पर एक पास करता है। मुझे नहीं लगता कि यह संभव है। विंडो फ़ंक्शन को एक कॉलम में सभी मानों पर लागू करने में सक्षम होना चाहिए। यह इस तरह से रीसेट गणना को बहुत कठिन बनाता है, क्योंकि एक रीसेट निम्नलिखित सभी मानों के लिए मूल्य बदलता है।
समस्या के बारे में सोचने का एक तरीका यह है कि आप अंतिम परिणाम प्राप्त कर सकते हैं यदि आप एक मूल रनिंग कुल की गणना करें जब तक कि आप सही पिछली पंक्ति से रनिंग कुल को घटा सकें। उदाहरण के लिए, आपके नमूना डेटा में id4 का मान है running total of row 4 - the running total of row 3। id6 के लिए मान है running total of row 6 - the running total of row 3क्योंकि एक रीसेट अभी तक नहीं हुआ है। id7 के लिए मूल्य running total of row 7 - the running total of row 6और इतने पर है।
मैं एक लूप में टी-एसक्यूएल के साथ इसे एप्रोच करूंगा। मैं थोड़ा दूर चला गया और मुझे लगता है कि मेरे पास एक पूर्ण समाधान है। 3 मिलियन पंक्तियों और 500 समूहों के लिए कोड 24 सेकंड में मेरे डेस्कटॉप पर समाप्त हो गया। मैं SQL सर्वर 2016 डेवलपर संस्करण के साथ 6 vCPU के साथ परीक्षण कर रहा हूं। मैं समानांतर आवेषण और सामान्य रूप से समानांतर निष्पादन का लाभ उठा रहा हूं ताकि आपको कोड बदलने की आवश्यकता हो यदि आप एक पुराने संस्करण पर हैं या डीओपी सीमाएं हैं।
उस कोड के नीचे जो मैंने डेटा उत्पन्न करने के लिए उपयोग किया था। पर पर्वतमाला 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) प्रत्येक समूह के लिए, तालिका में शेष रीसेट_वल्यू के ऊपर एक रनिंग कुल के साथ पहली पंक्ति की गणना करें और आईडी को स्टोर करें, चल रहा कुल जो बहुत बड़ा था, और पिछले चलने वाला कुल जो एक अस्थायी तालिका में बहुत बड़ा था।
2 बी) पहले अस्थायी तालिका से पंक्तियों को एक परिणाम अस्थायी तालिका में हटा दें , जिसमें दूसरे अस्थायी तालिका की IDतुलना में कम या बराबर है ID। आवश्यकतानुसार चलने वाले कुल को समायोजित करने के लिए अन्य कॉलम का उपयोग करें।
3) हटाने के बाद अब प्रक्रियाएं DELETE OUTPUTपरिणाम तालिका में अतिरिक्त चलाती हैं । यह समूह के अंत में पंक्तियों के लिए है जो रीसेट मूल्य से अधिक नहीं है।
मैं टी-एसक्यूएल चरण में उपरोक्त एल्गोरिथ्म के एक कार्यान्वयन के माध्यम से कदम से कदम मिलाकर चलूंगा।
कुछ टेम्प टेबल बनाकर शुरू करें। #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में सामान्य रूप से संकेत का प्रशंसक नहीं है , लेकिन यह एक सरल क्वेरी है और यह वह सबसे तेज़ तरीका है जो मुझे चाहिए था। प्रतिक्रिया समय के लिए वास्तव में अनुकूलित करने के लिए मुझे डीओपी 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;