कैसे REGEXP_SUBSTR () मारियाडीबी में काम करता है

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

यदि कोई मेल नहीं है (यानी इनपुट स्ट्रिंग में सबस्ट्रिंग शामिल नहीं है), तो परिणाम एक खाली स्ट्रिंग है।

सिंटैक्स

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

REGEXP_SUBSTR(subject,pattern)

जहां subject इनपुट स्ट्रिंग है और pattern सबस्ट्रिंग के लिए रेगुलर एक्सप्रेशन पैटर्न है।

ध्यान दें कि, लिखते समय, मारियाडीबी का REGEXP_SUBSTR() का संस्करण MySQL के REGEXP_SUBSTR() . की तुलना में कम तर्क स्वीकार करता है . MySQL का संस्करण आपको खोज की प्रारंभिक स्थिति के लिए तर्क प्रदान करने की अनुमति देता है, जो खोज की घटना है, साथ ही नियमित अभिव्यक्ति को परिष्कृत करने का एक तरीका है।

उदाहरण

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

SELECT REGEXP_SUBSTR('Thailand and Laos', 'l.nd');

परिणाम:

+--------------------------------------------+
| REGEXP_SUBSTR('Thailand and Laos', 'l.nd') |
+--------------------------------------------+
| land                                       |
+--------------------------------------------+

इस मामले में एक मैच होता है, और सबस्ट्रिंग वापस आ जाती है।

एकाधिक मिलान

डिफ़ॉल्ट रूप से, यदि स्ट्रिंग के भीतर एक से अधिक मिलान हैं, तो पहला मिलान वापस कर दिया जाता है:

SELECT REGEXP_SUBSTR('Lend for land', 'l.nd');

परिणाम:

+----------------------------------------+
| REGEXP_SUBSTR('Lend for land', 'l.nd') |
+----------------------------------------+
| Lend                                   |
+----------------------------------------+

कोई मिलान नहीं

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

SELECT REGEXP_SUBSTR('Lend for land', '^C');

परिणाम:

+--------------------------------------+
| REGEXP_SUBSTR('Lend for land', '^C') |
+--------------------------------------+
|                                      |
+--------------------------------------+

कोई मेल नहीं है, इसलिए परिणाम एक खाली स्ट्रिंग है।

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

REGEXP_SUBSTR() फ़ंक्शन प्रभावी संयोजन के केस संवेदनशीलता नियमों का पालन करता है। केस असंवेदनशील कॉलेशन के लिए केस असंवेदनशील रूप से मिलान किया जाता है, और केस संवेदनशील कॉलेशन के लिए केस संवेदनशील रूप से और बाइनरी डेटा के लिए किया जाता है।

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

SELECT 
    REGEXP_SUBSTR('My Cats', 'c.t') AS "My Default",
    REGEXP_SUBSTR(_latin7'My Cats' COLLATE latin7_general_ci, 'c.t') AS "Case Insensitive",
    REGEXP_SUBSTR(_latin7'My Cats' COLLATE latin7_general_cs, 'c.t') AS "Case Sensitive";

परिणाम:

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| Cat        | Cat              |                |
+------------+------------------+----------------+

मेरा डिफ़ॉल्ट संयोजन केस असंवेदनशील है। अन्य दो स्ट्रिंग्स को क्रमशः केस असंवेदनशील संयोजन और केस संवेदनशील संयोजन के लिए मजबूर किया गया था।

एक BINARY प्रदान करना स्ट्रिंग भी केस संवेदी है (नीचे देखें)।

बाइनरी स्ट्रिंग्स

एक BINARY पास करना स्ट्रिंग केस संवेदनशीलता को भी प्रभावित करती है। BINARY के साथ स्ट्रिंग्स, एक अपर केस कैरेक्टर अपने लोअर केस समकक्ष से अलग होता है:

उदाहरण:

SELECT 
    REGEXP_SUBSTR('My Cats', 'c.t') AS "Character",
    REGEXP_SUBSTR(BINARY 'My Cats', 'c.t') AS "Binary";

परिणाम:

+-----------+--------+
| Character | Binary |
+-----------+--------+
| Cat       |        |
+-----------+--------+

अगर हम मामला बदलते हैं तो यहां बताया गया है:

SELECT 
    REGEXP_SUBSTR('My Cats', 'C.t') AS "Character",
    REGEXP_SUBSTR(BINARY 'My Cats', 'C.t') AS "Binary";

परिणाम:

+-----------+--------+
| Character | Binary |
+-----------+--------+
| Cat       | Cat    |
+-----------+--------+

अशक्त तर्क

पासिंग null किसी भी तर्क के परिणामस्वरूप null . होता है :

SELECT 
    REGEXP_SUBSTR(null, 'c.t') AS "1",
    REGEXP_SUBSTR('Cat', null) AS "2",
    REGEXP_SUBSTR(null, null) AS "3";

परिणाम:

+------+------+------+
| 1    | 2    | 3    |
+------+------+------+
| NULL | NULL | NULL |
+------+------+------+

तर्कों की गलत संख्या

तर्कों की गलत संख्या पास करने या कोई तर्क नहीं देने से त्रुटि होती है:

SELECT REGEXP_SUBSTR('Cat');

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_SUBSTR'