SQL सर्वर में, आप DATEDIFF_BIG() . का उपयोग कर सकते हैं DATEDIFF() . के बजाय फ़ंक्शन फ़ंक्शन यदि आप लौटाए गए मूल्य को वास्तव में बड़ा होने की उम्मीद करते हैं। उदाहरण के लिए, यदि आप यह पता लगाने की कोशिश कर रहे हैं कि एक 1000 वर्षों में कितने मिलीसेकंड होते हैं, तो आपको एक त्रुटि मिलेगी।
ऐसा इसलिए है क्योंकि DATEDIFF() एक int . लौटाता है डेटा प्रकार, और परिणाम उस डेटा प्रकार को संभालने के लिए बहुत बड़ा है। दूसरी ओर, DATEDIFF_BIG() फ़ंक्शन एक हस्ताक्षरित बिगिंट . देता है डेटा प्रकार, जिसका अर्थ है कि आप इसका उपयोग बहुत बड़े मान वापस करने के लिए कर सकते हैं। दूसरे शब्दों में, आप तिथियों की अधिक विस्तृत श्रृंखला के साथ उपयोग कर सकते हैं।
इसके अलावा, दो कार्यों के बीच वास्तव में कोई अंतर नहीं है।
लेख DATEDIFF_BIG() . का उपयोग करने के उदाहरण प्रदान करता है SQL सर्वर में कार्य करता है।
सिंटैक्स
सबसे पहले, यहाँ सिंटैक्स है:
DATEDIFF_BIG ( datepart , startdate , enddate )
जहां डेटपार्ट दिनांक का वह भाग है जिसकी आप तुलना करना चाहते हैं। शुरू होने की तारीख पहली तारीख है और समाप्ति अंतिम तिथि है।
फ़ंक्शन प्रारंभ दिनांक . घटाता है समाप्ति तिथि . से .
जिस तरह से यह काम करता है वह यह है कि यह निर्दिष्ट datepart की गिनती (एक हस्ताक्षरित बड़े पूर्णांक मान के रूप में) देता है निर्दिष्ट आरंभ तिथि . के बीच की सीमाएं पार और समाप्ति तिथि ।
यह ठीक वही सिंटैक्स है जिसका इस्तेमाल DATEDIFF() . के साथ किया जाता है समारोह।
उदाहरण 1
यह कैसे काम करता है यह प्रदर्शित करने के लिए यह एक बुनियादी उदाहरण है।
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
परिणाम:
+----------+ | Result | |----------| | 3287547 | +----------+
ध्यान दें कि इस मामले में, हम DATEDIFF() . का उपयोग कर सकते थे , क्योंकि परिणाम एक पूर्णांक के लिए बहुत बड़ा नहीं है।
उदाहरण 2
यहां एक उदाहरण दिया गया है जहां हम दो तिथियों से विभिन्न दिनांक भागों का अंतर लौटाते हैं। इस मामले में मैं दो चर घोषित करता हूं और उन्हें दो अलग-अलग तिथियां निर्दिष्ट करता हूं (मैं DATEADD() का उपयोग करता हूं पहली तारीख में 1000 साल जोड़ने का कार्य):
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 1000, @date1);
SELECT
DATEDIFF_BIG( year, @date1, @date2 ) AS Years,
DATEDIFF_BIG( quarter, @date1, @date2 ) AS Quarters,
DATEDIFF_BIG( month, @date1, @date2 ) AS Months,
DATEDIFF_BIG( week, @date1, @date2 ) AS Weeks,
DATEDIFF_BIG( dayofyear, @date1, @date2 ) AS DayOfYear,
DATEDIFF_BIG( day, @date1, @date2 ) AS Days; परिणाम:
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1000 | 4000 | 12000 | 52178 | 365243 | 365243 | +---------+------------+----------+---------+-------------+--------+
फिर से, हम DATEDIFF() . का उपयोग कर सकते थे , क्योंकि कोई भी परिणाम पूर्णांक के लिए बहुत बड़ा नहीं है।
उदाहरण 3
इस उदाहरण में हम दो तिथियों के बीच घंटे, मिनट और सेकंड लौटाते हैं:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 1000, @date1);
SELECT
DATEDIFF_BIG( hour, @date1, @date2 ) AS Hours,
DATEDIFF_BIG( minute, @date1, @date2 ) AS Minutes,
DATEDIFF_BIG( second, @date1, @date2 ) AS Seconds; परिणाम:
+---------+-----------+-------------+ | Hours | Minutes | Seconds | |---------+-----------+-------------| | 8765832 | 525949920 | 31556995200 | +---------+-----------+-------------+
अब हम उस बिंदु पर हैं जहां DATEDIFF() एक त्रुटि लौटा दी होगी। int . के लिए सेकंड की संख्या बहुत बड़ी है (लेकिन बिगिन्ट . के लिए नहीं )।
उदाहरण 4
और अंत में, यहां मिलीसेकंड, माइक्रोसेकंड और नैनोसेकंड के साथ एक उदाहरण दिया गया है:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 100, @date1);
SELECT
DATEDIFF_BIG( millisecond, @date1, @date2 ) AS Milliseconds,
DATEDIFF_BIG( microsecond, @date1, @date2 ) AS Microseconds,
DATEDIFF_BIG( nanosecond, @date1, @date2 ) AS Nanoseconds; परिणाम:
+----------------+------------------+---------------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+------------------+---------------------| | 3155760000000 | 3155760000000000 | 3155760000000000000 | +----------------+------------------+---------------------+
इस मामले में, हम स्पष्ट रूप से यह लाभ देख सकते हैं कि DATEDIFF_BIG() DATEDIFF() से अधिक है . DATEDIFF() तीनों पर गिर गया होता।
