मारियाडीबी में, REGEXP_INSTR() फ़ंक्शन रेगुलर एक्सप्रेशन पैटर्न से मेल खाने वाले सबस्ट्रिंग का शुरुआती इंडेक्स देता है।
इंडेक्स 1 . से शुरू होता है . यदि कोई मेल नहीं है, तो परिणाम 0 . है ।
सिंटैक्स
वाक्य रचना इस प्रकार है:
REGEXP_INSTR(subject, pattern)
जहां subject इनपुट स्ट्रिंग है और pattern सबस्ट्रिंग के लिए रेगुलर एक्सप्रेशन पैटर्न है।
ध्यान दें कि, लिखते समय, मारियाडीबी का REGEXP_INSTR() का संस्करण MySQL के REGEXP_INSTR() . की तुलना में कम तर्क स्वीकार करता है . MySQL का संस्करण आपको खोज की प्रारंभिक स्थिति के लिए तर्क प्रदान करने की अनुमति देता है, किस घटना को खोजना है, किस प्रकार की स्थिति को वापस करना है, साथ ही नियमित अभिव्यक्ति को परिष्कृत करने का एक तरीका है।
उदाहरण
यहां एक बुनियादी उदाहरण दिया गया है:
SELECT REGEXP_INSTR('Cat', 'at');परिणाम:
+---------------------------+
| REGEXP_INSTR('Cat', 'at') |
+---------------------------+
| 2 |
+---------------------------+ इस मामले में एक मैच होता है, और सबस्ट्रिंग स्थिति 2 से शुरू होती है।
कोई मिलान नहीं
यहां एक उदाहरण दिया गया है जहां कोई मेल नहीं है:
SELECT REGEXP_INSTR('Cat', '^at');परिणाम:
+----------------------------+
| REGEXP_INSTR('Cat', '^at') |
+----------------------------+
| 0 |
+----------------------------+
कोई मेल नहीं है, इसलिए परिणाम 0 . है . कोई मेल नहीं है क्योंकि मैंने निर्दिष्ट किया है कि स्ट्रिंग को सबस्ट्रिंग से शुरू होना चाहिए।
आइए इसे बदलते हैं ताकि यह करता उस सबस्ट्रिंग से शुरू करें:
SELECT REGEXP_INSTR('at', '^at'); . चुनें परिणाम:
+---------------------------+
| REGEXP_INSTR('at', '^at') |
+---------------------------+
| 1 |
+---------------------------+
केस संवेदनशीलता
REGEXP_INSTR() फ़ंक्शन प्रभावी संयोजन के केस संवेदनशीलता नियमों का पालन करता है। केस असंवेदनशील कॉलेशन के लिए केस असंवेदनशील रूप से मिलान किया जाता है, और केस संवेदनशील कॉलेशन के लिए केस संवेदनशील रूप से और बाइनरी डेटा के लिए किया जाता है।
यहां एक उदाहरण दिया गया है:
SELECT
REGEXP_INSTR('Cat', 'c') AS "My Default",
REGEXP_INSTR(_latin7'Cat' COLLATE latin7_general_ci, 'c') AS "Case Insensitive",
REGEXP_INSTR(_latin7'Cat' COLLATE latin7_general_cs, 'c') AS "Case Sensitive";परिणाम:
+------------+------------------+----------------+ | My Default | Case Insensitive | Case Sensitive | +------------+------------------+----------------+ | 1 | 1 | 0 | +------------+------------------+----------------+
मेरा डिफ़ॉल्ट संयोजन केस असंवेदनशील है। अन्य दो स्ट्रिंग्स को क्रमशः केस असंवेदनशील संयोजन और केस संवेदनशील संयोजन के लिए मजबूर किया गया था।
एक BINARY प्रदान करना स्ट्रिंग भी केस संवेदी है (नीचे देखें)।
बाइनरी स्ट्रिंग्स
डिफ़ॉल्ट रूप से, पदों को बाइट्स के बजाय वर्णों में मापा जाता है। हालांकि, आप एक मल्टी-बाइट कैरेक्टर को BINARY . पर सेट कर सकते हैं यदि आपको आवश्यकता हो तो बाइट्स में ऑफ़सेट प्राप्त करने के लिए।
उदाहरण:
SELECT
REGEXP_INSTR('© Cat', 'C') AS "Character",
REGEXP_INSTR(BINARY '© Cat', 'C') AS "Binary";परिणाम:
+-----------+--------+ | Character | Binary | +-----------+--------+ | 3 | 4 | +-----------+--------+
कॉपीराइट प्रतीक दो बाइट्स का उपयोग करता है, और इसलिए इस उदाहरण में हमें 4 . का परिणाम मिलता है इसे BINARY . पर कास्ट करते समय , 3 . की तुलना में कि हम अन्यथा प्राप्त करते हैं।
हालांकि ध्यान दें कि BINARY . पास करना स्ट्रिंग केस संवेदनशीलता को भी प्रभावित करती है। BINARY के साथ स्ट्रिंग्स, एक अपर केस कैरेक्टर अपने लोअर केस समकक्ष से अलग होता है:
SELECT
REGEXP_INSTR('© Cat', 'c') AS "Character",
REGEXP_INSTR(BINARY '© Cat', 'c') AS "Binary";परिणाम:
+-----------+--------+ | Character | Binary | +-----------+--------+ | 3 | 0 | +-----------+--------+
यहां, मैंने लोअर केस c . की खोज की अपरकेस के बजाय, और BINARY स्ट्रिंग का मिलान नहीं हुआ।
अशक्त तर्क
पासिंग null किसी भी तर्क के परिणामस्वरूप null . होता है :
SELECT
REGEXP_INSTR(null, 'c') AS "1",
REGEXP_INSTR('Cat', null) AS "2",
REGEXP_INSTR(null, null) AS "3";परिणाम:
+------+------+------+ | 1 | 2 | 3 | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
तर्कों की गलत संख्या
तर्कों की गलत संख्या पास करने या कोई तर्क नहीं देने पर त्रुटि होती है:
SELECT REGEXP_INSTR('Cat');परिणाम:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_INSTR'
