कैसे नहीं पसंद मारियाडीबी में काम करता है

मारियाडीबी में, NOT LIKE ऑपरेटर का उपयोग यह जांचने के लिए किया जाता है कि कोई स्ट्रिंग नहीं करता है या नहीं एक पैटर्न से मेल करें। यह LIKE . का विलोम लौटाता है ऑपरेटर। यह NOT को लागू करने जैसा ही है संपूर्ण LIKE . के विरुद्ध ऑपरेटर अभिव्यक्ति।

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

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

सिंटैक्स

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

expr NOT 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       |
+-------+-----------+---------+---------+------------+

यहां NOT LIKE का उपयोग करने का एक उदाहरण दिया गया है उस तालिका के विरुद्ध:

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     7 |         3 |       2 | Bark    | NULL       |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

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

यह विपरीत परिणाम सेट है जो हमें मिला होता अगर हम सिर्फ LIKE . का उपयोग करते . उस स्थिति में, हमें केवल वही परिणाम मिलेंगे जहां पालतू जानवर का नाम F . अक्षर से शुरू होता है ।

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

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

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

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     7 |         3 |       2 | Bark    | NULL       |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

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

उदाहरण:

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

परिणाम:

+-------+-----------+---------+---------+------------+
| 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       |
+-------+-----------+---------+---------+------------+

इस बार पूरी मेज लौटा दी गई। ऐसा इसलिए है क्योंकि कुछ भी लोअर केस से मेल नहीं खाता f ।

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

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     7 |         3 |       2 | Bark    | NULL       |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

हमें उम्मीद के मुताबिक पांच मैच मिले। वे पंक्तियाँ जहाँ पालतू जानवर का नाम F . से शुरू होता है बाहर रखा गया है।

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

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

SELECT * 
FROM Pets 
WHERE PetId NOT LIKE 1;

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     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       |
+-------+-----------+---------+---------+------------+

तिथियां

यहां एक तारीख का उदाहरण दिया गया है:

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     3 |         2 |       2 | Scratch | 2018-10-01 |
+-------+-----------+---------+---------+------------+

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

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

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

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

उदाहरण:

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

परिणाम:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     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       |
+-------+-----------+---------+---------+------------+

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

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

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

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

SELECT * FROM Owners;

परिणाम:

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

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

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

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

परिणाम:

+---------+-----------+----------+----------------+-------------------+
| OwnerId | FirstName | LastName | Phone          | Email             |
+---------+-----------+----------+----------------+-------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | example@sqldat.com |
|       5 | Woody     | Eastwood | (308) 555-0112 | example@sqldat.com |
+---------+-----------+----------+----------------+-------------------+

इस मामले में, यह सिर्फ दो पंक्तियों में लौटा। इसने उन दो पंक्तियों को बाहर कर दिया जहां ईमेल पता b . से शुरू होता है , और उसके बाद एक अन्य वर्ण, और उसके बाद कितने भी वर्ण आते हैं। इसने null . वाली पंक्तियों को भी बाहर कर दिया ईमेल पता।

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

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

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

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

परिणाम:

+---------+-----------+----------+----------------+-------------------+
| OwnerId | FirstName | LastName | Phone          | Email             |
+---------+-----------+----------+----------------+-------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | example@sqldat.com |
|       5 | Woody     | Eastwood | (308) 555-0112 | example@sqldat.com |
|       6 | Burt      | Tyson    | (309) 565-0112 | example@sqldat.com  |
+---------+-----------+----------+----------------+-------------------+

हम देख सकते हैं कि परिणामों में बर्ट को जोड़ा गया है।

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

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

उदाहरण:

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

परिणाम:

+---------+-----------+----------+----------------+-------------------+
| OwnerId | FirstName | LastName | Phone          | Email             |
+---------+-----------+----------+----------------+-------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | example@sqldat.com |
|       5 | Woody     | Eastwood | (308) 555-0112 | example@sqldat.com |
|       6 | Burt      | Tyson    | (309) 565-0112 | example@sqldat.com  |
+---------+-----------+----------+----------------+-------------------+

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

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