आपने देखा होगा कि SQL सर्वर में MySQL के UNIX_TIMESTAMP() के बराबर नहीं है समारोह।
हालांकि, SQL सर्वर में यूनिक्स टाइमस्टैम्प को वापस करना इतना मुश्किल नहीं है।
यूनिक्स टाइमस्टैम्प (यूनिक्स युग समय, यूनिक्स समय, या पॉज़िक्स समय के रूप में भी जाना जाता है) केवल सेकंड की संख्या है जो 00:00:00 गुरुवार, 1 जनवरी 1970, कोऑर्डिनेटेड यूनिवर्सल टाइम (UTC) के बाद से बीत चुके हैं। इसलिए, SQL सर्वर में हम इसे वापस करने के लिए कुछ T-SQL फ़ंक्शंस का उपयोग कर सकते हैं।
SQL सर्वर यूनिक्स टाइमस्टैम्प
यहां बताया गया है कि आप SQL सर्वर में यूनिक्स टाइमस्टैम्प कैसे वापस कर सकते हैं।
SELECT DATEDIFF(SECOND,'1970-01-01', GETUTCDATE()) AS 'SQL Server Result';
परिणाम:
+---------------------+ | SQL Server Result | |---------------------| | 1560833178 | +---------------------+
तो हम DATEDIFF() . का उपयोग कर सकते हैं 1970-01-01 और अब के बीच सेकंड में अंतर को वापस करने के लिए कार्य करता है। हम GETUTCDATE() . का उपयोग करते हैं यूटीसी समय में वर्तमान तिथि और समय वापस करने के लिए कार्य करें।
यह कोड वर्ष 2038 ('2038-01-19 03:14:07' सटीक होने के लिए) तक काम करेगा। उसके बाद यूनिक्स टाइमस्टैम्प के लिए, आपको कोड को थोड़ा संशोधित करना होगा। यदि आपको उस तिथि के बाद यूनिक्स टाइमस्टैम्प की आवश्यकता है, तो पढ़ें।
MySQL यूनिक्स टाइमस्टैम्प समतुल्य
तुलना के लिए, अगर मैं MySQL का UNIX_TIMESTAMP() run चलाता हूं ठीक उसी समय, मुझे यह मिलता है:
SELECT UNIX_TIMESTAMP() AS 'MySQL Result';
परिणाम:
+--------------+ | MySQL Result | +--------------+ | 1560833178 | +--------------+
वही परिणाम। MySQL एक अहस्ताक्षरित पूर्णांक के रूप में परिणाम देता है। हालांकि, यदि (वैकल्पिक) दिनांक तर्क पारित किया जाता है, तो यह TIMESTAMP के समान श्रेणी का समर्थन करता है डेटा प्रकार।
मिलीसेकंड लौटाएं
यदि आपको उच्च सटीकता के साथ एक यूनिक्स टाइमस्टैम्प वापस करने की आवश्यकता है, तो कहें, मिलीसेकंड की संख्या '1970-01-01 00:00:00.000' यूटीसी के बाद से, आपको DATEDIFF() को स्वैप करना होगा DATEDIFF_BIG() . के लिए फ़ंक्शन ।
ऐसा इसलिए है क्योंकि DATEDIFF() एक int . लौटाता है , जो 1970 के बाद से मिलीसेकंड की संख्या को संभालने के लिए बहुत छोटा है। DATEDIFF_BIG() दूसरी ओर फ़ंक्शन, एक हस्ताक्षरित बिगिंट . देता है , जो मिलीसेकंड को संभालने के लिए पर्याप्त से अधिक है।
SELECT DATEDIFF_BIG(MILLISECOND,'1970-01-01 00:00:00.000', SYSUTCDATETIME()) Milliseconds;
परिणाम:
+----------------+ | Milliseconds | |----------------| | 1560835305461 | +----------------+
नैनोसेकंड लौटाएं
यहां एक और उदाहरण दिया गया है, इस बार '1970-01-01 00:00:00.0000000' यूटीसी के बाद से नैनोसेकंड तक।
SELECT DATEDIFF_BIG(NANOSECOND,'1970-01-01 00:00:00.0000000', SYSUTCDATETIME()) Nanoseconds;
परिणाम:
+---------------------+ | Nanoseconds | |---------------------| | 1560835321500279300 | +---------------------+
वर्ष 2038 की समस्या
रिटर्निंग मिलीसेकंड, माइक्रोसेकंड और नैनोसेकंड सभी अच्छे और अच्छे हैं, लेकिन कड़ाई से बोलते हुए, यह यूनिक्स युग का सही समय नहीं है। यूनिक्स युग का समय सेकंड . की संख्या है '1970-01-01 00:00:00' से।
हालांकि, DATEDIFF_BIG() सख्त यूनिक्स युग समय लौटाते समय अभी भी काम आ सकता है। विशेष रूप से, यह आपके डेटाबेस को 2038 की समस्या को दूर करने में मदद कर सकता है। इस मामले में, '2038-01-19 03:14:07' के बाद की किसी भी चीज़ को बिगिन्ट के रूप में वापस करना होगा (एक 8 बाइट पूर्णांक)। ऐसा इसलिए है क्योंकि int . के लिए सेकंड की संख्या बहुत बड़ी होगी डेटा प्रकार (एक 4 बाइट पूर्णांक)। इंट डेटा प्रकार केवल 2,147,483,647 तक जाता है, जबकि एक बड़ा 9,223,372,036,854,775,807 तक जाता है।
इसलिए, '2038-01-19 03:14:07' से पहले यूनिक्स टाइमस्टैम्प वापस करने के लिए, DATEDIFF_BIG() का उपयोग करें DATEDIFF() . के बजाय फ़ंक्शन ।
इसे प्रदर्शित करने के लिए, यहां DATEDIFF() using का उपयोग करने का एक उदाहरण दिया गया है ठीक उसी तारीख/समय पर यूनिक्स समय लौटाने के लिए:
SELECT DATEDIFF(SECOND,'1970-01-01', '2038-01-19 03:14:07') AS 'Unix Epoch time';
परिणाम:
+-------------------+ | Unix Epoch time | |-------------------| | 2147483647 | +-------------------+
अब तक सब ठीक है. यह परिणाम int . के भीतर है -2,147,483,648 से 2,147,483,647 की सीमा (हालांकि यह ऊपरी सीमा पर सही है) इसलिए सही परिणाम लौटाया जाता है।
लेकिन अगर हम इसे एक सेकंड बढ़ा दें तो क्या होगा:
SELECT DATEDIFF(SECOND,'1970-01-01', '2038-01-19 03:14:08') AS 'Unix Epoch time';
परिणाम:
The datediff function resulted in an overflow. The number of dateparts separating two date/time instances is too large. Try to use datediff with a less precise datepart.
हमें त्रुटि मिलती है क्योंकि लौटाया गया मान int . के बाहर होगा रेंज।
तो जैसा कि उल्लेख किया गया है, हमें केवल DATEDIFF() स्वैप करना है DATEDIFF_BIG() . के लिए :
SELECT DATEDIFF_BIG(SECOND,'1970-01-01', '2038-01-19 03:14:08') AS 'Unix Epoch time';
परिणाम:
+-------------------+ | Unix Epoch time | |-------------------| | 2147483648 | +-------------------+
हालांकि, यह जरूरी नहीं कि सभी वर्ष 2038 की समस्याओं का समाधान हो, क्योंकि अधिकांश संभावित मुद्दे शायद ऑपरेटिंग सिस्टम से प्राप्त होंगे।
मुझे यह भी बताना चाहिए कि इस कोड में से कोई भी अनिवार्य रूप से "वर्ष 10,000 समस्या" से प्रतिरक्षित नहीं होगा, क्योंकि इसमें डेटाटाइम2 शामिल है। डेटा प्रकार, जिसकी ऊपरी सीमा '9999-12-31' है।
