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

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

प्रतिस्थापन के साथ पूरी स्ट्रिंग लौटा दी जाती है।

यदि कोई मेल नहीं है (यानी इनपुट स्ट्रिंग में सबस्ट्रिंग शामिल नहीं है), तो पूरी स्ट्रिंग अपरिवर्तित लौटा दी जाती है।

सिंटैक्स

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

REGEXP_REPLACE(subject, pattern, replace)

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

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

उदाहरण

यहां REGEXP_REPLACE() . का उपयोग करने का एक बुनियादी उदाहरण दिया गया है मारियाडीबी में:

SELECT REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird');

परिणाम:

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird') |
+------------------------------------------------+
| Cats and birds                                 |
+------------------------------------------------+

इस मामले में एक मैच होता है, और सबस्ट्रिंग को प्रतिस्थापन स्ट्रिंग से बदल दिया जाता है।

नियमित अभिव्यक्ति बहुत शक्तिशाली हो सकती है, और यह उदाहरण एक बहुत ही सरल उदाहरण का उपयोग करता है। REGEXP_REPLACE() use का उपयोग करने के लिए प्रभावी ढंग से, आपको वांछित परिणाम के लिए उपयोग करने के लिए सही पैटर्न जानने की आवश्यकता होगी।

एकाधिक मिलान

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

SELECT REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird');

परिणाम:

+----------------------------------------------------------+
| REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird') |
+----------------------------------------------------------+
| My bird likes other birds                                |
+----------------------------------------------------------+

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

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

SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');

परिणाम:

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs                                  |
+------------------------------------------------+

कोई मेल नहीं है, इसलिए मूल स्ट्रिंग अपरिवर्तित है।

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

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

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

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

परिणाम:

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My dogs    | My dogs          | My Cats        |
+------------+------------------+----------------+

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

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

केस संवेदनशीलता को ओवरराइड करें

कोलेशन केस संवेदनशीलता को (?i . का उपयोग करके ओवरराइड किया जा सकता है ) और (?-i ) पीसीआरई झंडे।

यहां पिछला उदाहरण है, लेकिन इस बार (?-i) . का उपयोग करके केस संवेदनशीलता को बल देने के लिए प्रत्येक पैटर्न पर फ़्लैग करें:

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?-i)c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?-i)c.t', 'dog') AS "Case Sensitive";

परिणाम:

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

और यहाँ यह (?i) . का उपयोग कर रहा है केस असंवेदनशीलता को बाध्य करने के लिए ध्वज:

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

परिणाम:

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

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

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

उदाहरण:

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

परिणाम:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My Cats |
+-----------+---------+

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

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

परिणाम:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My dogs |
+-----------+---------+

BINARY . पर केस संवेदनशीलता स्ट्रिंग्स को (?-i) . से भी ओवरराइड किया जा सकता है और (?i) पीसीआरई झंडे:

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', '(?-i)c.t', 'dog') AS "Binary";

परिणाम:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My Cats   | My Cats |
+-----------+---------+

अशक्त तर्क

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

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

परिणाम:

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

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

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

SELECT REGEXP_REPLACE();

परिणाम:

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