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

Oracle में, REGEXP_INSTR() फ़ंक्शन नियमित अभिव्यक्ति पैटर्न के लिए एक स्ट्रिंग खोजता है। यह मिलान किए गए सबस्ट्रिंग (जो भी आप निर्दिष्ट करते हैं) की शुरुआत या समाप्ति स्थिति को इंगित करने वाला एक पूर्णांक देता है।

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

सिंटैक्स

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

REGEXP_INSTR ( source_char, pattern
               [, position
                  [, occurrence
                     [, return_opt
                        [, match_param
                           [, subexpr ]
                        ]
                     ]
                  ]
               ]
             )

कहां:

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

उदाहरण

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

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g')
FROM DUAL;

परिणाम:

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

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

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

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

SELECT REGEXP_INSTR('My dogs like dregs', 't.g')
FROM DUAL;

परिणाम:

कोई मेल नहीं है, इसलिए 0 लौटा दिया गया है।

एकाधिक मिलान

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

SELECT 
    REGEXP_INSTR('My dogs have dags', 'd.g')
FROM DUAL;

परिणाम:

इसने पहली घटना की स्थिति लौटा दी।

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

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 1, 2)
FROM DUAL;

परिणाम:

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

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

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 8, 2)
FROM DUAL;

परिणाम:

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

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

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 8, 1)
FROM DUAL;

परिणाम:

अंतिम स्थिति लौटाएं

आप 0 . का पांचवां तर्क पारित कर सकते हैं या 1 यह निर्दिष्ट करने के लिए कि क्या फ़ंक्शन को सबस्ट्रिंग की शुरुआत या समाप्ति स्थिति वापस करनी चाहिए।

डिफ़ॉल्ट मान 0 है (शुरुआती स्थिति के लिए)। यदि हम 1 . निर्दिष्ट करते हैं तो यहां क्या होता है :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1)
FROM DUAL;

परिणाम:

बस स्पष्ट होने के लिए, 0 . के साथ तुलना करने पर यह फिर से है :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 0) AS "Start",
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1) AS "End"
FROM DUAL;

परिणाम:

   Start    End 
________ ______ 
       4      7

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

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

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

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

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

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

परिणाम:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

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

सबएक्सप्रेशन

विशिष्ट उप-अभिव्यक्ति पैटर्न को वापस करने के लिए छठे तर्क का उपयोग करने का एक उदाहरण यहां दिया गया है:

SELECT REGEXP_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 1
    )
FROM DUAL;

परिणाम:

इस मामले में मैंने पहली उप-अभिव्यक्ति लौटा दी।

अगर मैं तीसरी उप-अभिव्यक्ति निर्दिष्ट करता हूं तो यहां क्या होता है:

SELECT REGEXP_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 3
    )
FROM DUAL;

परिणाम:

अशक्त तर्क

छठे तर्क के अपवाद के साथ, null . प्रदान करना एक तर्क के लिए null . में परिणाम होता है :

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

परिणाम:

      1       2       3       4       5    6       7 
_______ _______ _______ _______ _______ ____ _______ 
   null    null    null    null    null    0    null

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

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

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

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

SELECT REGEXP_INSTR()
FROM DUAL;

परिणाम:

Error starting at line : 1 in command -
SELECT REGEXP_INSTR()
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_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, 'oops')
FROM DUAL;

परिणाम:

Error starting at line : 1 in command -
SELECT REGEXP_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, '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_INSTR() फ़ंक्शन (साथ ही साथ Oracle का रेगुलर एक्सप्रेशन का अन्य कार्यान्वयन) IEEE पोर्टेबल ऑपरेटिंग सिस्टम इंटरफ़ेस (POSIX) रेगुलर एक्सप्रेशन मानक और यूनिकोड कंसोर्टियम के यूनिकोड रेगुलर एक्सप्रेशन दिशानिर्देशों के अनुरूप है।

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