विभिन्न ऑपरेटरों
LIKEऔर =अलग-अलग ऑपरेटर हैं। यहां अधिकांश उत्तर वाइल्डकार्ड समर्थन पर ध्यान केंद्रित करते हैं, जो इन ऑपरेटरों के बीच एकमात्र अंतर नहीं है!
=एक तुलना ऑपरेटर है जो संख्याओं और तारों पर काम करता है। स्ट्रिंग्स की तुलना करते समय, तुलना ऑपरेटर पूरे स्ट्रिंग्स की तुलना करता है ।
LIKEएक स्ट्रिंग ऑपरेटर है जो चरित्र की तुलना चरित्र से करता है ।
मामलों को जटिल करने के लिए, दोनों ऑपरेटर एक टकराव का उपयोग करते हैं जो तुलना के परिणाम पर महत्वपूर्ण प्रभाव डाल सकते हैं।
प्रेरक उदाहरण
आइए पहले एक उदाहरण की पहचान करें जहां ये ऑपरेटर स्पष्ट रूप से अलग-अलग परिणाम देते हैं। मुझे MySQL मैनुअल से उद्धृत करने की अनुमति दें:
SQL मानक के अनुसार, LIKE प्रति-वर्ण आधार पर मिलान करता है, इस प्रकार यह परिणाम = तुलना ऑपरेटर से भिन्न परिणाम उत्पन्न कर सकता है:
mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
| 0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
| 1 |
+--------------------------------------+
कृपया ध्यान दें कि MySQL मैनुअल के इस पृष्ठ को स्ट्रिंग तुलनात्मक कार्य कहा जाता है , और =इस पर चर्चा नहीं की जाती है, जिसका अर्थ है कि =कड़े तुलना फ़ंक्शन नहीं है।
कैसे =काम करता है ?
एसक्यूएल स्टैंडर्ड § 8.2 वर्णन करता है कि =तार तुलना:
दो वर्ण तारों की तुलना निम्नानुसार निर्धारित की जाती है:
a) यदि X के वर्णों की लंबाई Y के वर्णों में लंबाई के बराबर नहीं है, तो तुलना के प्रयोजनों के लिए छोटी स्ट्रिंग को प्रभावी रूप से प्रतिस्थापित किया जाता है, इसकी एक प्रति के साथ जिसकी लंबाई स्ट्रिंग की लंबाई तक बढ़ा दी गई है एक या एक से अधिक पैड कैरेक्टर के दाईं ओर कॉन्सेप्टेशन द्वारा, जहां पैड कैरेक्टर को CS के आधार पर चुना जाता है। यदि CS में कोई PAD विशेषता नहीं है, तो पैड वर्ण X और Y के वर्ण सेट में किसी भी वर्ण से भिन्न एक कार्यान्वयन-निर्भर चरित्र है जो CS के अंतर्गत किसी स्ट्रिंग से कम टकराता है। अन्यथा, पैड चरित्र एक है।
b) X और Y की तुलना का परिणाम कोलाटिंग अनुक्रम CS द्वारा दिया गया है।
ग) कोलाटिंग अनुक्रम के आधार पर, दो तारों की तुलना समान हो सकती है, भले ही वे अलग-अलग लंबाई के हों या पात्रों के विभिन्न अनुक्रम हों। जब ऑपरेशन MAX, MIN, DISTINCT, एक समूहीकरण कॉलम के संदर्भ में, और UNION, EXCEPT, और INTERSECT ऑपरेटर वर्ण स्ट्रिंग्स को संदर्भित करते हैं, तो इन समान मानों के सेट से इन परिचालनों द्वारा चयनित विशिष्ट मूल्य कार्यान्वयन-निर्भर है।
(महत्व दिया।)
इसका क्या मतलब है? इसका मतलब है कि जब तारों की तुलना की जाती है, तो =ऑपरेटर वर्तमान टकराव के चारों ओर एक पतला आवरण होता है। एक टकराव एक पुस्तकालय है जिसमें तार की तुलना करने के लिए विभिन्न नियम हैं। यहाँ MySQL से द्विआधारी टकराव का एक उदाहरण दिया गया है :
static int my_strnncoll_binary(const CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, size_t slen,
const uchar *t, size_t tlen,
my_bool t_is_prefix)
{
size_t len= MY_MIN(slen,tlen);
int cmp= memcmp(s,t,len);
return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
}
यह विशेष टकराव बाइट-बाइट की तुलना में होता है (यही कारण है कि इसे "बाइनरी" कहा जाता है - यह स्ट्रिंग्स को कोई विशेष अर्थ नहीं देता है)। अन्य टकराव अधिक उन्नत तुलना प्रदान कर सकते हैं।
उदाहरण के लिए, यहां UTF-8 समतलीकरण है जो केस-असंवेदनशील तुलनाओं का समर्थन करता है। कोड यहां पेस्ट करने के लिए बहुत लंबा है, लेकिन उस लिंक पर जाएं और के शरीर को पढ़ें my_strnncollsp_utf8mb4()। यह टकराव एक बार में कई बाइट्स को संसाधित कर सकता है और यह विभिन्न ट्रांसफ़ॉर्म (जैसे केस असंवेदनशील तुलना) लागू कर सकता है। =ऑपरेटर पूरी तरह से मिलान की अनियमितता से निकाला गया है।
कैसे LIKEकाम करता है ?
एसक्यूएल स्टैंडर्ड § 8.5 वर्णन करता है कि LIKEतार तुलना:
<विधेय>
M LIKE P
सच है अगर वहाँ एम विभाजन का अस्तित्व में है जैसे कि:
i) M का एक विकल्प 0 का अनुक्रम है या अधिक सन्निहित <चरित्र प्रतिनिधित्व> M का है और M का प्रत्येक <वर्ण प्रतिनिधित्व> वास्तव में एक प्रतिस्थापन का हिस्सा है।
ii) यदि P का i-th विकल्प निर्दिष्ट करने वाला एक मनमाना वर्ण विनिर्देशक है, तो M का i-th विकल्प किसी एकल <वर्ण प्रतिनिधित्व> है।
iii) यदि P का i-th विकल्प निर्दिष्ट करने वाला एक मनमाना स्ट्रिंग विनिर्देशक है, तो M का i-th विकल्प 0 या अधिक <वर्ण प्रतिनिधित्व> s का कोई अनुक्रम है।
iv) यदि P का i-th विकल्प निर्दिष्ट करने वाला न तो एक मनमाना वर्ण विनिर्देशक है और न ही एक मनमाना स्ट्रिंग विनिर्देशक है, तो M का i-th विकल्प उस प्रतिस्थापन निर्दिष्टक के अनुसार <प्रतिस्थापन की तरह; M के लिए <space> वर्णों का अपडेशन, और उस स्पेसिफिक स्पेसियर के समान लंबाई है।
v) M के सबस्ट्रिंग की संख्या P के स्थानापन्न विनिर्देशक की संख्या के बराबर है।
(महत्व दिया।)
यह बहुत ही चिंताजनक है, तो चलिए इसे तोड़ते हैं। आइटम ii और iii क्रमशः वाइल्डकार्ड _और संदर्भित करते %हैं। यदि Pकोई वाइल्डकार्ड नहीं है, तो केवल आइटम iv लागू होता है। यह ओपी द्वारा लगाए गए ब्याज का मामला है।
इस मामले में, यह प्रत्येक "प्रतिस्थापन" (व्यक्तिगत पात्रों) की Mतुलना Pवर्तमान टकराव का उपयोग करने वाले प्रत्येक प्रतिस्थापन के खिलाफ करता है ।
निष्कर्ष
लब्बोलुआब यह है कि तार की =तुलना करते LIKEसमय, एक बार में एक चरित्र की तुलना करते समय पूरे स्ट्रिंग की तुलना करते हैं । दोनों तुलनाएं वर्तमान टकराव का उपयोग करती हैं। यह अंतर कुछ मामलों में विभिन्न परिणामों की ओर जाता है, जैसा कि इस पोस्ट में पहले उदाहरण में स्पष्ट किया गया है।
आपको किसका उपयोग करना चाहिए? कोई भी आपको यह नहीं बता सकता है कि - आपको अपने उपयोग के मामले के लिए सही उपयोग करने की आवश्यकता है। तुलना ऑपरेटरों को स्विच करके समय से पहले अनुकूलन न करें।
