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

मारियाडीबी में, CONCAT_WS() एक अंतर्निर्मित स्ट्रिंग फ़ंक्शन है जो सेपरेटर के साथ Concatenate के लिए खड़ा है।

CONCAT_WS() अपने तर्कों पर एक स्ट्रिंग संयोजन करता है, जिसमें पहला तर्क शेष तर्कों के लिए विभाजक होता है।

Concatenation दो या दो से अधिक स्ट्रिंग्स को एंड-टू-एंड जोड़ने का ऑपरेशन है।

CONCAT_WS() दो या दो से अधिक तर्कों को स्वीकार करता है (हालांकि केवल दो तर्क प्रदान करने के परिणामस्वरूप कुछ भी संयोजित नहीं होगा, पहला तर्क विभाजक होने के कारण, और दूसरा एक एकल स्ट्रिंग होने के कारण… और कुछ नहीं)।

सिंटैक्स

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

CONCAT_WS(separator,str1,str2,...)

जहां separator एक विभाजक के रूप में उपयोग की जाने वाली स्ट्रिंग है, और str1, str2, … स्ट्रिंग तर्कों का प्रतिनिधित्व करते हैं जिसके लिए संयोजित करना है।

उदाहरण

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

SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread');

परिणाम:

+---------------------------------------------+
| CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread') |
+---------------------------------------------+
| Milk, Cheese, Bread                         |
+---------------------------------------------+

इस मामले में, हमने अल्पविराम और विभाजक के रूप में एक स्थान का उपयोग करके तीन तारों को संयोजित किया।

यहाँ एक और है जो एक अलग विभाजक का उपयोग करता है:

SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green');

परिणाम:

+----------------------------------------+
| CONCAT_WS('-', 'Blue', 'Red', 'Green') |
+----------------------------------------+
| Blue-Red-Green                         |
+----------------------------------------+

CONCAT_WS() CONCAT() . के समान है समारोह। CONCAT_WS() . के लाभों में से एक CONCAT() से अधिक कई तारों को जोड़कर स्पष्ट हो जाता है।

पिछले उदाहरण को CONCAT() के साथ करने के लिए , हमें प्रत्येक स्ट्रिंग के बीच विभाजक को दोहराना होगा।

इस तरह:

SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');

परिणाम:

+------------------------------------------+
| CONCAT('Blue', '-', 'Red', '-', 'Green') |
+------------------------------------------+
| Blue-Red-Green                           |
+------------------------------------------+

यदि हमारे पास जोड़ने के लिए बहुत सारे तार हों तो यह बोझिल हो सकता है।

कोई विभाजक नहीं

विभाजक के रूप में एक खाली स्ट्रिंग प्रदान करना एक विभाजक के बिना तारों को जोड़ता है:

SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');

परिणाम:

+---------------------------------------+
| CONCAT_WS('', 'Blue', 'Red', 'Green') |
+---------------------------------------+
| BlueRedGreen                          |
+---------------------------------------+

इस मामले में हमें वही परिणाम मिलता है जो हमें CONCAT() . का उपयोग करते समय मिलता था उन तीन तारों को जोड़ने के लिए।

विभाजक प्रदान करना महत्वपूर्ण है, भले ही वह खाली हो। एक विभाजक प्रदान करने में विफल होने के परिणामस्वरूप पहली संयोजन स्ट्रिंग को विभाजक के रूप में उपयोग किया जाएगा, जो शायद वह नहीं है जो आप चाहते हैं।

उदाहरण:

SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');

परिणाम:

+---------------------------------------------+
| CONCAT_WS('Blue', 'Red', 'Green', 'Orange') |
+---------------------------------------------+
| RedBlueGreenBlueOrange                      |
+---------------------------------------------+

इस मामले में, Blue पहला तर्क है, और इसलिए इसे विभाजक के रूप में इस्तेमाल किया जा रहा है।

अशक्त तर्कों को जोड़ना

एक अन्य लाभ यह है कि CONCAT_WS() CONCAT() से अधिक है क्या यह null है -सुरक्षित।

यदि कोई तर्क संगत किया जाना है तो null . है , CONCAT_WS() उनकी उपेक्षा करता है। CONCAT() दूसरी ओर फ़ंक्शन, null returns लौटाता है (जब तक कि यह Oracle मोड में न हो, उस स्थिति में यह null . पर ध्यान नहीं देता है तर्क)।

आइए CONCAT_WS() पर कॉल करें एक null . के साथ तर्क:

SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');

परिणाम:

+---------------------------------------+
| CONCAT_WS('-', 'Blue', NULL, 'Green') |
+---------------------------------------+
| Blue-Green                            |
+---------------------------------------+

जैसा अपेक्षित था, CONCAT_WS() शून्य तर्क को छोड़ दिया, और शेष तर्कों को जोड़ दिया।

इसका मतलब यह है कि, अगर हम विभाजक के रूप में एक खाली स्ट्रिंग प्रदान करते हैं, तो हम CONCAT_WS() का उपयोग कर सकते हैं। null . के रूप में CONCAT() . का सुरक्षित संस्करण :

SELECT CONCAT_WS('', 'Blue', NULL, 'Green');

परिणाम:

+--------------------------------------+
| CONCAT_WS('', 'Blue', NULL, 'Green') |
+--------------------------------------+
| BlueGreen                            |
+--------------------------------------+

नल सेपरेटर

एक null प्रदान करना विभाजक एक अलग कहानी है। ऐसा करने से null returns लौटता है .

SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');

परिणाम:

+-----------------------------------------+
| CONCAT_WS(NULL, 'Blue', 'Red', 'Green') |
+-----------------------------------------+
| NULL                                    |
+-----------------------------------------+

बाइनरी स्ट्रिंग्स

यदि कोई भी तर्क बाइनरी स्ट्रिंग है, तो परिणाम एक बाइनरी स्ट्रिंग है:

SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');

परिणाम:

+-------------------------------------------+
| CONCAT_WS(', ', BINARY 'Apple', 'Orange') |
+-------------------------------------------+
| Apple, Orange                             |
+-------------------------------------------+

हम COLLATION() . का उपयोग कर सकते हैं परिणाम के मिलान की जांच करने के लिए कार्य करें:

SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));

परिणाम:

+------------------------------------------------------+
| COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange')) |
+------------------------------------------------------+
| binary                                               |
+------------------------------------------------------+

अगर हम BINARY को हटा दें ऑपरेटर, हमें एक अलग परिणाम मिलता है:

SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));

परिणाम:

+-----------------------------------------------+
| COLLATION(CONCAT_WS(', ', 'Apple', 'Orange')) |
+-----------------------------------------------+
| utf8_general_ci                               |
+-----------------------------------------------+

एकल तर्क

कॉलिंग CONCAT_WS() केवल एक तर्क के साथ एक त्रुटि देता है:

SELECT CONCAT_WS('Blue');

परिणाम:

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

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

कॉलिंग CONCAT_WS() कोई तर्क पारित किए बिना त्रुटि उत्पन्न होती है:

SELECT CONCAT_WS();

परिणाम:

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