MySQL REGEXP उदाहरण

MySQL में, REGEXP ऑपरेटर का उपयोग यह निर्धारित करने के लिए किया जाता है कि स्ट्रिंग नियमित अभिव्यक्ति से मेल खाती है या नहीं। यह REGEXP_LIKE() . का समानार्थी है ।

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

सिंटैक्स

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

expr REGEXP pat

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

उदाहरण 1 - बेसिक रेगुलर एक्सप्रेशन

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

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

उदाहरण 2 - एक स्ट्रिंग की शुरुआत का मिलान करें

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

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

परिणाम:

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

उदाहरण 3 - एक स्ट्रिंग के अंत का मिलान करें

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

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

परिणाम:

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

उदाहरण 4 - किसी भी वर्ण का मिलान करें

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

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

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

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

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

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

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

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

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

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

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

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

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

उदाहरण 8 - विकल्प

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

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

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

उदाहरण 9 - अनुक्रम के शून्य या अधिक उदाहरणों का मिलान करें

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

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

उदाहरण 10 - दोहराव

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

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

परिणाम:

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

उदाहरण 11 - रेंज

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

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';

परिणाम:

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

उदाहरण 12 - एक सीमा के भीतर नहीं

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

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

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