शायद FORMAT() . की कम ज्ञात विशेषताओं में से एक SQL सर्वर में फ़ंक्शन वह है जो आपको किसी संख्या पर सशर्त स्वरूपण लागू करने में सक्षम बनाता है।
यह SQL सर्वर (या T-SQL) सुविधा की तुलना में .NET सुविधा से अधिक है, लेकिन SQL सर्वर/T-SQL इसका समर्थन करता है, जिससे आप संख्याओं पर सशर्त स्वरूपण लागू करने की क्षमता का पूरा लाभ उठा सकते हैं।
यह सब उस प्रारूप स्ट्रिंग में आता है जिसे आप FORMAT() . पर पास करते हैं समारोह।
आप एक प्रारूप स्ट्रिंग पास कर सकते हैं जो निर्दिष्ट करती है कि संख्या को कैसे स्वरूपित किया जाना चाहिए, यह इस पर निर्भर करता है कि यह सकारात्मक, नकारात्मक या शून्य है।
स्पष्ट होने के लिए, मैं रंगों या फोंट आदि के साथ संख्या को स्वरूपित करने के बारे में बात नहीं कर रहा हूं। मैं केवल उस संख्या स्वरूपण के बारे में बात कर रहा हूं जिसे आप आमतौर पर FORMAT() का उपयोग करेंगे। के लिए कार्य (जैसे हजारों विभाजक, प्रतिशत चिह्न, दशमलव अंक, आदि जोड़ना)।
साथ ही, यह सशर्त स्वरूपण काफी सीमित है - (सकारात्मक, नकारात्मक, या शून्य) के लिए केवल तीन स्थितियों का परीक्षण किया जा सकता है। हालाँकि, यदि आवश्यक हो तो आप एक ही स्वरूपण को दो स्थितियों में एक साथ लागू कर सकते हैं।
किसी भी मामले में, यहां FORMAT() . का उपयोग करने का तरीका बताया गया है SQL सर्वर में किसी संख्या पर सशर्त स्वरूपण लागू करने के लिए कार्य करता है।
पेश है ; - सेक्शन सेपरेटर
.NET अर्धविराम को परिभाषित करता है (; ) अपने कस्टम संख्यात्मक प्रारूप विनिर्देशकों में से एक के रूप में, जिसे अनुभाग विभाजक कहा जाता है .
अनुभाग विभाजक एक सशर्त प्रारूप विनिर्देशक है जो सकारात्मक, नकारात्मक और शून्य संख्याओं के लिए अलग-अलग प्रारूप स्ट्रिंग वाले अनुभागों को परिभाषित करता है। यह आपको किसी संख्या पर अलग-अलग स्वरूपण लागू करने की अनुमति देता है, जो इस बात पर निर्भर करता है कि उसका मान धनात्मक, ऋणात्मक या शून्य है या नहीं।
एक कस्टम संख्यात्मक प्रारूप स्ट्रिंग में अर्धविराम द्वारा अलग किए गए अधिकतम तीन खंड हो सकते हैं। ये इस प्रकार हैं:
- एक खंड :इस मामले में कोई सशर्त स्वरूपण लागू नहीं होता है। प्रारूप स्ट्रिंग सभी मानों पर लागू होती है। किसी अनुभाग विभाजक की आवश्यकता नहीं है (क्योंकि केवल एक खंड है)। इसमें कोई शक नहीं, यह प्रारूप स्ट्रिंग का सबसे सामान्य रूप है।
- दो खंड :पहला खंड सकारात्मक मूल्यों और शून्य पर लागू होता है, और दूसरा खंड नकारात्मक मूल्यों पर लागू होता है।
यदि स्वरूपित की जाने वाली संख्या ऋणात्मक है, लेकिन दूसरे खंड में प्रारूप के अनुसार गोल करने के बाद शून्य हो जाती है, तो परिणामी शून्य को पहले खंड के अनुसार स्वरूपित किया जाता है।
- तीन खंड :पहला खंड सकारात्मक मूल्यों पर लागू होता है, दूसरा खंड नकारात्मक मूल्यों पर लागू होता है, और तीसरा खंड शून्य पर लागू होता है।
दूसरा खंड खाली छोड़ा जा सकता है (अर्धविरामों के बीच कुछ भी नहीं होने के कारण), जिस स्थिति में पहला खंड सभी गैर-शून्य मानों पर लागू होता है।
यदि स्वरूपित की जाने वाली संख्या शून्य नहीं है, लेकिन पहले या दूसरे खंड में प्रारूप के अनुसार गोल करने के बाद शून्य हो जाती है, तो परिणामी शून्य को तीसरे खंड के अनुसार स्वरूपित किया जाता है।
ध्यान दें कि जब सेक्शन सेपरेटर का उपयोग किया जाता है तो ऋणात्मक मान हमेशा ऋणात्मक चिह्न के बिना प्रदर्शित होते हैं (हालाँकि अपवाद हैं, जैसा कि आप बाद में देखेंगे)। यदि आप चाहते हैं कि अंतिम स्वरूपित मान में ऋण चिह्न हो, तो आपको कस्टम प्रारूप स्ट्रिंग के भाग के रूप में ऋण चिह्न को स्पष्ट रूप से शामिल करना होगा। यह किसी संख्या से संबद्ध किसी अन्य पहले से मौजूद स्वरूपण पर भी लागू होता है।
उदाहरण 1 - एक खंड (कोई सशर्त स्वरूपण नहीं)
यहाँ एक विशिष्ट संख्यात्मक प्रारूप स्ट्रिंग है जिसमें एक खंड है। किसी अनुभाग विभाजक का उपयोग नहीं किया जाता है, और इसलिए कोई सशर्त स्वरूपण लागू नहीं होता है ।
कोड:
SELECT FORMAT(123, '0 (Number)') Positive, FORMAT(-123, '0 (Number)') Negative, FORMAT(0, '0 (Number)') Zero;
परिणाम:
+--------------+---------------+------------+ | Positive | Negative | Zero | |--------------+---------------+------------| | 123 (Number) | -123 (Number) | 0 (Number) | +--------------+---------------+------------+
ध्यान दें कि ऋण चिह्न बरकरार रहता है। अगर हम सेक्शन सेपरेटर का इस्तेमाल करते तो इसे हटा दिया जाता।
उदाहरण 2 - दो खंड (सशर्त स्वरूपण)
यहां वह जगह है जहां सशर्त स्वरूपण शुरू होता है।
इस उदाहरण में, हमारे पास दो खंड हैं (एक खंड विभाजक द्वारा अलग)। विभाजक के बाईं ओर का खंड केवल उन मानों पर लागू होता है जो या तो सकारात्मक या शून्य हैं। दाईं ओर का अनुभाग केवल नकारात्मक मानों पर लागू होता है।
कोड:
SELECT FORMAT(123, '0 (Positive or Zero); 0 (Negative)') Result;
परिणाम:
+------------------------+ | Result | |------------------------| | 123 (Positive or Zero) | +------------------------+
इस मामले में संख्या सकारात्मक थी, इसलिए इसे प्रारूपित करने के लिए पहले खंड का उपयोग किया गया था।
उदाहरण 3 - दो खंड (एक ही प्रारूप स्ट्रिंग, अलग-अलग मान)
अगले उदाहरण में, एक ही प्रारूप स्ट्रिंग विभिन्न मानों (सकारात्मक, नकारात्मक और शून्य) पर लागू होती है।
कोड:
SELECT FORMAT(123, '0 (Positive or Zero); 0 (Negative)') Positive, FORMAT(-123, '0 (Positive or Zero); 0 (Negative)') Negative, FORMAT(0, '0 (Positive or Zero); 0 (Negative)') Zero;
परिणाम:
+------------------------+-----------------+----------------------+ | Positive | Negative | Zero | |------------------------+-----------------+----------------------| | 123 (Positive or Zero) | 123 (Negative) | 0 (Positive or Zero) | +------------------------+-----------------+----------------------+
तो यह उदाहरण खंड विभाजकों के वास्तविक लाभ को दर्शाता है - कि हम मूल्य के आधार पर एक अलग परिणाम प्राप्त कर सकते हैं।
उदाहरण 4 - दो खंड राउंडिंग के साथ
दो अनुभागों का उपयोग करते समय, शून्य पर पूर्णांकित कोई भी ऋणात्मक मान पहले स्वरूप स्ट्रिंग के अंतर्गत स्वरूपित किया जाता है।
कोड:
SELECT FORMAT(0.1, '0 (Positive or Zero); 0 (Negative)') Positive, FORMAT(-0.1, '0 (Positive or Zero); 0 (Negative)') Negative;
परिणाम:
+----------------------+----------------------+ | Positive | Negative | |----------------------+----------------------| | 0 (Positive or Zero) | 0 (Positive or Zero) | +----------------------+----------------------+
उदाहरण 5 - तीन खंड (मूल उपयोग)
यहां तीन खंडों को निर्दिष्ट करने का एक मूल उदाहरण दिया गया है। इसे प्राप्त करने के लिए हम दो खंड विभाजकों का उपयोग करते हैं।
कोड:
SELECT FORMAT(123, '0 (Positive); 0 (Negative); 0 (Zero)') Result;
परिणाम:
+----------------+ | Result | |----------------| | 123 (Positive) | +----------------+
इस मामले में, संख्या एक सकारात्मक मान थी, इसलिए इसे पहले खंड के तहत स्वरूपित किया गया था।
उदाहरण 6 - तीन खंड (एक ही प्रारूप स्ट्रिंग, अलग-अलग मान)
यह उदाहरण इनपुट मूल्य के आधार पर पिछले उदाहरण से प्राप्त विभिन्न परिणामों को प्रदर्शित करता है।
यहां, एक ही प्रारूप स्ट्रिंग विभिन्न मानों पर लागू होती है। मैं एक चर के लिए प्रारूप स्ट्रिंग भी निर्दिष्ट करता हूं, लेकिन यह केवल पढ़ने में आसान बनाने के लिए है।
DECLARE @formatstring varchar(35); SET @formatstring = '0 (Positive); 0 (Negative); 0 (Zero)'; SELECT FORMAT(123, @formatstring) 'Positive', FORMAT(-123, @formatstring) 'Negative', FORMAT(0, @formatstring) 'Zero', FORMAT(0.123, @formatstring) 'Rounded to Zero';
परिणाम:
+----------------+-----------------+----------+-------------------+ | Positive | Negative | Zero | Rounded to Zero | |----------------+-----------------+----------+-------------------| | 123 (Positive) | 123 (Negative) | 0 (Zero | 0 (Zero | +----------------+-----------------+----------+-------------------+
उदाहरण 7 - तीन खंड (एक खाली सहित)
यदि आप दूसरी प्रारूप स्ट्रिंग को खाली छोड़ देते हैं, तो पहला खंड सभी गैर-शून्य मानों पर लागू होता है। इसे खाली छोड़ने के लिए, अर्धविरामों के बीच कुछ भी न छोड़ें।
कोड:
SELECT FORMAT(123, '0 (Nonzero);; 0 (Zero)') 'Positive', FORMAT(-123, '0 (Nonzero);; 0 (Zero)') 'Negative', FORMAT(0, '0 (Nonzero);; 0 (Zero)') 'Zero', FORMAT(0.123, '0 (Nonzero);; 0 (Zero)') 'Rounded to Zero';
परिणाम:
+---------------+----------------+-----------+-------------------+ | Positive | Negative | Zero | Rounded to Zero | |---------------+----------------+-----------+-------------------| | 123 (Nonzero) | -123 (Nonzero) | 0 (Zero) | 0 (Zero) | +---------------+----------------+-----------+-------------------+
दिलचस्प बात यह है कि इस मामले में ऋणात्मक मान के लिए ऋण चिह्न बरकरार रहता है।
उदाहरण 8 - ऋण चिह्न
जैसा कि उल्लेख किया गया है, अनुभाग विभाजक संख्या से जुड़े किसी भी पूर्ववर्ती स्वरूपण को अनदेखा करता है। इसमें नकारात्मक मानों के लिए कोई भी ऋण चिह्न शामिल है (हालांकि पिछला उदाहरण इसका अपवाद प्रतीत होता है)।
यदि आप ऋण चिह्न शामिल करना चाहते हैं, तो आपको उसे अपनी प्रारूप स्ट्रिंग में स्पष्ट रूप से जोड़ना होगा। नीचे उदाहरण।
कोड:
SELECT FORMAT(-123, '0 (P); 0 (N); 0 (Z)') 'Without minus sign', FORMAT(-123, '0 (P); -0 (N); 0 (Z)') 'With minus sign';
परिणाम:
+----------------------+-------------------+ | Without minus sign | With minus sign | |----------------------+-------------------| | 123 (N) | -123 (N) | +----------------------+-------------------+
जैसा कि बताया गया है, पिछला उदाहरण इसका अपवाद प्रतीत होता है, इसलिए कुछ ध्यान में रखना चाहिए। अगर मैं पिछले उदाहरण में नकारात्मक मान के लिए प्रारूप स्ट्रिंग में ऋण चिह्न जोड़ता हूं तो यहां क्या होता है:
SELECT FORMAT(-123, '-0 (Nonzero);; 0 (Zero)') Result;
परिणाम:
+-----------------+ | Result | |-----------------| | --123 (Nonzero) | +-----------------+
