MySQL में REGEXP_INSTR () फ़ंक्शन कैसे काम करता है

MySQL में, REGEXP_INSTR() फ़ंक्शन रेगुलर एक्सप्रेशन पैटर्न से मेल खाने वाले सबस्ट्रिंग का शुरुआती इंडेक्स देता है।

इंडेक्स 1 . से शुरू होता है . यदि कोई मेल नहीं है, तो परिणाम 0 . है ।

सिंटैक्स

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

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

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

वैकल्पिक pos तर्क आपको खोज शुरू करने के लिए स्ट्रिंग के भीतर एक स्थिति निर्दिष्ट करने की अनुमति देता है। यदि छोड़ा गया है, तो यह स्थिति 1 से शुरू होता है।

वैकल्पिक occurrence तर्क आपको यह निर्दिष्ट करने की अनुमति देता है कि किस मैच की खोज करनी है। यदि छोड़ा गया है, तो पहली घटना का उपयोग किया जाता है (घटना 1)।

वैकल्पिक return_option तर्क आपको यह निर्दिष्ट करने की अनुमति देता है कि किस प्रकार की स्थिति वापस करनी है। अगर आप 0 . का इस्तेमाल करते हैं , यह मिलान करने वाले सबस्ट्रिंग में पहले वर्ण की स्थिति लौटाएगा। अगर आप 1 का इस्तेमाल करते हैं यह निम्नलिखित . के पहले वर्ण की स्थिति लौटाता है मिलान करने वाला सबस्ट्रिंग। यदि छोड़ा गया है, तो मान 0 है ।

वैकल्पिक match_type तर्क आपको नियमित अभिव्यक्ति को परिष्कृत करने की अनुमति देता है। उदाहरण के लिए, आप इस तर्क का उपयोग केस-संवेदी मिलान निर्दिष्ट करने के लिए कर सकते हैं या नहीं।

उदाहरण 1 - मूल उपयोग

यहां एक बुनियादी उदाहरण दिया गया है:

SELECT REGEXP_INSTR('Cat', 'at') Result;

परिणाम:

+--------+
| Result |
+--------+
|      2 |
+--------+

इस मामले में एक मैच होता है, और सबस्ट्रिंग स्थिति 2 से शुरू होती है।

उदाहरण 2 - कोई मिलान नहीं

यहां एक उदाहरण दिया गया है जहां कोई मेल नहीं है:

SELECT REGEXP_INSTR('Cat', '^at') Result;

परिणाम:

+--------+
| Result |
+--------+
|      0 |
+--------+

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

आइए इसे बदलते हैं ताकि यह करता उस सबस्ट्रिंग से शुरू करें:

SELECT REGEXP_INSTR('at', '^at') Result;

परिणाम:

+--------+
| Result |
+--------+
|      1 |
+--------+

उदाहरण 3 - pos तर्क

आरंभिक स्थिति निर्दिष्ट करने का एक उदाहरण यहां दिया गया है:

SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Result;

परिणाम:

+--------+
| Result |
+--------+
|      5 |
+--------+

तो हमें दूसरी घटना का सूचकांक मिलता है।

ध्यान दें कि सूचकांक अभी भी स्थिति 1 से गिनना शुरू कर देता है, भले ही आप प्रारंभिक स्थिति निर्दिष्ट करें।

निम्न उदाहरण इसे और अधिक स्पष्ट रूप से प्रदर्शित करता है:

SELECT 
  REGEXP_INSTR('Cat Cat', 'Cat', 2) AS 'Pos 2', 
  REGEXP_INSTR('Cat Cat', 'Cat', 3) AS 'Pos 3', 
  REGEXP_INSTR('Cat Cat', 'Cat', 5) AS 'Pos 5';

परिणाम:

+-------+-------+-------+
| Pos 2 | Pos 3 | Pos 5 |
+-------+-------+-------+
|     5 |     5 |     5 |
+-------+-------+-------+

बेशक, आपके रेगेक्स पैटर्न के आधार पर, यह पूरी तरह से अलग सबस्ट्रिंग की अनुक्रमणिका वापस कर सकता है। उदाहरण:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6';

परिणाम:

+-------+-------+-------+
| Pos 1 | Pos 2 | Pos 6 |
+-------+-------+-------+
|     1 |     5 |    16 |
+-------+-------+-------+

हम सबस्ट्रिंग की जांच REGEXP_SUBSTR() . से कर सकते हैं समारोह:

SELECT 
  REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
  REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
  REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6';

परिणाम:

+-------+-------+-------+
| Pos 1 | Pos 2 | Pos 6 |
+-------+-------+-------+
| Cat   | Cit   | Cut   |
+-------+-------+-------+

उदाहरण 4 - occurrence तर्क

यहां occurrence का उपयोग करने का एक उदाहरण दिया गया है बहस। सभी मामलों में, हम स्थिति 1 से शुरू करते हैं:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1) 'Occurrence 1',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2) 'Occurrence 2',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3) 'Occurrence 3';

परिणाम:

+--------------+--------------+--------------+
| Occurrence 1 | Occurrence 2 | Occurrence 3 |
+--------------+--------------+--------------+
|            1 |            5 |           16 |
+--------------+--------------+--------------+

हालांकि, अगर हम एक अलग स्थिति से शुरू करते हैं, तो परिणाम अलग होता है:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 1) 'Occurrence 1',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 2) 'Occurrence 2',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 3) 'Occurrence 3';

परिणाम:

+--------------+--------------+--------------+
| Occurrence 1 | Occurrence 2 | Occurrence 3 |
+--------------+--------------+--------------+
|            5 |           16 |            0 |
+--------------+--------------+--------------+

ऐसा इसलिए हुआ क्योंकि हमारी शुरुआती स्थिति पहली घटना शुरू होने के बाद आई थी। इसलिए, घटना 2 घटना 1 बन गई, और घटना 3 घटना 2 बन गई। और क्योंकि कोई और घटना नहीं थी, इसलिए घटना 3 का परिणाम नकारात्मक था (अर्थात कोई घटना नहीं थी 3)।

उदाहरण 5 - return_option तर्क

यहां return_option . का इस्तेमाल करने का एक उदाहरण दिया गया है तर्क:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Option 0',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1) 'Option 1';

परिणाम:

+----------+----------+
| Option 0 | Option 1 |
+----------+----------+
|        1 |        4 |
+----------+----------+

विकल्प 0 ने मिलान किए गए सबस्ट्रिंग के पहले वर्ण को वापस कर दिया। विकल्प 1 ने मिलान किए गए सबस्ट्रिंग के बाद स्थिति लौटा दी।

यदि हम इसे पिछले उदाहरण पर लागू करते हैं तो यह कैसा दिखता है:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Occurrence 1',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 0) 'Occurrence 2',
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 0) 'Occurrence 3'
UNION ALL
SELECT
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1),
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 1),
  REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 1);

परिणाम:

+--------------+--------------+--------------+
| Occurrence 1 | Occurrence 2 | Occurrence 3 |
+--------------+--------------+--------------+
|            1 |            5 |           16 |
|            4 |            8 |           19 |
+--------------+--------------+--------------+

इस मामले में हमने विकल्प 0 का उपयोग करके एक सेट किया, और दूसरा विकल्प 1 का उपयोग करके, फिर UNION ALL का उपयोग करके उन्हें एक साथ जोड़ दिया। .

उदाहरण 6 - match_type तर्क

आप मिलान प्रकार निर्धारित करने के लिए एक अतिरिक्त तर्क प्रदान कर सकते हैं। यह आपको यह निर्दिष्ट करने की अनुमति देता है कि मैच केस-संवेदी है या नहीं, लाइन टर्मिनेटर शामिल करना है या नहीं, आदि।

केस-संवेदी मिलान और केस-संवेदी मिलान निर्दिष्ट करने का एक उदाहरण यहां दिया गया है:

SELECT 
  REGEXP_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive',
  REGEXP_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'i') 'Case-Insensitive';

परिणाम:

+----------------+------------------+
| Case-Sensitive | Case-Insensitive |
+----------------+------------------+
|              0 |                1 |
+----------------+------------------+

match_type तर्क में निम्नलिखित वर्ण हो सकते हैं:

c

केस संवेदनशील मिलान।

i

केस असंवेदनशील मिलान।

m

बहु-पंक्ति मोड। स्ट्रिंग के भीतर लाइन टर्मिनेटर को पहचानें। डिफ़ॉल्ट व्यवहार केवल स्ट्रिंग एक्सप्रेशन के प्रारंभ और अंत में लाइन टर्मिनेटर का मिलान करना है।

n

. चरित्र लाइन टर्मिनेटर से मेल खाता है। डिफ़ॉल्ट . पंक्ति के अंत में रुकने के लिए मिलान।

u

यूनिक्स-ओनली लाइन एंडिंग्स। केवल न्यूलाइन कैरेक्टर को . , ^ , और $ मैच ऑपरेटर।