SQL सर्वर कब रिवाइंड करता है?

परिचय

रिवाइंड्स एक नेस्टेड लूप के अंदरूनी हिस्से में शामिल होने या लागू होने वाले ऑपरेटरों के लिए विशिष्ट हैं। विचार एक निष्पादन योजना के हिस्से से पहले से गणना किए गए परिणामों का पुन:उपयोग करना है जहां ऐसा करना सुरक्षित है।

आलसी टेबल स्पूल . एक प्लान ऑपरेटर का प्रामाणिक उदाहरण है जो रिवाइंड कर सकता है . इसका रासन डी'एत्रे योजना उपट्री से परिणाम पंक्तियों को कैश करना है, फिर उन पंक्तियों को बाद के पुनरावृत्तियों पर फिर से चलाएं यदि कोई सहसंबंधित लूप पैरामीटर अपरिवर्तित हैं। पंक्तियों को फिर से चलाना उन सबट्री को फिर से निष्पादित करने से सस्ता हो सकता है जो उन्हें उत्पन्न करते हैं। इन प्रदर्शन स्पूल . पर अधिक पृष्ठभूमि के लिए मेरा पिछला लेख देखें।

दस्तावेज़ीकरण कहता है कि केवल निम्नलिखित ऑपरेटर ही रिवाइंड कर सकते हैं:

• टेबल स्पूल
• रो काउंट स्पूल
• असंकुल सूचकांक स्पूल
• तालिका-मूल्यवान फ़ंक्शन
• क्रमबद्ध करें
• दूरस्थ क्वेरी
• जोर दें और फ़िल्टर करें स्टार्टअप एक्सप्रेशन . वाले ऑपरेटर

पहले तीन आइटम अक्सर प्रदर्शन स्पूल होते हैं, हालांकि उन्हें अन्य कारणों से पेश किया जा सकता है (जब वे उत्सुक होने के साथ-साथ आलसी भी हो सकते हैं)।

तालिका-मूल्यवान फ़ंक्शन तालिका चर का उपयोग करें, जिसका उपयोग उपयुक्त परिस्थितियों में परिणामों को कैश करने और फिर से चलाने के लिए किया जा सकता है। यदि आप टेबल-वैल्यू फंक्शन रिवाइंड में रुचि रखते हैं, तो कृपया डेटाबेस एडमिनिस्ट्रेटर स्टैक एक्सचेंज पर मेरा प्रश्नोत्तर देखें।

उन लोगों के साथ, यह लेख विशेष रूप से सॉर्ट्स . के बारे में है और जब वे रिवाइंड कर सकते हैं।

रिवाइंड क्रमित करें

सॉर्ट स्टोरेज का उपयोग करते हैं (स्मृति और शायद डिस्क यदि वे फैलते हैं) तो उनके पास एक सुविधा है सक्षम लूप पुनरावृत्तियों के बीच पंक्तियों को संग्रहीत करना। विशेष रूप से, सॉर्ट किया गया आउटपुट, सिद्धांत रूप में, फिर से चलाया जा सकता है (रिवाउंड)।

फिर भी, शीर्षक प्रश्न का संक्षिप्त उत्तर, "डू सॉर्ट्स रिवाइंड?" है:

हां, लेकिन आप इसे बहुत बार नहीं देख पाएंगे।

सॉर्ट प्रकार

आंतरिक रूप से सॉर्ट कई अलग-अलग प्रकारों में आते हैं, लेकिन हमारे वर्तमान उद्देश्यों के लिए केवल दो ही हैं:

1. इन-मेमोरी सॉर्ट (CQScanInMemSortNew ).
   • हमेशा स्मृति में; छिड़क नहीं सकता डिस्क पर।
   • मानक पुस्तकालय त्वरित सॉर्ट का उपयोग करता है।
   • अधिकतम 500 पंक्तियां और दो 8KB पृष्ठ कुल मिलाकर।
   • सभी इनपुट रनटाइम स्थिरांक होने चाहिए। आमतौर पर इसका मतलब है कि संपूर्ण सॉर्ट सबट्री में केवल . होना चाहिए लगातार स्कैन और/या स्केलर की गणना करें ऑपरेटरों।
   • निष्पादन योजनाओं में केवल तभी स्पष्ट रूप से पहचाना जा सकता है जब वर्बोज़ शोप्लान सक्षम है (ट्रेस ध्वज 8666)। यह सॉर्ट करें . में अतिरिक्त गुण जोड़ता है ऑपरेटर, जिनमें से एक "इनमेमरी=[0|1]" है।
2. अन्य सभी प्रकार।

(दोनों प्रकार के क्रमबद्ध करें ऑपरेटर में उनके टॉप एन सॉर्ट . शामिल हैं और अलग क्रमबद्ध करें वेरिएंट)।

रिवाइंड बिहेवियर

• इन-मेमोरी सॉर्ट हमेशा रिवाइंड कर सकते हैं जब यह सुरक्षित हो। यदि कोई सहसंबद्ध लूप पैरामीटर नहीं हैं, या पैरामीटर मान तत्काल पूर्व पुनरावृत्ति से अपरिवर्तित हैं, तो इस प्रकार का सॉर्ट निष्पादन योजना में इसके नीचे के ऑपरेटरों को फिर से निष्पादित करने के बजाय अपने संग्रहीत डेटा को फिर से चला सकता है।

• गैर-मेमोरी सॉर्ट्स रिवाइंड कर सकते हैं सुरक्षित होने पर, लेकिन केवल तभी जब क्रमबद्ध करें ऑपरेटर में अधिकतम एक पंक्ति . है . कृपया एक क्रमबद्ध करें नोट करें इनपुट कुछ पुनरावृत्तियों पर एक पंक्ति प्रदान कर सकता है, लेकिन अन्य नहीं। इसलिए रनटाइम व्यवहार रिवाइंड और रिबाइंड का एक जटिल मिश्रण हो सकता है। यह पूरी तरह से इस बात पर निर्भर करता है कि सॉर्ट करें . के लिए कितनी पंक्तियाँ प्रदान की जाती हैं रनटाइम पर प्रत्येक पुनरावृत्ति पर। आप आमतौर पर अनुमान नहीं लगा सकते कि सॉर्ट करें निष्पादन योजना का निरीक्षण करके प्रत्येक पुनरावृत्ति पर करेंगे।

उपरोक्त विवरण में "सुरक्षित" शब्द का अर्थ है:या तो पैरामीटर में कोई परिवर्तन नहीं हुआ, या सॉर्ट करें के नीचे कोई ऑपरेटर नहीं है परिवर्तित मूल्य की निर्भरता है।

निष्पादन योजनाओं के बारे में महत्वपूर्ण नोट

निष्पादन योजनाएं हमेशा सॉर्ट करें के लिए रिवाइंड (और रीबाइंड) की सही रिपोर्ट नहीं करती हैं ऑपरेटरों। ऑपरेटर रिपोर्ट करेगा यदि कोई सहसंबद्ध पैरामीटर अपरिवर्तित हैं, तो रिवाइंड करें और अन्यथा रिबाइंड करें।

गैर-मेमोरी प्रकार (सबसे दूर और सबसे आम) के लिए, एक रिपोर्ट किया गया रिवाइंड वास्तव में केवल संग्रहीत सॉर्ट परिणामों को फिर से चलाएगा यदि सॉर्ट आउटपुट बफर में अधिकतम एक पंक्ति है। अन्यथा, सॉर्ट रिपोर्ट करेगा एक उल्टा, लेकिन उपट्री अभी भी पूरी तरह से फिर से निष्पादित होगी (एक रिबाइंड)।

यह देखने के लिए कि कितने रिपोर्ट किए गए रिवाइंड वास्तविक रिवाइंड थे, निष्पादनों की संख्या जांचें क्रमबद्ध करें . के नीचे ऑपरेटरों पर संपत्ति ।

इतिहास और मेरी व्याख्या

क्रमबद्ध करें ऑपरेटर का उल्टा व्यवहार अजीब लग सकता है, लेकिन यह (कम से कम) SQL Server 2000 से SQL Server 2019 समावेशी (साथ ही Azure SQL डेटाबेस) से इस तरह से रहा है। मुझे इसके बारे में कोई आधिकारिक स्पष्टीकरण या दस्तावेज़ीकरण नहीं मिला है।

मेरा निजी विचार है कि क्रमबद्ध करें रिवाइंड्स अंतर्निहित सॉर्टिंग मशीनरी, स्पिल सुविधाओं सहित, और tempdb में सिस्टम लेनदेन के उपयोग के कारण काफी महंगे हैं। ।

ज्यादातर मामलों में, अनुकूलक स्पष्ट प्रदर्शन स्पूल . को पेश करने के लिए बेहतर करेगा जब यह डुप्लिकेट सहसंबद्ध लूप मापदंडों की संभावना का पता लगाता है। आंशिक परिणामों को कैश करने के लिए स्पूल सबसे कम खर्चीला तरीका है।

यह संभव है जो एक सॉर्ट करें . को फिर से चला रहा है परिणाम केवल स्पूल . की तुलना में अधिक लागत प्रभावी होगा जब क्रमबद्ध करें अधिकतम एक पंक्ति शामिल है। आखिरकार, एक पंक्ति (या कोई पंक्तियाँ नहीं!) को छाँटने में वास्तव में कोई छँटाई शामिल नहीं है, इसलिए बहुत अधिक ओवरहेड से बचा जा सकता है।

शुद्ध अटकलें, लेकिन कोई पूछने के लिए बाध्य था, तो यह है।

डेमो 1:गलत रिवाइंड्स

इस पहले उदाहरण में दो तालिका चर हैं। पहले में तीन मान हैं जो तीन बार कॉलम c1 . में दोहराए गए हैं . दूसरी तालिका में प्रत्येक मैच के लिए c2 = c1 . पर दो पंक्तियाँ हैं . दो मेल खाने वाली पंक्तियों को c3 column कॉलम में एक मान से पहचाना जाता है ।

कार्य दूसरी तालिका से उच्चतम c3 . के साथ पंक्ति को वापस करना है c1 = c2 . पर प्रत्येक मैच के लिए मान . कोड शायद मेरे स्पष्टीकरण से अधिक स्पष्ट है:

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
INSERT @T2 
    (c2, c3)
VALUES
    (1, 1),
    (1, 2),
    (2, 3),
    (2, 4),
    (3, 5),
    (3, 6);
 
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
CROSS APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

NO_PERFORMANCE_SPOOL ऑप्टिमाइज़र को एक प्रदर्शन स्पूल शुरू करने से रोकने के लिए संकेत है। यह तालिका चर के साथ हो सकता है जब उदा। ट्रेस फ्लैग 2453 सक्षम है, या तालिका चर आस्थगित संकलन उपलब्ध है, इसलिए अनुकूलक तालिका चर (लेकिन मूल्य वितरण नहीं) की वास्तविक कार्डिनैलिटी देख सकता है।

क्वेरी परिणाम c2 . दिखाते हैं और c3 लौटाए गए मान प्रत्येक विशिष्ट c1 . के लिए समान हैं मूल्य:

क्वेरी के लिए वास्तविक निष्पादन योजना है:

c1 मान, क्रम में प्रस्तुत, पिछले पुनरावृत्ति से 6 बार मेल खाते हैं, और 3 बार बदलते हैं। क्रमबद्ध करें इसे 6 रिवाइंड और 3 रिबाइंड के रूप में रिपोर्ट करता है।

अगर यह सच था, टेबल स्कैन केवल 3 बार निष्पादित होगा। क्रमबद्ध करें अन्य 6 मौकों पर इसके परिणामों को फिर से चलाएगा (रिवाइंड) करेगा।

वैसे भी, हम टेबल स्कैन देख सकते हैं तालिका @T1 . से प्रत्येक पंक्ति के लिए एक बार 9 बार निष्पादित किया गया था . यहां कोई रिवाइंड नहीं हुआ ।

डेमो 2:रिवाइंड को सॉर्ट करें

पिछले उदाहरण ने सॉर्ट करें . की अनुमति नहीं दी रिवाइंड करने के लिए क्योंकि (ए) यह इन-मेमोरी सॉर्ट . नहीं है; और (बी) लूप के प्रत्येक पुनरावृत्ति पर, सॉर्ट करें जिसमें दो पंक्तियाँ थीं। प्लान एक्सप्लोरर टेबल स्कैन . से कुल 18 पंक्तियां दिखाता है , 9 पुनरावृत्तियों में से प्रत्येक पर दो पंक्तियाँ।

आइए अब उदाहरण में बदलाव करें ताकि केवल एक . हो तालिका में पंक्ति @T2 @T1 . से प्रत्येक मिलान पंक्ति के लिए :

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- Only one matching row per iteration now
INSERT @T2 
    (c2, c3)
VALUES
    --(1, 1),
    (1, 2),
    --(2, 3),
    (2, 4),
    --(3, 5),
    (3, 6);
 
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
CROSS APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

परिणाम वही हैं जो पहले दिखाए गए थे क्योंकि हमने मिलान पंक्ति को रखा था जो कॉलम c3 पर सबसे अधिक क्रमबद्ध थी . निष्पादन योजना भी सतही रूप से समान है, लेकिन एक महत्वपूर्ण अंतर के साथ:

सॉर्ट करें . में एक पंक्ति के साथ किसी भी समय, यह सहसंबद्ध पैरामीटर c1 . होने पर रिवाइंड करने में सक्षम होता है नहीं बदलता। टेबल स्कैन परिणामस्वरूप केवल 3 बार निष्पादित किया जाता है।

ध्यान दें क्रमबद्ध करें अधिक पंक्तियां उत्पन्न करता है (9) की तुलना में यह प्राप्त करता है (3)। यह एक अच्छा संकेत है कि क्रमबद्ध करें परिणाम सेट को एक या अधिक बार कैश करने में कामयाब रहा है - एक सफल रिवाइंड।

डेमो 3:रिवाइंडिंग नथिंग

मैंने पहले उल्लेख किया था कि एक गैर-मेमोरी सॉर्ट करें रिवाइंड कर सकता है जब इसमें अधिकतम . हो एक पंक्ति।

यह देखने के लिए कि शून्य पंक्तियों . के साथ कार्रवाई में , हम एक OUTER APPLY . में बदलते हैं और किसी भी पंक्ति को तालिका में न रखें @T2 . जिन कारणों से शीघ्र ही स्पष्ट हो जाएगा, हम कॉलम c2 . को प्रोजेक्ट करना भी बंद कर देंगे :

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- No rows added to table @T2
 
-- No longer projecting c2
SELECT
    T1.c1,
    --CA.c2,
    CA.c3
FROM @T1 AS T1
OUTER APPLY
(
    SELECT TOP (1)
        --T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

परिणामों में अब NULL है कॉलम में c3 उम्मीद के मुताबिक:

निष्पादन योजना है:

क्रमबद्ध करें अपने बफर में पंक्तियों के बिना रिवाइंड करने में सक्षम था, इसलिए टेबल स्कैन केवल 3 बार निष्पादित किया गया था, हर बार कॉलम c1 परिवर्तित मूल्य।

डेमो 4:अधिकतम रिवाइंड!

रिवाइंड का समर्थन करने वाले अन्य ऑपरेटरों की तरह, एक सॉर्ट करें केवल रीबाइंड होगा इसका उपप्रकार यदि एक सहसंबद्ध पैरामीटर बदल गया है और सबट्री किसी तरह उस मान पर निर्भर करता है।

कॉलम को पुनर्स्थापित करना c2 डेमो 3 का प्रक्षेपण इसे क्रिया में दिखाएगा:

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- Still no rows in @T2
-- Column c2 is back!
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
OUTER APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

परिणाम अब दो NULL show दिखाते हैं बेशक कॉलम:

निष्पादन योजना काफी अलग है:

इस बार, फ़िल्टर चेक शामिल है T2.c2 = T1.c1 , टेबल स्कैन . बनाना स्वतंत्र सहसंबद्ध पैरामीटर के वर्तमान मान का c1 . क्रमबद्ध करें सुरक्षित रूप से 8 बार रिवाइंड कर सकता है, जिसका अर्थ है कि स्कैन केवल एक बार निष्पादित किया जाता है ।

डेमो 5:इन-मेमोरी सॉर्ट

अगला उदाहरण इन-मेमोरी सॉर्ट करें . दिखाता है ऑपरेटर:

DECLARE @T table (v integer NOT NULL);
 
INSERT @T 
    (v)
VALUES 
    (1), (2), (3), 
    (4), (5), (6);
 
SELECT 
    T.v,
    OA.i 
FROM @T AS T
OUTER APPLY
(
    SELECT TOP (1) 
        X.i 
    FROM 
    (
        VALUES
            (REPLICATE('Z', 1390)),
            ('0'), ('1'), ('2'), ('3'), ('4'), 
            ('5'), ('6'), ('7'), ('8'), ('9')
    ) AS X (i)
    ORDER BY NEWID()
) AS OA
OPTION (NO_PERFORMANCE_SPOOL);

आपको मिलने वाले परिणाम निष्पादन से निष्पादन में भिन्न होंगे, लेकिन यहां एक उदाहरण दिया गया है:

दिलचस्प बात यह है कि कॉलम i . में मान हैं हमेशा वही रहेगा — ORDER BY NEWID() . के बावजूद खंड।

आप शायद पहले ही अनुमान लगा चुके होंगे कि इसका कारण सॉर्ट करें . है कैशिंग परिणाम (रिवाइंडिंग)। निष्पादन योजना लगातार स्कैन दिखाती है केवल एक बार क्रियान्वित, कुल 11 पंक्तियों का निर्माण:

यह क्रमबद्ध करें केवल गणना स्केलर . है और लगातार स्कैन इसके इनपुट पर ऑपरेटर इसलिए यह एक मेमोरी सॉर्ट में . है . याद रखें, ये ज़्यादा से ज़्यादा एक पंक्ति तक सीमित नहीं हैं — ये 500 पंक्तियों और 16KB को समायोजित कर सकते हैं।

जैसा कि पहले उल्लेख किया गया है, यह स्पष्ट रूप से देखना संभव नहीं है कि क्या क्रमबद्ध करें इन-मेमोरी है या नियमित निष्पादन योजना का निरीक्षण करके नहीं। हमें वर्बोज़ शोप्लान आउटपुट need चाहिए , गैर-दस्तावेज ट्रेस ध्वज 8666 के साथ सक्षम है। इसके सक्षम होने पर, अतिरिक्त ऑपरेटर गुण प्रकट होते हैं:

जब अनिर्दिष्ट ट्रेस फ़्लैग का उपयोग करना व्यावहारिक नहीं है, तो आप अनुमान लगा सकते हैं कि सॉर्ट करें इसके इनपुट मेमोरी फ़्रैक्शन . द्वारा "इनमेमोरी" है शून्य होना, और स्मृति उपयोग पोस्ट-निष्पादन शोप्लान (उस जानकारी का समर्थन करने वाले SQL सर्वर संस्करणों पर) में तत्व उपलब्ध नहीं हैं।

निष्पादन योजना पर वापस जाएं:कोई सहसंबद्ध पैरामीटर नहीं हैं इसलिए क्रमबद्ध करें 5 बार रिवाइंड करने के लिए स्वतंत्र है, जिसका अर्थ है लगातार स्कैन केवल एक बार निष्पादित किया जाता है। बेझिझक TOP (1) बदलें करने के लिए TOP (3) या जो भी आपको पसंद हो। रिवाइंडिंग का अर्थ है कि परिणाम प्रत्येक इनपुट पंक्ति के लिए समान (कैश्ड/रिवाउंड) होंगे।

आप ORDER BY NEWID() . से परेशान हो सकते हैं खंड रीवाइंडिंग को नहीं रोक रहा है। यह वास्तव में एक विवादास्पद बिंदु है, लेकिन बिल्कुल भी सीमित नहीं है। अधिक विस्तृत चर्चा के लिए (चेतावनी:संभव खरगोश छेद) कृपया यह प्रश्नोत्तर देखें। संक्षिप्त संस्करण यह है कि यह एक जानबूझकर उत्पाद डिजाइन निर्णय है, जो प्रदर्शन के लिए अनुकूलित है, लेकिन समय के साथ व्यवहार को और अधिक सहज बनाने की योजना है।

डेमो 6:इन-मेमोरी सॉर्ट नहीं

यह डेमो 5 के समान है, सिवाय प्रतिरूपित स्ट्रिंग के एक वर्ण लंबा है:

DECLARE @T table (v integer NOT NULL);
 
INSERT @T 
    (v)
VALUES 
    (1), (2), (3), 
    (4), (5), (6);
 
SELECT 
    T.v,
    OA.i 
FROM @T AS T
OUTER APPLY
(
    SELECT TOP (1) 
        X.i 
    FROM 
    (
        VALUES
            -- 1391 instead of 1390
            (REPLICATE('Z', 1391)),
            ('0'), ('1'), ('2'), ('3'), ('4'), 
            ('5'), ('6'), ('7'), ('8'), ('9')
    ) AS X (i)
    ORDER BY NEWID()
) AS OA
OPTION (NO_PERFORMANCE_SPOOL);

फिर, परिणाम प्रति निष्पादन अलग-अलग होंगे, लेकिन यहां एक उदाहरण है। ध्यान दें i मान अब सभी समान नहीं हैं:

अतिरिक्त वर्ण केवल 16KB से अधिक सॉर्ट किए गए डेटा के अनुमानित आकार को आगे बढ़ाने के लिए पर्याप्त है। इसका अर्थ है एक इन-मेमोरी सॉर्ट इस्तेमाल नहीं किया जा सकता, और रिवाइंड गायब हो जाते हैं।

निष्पादन योजना है:

क्रमबद्ध करें अभी भी रिपोर्ट 5 रिवाइंड, लेकिन लगातार स्कैन 6 बार निष्पादित किया जाता है, जिसका अर्थ है कि वास्तव में कोई रिवाइंड नहीं हुआ। यह कुल 66 पंक्तियों को देते हुए, 6 निष्पादनों में से प्रत्येक पर सभी 11 पंक्तियों का निर्माण करता है।

सारांश और अंतिम विचार

आपको सॉर्ट करें . नहीं दिखाई देगा ऑपरेटर सच में बहुत बार रिवाइंड करना, हालांकि आप इसे कहते हुए देखेंगे बहुत कुछ।

याद रखें, एक नियमित सॉर्ट करें रिवाइंड तभी कर सकता है जब यह सुरक्षित हो और उस समय सॉर्ट में अधिकतम एक पंक्ति होती है। "सुरक्षित" होने का अर्थ है या तो लूप सहसंबंध पैरामीटर में कोई बदलाव नहीं है, या सॉर्ट करें . के नीचे कुछ भी नहीं है पैरामीटर परिवर्तन से प्रभावित होता है।

एक इन-मेमोरी सॉर्ट लगातार स्कैन . से प्राप्त 500 पंक्तियों और 16KB डेटा तक पर काम कर सकता है और गणना स्केलर केवल ऑपरेटरों। यह सुरक्षित होने पर ही रिवाइंड भी करेगा (उत्पाद बग एक तरफ!) लेकिन अधिकतम एक पंक्ति तक सीमित नहीं है।

ये गूढ़ विवरण की तरह लग सकते हैं, और मुझे लगता है कि वे हैं। ऐसा कहते हुए, उन्होंने मुझे एक निष्पादन योजना को समझने और एक से अधिक बार अच्छे प्रदर्शन सुधार खोजने में मदद की है। शायद एक दिन आपको जानकारी भी उपयोगी लगे।

क्रमबद्ध . के लिए देखें जो उनके इनपुट की तुलना में अधिक पंक्तियाँ उत्पन्न करते हैं!

यदि आप सॉर्ट करें . का अधिक यथार्थवादी उदाहरण देखना चाहते हैं उनके निकटतम मैच के भाग एक में प्रदान किए गए एक डेमो इत्ज़िक बेन-गण पर आधारित रिवाइंड्स श्रृंखला कृपया रिवाइंड क्रमबद्ध करें के साथ निकटतम मैच देखें।