Oracle में REGEXP_REPLACE () फ़ंक्शन

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

यह REPLACE() . की कार्यक्षमता का विस्तार करता है हमें नियमित अभिव्यक्ति पैटर्न का उपयोग करने की अनुमति देकर कार्य करते हैं।

सिंटैक्स

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

REGEXP_REPLACE ( source_char, pattern
                 [, replace_string
                    [, position
                       [, occurrence
                          [, match_param ]
                       ]
                    ]
                 ]
               )

कहां:

• source_char एक चरित्र अभिव्यक्ति है जो खोज मूल्य के रूप में कार्य करती है।
• pattern नियमित अभिव्यक्ति है।
• replace_string प्रतिस्थापन स्ट्रिंग है।
• position एक धनात्मक पूर्णांक है जो निर्दिष्ट करता है कि खोज कहाँ से शुरू करनी है। डिफ़ॉल्ट 1 है , यानी, पहले अक्षर पर खोज शुरू करें।
• occurrence एक गैर-ऋणात्मक पूर्णांक है जो निर्दिष्ट करता है कि किस घटना को प्रतिस्थापित करना है। डिफ़ॉल्ट 0 है , जिसका अर्थ है सभी घटनाओं को बदलें।
• match_param आपको फ़ंक्शन के डिफ़ॉल्ट मिलान व्यवहार को बदलने देता है। उदाहरण के लिए, यह आपको केस-सेंसिटिविटी निर्दिष्ट करने की अनुमति देता है, कि कई लाइनों और रिक्त स्थान से कैसे निपटा जाता है, आदि। यह तर्क उसी तरह काम करता है जब REGEXP_COUNT() के साथ प्रयोग किया जाता है। समारोह। अधिक जानकारी के लिए Oracle के दस्तावेज़ देखें।

उदाहरण

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

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

परिणाम:

Cats and birds

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

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

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

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

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

परिणाम:

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

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

एकाधिक मिलान

यहां एक से अधिक मिलानों का उदाहरण दिया गया है:

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

परिणाम:

My bird likes other birds

हालांकि, यदि आवश्यक हो तो आप निर्दिष्ट कर सकते हैं कि किस घटना को बदलना है:

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

परिणाम:

My dog likes other birds

ध्यान दें कि मैंने यहां दो तर्क जोड़े हैं - 1 और 2 . 1 खोज शुरू करने के लिए स्ट्रिंग में ठिकाना निर्दिष्ट करता है (इस मामले में, पहले वर्ण पर)। 2 वह है जो निर्दिष्ट करता है कि किस घटना को बदलना है। इस मामले में, दूसरी घटना को बदल दिया जाता है।

अगर मैं पहली बार खोज शुरू करता हूं तो यहां क्या होता है:

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

परिणाम:

My dog likes other dogs

इस मामले में स्ट्रिंग अपडेट नहीं होती है, क्योंकि शुरुआती स्थिति के बाद केवल एक और घटना होती है।

अगर मैं अंतिम तर्क को 1 . में बदल दूं , फिर इसे निर्दिष्ट के रूप में अपडेट किया जाता है (क्योंकि यह निर्दिष्ट प्रारंभिक स्थिति के बाद पहली घटना है):

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

परिणाम:

My dog likes other birds

और अगर आप सोच रहे हैं, 0 सभी घटनाओं को निर्दिष्ट करता है:

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 1, 0
    )
FROM DUAL;

परिणाम:

My bird likes big birds and small birds

लेकिन यह अभी भी निर्दिष्ट की गई किसी भी प्रारंभिक स्थिति का सम्मान करता है:

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 7, 0
    )
FROM DUAL;

परिणाम:

My dog likes big birds and small birds

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

REGEXP_REPLACE() फ़ंक्शन ओरेकल के संयोजन निर्धारण और व्युत्पत्ति नियमों का पालन करता है, जो पैटर्न के साथ स्ट्रिंग का मिलान करते समय उपयोग करने के लिए संयोजन को परिभाषित करता है।

हालांकि, आप वैकल्पिक छठे तर्क के साथ केस-संवेदनशीलता को स्पष्ट रूप से निर्दिष्ट कर सकते हैं। जब आप ऐसा करते हैं, तो यह निर्धारित संयोजन की किसी भी केस-संवेदनशीलता या उच्चारण-संवेदनशीलता को ओवरराइड करता है।

आप i . निर्दिष्ट कर सकते हैं केस-असंवेदनशील मिलान और c . के लिए केस-संवेदी मिलान के लिए।

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

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0) AS "Default",
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0, 'i') AS "Case Insensitive",
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0, 'c') AS "Case Sensitive"
FROM DUAL;

परिणाम:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
My Cats    My dogs             My Cats         

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

अशक्त तर्क

पासिंग null परिणाम null दूसरे और छठे तर्कों को छोड़कर अधिकांश तर्कों के लिए:

SET NULL 'null';
SELECT 
    REGEXP_REPLACE(null, 'c.t', 'dog', 1, 0, 'i') AS "1",
    REGEXP_REPLACE('Cat', null, 'dog', 1, 0, 'i') AS "2",
    REGEXP_REPLACE('Cat', 'c.t', null, 1, 0, 'i') AS "3",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', null, 0, 'i') AS "4",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, null, 'i') AS "5",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, null) AS "6"
FROM DUAL;

परिणाम:

      1      2       3       4       5      6 
_______ ______ _______ _______ _______ ______ 
null    Cat    null    null    null    Cat   

डिफ़ॉल्ट रूप से, SQLcl और SQL*Plus जब भी null . खाली स्थान लौटाते हैं SQL SELECT . के परिणामस्वरूप होता है बयान।

हालांकि, आप SET NULL . का उपयोग कर सकते हैं वापस करने के लिए एक अलग स्ट्रिंग निर्दिष्ट करने के लिए। यहाँ मैंने निर्दिष्ट किया है कि स्ट्रिंग null लौटाया जाना चाहिए।

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

फ़ंक्शन के लिए कोई तर्क नहीं पारित करने, या बहुत कम, एक त्रुटि में परिणाम:

SELECT REGEXP_REPLACE()
FROM DUAL;

परिणाम:

Error starting at line : 1 in command -
SELECT REGEXP_REPLACE()
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00938: not enough arguments for function
00938. 00000 -  "not enough arguments for function"
*Cause:    
*Action:

बहुत सारे तर्क पारित करने के साथ ही:

SELECT REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, 'i', 'oops')
FROM DUAL;

परिणाम:

Error starting at line : 1 in command -
SELECT REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, 'i', 'oops')
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00939: too many arguments for function
00939. 00000 -  "too many arguments for function"
*Cause:    
*Action:

अधिक जानकारी

REGEXP_REPLACE() फ़ंक्शन (साथ ही साथ Oracle का रेगुलर एक्सप्रेशन का अन्य कार्यान्वयन) IEEE पोर्टेबल ऑपरेटिंग सिस्टम इंटरफ़ेस (POSIX) रेगुलर एक्सप्रेशन मानक और यूनिकोड कंसोर्टियम के यूनिकोड रेगुलर एक्सप्रेशन दिशानिर्देशों के अनुरूप है।

अधिक जानकारी और REGEXP_REPLACE() . के उदाहरणों के लिए Oracle दस्तावेज़ देखें समारोह।