मारियाडीबी में REGEXP कैसे काम करता है

मारियाडीबी में, REGEXP ऑपरेटर का उपयोग यह निर्धारित करने के लिए किया जाता है कि स्ट्रिंग रेगुलर एक्सप्रेशन से मेल खाती है या नहीं।

यदि स्ट्रिंग प्रदान की गई नियमित अभिव्यक्ति से मेल खाती है, तो परिणाम 1 . है , अन्यथा यह 0 है ।

सिंटैक्स

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

expr REGEXP pat

जहां expr इनपुट स्ट्रिंग है और pat वह रेगुलर एक्सप्रेशन है जिसके लिए आप स्ट्रिंग का परीक्षण कर रहे हैं।

उदाहरण

नीचे REGEXP . का उपयोग करने के उदाहरण दिए गए हैं विभिन्न पैटर्न वाले ऑपरेटर।

बेसिक रेगुलर एक्सप्रेशन

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

SELECT 
  'Corn' REGEXP 'Corn' AS "Corn",
  'Acorn' REGEXP 'Corn' AS "Acorn",
  'Corner' REGEXP 'Corn' AS "Corner",
  'Cheese' REGEXP 'Corn' AS "Cheese";

परिणाम:

+------+-------+--------+--------+
| Corn | Acorn | Corner | Cheese |
+------+-------+--------+--------+
|    1 |     1 |      1 |      0 |
+------+-------+--------+--------+

स्ट्रिंग की शुरुआत का मिलान करें

इस उदाहरण में, रेगुलर एक्सप्रेशन निर्दिष्ट करता है कि स्ट्रिंग Co . से शुरू होनी चाहिए ।

SELECT 
  'Corn' REGEXP '^Co' AS "Corn",
  'Acorn' REGEXP '^Co' AS "Acorn",
  'Cheese' REGEXP '^Co' AS "Cheese";

परिणाम:

+------+-------+--------+
| Corn | Acorn | Cheese |
+------+-------+--------+
|    1 |     0 |      0 |
+------+-------+--------+

स्ट्रिंग के अंत का मिलान करें

इस उदाहरण में, रेगुलर एक्सप्रेशन निर्दिष्ट करता है कि स्ट्रिंग को rn . के साथ समाप्त होना चाहिए ।

SELECT 
  'Corn' REGEXP 'rn$' AS "Corn",
  'Acorn' REGEXP 'rn$' AS "Acorn",
  'Cheese' REGEXP 'rn$' AS "Cheese";

परिणाम:

+------+-------+--------+
| Corn | Acorn | Cheese |
+------+-------+--------+
|    1 |     1 |      0 |
+------+-------+--------+

किसी भी वर्ण का मिलान करें

. वर्ण किसी भी वर्ण से मेल खाता है।

SELECT 
  'Corn' REGEXP '.' AS "Corn",
  'Cheese' REGEXP '.' AS "Cheese",
  '' REGEXP '.' AS "";

परिणाम:

+------+--------+---+
| Corn | Cheese |   |
+------+--------+---+
|    1 |      1 | 0 |
+------+--------+---+

यह वर्ण आम तौर पर आगे के मानदंड निर्दिष्ट करने के लिए अन्य वर्णों के साथ संयोजन के रूप में उपयोग किया जाता है। उदाहरण के लिए:

SELECT 
  'Corn' REGEXP '^C.rn$' AS "Corn", 
  'Crn' REGEXP '^C.rn$' AS "Crn";

परिणाम:

+------+-----+
| Corn | Crn |
+------+-----+
|    1 |   0 |
+------+-----+

यहां हम निर्दिष्ट करते हैं कि स्ट्रिंग C . से शुरू होनी चाहिए , कि इसके बाद एक वर्ण (कोई भी वर्ण) होना चाहिए, और यह कि यह rn . के साथ समाप्त होना चाहिए ।

ध्यान दें कि यह वर्ण वर्ण के एकल उदाहरण को निर्दिष्ट करता है। यदि आप एकाधिक उदाहरण निर्दिष्ट करना चाहते हैं (उदाहरण के लिए ee केवल e . के बजाय ), आपको और . वर्ण।

SELECT 
  'Tweet' REGEXP '^Tw..t$' AS "Tweet", 
  'Tweat' REGEXP '^Tw..t$' AS "Tweat", 
  'Tweet' REGEXP '^Tw.t$' AS "Tweet", 
  'Twit' REGEXP '^Tw..t$' AS "Twit";

परिणाम:

+-------+-------+-------+------+
| Tweet | Tweat | Tweet | Twit |
+-------+-------+-------+------+
|     1 |     1 |     0 |    0 |
+-------+-------+-------+------+

ऐसा करने का एक और तरीका है कि घुंघराले कोष्ठक के भीतर घटनाओं की संख्या निर्दिष्ट करें:

SELECT 
  'Tweet' REGEXP '^Tw.{2}t$' AS "Tweet", 
  'Tweat' REGEXP '^Tw.{2}t$' AS "Tweat", 
  'Tweet' REGEXP '^Tw.{1}t$' AS "Tweet", 
  'Twit' REGEXP '^Tw.{2}t$' AS "Twit";

परिणाम:

+-------+-------+-------+------+
| Tweet | Tweat | Tweet | Twit |
+-------+-------+-------+------+
|     1 |     1 |     0 |    0 |
+-------+-------+-------+------+

हालांकि, यदि आप उस वर्ण को जानते हैं जिसे आप ढूंढ रहे हैं, तो आप उस वर्ण को निर्दिष्ट कर सकते हैं (. चरित्र), जैसा कि निम्नलिखित उदाहरण में दिखाया गया है।

किसी विशिष्ट वर्ण के शून्य या अधिक उदाहरणों का मिलान करें

हम e . के शून्य या अधिक उदाहरण निर्दिष्ट करने के लिए निम्न कार्य कर सकते हैं चरित्र:

SELECT 
  'Twet' REGEXP '^Twe*t$' AS "Twet",
  'Tweet' REGEXP '^Twe*t$' AS "Tweet",
  'Tweeet' REGEXP '^Twe*t$' AS "Tweeet",
  'Twt' REGEXP '^Twe*t$' AS "Twt",
  'Twit' REGEXP '^Twe*t$' AS "Twit",
  'Twiet' REGEXP '^Twe*t$' AS "Twiet",
  'Tweit' REGEXP '^Twe*t$' AS "Tweit";

परिणाम:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     1 |      1 |   1 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

पहले चार मैच लेकिन अंतिम तीन नहीं।

एक विशिष्ट वर्ण के एक या अधिक उदाहरणों का मिलान करें

हम पिछले उदाहरण को संशोधित कर सकते हैं ताकि हमें केवल एक मैच मिल सके यदि एक या अधिक वर्ण पाए जाते हैं (पिछला उदाहरण एक मैच लौटाता है यदि शून्य या अधिक पाए गए)। ऐसा करने के लिए, हम बस + . का उपयोग करते हैं * . के बजाय :

SELECT 
  'Twet' REGEXP '^Twe+t$' AS "Twet",
  'Tweet' REGEXP '^Twe+t$' AS "Tweet",
  'Tweeet' REGEXP '^Twe+t$' AS "Tweeet",
  'Twt' REGEXP '^Twe+t$' AS "Twt",
  'Twit' REGEXP '^Twe+t$' AS "Twit",
  'Twiet' REGEXP '^Twe+t$' AS "Twiet",
  'Tweit' REGEXP '^Twe+t$' AS "Tweit";

परिणाम:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     1 |      1 |   0 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

इस मामले में, चौथा शब्द पिछले उदाहरण से भिन्न परिणाम देता है।

शून्य या विशिष्ट वर्ण का एक उदाहरण से मिलान करें

हम पिछले उदाहरण को संशोधित कर सकते हैं ताकि हमें केवल शून्य या वांछित वर्णों में से एक मैच मिल सके। ऐसा करने के लिए, हम ? . का उपयोग करते हैं :

SELECT 
  'Twet' REGEXP '^Twe?t$' AS "Twet",
  'Tweet' REGEXP '^Twe?t$' AS "Tweet",
  'Tweeet' REGEXP '^Twe?t$' AS "Tweeet",
  'Twt' REGEXP '^Twe?t$' AS "Twt",
  'Twit' REGEXP '^Twe?t$' AS "Twit",
  'Twiet' REGEXP '^Twe?t$' AS "Twiet",
  'Tweit' REGEXP '^Twe?t$' AS "Tweit";

परिणाम:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     0 |      0 |   1 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

वैकल्पिक

आप | . का उपयोग कर सकते हैं वर्णों के एक या दूसरे क्रम से मेल खाने वाला वर्ण:

SELECT 
  'Tweet' REGEXP 'Tw|et' AS "Tweet",
  'For Let' REGEXP 'Tw|et' AS "For Let",
  'Banana' REGEXP 'Tw|et' AS "Banana";

परिणाम:

+-------+---------+--------+
| Tweet | For Let | Banana |
+-------+---------+--------+
|     1 |       1 |      0 |
+-------+---------+--------+

यहां एक और उदाहरण दिया गया है जहां मैं पूरे शब्द खोजता हूं:

SELECT 
  'Cat' REGEXP 'Cat|Dog' AS "Cat",
  'Dog' REGEXP 'Cat|Dog' AS "Dog",
  'Doggone' REGEXP 'Cat|Dog' AS "Doggone",
  'Banana' REGEXP 'Cat|Dog' AS "Banana";

परिणाम:

+-----+-----+---------+--------+
| Cat | Dog | Doggone | Banana |
+-----+-----+---------+--------+
|   1 |   1 |       1 |      0 |
+-----+-----+---------+--------+

जब हमारा रेगुलर एक्सप्रेशन केवल स्ट्रिंग के हिस्से से मेल खाता है तब भी हमें एक मैच मिलता है।

किसी क्रम के शून्य या अधिक इंस्टेंस का मिलान करें

आप तारक के साथ कोष्ठक का उपयोग कर सकते हैं ()* अनुक्रम के शून्य या अधिक उदाहरण निर्दिष्ट करने के लिए:

SELECT 
  'Banana' REGEXP '(an)*' AS "Banana",
  'Land' REGEXP '(an)*' AS "Land",
  'Cheese' REGEXP '(an)*' AS "Cheese";

परिणाम:

+--------+------+--------+
| Banana | Land | Cheese |
+--------+------+--------+
|      1 |    1 |      1 |
+--------+------+--------+

एक और उदाहरण:

SELECT 
  'Banana' REGEXP '^B(an)*d$' AS "Banana",
  'Band' REGEXP '^B(an)*d$' AS "Band",
  'Bald' REGEXP '^B(an)*d$' AS "Bald",
  'Bad' REGEXP '^B(an)*d$' AS "Bad";

परिणाम:

+--------+------+------+-----+
| Banana | Band | Bald | Bad |
+--------+------+------+-----+
|      0 |    1 |    0 |   0 |
+--------+------+------+-----+

दोहराव

जैसा कि पिछले उदाहरण में देखा गया है, आप दोहराव निर्दिष्ट करने के लिए घुंघराले कोष्ठक का उपयोग कर सकते हैं। यह संकेतन पिछले कुछ उदाहरणों की तुलना में नियमित अभिव्यक्ति लिखने का अधिक सामान्य तरीका प्रदान करता है:

SELECT 
  'Tweeet' REGEXP 'e{3}' AS "Tweeet",
  'Tweet' REGEXP 'e{3}' AS "Tweet";

परिणाम:

+--------+-------+
| Tweeet | Tweet |
+--------+-------+
|      1 |     0 |
+--------+-------+

रेंज

आप एक श्रेणी निर्दिष्ट करने के लिए हाइफ़न वर्ण का उपयोग कर सकते हैं। यहां एक उदाहरण दिया गया है जो संख्याओं की श्रेणी निर्दिष्ट करता है:

SELECT 
  'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
  'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";

परिणाम:

+--------+-------+
| Tweeet | Tweet |
+--------+-------+
|      1 |     0 |
+--------+-------+

और निम्न उदाहरण अक्षरों की श्रेणी निर्दिष्ट करता है:

SELECT 
  'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
  'ABC' REGEXP '[A-Z]' AS "ABC",
  '123' REGEXP '[A-Z]' AS "123";

परिणाम:

+-----------+-----+-----+
| Tweet 123 | ABC | 123 |
+-----------+-----+-----+
|         1 |   1 |   0 |
+-----------+-----+-----+

यदि हम संख्याओं की सीमा को सीमित करते हैं तो यहां क्या होता है:

SELECT 
  '123' REGEXP '[1-3]' AS "123",
  '012' REGEXP '[1-3]' AS "012",
  '045' REGEXP '[1-3]' AS "045";

परिणाम:

+-----+-----+-----+
| 123 | 012 | 045 |
+-----+-----+-----+
|   1 |   1 |   0 |
+-----+-----+-----+

एक सीमा के भीतर नहीं

हम ^ . का उपयोग कर सकते हैं वर्ण पिछले उदाहरण को संशोधित करने के लिए ताकि वर्णों की निर्दिष्ट श्रेणी को बाहर रखा जा सके:

SELECT 
  '123' REGEXP '[^1-3]' AS "123",
  '012' REGEXP '[^1-3]' AS "012",
  '045' REGEXP '[^1-3]' AS "045";

परिणाम:

+-----+-----+-----+
| 123 | 012 | 045 |
+-----+-----+-----+
|   0 |   1 |   1 |
+-----+-----+-----+

इस मामले में हमें पिछले उदाहरण के विपरीत परिणाम मिलता है।

शून्य मान

यदि या तो व्यंजक या प्रतिमान null है , परिणाम null . है :

SELECT 
  null REGEXP 'Corn' AS "Corn",
  'Acorn' REGEXP null AS "Acorn",
  null REGEXP null AS "Corner";

परिणाम:

+------+-------+--------+
| Corn | Acorn | Corner |
+------+-------+--------+
| NULL |  NULL |   NULL |
+------+-------+--------+