बकेटाइज़िंग दिनांक और समय डेटा

तारीख और समय डेटा को बकेट करना विश्लेषणात्मक उद्देश्यों के लिए समय के निश्चित अंतराल का प्रतिनिधित्व करने वाले समूहों में डेटा को व्यवस्थित करना शामिल है। अक्सर इनपुट एक तालिका में संग्रहीत समय श्रृंखला डेटा होता है जहां पंक्तियां नियमित समय अंतराल पर किए गए मापों का प्रतिनिधित्व करती हैं। उदाहरण के लिए, माप हर 5 मिनट में तापमान और आर्द्रता रीडिंग हो सकता है, और आप प्रति घंटा बकेट का उपयोग करके डेटा को समूहित करना चाहते हैं और औसत प्रति घंटे की तरह योग की गणना करना चाहते हैं। भले ही समय श्रृंखला डेटा बकेट-आधारित विश्लेषण के लिए एक सामान्य स्रोत है, यह अवधारणा किसी भी डेटा के लिए उतनी ही प्रासंगिक है जिसमें दिनांक और समय विशेषताएँ और संबद्ध उपाय शामिल हैं। उदाहरण के लिए, हो सकता है कि आप बिक्री डेटा को वित्तीय वर्ष बकेट में व्यवस्थित करना चाहें और प्रति वित्तीय वर्ष कुल बिक्री मूल्य जैसे योगों की गणना करना चाहें। इस लेख में, मैं दिनांक और समय डेटा को बकेटाइज़ करने के दो तरीकों को शामिल करता हूँ। एक DATE_BUCKET नामक फ़ंक्शन का उपयोग कर रहा है, जो लेखन के समय केवल Azure SQL Edge में उपलब्ध है। दूसरा एक कस्टम गणना का उपयोग कर रहा है जो DATE_BUCKET फ़ंक्शन का अनुकरण करता है, जिसका उपयोग आप SQL सर्वर और Azure SQL डेटाबेस के किसी भी संस्करण, संस्करण और स्वाद में कर सकते हैं।

मेरे उदाहरणों में, मैं नमूना डेटाबेस TSQLV5 का उपयोग करूँगा। आप TSQLV5 को बनाने और भरने वाली स्क्रिप्ट यहाँ और इसके ER आरेख यहाँ पा सकते हैं।

DATE_BUCKET

जैसा कि उल्लेख किया गया है, DATE_BUCKET फ़ंक्शन वर्तमान में केवल Azure SQL Edge में उपलब्ध है। SQL सर्वर प्रबंधन स्टूडियो में पहले से ही IntelliSense समर्थन है, जैसा कि चित्र 1 में दिखाया गया है:

चित्र 1:SSMS में DATE_BUCKET के लिए इंटेलिजेंस समर्थन

फ़ंक्शन का सिंटैक्स इस प्रकार है:

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

इनपुट टाइमस्टैम्प समय में एक मनमाना बिंदु है जिसे इसके युक्त बाल्टी के साथ जोड़ा जाना चाहिए। इसके डेटा प्रकार को इनपुट के डेटा प्रकार से मेल खाना चाहिए मूल . इनपुट टाइमस्टैम्प आपके द्वारा कैप्चर किए जा रहे उपायों से संबद्ध दिनांक और समय मान है।

फ़ंक्शन का आउटपुट तब युक्त बाल्टी का प्रारंभिक बिंदु होता है। आउटपुट का डेटा प्रकार इनपुट का है टाइमस्टैम्प ।

यदि यह पहले से स्पष्ट नहीं था, तो आमतौर पर आप DATE_BUCKET फ़ंक्शन का उपयोग क्वेरी के GROUP BY क्लॉज़ में समूह सेट तत्व के रूप में करते हैं और स्वाभाविक रूप से इसे SELECT सूची में भी एकत्रित उपायों के साथ वापस कर देते हैं।

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

निम्नलिखित उदाहरण पर विचार करें:

DECLARE @timestamp AS DATETIME2 ='20210510 06:30:00', @bucketwidth AS INT =2, @origin AS DATETIME2 ='20210115 00:00:00'; DATE_BUCKET (माह, @bucketwidth, @timestamp, @origin) चुनें;

आप चित्र 2 में फ़ंक्शन के तर्क का एक दृश्य चित्रण पा सकते हैं।

चित्र 2:DATE_BUCKET फ़ंक्शन के तर्क का दृश्य चित्रण

जैसा कि आप चित्र 2 में देख सकते हैं, मूल बिंदु DATETIME2 मान 15 जनवरी, 2021, मध्यरात्रि है। यदि यह मूल बिंदु थोड़ा अजीब लगता है, तो आप सहज रूप से यह समझने में सही होंगे कि आम तौर पर आप किसी वर्ष की शुरुआत या किसी दिन की शुरुआत जैसे अधिक प्राकृतिक का उपयोग करेंगे। वास्तव में, आप अक्सर डिफ़ॉल्ट से संतुष्ट होंगे, जैसा कि आपको याद है, 1 जनवरी, 1900 को मध्यरात्रि में। मैं जानबूझकर कुछ जटिलताओं पर चर्चा करने में सक्षम होने के लिए एक कम तुच्छ मूल बिंदु का उपयोग करना चाहता था जो कि अधिक प्राकृतिक का उपयोग करते समय प्रासंगिक नहीं हो सकता है। इस पर और जल्द ही।

फिर समयरेखा को मूल बिंदु से शुरू करते हुए असतत 2-महीने के अंतराल में विभाजित किया जाता है। इनपुट टाइमस्टैम्प DATETIME2 मान 10 मई, 2021, सुबह 6:30 बजे है।

ध्यान दें कि इनपुट टाइमस्टैम्प उस बकेट का हिस्सा है जो 15 मार्च, 2021, मध्यरात्रि को शुरू होता है। दरअसल, फ़ंक्शन इस मान को DATETIME2-टाइप किए गए मान के रूप में लौटाता है:

---------------------------2021-03-15 00:00:00.0000000

DATE_BUCKET का अनुकरण करना

जब तक आप Azure SQL Edge का उपयोग नहीं कर रहे हैं, यदि आप दिनांक और समय डेटा को बकेट करना चाहते हैं, तो कुछ समय के लिए आपको DATE_BUCKET फ़ंक्शन का अनुकरण करने के लिए अपना स्वयं का कस्टम समाधान बनाने की आवश्यकता होगी। ऐसा करना बहुत जटिल नहीं है, लेकिन यह बहुत आसान भी नहीं है। दिनांक और समय डेटा से निपटने में अक्सर मुश्किल तर्क और नुकसान शामिल होते हैं जिनसे आपको सावधान रहने की आवश्यकता होती है।

मैं चरणों में गणना का निर्माण करूंगा और उसी इनपुट का उपयोग करूंगा जिसका उपयोग मैंने पहले दिखाए गए DATE_BUCKET उदाहरण के साथ किया था:

DECLARE @timestamp AS DATETIME2 ='20210510 06:30:00', @bucketwidth AS INT =2, @origin AS DATETIME2 ='20210115 00:00:00';

यदि आप वास्तव में कोड चलाना चाहते हैं, तो मेरे द्वारा दिखाए जाने वाले प्रत्येक कोड नमूने से पहले इस भाग को शामिल करना सुनिश्चित करें।

चरण 1 में, आप दिनांक भाग . में अंतर की गणना करने के लिए DATEDIFF फ़ंक्शन का उपयोग करते हैं मूल . के बीच की इकाइयां और टाइमस्टैम्प . मैं इस अंतर को diff1 . के रूप में संदर्भित करूंगा . यह निम्नलिखित कोड के साथ किया जाता है:

DatedIFF(माह, @origin, @timestamp) AS diff1 चुनें;

हमारे नमूना इनपुट के साथ, यह व्यंजक 4 लौटाता है।

यहां मुश्किल हिस्सा यह है कि आपको यह गणना करने की आवश्यकता है कि दिनांक भाग . की कितनी संपूर्ण इकाइयाँ हैं मूल . के बीच मौजूद है और टाइमस्टैम्प . हमारे नमूना इनपुट के साथ, दोनों के बीच पूरे 3 महीने होते हैं और 4 नहीं। DATEDIFF फ़ंक्शन रिपोर्ट 4 का कारण यह है कि, जब यह अंतर की गणना करता है, तो यह केवल इनपुट के अनुरोधित भाग और उच्च भागों को देखता है, लेकिन निचले भागों को नहीं। . इसलिए, जब आप महीनों में अंतर मांगते हैं, तो फ़ंक्शन केवल इनपुट के वर्ष और महीने के हिस्सों की परवाह करता है, न कि महीने के नीचे के हिस्सों (दिन, घंटे, मिनट, सेकंड, आदि) के बारे में। दरअसल, जनवरी 2021 और मई 2021 के बीच 4 महीने हैं, फिर भी पूर्ण इनपुट के बीच केवल 3 पूरे महीने हैं।

फिर चरण 2 का उद्देश्य यह गणना करना है कि दिनांक भाग . की कितनी संपूर्ण इकाइयाँ हैं मूल . के बीच मौजूद है और टाइमस्टैम्प . मैं इस अंतर को diff2 . के रूप में संदर्भित करूंगा . इसे प्राप्त करने के लिए, आप diff1 . जोड़ सकते हैं दिनांक भाग . की इकाइयां मूल . तक . यदि परिणाम टाइमस्टैम्प . से अधिक है , आप diff1 . से 1 घटाते हैं diff2 . की गणना करने के लिए , अन्यथा 0 घटाएं और इसलिए diff1 . का उपयोग करें diff2 . के रूप में . यह CASE एक्सप्रेशन का उपयोग करके किया जा सकता है, जैसे:

 दिनांकित चुनें (माह, @origin, @timestamp) - मामला जब DATEADD (माह, DATEDIFF (माह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END AS diff2;

यह व्यंजक 3 देता है, जो दो इनपुट के बीच पूरे महीनों की संख्या है।

याद रखें कि पहले मैंने उल्लेख किया था कि मेरे उदाहरण में मैंने जानबूझकर एक मूल बिंदु का उपयोग किया है जो एक अवधि की शुरुआत की तरह एक प्राकृतिक नहीं है ताकि मैं कुछ जटिलताओं पर चर्चा कर सकूं जो तब प्रासंगिक हो सकती हैं। उदाहरण के लिए, यदि आप माह . का उपयोग करते हैं दिनांक भाग के रूप में, और मूल के रूप में कुछ महीने की सटीक शुरुआत (किसी महीने की आधी रात को), आप सुरक्षित रूप से चरण 2 को छोड़ सकते हैं और diff1 का उपयोग कर सकते हैं diff2 . के रूप में . ऐसा इसलिए है क्योंकि मूल + diff1 कभी नहीं हो सकता> टाइमस्टैम्प ऐसी स्थिति में। हालांकि, मेरा लक्ष्य DATE_BUCKET फ़ंक्शन के लिए तार्किक रूप से समकक्ष विकल्प प्रदान करना है जो किसी भी मूल बिंदु के लिए सही ढंग से काम करेगा, सामान्य या नहीं। इसलिए, मैं अपने उदाहरणों में चरण 2 के लिए तर्क शामिल करूंगा, लेकिन बस याद रखें जब आप ऐसे मामलों की पहचान करते हैं जहां यह चरण प्रासंगिक नहीं है, तो आप सुरक्षित रूप से उस हिस्से को हटा सकते हैं जहां आप CASE व्यंजक के आउटपुट को घटाते हैं।

चरण 3 में आप पहचानते हैं कि दिनांक भाग . की कितनी इकाइयाँ हैं मूल . के बीच मौजूद संपूर्ण बकेट में हैं और टाइमस्टैम्प . मैं इस मान को diff3 . के रूप में संदर्भित करूंगा . यह निम्न सूत्र के साथ किया जा सकता है:

diff3 =diff2 / <बाल्टी की चौड़ाई> * <बाल्टी की चौड़ाई>

यहां चाल यह है कि पूर्णांक ऑपरेंड के साथ टी-एसक्यूएल में डिवीजन ऑपरेटर / का उपयोग करते समय, आपको पूर्णांक विभाजन मिलता है। उदाहरण के लिए, टी-एसक्यूएल में 3/2 1 है और 1.5 नहीं। व्यंजक diff2 / <बाल्टी की चौड़ाई> आपको मूल . के बीच मौजूद संपूर्ण बकेट की संख्या देता है और टाइमस्टैम्प (हमारे मामले में)। परिणाम को बाल्टी की चौड़ाई . से गुणा करना फिर आपको दिनांक भाग . की इकाइयों की संख्या देता है जो उन पूरी बाल्टियों (हमारे मामले में 2) के भीतर मौजूद हैं। यह सूत्र T-SQL में निम्न व्यंजक का अनुवाद करता है:

चुनें ( DATEDIFF(माह, @origin, @timestamp) - केस जब DATEADD (माह, DATEDIFF (माह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END ) / @bucketwidth * @ बकेटविड्थ AS diff3;

यह एक्सप्रेशन 2 देता है, जो दो इनपुट के बीच मौजूद पूरे 2-महीने की बकेट में महीनों की संख्या है।

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

 DATEADD चुनें (माह, ( DATEDIFF (माह, @origin, @timestamp) - मामला जब DATEADD (माह, DATEDIFF (माह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END) / @bucketwidth * @bucketwidth, @origin);

यह कोड निम्न आउटपुट उत्पन्न करता है:

---------------------------2021-03-15 00:00:00.0000000

जैसा कि आपको याद है, यह वही आउटपुट है जो समान इनपुट के लिए DATE_BUCKET फ़ंक्शन द्वारा उत्पादित किया जाता है।

मेरा सुझाव है कि आप इस अभिव्यक्ति को विभिन्न इनपुट और भागों के साथ आजमाएं। मैं यहां कुछ उदाहरण दिखाऊंगा, लेकिन बेझिझक अपना खुद का प्रयास करें।

यहां एक उदाहरण दिया गया है जहां मूल टाइमस्टैम्प . से कुछ ही आगे है महीने में:

DECLARE @timestamp AS DATETIME2 ='20210510 06:30:00', @bucketwidth AS INT =2, @origin AS DATETIME2 ='20210110 06:30:01'; - DATE_BUCKET चुनें (सप्ताह, @bucketwidth, @timestamp, @origin); DATEADD चुनें (माह, ( DATEDIFF (माह, @origin, @timestamp) - मामला जब DATEADD (माह, DATEDIFF (माह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END) / @bucketwidth * @bucketwidth, @origin);

यह कोड निम्न आउटपुट उत्पन्न करता है:

---------------------------2021-03-10 06:30:01.0000000

ध्यान दें कि युक्त बाल्टी की शुरुआत मार्च में होती है।

यहां एक उदाहरण दिया गया है जहां मूल महीने के भीतर टाइमस्टैम्प . के समान बिंदु पर है :

DECLARE @timestamp AS DATETIME2 ='20210510 06:30:00', @bucketwidth AS INT =2, @origin AS DATETIME2 ='20210110 06:30:00'; - DATE_BUCKET चुनें (सप्ताह, @bucketwidth, @timestamp, @origin); DATEADD चुनें (माह, ( DATEDIFF (माह, @origin, @timestamp) - मामला जब DATEADD (माह, DATEDIFF (माह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END) / @bucketwidth * @bucketwidth, @origin);

यह कोड निम्न आउटपुट उत्पन्न करता है:

---------------------------2021-05-10 06:30:00.0000000

ध्यान दें कि इस बार युक्त बाल्टी की शुरुआत मई में है।

यहां 4-सप्ताह के बकेट के साथ एक उदाहरण दिया गया है:

DECLARE @timestamp AS DATETIME2 ='20210303 21:22:11', @bucketwidth AS INT =4, @origin AS DATETIME2 ='20210115'; - DATE_BUCKET चुनें (सप्ताह, @bucketwidth, @timestamp, @origin); DATEADD चुनें (सप्ताह, ( DATEDIFF (सप्ताह, @origin, @timestamp) - मामला जब DATEADD (सप्ताह, DATEDIFF (सप्ताह, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END) / @bucketwidth * @bucketwidth, @origin);

ध्यान दें कि कोड सप्ताह . का उपयोग करता है इस बार भाग लें।

यह कोड निम्न आउटपुट उत्पन्न करता है:

---------------------------2021-02-12 00:00:00.0000000

यहां 15 मिनट की बकेट के साथ एक उदाहरण दिया गया है:

DECLARE @timestamp AS DATETIME2 ='20210203 21:22:11', @bucketwidth AS INT =15, @origin AS DATETIME2 ='19000101'; - DATE_BUCKET (मिनट, @bucketwidth, @timestamp) चुनें; DATEADD चुनें (मिनट, ( DATEDIFF (मिनट, @origin, @timestamp) - मामला जब DATEADD (मिनट, DATEDIFF (मिनट, @origin, @timestamp), @origin)> @timestamp तब 1 ELSE 0 END) / @bucketwidth * @bucketwidth, @origin);

यह कोड निम्न आउटपुट उत्पन्न करता है:

---------------------------2021-02-03 21:15:00.0000000

ध्यान दें कि भाग मिनट है . इस उदाहरण में, आप घंटे के निचले भाग से शुरू होने वाले 15-मिनट के बकेट का उपयोग करना चाहते हैं, इसलिए एक मूल बिंदु जो कि किसी भी घंटे का निचला भाग है, काम करेगा। वास्तव में, एक मूल बिंदु जिसमें 00, 15, 30 या 45 की एक मिनट की इकाई निचले हिस्सों में शून्य के साथ होती है, किसी भी तारीख और घंटे के साथ काम करेगी। तो डिफ़ॉल्ट जो DATE_BUCKET फ़ंक्शन इनपुट के लिए उपयोग करता है मूल काम करेगा। बेशक, कस्टम अभिव्यक्ति का उपयोग करते समय, आपको मूल बिंदु के बारे में स्पष्ट होना चाहिए। इसलिए, DATE_BUCKET फ़ंक्शन के साथ सहानुभूति रखने के लिए, आप आधार तिथि का उपयोग मध्यरात्रि में कर सकते हैं जैसे मैं उपरोक्त उदाहरण में करता हूं।

संयोग से, क्या आप देख सकते हैं कि यह एक अच्छा उदाहरण क्यों होगा जहां समाधान में चरण 2 को छोड़ना पूरी तरह से सुरक्षित है? यदि आपने वास्तव में चरण 2 को छोड़ना चुना है, तो आपको निम्न कोड प्राप्त होगा:

DECLARE @timestamp AS DATETIME2 ='20210203 21:22:11', @bucketwidth AS INT =15, @origin AS DATETIME2 ='19000101'; - DATE_BUCKET (मिनट, @bucketwidth, @timestamp) चुनें; DATEADD चुनें (मिनट, ( DATEDIFF (मिनट, @origin, @timestamp)) / @bucketwidth * @bucketwidth, @origin);

स्पष्ट रूप से, चरण 2 की आवश्यकता नहीं होने पर कोड काफी सरल हो जाता है।

डेटा को दिनांक और समय बकेट के अनुसार समूहीकृत और एकत्र करना

ऐसे मामले हैं जहां आपको दिनांक और समय डेटा को बकेट करने की आवश्यकता होती है जिसके लिए परिष्कृत कार्यों या अनावश्यक अभिव्यक्तियों की आवश्यकता नहीं होती है। उदाहरण के लिए, मान लें कि आप TSQLV5 डेटाबेस में Sales.OrderValues ​​दृश्य को क्वेरी करना चाहते हैं, डेटा को वार्षिक रूप से समूहीकृत करना चाहते हैं, और प्रति वर्ष कुल ऑर्डर गणना और मानों की गणना करना चाहते हैं। स्पष्ट रूप से, समूह सेट तत्व के रूप में YEAR(orderdate) फ़ंक्शन का उपयोग करना पर्याप्त है, जैसे:

TSQLV5 का उपयोग करें; ऑर्डर वर्ष के रूप में वर्ष (आदेश दिनांक) चुनें, संख्याओं के रूप में COUNT (*), बिक्री से कुल मूल्य के रूप में योग (वैल) का चयन करें। 

 यह कोड निम्न आउटपुट उत्पन्न करता है:
 
आदेशवर्ष संख्याकुलमूल्य-----------------------------------2017 152 208083.992018 408 617085.302019 270 440623.93
 

 लेकिन क्या होगा यदि आप अपने संगठन के वित्तीय वर्ष के अनुसार डेटा को बकेट करना चाहते हैं? कुछ संगठन वित्तीय वर्ष का उपयोग लेखांकन, बजट और वित्तीय रिपोर्टिंग उद्देश्यों के लिए करते हैं, कैलेंडर वर्ष के साथ संरेखित नहीं। उदाहरण के लिए, मान लें कि आपके संगठन का वित्तीय वर्ष अक्टूबर से सितंबर के वित्तीय कैलेंडर पर संचालित होता है, और उस कैलेंडर वर्ष द्वारा दर्शाया जाता है जिसमें वित्तीय वर्ष समाप्त होता है। तो 3 अक्टूबर 2018 को हुई एक घटना वित्तीय वर्ष से संबंधित है जो 1 अक्टूबर 2018 को शुरू हुआ, 30 सितंबर, 2019 को समाप्त हुआ, और इसे वर्ष 2019 तक दर्शाया गया है।
 

 DATE_BUCKET फ़ंक्शन के साथ इसे हासिल करना काफी आसान है, जैसे:
 
DECLARE @bucketwidth AS INT =1, @origin AS DATETIME2 ='19001001'; -- यह किसी वर्ष का 1 अक्टूबर है, वित्तीय वर्ष के रूप में वर्ष (स्टार्टऑफ़बकेट) + 1 के रूप में, COUNT(*) संख्याओं के रूप में, बिक्री से कुल मूल्य के रूप में एसयूएम (वैल) का चयन करें। मूल )) ) AS A(startofbucket) GROUP BY startofbucketORDER by startofbucket;
 

 और यहां DATE_BUCKET फ़ंक्शन के कस्टम लॉजिकल समकक्ष का उपयोग करने वाला कोड है:
 
DECLARE @bucketwidth AS INT =1, @origin AS DATETIME2 ='19001001'; - यह किसी वर्ष का 1 अक्टूबर है, वित्तीय वर्ष के रूप में वर्ष (स्टार्टऑफ़बकेट) + 1 के रूप में, संख्याओं के रूप में काउंट (*), बिक्री से कुल मूल्य के रूप में योग (वैल) का चयन करें। मूल, आदेश दिनांक) - मामला जब DATEADD(वर्ष, DATEDIFF(वर्ष, @origin, आदेश दिनांक), @origin)> आदेश दिनांक तब 1 ELSE 0 END ) / @bucketwidth * @bucketwidth, @origin) ) AS A(startofbucket)GROUP startofbucketORDER द्वारा startofbucket द्वारा;
 

 यह कोड निम्न आउटपुट उत्पन्न करता है:
 
वित्तीय वर्ष संख्या कुल मूल्य-----------------------------------2017 70 79728.582018 370 563759.242019 390 622305.40
 

 मैंने कोड को अधिक सामान्यीकृत करने के लिए बकेट की चौड़ाई और मूल बिंदु के लिए यहां चर का उपयोग किया था, लेकिन यदि आप हमेशा एक ही का उपयोग कर रहे हैं, तो आप उन्हें स्थिरांक से बदल सकते हैं, और फिर गणना को उपयुक्त के रूप में सरल बना सकते हैं।
 

 उपरोक्त के थोड़े से बदलाव के रूप में, मान लीजिए कि आपका वित्तीय वर्ष एक कैलेंडर वर्ष के 15 जुलाई से अगले कैलेंडर वर्ष के 14 जुलाई तक चलता है, और उस कैलेंडर वर्ष द्वारा दर्शाया जाता है जिससे वित्तीय वर्ष की शुरुआत होती है। तो 18 जुलाई, 2018 को हुई एक घटना वित्तीय वर्ष 2018 से संबंधित है। 14 जुलाई, 2018 को हुई एक घटना वित्तीय वर्ष 2017 से संबंधित है। DATE_BUCKET फ़ंक्शन का उपयोग करके, आप इसे इस प्रकार प्राप्त करेंगे:
 
DECLARE @bucketwidth AS INT =1, @origin AS DATETIME2 ='19000715'; -- 15 जुलाई वित्तीय वर्ष की शुरुआत वित्तीय वर्ष के रूप में वर्ष (स्टार्टऑफबकेट) का चयन करें, -- यहां 1 जोड़ने की आवश्यकता नहीं है COUNT(*) संख्याओं के रूप में, एसयूएम (वैल) बिक्री से कुल मूल्य के रूप में। ऑर्डर वैल्यू क्रॉस लागू करें ( VALUES( DATE_BUCKET(वर्ष, @bucketwidth, orderdate, @origin ) ) AS A(startofbucket) GROUP BY startofbucketORDER by startofbucket;
 

 आप टिप्पणियों में पिछले उदाहरण की तुलना में परिवर्तन देख सकते हैं।
 

 और यहां DATE_BUCKET फ़ंक्शन के अनुरूप कस्टम लॉजिकल का उपयोग करने वाला कोड है:
 
DECLARE @bucketwidth AS INT =1, @origin AS DATETIME2 ='19000715'; वित्तीय वर्ष के रूप में वर्ष (स्टार्टऑफ़बकेट) का चयन करें, संख्याओं के रूप में काउंट (*), बिक्री से कुल मूल्य के रूप में एसयूएम (वैल)। DATEDIFF(वर्ष, @origin, orderdate), @origin)> आदेश दिनांक 1 ELSE 0 END ) / @bucketwidth * @bucketwidth, @origin) ) AS A(startofbucket) GROUP BY startofbucketORDER by startofbucket;
 

 यह कोड निम्न आउटपुट उत्पन्न करता है:
 
वित्तीय वर्ष संख्या कुल मूल्य ----------- ---------------------2016 8 12599.882017 343 495118.142018 479 758075.20
 

 जाहिर है, ऐसे वैकल्पिक तरीके हैं जिनका आप विशिष्ट मामलों में उपयोग कर सकते हैं। अंतिम से पहले का उदाहरण लें, जहां वित्तीय वर्ष अक्टूबर से सितंबर तक चलता है और कैलेंडर वर्ष द्वारा दर्शाया जाता है जिसमें वित्तीय वर्ष समाप्त होता है। ऐसे मामले में आप निम्नलिखित, अधिक सरल, अभिव्यक्ति का उपयोग कर सकते हैं:
 
वर्ष(आदेश दिनांक) + मामला जब माह (आदेश दिनांक) 10 और 12 के बीच तब 1 और 0 समाप्त होता है
 

 और फिर आपकी क्वेरी कुछ इस तरह दिखेगी:
 
वित्तीय वर्ष का चयन करें, संख्याओं के रूप में COUNT(*), बिक्री से कुल मूल्य के रूप में SUM(val) लागू करें। ए (वित्तीय वर्ष) वित्तीय वर्ष के अनुसार समूह वित्तीय वर्ष द्वारा आदेश;
 

 हालांकि, यदि आप एक सामान्यीकृत समाधान चाहते हैं जो कई और मामलों में काम करेगा, और आप पैरामीटर कर सकते हैं, तो आप स्वाभाविक रूप से अधिक सामान्य रूप का उपयोग करना चाहेंगे। यदि आपके पास DATE_BUCKET फ़ंक्शन तक पहुंच है, तो यह बहुत अच्छा है। यदि आप नहीं करते हैं, तो आप कस्टम तार्किक समकक्ष का उपयोग कर सकते हैं।
 
निष्कर्ष
 

 DATE_BUCKET फ़ंक्शन काफी आसान फ़ंक्शन है जो आपको दिनांक और समय डेटा को बकेटाइज़ करने में सक्षम बनाता है। यह समय श्रृंखला डेटा को संभालने के लिए उपयोगी है, लेकिन किसी भी डेटा को बकेटाइज़ करने के लिए भी जिसमें दिनांक और समय विशेषताएँ शामिल हैं। इस लेख में मैंने बताया कि DATE_BUCKET फ़ंक्शन कैसे काम करता है और यदि आप जिस प्लेटफ़ॉर्म का उपयोग कर रहे हैं वह इसका समर्थन नहीं करता है, तो एक कस्टम लॉजिकल समकक्ष प्रदान करता है।