मारियाडीबी में लाइक ऑपरेटर कैसे काम करता है?

MariaDB में, LIKE ऑपरेटर आपको पैटर्न मिलान करने की अनुमति देता है। यह निर्धारित करता है कि एक विशिष्ट वर्ण स्ट्रिंग एक निर्दिष्ट पैटर्न से मेल खाती है या नहीं। यह या तो 1 लौटाता है (TRUE) या 0 (झूठा)।

एक पैटर्न में नियमित वर्ण, साथ ही % . शामिल हो सकते हैं और _ वाइल्डकार्ड वर्ण।

उन वाइल्डकार्ड वर्णों को निम्न तालिका में समझाया गया है।

सिंटैक्स

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

expr LIKE pat [ESCAPE 'escape_char']

उदाहरण

मान लीजिए हमारे पास निम्न तालिका है:

SELECT * FROM Pets;

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
|     7 |         3 |       2 | Bark    | NULL       |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

यह दिखाने के लिए यहां एक उदाहरण दिया गया है कि कैसे LIKE ऑपरेटर काम करता है।

SELECT *
FROM Pets
WHERE PetName LIKE 'F%';

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

इस उदाहरण में, मैंने LIKE . का उपयोग किया है % . के साथ संचालिका वाइल्डकार्ड ऑपरेटर उन पालतू जानवरों को लौटाएगा जिनका नाम F . अक्षर से शुरू होता है ।

केस संवेदनशीलता

LIKE यदि एक्सप्रेशन और पैटर्न के लिए संयोजन केस-असंवेदनशील है, तो केस-असंवेदनशील सबस्ट्रिंग मैच करता है।

इसलिए, हम लोअरकेस f . का उपयोग करने के लिए पिछले उदाहरण को बदल सकते हैं , और फिर भी वही परिणाम प्राप्त करें:

SELECT *
FROM Pets
WHERE PetName LIKE 'f%';

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

हालांकि, हम COLLATE . का उपयोग करके केस-संवेदी मिलान को बाध्य कर सकते हैं एक द्विआधारी संयोजन के साथ खंड। वैकल्पिक रूप से, आप CAST() . का उपयोग कर सकते हैं इसे एक बाइनरी स्ट्रिंग के साथ जबरदस्ती करने के लिए।

उदाहरण:

SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;

परिणाम:

Empty set (0.000 sec)

कोई परिणाम नहीं लौटाया गया।

लेकिन अगर हम इसे अपरकेस F . में बदलते हैं :

SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

हमें उम्मीद के मुताबिक तीन मैच मिले।

संख्यात्मक तर्क

संख्यात्मक तर्कों को बाइनरी स्ट्रिंग्स के लिए मजबूर किया जाता है।

SELECT * 
FROM Pets 
WHERE PetId LIKE 7;

परिणाम:

+-------+-----------+---------+---------+------+
| PetId | PetTypeId | OwnerId | PetName | DOB  |
+-------+-----------+---------+---------+------+
|     7 |         3 |       2 | Bark    | NULL |
+-------+-----------+---------+---------+------+

तिथियां

यहां एक उदाहरण दिया गया है जो किसी तारीख से वर्ष से मेल खाता है:

SELECT * 
FROM Pets 
WHERE DOB LIKE '2020%';

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

आप LIKE . का भी उपयोग कर सकते हैं दिनांक कार्यों के परिणाम के विरुद्ध ऑपरेटर, जैसे DAYNAME() , MONTHNAME() , आदि.

SELECT * 
FROM Pets 
WHERE MONTHNAME(DOB) LIKE 'Nov%';

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
+-------+-----------+---------+---------+------------+

द _ वाइल्डकार्ड ऑपरेटर

अंडरस्कोर (_ ) वाइल्डकार्ड ऑपरेटर किसी एक वर्ण से मेल खाता है।

उदाहरण:

SELECT *
FROM Pets
WHERE PetName LIKE '_e%';

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

इस मामले में, हमने पालतू जानवरों के नामों का मिलान किया जहां दूसरा वर्ण एक e . है ।

द एस्केप कैरेक्टर

कभी-कभी आप खुद को ऐसी स्थिति में पाते हैं जहां आपको अंडरस्कोर या प्रतिशत चिह्न की खोज करने की आवश्यकता होती है। ऐसे मामलों में, आप बैकस्लैश का उपयोग कर सकते हैं (\ ) इन पात्रों से बचने के लिए। यह उन्हें वाइल्डकार्ड वर्णों के रूप में व्याख्यायित होने से रोकेगा।

मान लीजिए हमारे पास निम्न तालिका है:

SELECT * FROM Owners;

परिणाम:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | [email protected]  |
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       3 | Nancy     | Simpson  | (489) 591-0408 | NULL               |
|       4 | Boris     | Trump    | (349) 611-8908 | NULL               |
|       5 | Woody     | Eastwood | (308) 555-0112 | [email protected]  |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

ध्यान दें कि स्वामी 2 (बार्ट) के पास एक ईमेल पता है जिसमें एक अंडरस्कोर है।

जब हम नहीं करते हैं तो क्या होता है इसका एक उदाहरण यहां दिया गया है अंडरस्कोर से बचें:

SELECT * FROM Owners
WHERE Email LIKE 'b_%';

परिणाम:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

इस मामले में, यह दो पंक्तियों से मेल खाता है। इस मामले में, इससे कोई फ़र्क नहीं पड़ता कि दूसरा वर्ण क्या था - यह किसी भी . से मेल खाता था चरित्र। तथ्य यह है कि पहली पंक्ति में दूसरे वर्ण के लिए अंडरस्कोर होता है, यह सिर्फ एक संयोग है। यह कुछ और होता तो भी मेल खाता।

लेकिन क्या होगा यदि हम केवल उन ईमेल पतों का मिलान करना चाहते हैं जिनके दूसरे अक्षर के रूप में वास्तविक अंडरस्कोर है?

यहीं से एस्केप कैरेक्टर आता है।

SELECT * FROM Owners
WHERE Email LIKE 'b\_%';

परिणाम:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

अब हमें केवल एक पंक्ति मिलती है - वह पंक्ति जिसमें अंडरस्कोर दूसरे वर्ण के रूप में होता है।

एस्केप कैरेक्टर बदलना

भागने के चरित्र को बदलना संभव है। आप इसे ESCAPE . के साथ कर सकते हैं तर्क।

उदाहरण:

SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';

परिणाम:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

इस मामले में मैंने तारांकन सौंपा (* ) एस्केप कैरेक्टर के रूप में।

यह विशेष रूप से उपयोगी हो सकता है जब आपको अन्य उद्देश्यों के लिए बैकस्लैश का उपयोग करने की आवश्यकता होती है, जैसे कि विशेष वर्णों को एन्कोड करना। ऐसे मामलों में, आप खुद को इन पात्रों से "डबल-एस्केप" कर सकते हैं, जो भ्रमित करने वाला हो सकता है। इसलिए एस्केप कैरेक्टर को बदलने से ऐसी स्थितियों में मदद मिल सकती है।

शून्य मान

प्रतिशत (% ) वाइल्डकार्ड किसी भी चीज़ से मेल खाता है - लगभग। एक चीज जो मेल नहीं खाती वह है NULL .

SELECT * FROM Owners
WHERE Email LIKE '%';

परिणाम:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | [email protected]  |
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       5 | Woody     | Eastwood | (308) 555-0112 | [email protected]  |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

हमारी तालिका में, NULL . के साथ दो पंक्तियाँ हैं Email . में कॉलम, लेकिन वे यहां वापस नहीं किए गए हैं।

प्रदर्शन

वे क्वेरी जिनमें LIKE . शामिल हैं ऑपरेटर अन्य प्रश्नों की तुलना में बहुत धीमी गति से चल सकता है, और आपको संभवतः LIKE . का उपयोग करने से बचना चाहिए ऑपरेटर जब तक आपको वास्तव में इसकी आवश्यकता न हो। % का उपयोग करना उपसर्ग के रूप में ऑपरेटर विशेष रूप से धीमा हो सकता है।

इसका मतलब यह नहीं है कि आपको इसका इस्तेमाल बिल्कुल नहीं करना चाहिए। LIKE ऑपरेटर एसक्यूएल का एक अभिन्न अंग है, और आप कई परिदृश्यों का सामना करेंगे जहां यह एकमात्र विकल्प होगा (या कम से कम, सबसे अच्छा विकल्प)।

NOT LIKE संचालिका

आप NOT LIKE . का भी उपयोग कर सकते हैं यह जांचने के लिए कि कोई स्ट्रिंग नहीं करती है या नहीं एक पैटर्न से मेल करें।