एसक्यूएल, संख्याओं की सहायक तालिका

हे... क्षमा करें मुझे एक पुरानी पोस्ट का जवाब देने में इतनी देर हो रही है। और, हाँ, मुझे जवाब देना पड़ा क्योंकि इस धागे पर सबसे लोकप्रिय उत्तर (उस समय, 14 अलग-अलग तरीकों के लिंक के साथ रिकर्सिव सीटीई उत्तर) है, उम्म... प्रदर्शन को सर्वश्रेष्ठ चुनौती दी गई है।

सबसे पहले, 14 अलग-अलग समाधानों वाला आलेख फ्लाई पर नंबर/टैली तालिका बनाने के विभिन्न तरीकों को देखने के लिए ठीक है, लेकिन जैसा कि लेख और उद्धृत धागे में बताया गया है, वहां एक बहुत है महत्वपूर्ण उद्धरण...

"दक्षता और प्रदर्शन के बारे में सुझाव अक्सर व्यक्तिपरक होते हैं। चाहे किसी क्वेरी का उपयोग कैसे किया जा रहा हो, भौतिक कार्यान्वयन एक क्वेरी की दक्षता को निर्धारित करता है। इसलिए, पक्षपाती दिशानिर्देशों पर भरोसा करने के बजाय, यह अनिवार्य है कि आप क्वेरी का परीक्षण करें और निर्धारित करें कि कौन सा बेहतर प्रदर्शन करता है।" पी>

विडंबना यह है कि लेख में ही कई व्यक्तिपरक बयान और "पक्षपाती दिशानिर्देश" शामिल हैं जैसे कि "एक पुनरावर्ती सीटीई एक संख्या सूची उत्पन्न कर सकता है काफी कुशलता से " और "यह एक कुशल तरीका है इत्ज़िक बेन-जेन द्वारा पोस्ट किए गए समाचार समूह से WHILE लूप का उपयोग करने के बारे में" (जो मुझे यकीन है कि उन्होंने सिर्फ तुलना उद्देश्यों के लिए पोस्ट किया है)। चलो दोस्तों... इत्ज़िक के अच्छे नाम का उल्लेख करने से कुछ खराब स्लोब वास्तव में उस भयानक तरीके का उपयोग कर सकते हैं। लेखक को अभ्यास करना चाहिए कि वह क्या उपदेश देता है और इस तरह के हास्यास्पद रूप से गलत बयान देने से पहले विशेष रूप से किसी भी मापनीयता के सामने थोड़ा प्रदर्शन परीक्षण करना चाहिए।

कोई भी कोड क्या करता है या कोई क्या "पसंद करता है" के बारे में कोई व्यक्तिपरक दावा करने से पहले वास्तव में कुछ परीक्षण करने के विचार के साथ, यहां कुछ कोड है जिसके साथ आप अपना परीक्षण कर सकते हैं। जिस SPID से आप परीक्षण चला रहे हैं उसके लिए प्रोफाइलर सेट करें और इसे स्वयं देखें... अपने "पसंदीदा" नंबर के लिए 1000000 नंबर का "Search'n'Replace" करें और देखें...

--===== Test for 1000000 rows ==================================
GO
--===== Traditional RECURSIVE CTE method
   WITH Tally (N) AS 
        ( 
         SELECT 1 UNION ALL 
         SELECT 1 + N FROM Tally WHERE N < 1000000 
        ) 
 SELECT N 
   INTO #Tally1 
   FROM Tally 
 OPTION (MAXRECURSION 0);
GO
--===== Traditional WHILE LOOP method
 CREATE TABLE #Tally2 (N INT);
    SET NOCOUNT ON;
DECLARE @Index INT;
    SET @Index = 1;
  WHILE @Index <= 1000000 
  BEGIN 
         INSERT #Tally2 (N) 
         VALUES (@Index);
            SET @Index = @Index + 1;
    END;
GO
--===== Traditional CROSS JOIN table method
 SELECT TOP (1000000)
        ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS N
   INTO #Tally3
   FROM Master.sys.All_Columns ac1
  CROSS JOIN Master.sys.ALL_Columns ac2;
GO
--===== Itzik's CROSS JOINED CTE method
   WITH E00(N) AS (SELECT 1 UNION ALL SELECT 1),
        E02(N) AS (SELECT 1 FROM E00 a, E00 b),
        E04(N) AS (SELECT 1 FROM E02 a, E02 b),
        E08(N) AS (SELECT 1 FROM E04 a, E04 b),
        E16(N) AS (SELECT 1 FROM E08 a, E08 b),
        E32(N) AS (SELECT 1 FROM E16 a, E16 b),
   cteTally(N) AS (SELECT ROW_NUMBER() OVER (ORDER BY N) FROM E32)
 SELECT N
   INTO #Tally4
   FROM cteTally
  WHERE N <= 1000000;
GO
--===== Housekeeping
   DROP TABLE #Tally1, #Tally2, #Tally3, #Tally4;
GO

जब हम इस पर होते हैं, तो मुझे एसक्यूएल प्रोफाइलर से 100, 1000, 10000, 100000, और 100000 के मानों के लिए नंबर मिलते हैं...

SPID TextData                                 Dur(ms) CPU   Reads   Writes
---- ---------------------------------------- ------- ----- ------- ------
  51 --===== Test for 100 rows ==============       8     0       0      0
  51 --===== Traditional RECURSIVE CTE method      16     0     868      0
  51 --===== Traditional WHILE LOOP method CR      73    16     175      2
  51 --===== Traditional CROSS JOIN table met      11     0      80      0
  51 --===== Itzik's CROSS JOINED CTE method        6     0      63      0
  51 --===== Housekeeping   DROP TABLE #Tally      35    31     401      0

  51 --===== Test for 1000 rows =============       0     0       0      0
  51 --===== Traditional RECURSIVE CTE method      47    47    8074      0
  51 --===== Traditional WHILE LOOP method CR      80    78    1085      0
  51 --===== Traditional CROSS JOIN table met       5     0      98      0
  51 --===== Itzik's CROSS JOINED CTE method        2     0      83      0
  51 --===== Housekeeping   DROP TABLE #Tally       6    15     426      0

  51 --===== Test for 10000 rows ============       0     0       0      0
  51 --===== Traditional RECURSIVE CTE method     434   344   80230     10
  51 --===== Traditional WHILE LOOP method CR     671   563   10240      9
  51 --===== Traditional CROSS JOIN table met      25    31     302     15
  51 --===== Itzik's CROSS JOINED CTE method       24     0     192     15
  51 --===== Housekeeping   DROP TABLE #Tally       7    15     531      0

  51 --===== Test for 100000 rows ===========       0     0       0      0
  51 --===== Traditional RECURSIVE CTE method    4143  3813  800260    154
  51 --===== Traditional WHILE LOOP method CR    5820  5547  101380    161
  51 --===== Traditional CROSS JOIN table met     160   140     479    211
  51 --===== Itzik's CROSS JOINED CTE method      153   141     276    204
  51 --===== Housekeeping   DROP TABLE #Tally      10    15     761      0

  51 --===== Test for 1000000 rows ==========       0     0       0      0
  51 --===== Traditional RECURSIVE CTE method   41349 37437 8001048   1601
  51 --===== Traditional WHILE LOOP method CR   59138 56141 1012785   1682
  51 --===== Traditional CROSS JOIN table met    1224  1219    2429   2101
  51 --===== Itzik's CROSS JOINED CTE method     1448  1328    1217   2095
  51 --===== Housekeeping   DROP TABLE #Tally       8     0     415      0

जैसा कि आप देख सकते हैं, रिकर्सिव सीटीई विधि, जबकि लूप फॉर ड्यूरेशन और सीपीयू के बाद दूसरा सबसे खराब है और इसमें लॉजिकल रीड के रूप में मेमोरी प्रेशर जबकि लूप की तुलना में 8 गुना है . यह स्टेरॉयड पर आरबीएआर है और किसी भी एकल पंक्ति गणना के लिए, हर कीमत से बचा जाना चाहिए, जैसे कि लूप से बचा जाना चाहिए। ऐसे स्थान हैं जहां रिकर्सन काफी मूल्यवान है लेकिन यह उनमें से एक नहीं है ।

एक साइड बार के रूप में, मिस्टर डेनी बिल्कुल हाजिर हैं... एक सही आकार का स्थायी नंबर या टैली टेबल अधिकांश चीजों के लिए जाने का रास्ता है। सही आकार का क्या मतलब है? ठीक है, ज्यादातर लोग टैली टेबल का उपयोग तारीख बनाने या VARCHAR (8000) पर विभाजन करने के लिए करते हैं। यदि आप "एन" पर सही क्लस्टर इंडेक्स के साथ 11,000 पंक्ति टैली टेबल बनाते हैं, तो आपके पास 30 साल से अधिक की तारीखें बनाने के लिए पर्याप्त पंक्तियां होंगी (मैं बंधक के साथ काम करता हूं इसलिए 30 साल मेरे लिए एक महत्वपूर्ण संख्या है ) और निश्चित रूप से एक VARCHAR(8000) विभाजन को संभालने के लिए पर्याप्त है। "सही आकार" इतना महत्वपूर्ण क्यों है? यदि टैली टेबल का बहुत अधिक उपयोग किया जाता है, तो यह आसानी से कैश में फिट हो जाती है जो इसे मेमोरी पर अधिक दबाव के बिना बहुत तेज बनाता है।

अंतिम लेकिन कम से कम, हर कोई जानता है कि यदि आप एक स्थायी टैली टेबल बनाते हैं, तो इससे कोई फर्क नहीं पड़ता कि आप इसे बनाने के लिए किस विधि का उपयोग करते हैं क्योंकि 1) यह केवल एक बार बनने जा रहा है और 2) यदि यह 11,000 पंक्ति जैसा कुछ है तालिका में, सभी विधियां "काफी अच्छी" चलने जा रही हैं। तो किस विधि का उपयोग करने के बारे में मेरी ओर से सभी आक्रोश क्यों???

इसका उत्तर यह है कि कुछ गरीब लड़का/लड़की जो किसी भी बेहतर नहीं जानते हैं और बस अपना काम पूरा करने की जरूरत है, वे रिकर्सिव सीटीई विधि की तरह कुछ देख सकते हैं और इसे इमारत से कहीं अधिक बड़े और अधिक बार उपयोग किए जाने के लिए उपयोग करने का निर्णय ले सकते हैं एक स्थायी टैली टेबल है और मैं उन लोगों की रक्षा करने की कोशिश कर रहा हूं, जिन सर्वरों पर उनका कोड चलता है, और कंपनी जो उन सर्वरों पर डेटा का मालिक है . हाँ... इतनी बड़ी बात है। यह बाकी सभी के लिए भी होना चाहिए। "काफी अच्छा" के बजाय चीजों को करने का सही तरीका सिखाएं। किसी पोस्ट या किताब से कुछ पोस्ट करने या उपयोग करने से पहले कुछ परीक्षण करें ... आप जो जीवन बचाते हैं, वह वास्तव में आपका अपना हो सकता है, खासकर यदि आपको लगता है कि एक पुनरावर्ती सीटीई ऐसा कुछ करने का तरीका है।;-)

सुनने के लिए धन्यवाद...