कैसे EXPORT_SET () मारियाडीबी में काम करता है

मारियाडीबी में, EXPORT_SET() एक अंतर्निहित स्ट्रिंग फ़ंक्शन है जो एक स्ट्रिंग देता है जो निर्दिष्ट मान में बिट्स को दर्शाता है। निर्दिष्ट मान में प्रत्येक बिट सेट के लिए, आपको एक "चालू" स्ट्रिंग मिलती है और प्रत्येक बिट के लिए जो मान में सेट नहीं होती है, आपको एक "ऑफ" स्ट्रिंग मिलती है।

यह कम से कम तीन तर्कों, साथ ही दो वैकल्पिक तर्कों को स्वीकार करता है।

सिंटैक्स

वाक्य रचना इस प्रकार है:

EXPORT_SET(bits, on, off[, separator[, number_of_bits]])

निम्न तालिका उन तर्कों की व्याख्या प्रदान करती है।

उदाहरण

यहां एक बुनियादी उदाहरण दिया गया है:

SELECT EXPORT_SET(13,'On','Off',',',4);

परिणाम:

+---------------------------------+
| EXPORT_SET(13,'On','Off',',',4) |
+---------------------------------+
| On,Off,On,On                    |
+---------------------------------+

हम देख सकते हैं कि पहला, तीसरा और चौथा बिट सेट है, लेकिन दूसरा नहीं है।

हम BIN() . का उपयोग कर सकते हैं समान परिणाम लौटाने के लिए कार्य करता है, लेकिन उल्टे क्रम में:

SELECT BIN(13);

परिणाम:

+---------+
| BIN(13) |
+---------+
| 1101    |
+---------+

BIN() फ़ंक्शन दिए गए लॉन्गलॉन्ग के बाइनरी मान का एक स्ट्रिंग प्रतिनिधित्व देता है। इस उदाहरण में, इसने तीन 1 लौटाया एस।

हमारे EXPORT_SET() . में उदाहरण के लिए, हमने निर्दिष्ट किया है कि on और off 1 . का प्रतिनिधित्व करने के लिए इस्तेमाल किया जाना चाहिए और 0 क्रमश। हालांकि हम इसे बदल सकते हैं (नीचे)।

साथ ही, EXPORT_SET() . के साथ , परिणाम में बाएं से दाएं तार जोड़े जाते हैं। इसलिए EXPORT_SET() . से परिणाम BIN() . से परिणाम की दर्पण छवि की तरह दिखता है ।

चालू/बंद मान बदलें

यहाँ यह फिर से है, लेकिन इस बार हम on . के लिए एक अलग स्ट्रिंग का उपयोग करते हैं और off राज्यों।

SELECT EXPORT_SET(7,'1','0',',',4);

परिणाम:

+-----------------------------+
| EXPORT_SET(7,'1','0',',',4) |
+-----------------------------+
| 1,1,1,0                     |
+-----------------------------+

इस बार हम 1 . का उपयोग कर रहे हैं और 0 , जो BIN() . के समान है फ़ंक्शन वापस आता है, लेकिन एक अतिरिक्त विभाजक (और उलट) के साथ।

विभाजक बदलें

चौथा (वैकल्पिक) तर्क निर्दिष्ट करता है कि किस विभाजक का उपयोग करना है। यहाँ यह एक अलग विभाजक के साथ है:

SELECT EXPORT_SET(7,'True','False','-',4);

परिणाम:

+------------------------------------+
| EXPORT_SET(7,'True','False','-',4) |
+------------------------------------+
| True-True-True-False               |
+------------------------------------+

जांच करने के लिए बिट्स की संख्या बदलें

पांचवां (वैकल्पिक) तर्क निर्दिष्ट करता है कि कितने बिट्स की जांच करनी है। पिछले उदाहरणों में, हमने जांच करने के लिए बिट्स की संख्या के रूप में 4 का उपयोग किया था। हम चाहें तो इसे बढ़ा सकते हैं:

SELECT EXPORT_SET(7,'1','0',',',10);

परिणाम:

+------------------------------+
| EXPORT_SET(7,'1','0',',',10) |
+------------------------------+
| 1,1,1,0,0,0,0,0,0,0          |
+------------------------------+

इस मामले में, सभी अतिरिक्त बिट्स सेट नहीं हैं। आइए पहले तर्क का मान बढ़ाएँ यह देखने के लिए कि यह परिणाम को कैसे प्रभावित करता है:

SELECT EXPORT_SET(172,'1','0',',',10);

परिणाम:

+--------------------------------+
| EXPORT_SET(172,'1','0',',',10) |
+--------------------------------+
| 0,0,1,1,0,1,0,1,0,0            |
+--------------------------------+

डिफ़ॉल्ट मान

जैसा कि बताया गया है, चौथा और पांचवां तर्क वैकल्पिक हैं। जब आप इन्हें छोड़ देते हैं, तो डिफ़ॉल्ट मानों का उपयोग किया जाता है।

बिट्स की डिफ़ॉल्ट संख्या

यदि हम अंतिम तर्क को हटाते हैं, तो 64 बिट्स की जांच की जाती है:

SELECT EXPORT_SET(172,'1','0','');

परिणाम:

+------------------------------------------------------------------+
| EXPORT_SET(172,'1','0','')                                       |
+------------------------------------------------------------------+
| 0011010100000000000000000000000000000000000000000000000000000000 |
+------------------------------------------------------------------+

इस मामले में आउटपुट को और संक्षिप्त बनाने के लिए मैंने विभाजक को भी हटा दिया।

डिफ़ॉल्ट विभाजक

हम विभाजक तर्क को भी हटा सकते हैं। जब हम ऐसा करते हैं, EXPORT_SET() अल्पविराम का उपयोग डिफ़ॉल्ट विभाजक के रूप में करता है।

SELECT EXPORT_SET(123456789,'1','0');

परिणाम:

+-----------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------+
| EXPORT_SET(123456789,'1','0')                                                                                                   |
+---------------------------------------------------------------------------------------------------------------------------------+
| 1,0,1,0,1,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 |
+---------------------------------------------------------------------------------------------------------------------------------+

अशक्त तर्क

यदि कोई तर्क null है , परिणाम null . है :

SELECT 
    EXPORT_SET(null,'1','0') AS "1",
    EXPORT_SET(7,null,'0') AS "2",
    EXPORT_SET(7,'1',null) AS "3",
    EXPORT_SET(7,'1','0',null,4) AS "4",
    EXPORT_SET(7,'1','0',',',null) AS "5";

परिणाम:

+------+------+------+------+------+
| 1    | 2    | 3    | 4    | 5    |
+------+------+------+------+------+
| NULL | NULL | NULL | NULL | NULL |
+------+------+------+------+------+

अनुपलब्ध तर्क

कॉलिंग EXPORT_SET() कोई तर्क पारित किए बिना (या तर्कों की गलत संख्या के साथ) एक त्रुटि में परिणाम:

SELECT EXPORT_SET();

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'EXPORT_SET'