REGEXP_INSTR() Funktion i Oracle

I Oracle, REGEXP_INSTR() funktion söker i en sträng efter ett reguljärt uttrycksmönster. Den returnerar ett heltal som anger start- eller slutpositionen för den matchade delsträngen (vilken du än anger).

Det utökar funktionaliteten för INSTR() funktion genom att tillåta oss att använda reguljära uttrycksmönster.

Syntax

Syntaxen ser ut så här:

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

Var:

source_char är ett teckenuttryck som fungerar som sökvärde.
pattern är det reguljära uttrycket.
position är ett positivt heltal som anger var sökningen ska börja. Standard är 1 , vilket betyder, starta sökningen vid det första tecknet.
occurrence är ett positivt heltal som anger vilken förekomst som ska sökas efter. Standard är 1 , vilket betyder sökningar efter den första förekomsten.
return_opt anger om Oracle ska returnera start- eller slutpositionen för den matchade delsträngen. Använd 0 för början och 1 för slutet. Standardvärdet är 0 .
match_param låter dig ändra standardmatchningsbeteendet för funktionen. Det låter dig till exempel ange skiftlägeskänslighet, hur flera rader och mellanslag hanteras, etc. Detta argument fungerar på samma sätt som när det används med REGEXP_COUNT() fungera. Se Oracles dokumentation för den funktionen för mer information.
För ett pattern med underuttryck, subexpr är ett icke-negativt heltal från 0 till 9 som indikerar vilket underuttryck i pattern ska returneras av funktionen. Detta argument fungerar på samma sätt som när det används med REGEXP_INSTR() fungera. Se Oracles dokumentation för den funktionen för mer information.

Exempel

Här är ett grundläggande exempel på hur du använder REGEXP_INSTR() i Oracle:

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

Resultat:

I det här fallet finns det en matchning och startpositionen för delsträngen returneras.

Reguljära uttryck kan vara mycket kraftfulla, och det här exemplet använder ett mycket enkelt exempel. För att använda REGEXP_INSTR() i praktiken måste du känna till det korrekta mönstret att använda för det önskade resultatet.

Ingen match

Här är ett exempel där det inte finns någon matchning:

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

Resultat:

Det finns ingen matchning, så 0 returneras.

Flera matchningar

Här är ett exempel med flera matchningar:

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

Resultat:

Den returnerade positionen för den första förekomsten.

Du kan dock ange vilken förekomst som ska ersättas:

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

Resultat:

Observera att jag lagt till två argument här; 1 och 2 . 1 anger var i strängen för att starta sökningen (i det här fallet vid det första tecknet). 2 är det som anger vilken händelse som ska sökas efter. I det här fallet söks den andra förekomsten efter.

Så här händer om jag startar sökningen efter den första händelsen:

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

Resultat:

I det här fallet finns det ingen match, eftersom det bara finns en händelse till efter startpositionen.

Om jag ändrar det sista argumentet till 1 , då får vi en matchning (eftersom det är den första händelsen efter den angivna startpositionen):

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

Resultat:

Återställ slutpositionen

Du kan skicka ett femte argument av antingen 0 eller 1 för att ange om funktionen ska returnera start- eller slutpositionen för delsträngen.

Standardvärdet är 0 (för startpositionen). Så här händer om vi anger 1 :

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

Resultat:

Bara för att vara tydlig, här är den igen jämfört med 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;

Resultat:

   Start    End 
________ ______ 
       4      7

Skaftkänslighet

REGEXP_INSTR() funktionen följer Oracles sorteringsbestämning och härledningsregler, som definierar sorteringen som ska användas när strängen matchas med mönstret.

Du kan dock uttryckligen ange skiftlägeskänslighet med det valfria sjätte argumentet. När du gör detta åsidosätter det all skiftlägeskänslighet eller accentkänslighet för den fastställda sorteringen.

Du kan ange i för skiftlägesokänslig matchning och c för skiftlägeskänslig matchning.

Här är ett exempel:

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;

Resultat:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

Min sortering verkar vara skiftlägeskänslig, baserat på dessa resultat. De andra två strängarna tvingades till en skiftlägesokänslig respektive skiftlägeskänslig matchning.

Underuttryck

Här är ett exempel på hur det sjätte argumentet används för att returnera ett specifikt underuttrycksmönster:

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

Resultat:

I det här fallet returnerade jag det första underuttrycket.

Så här händer om jag anger det tredje underuttrycket:

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

Resultat:

Nollargument

Med undantag för det sjätte argumentet, som ger null för ett argument resulterar i 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;

Resultat:

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

Som standard returnerar SQLcl och SQL*Plus ett tomt utrymme när null uppstår som ett resultat av en SQL SELECT påstående.

Du kan dock använda SET NULL för att ange en annan sträng som ska returneras. Här specificerade jag att strängen null bör returneras.

Fel antal argument

Att skicka inga argument till funktionen, eller för få, resulterar i ett fel:

SELECT REGEXP_INSTR()
FROM DUAL;

Resultat:

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:

Detsamma gäller när vi skickar för många argument:

SELECT REGEXP_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, 'oops')
FROM DUAL;

Resultat:

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:

Mer information

REGEXP_INSTR() funktion (liksom Oracles andra implementering av reguljära uttryck) överensstämmer med IEEE Portable Operating System Interface (POSIX) reguljära uttrycksstandard och Unicode Regular Expression Guidelines från Unicode Consortium.

Se Oracle-dokumentationen för mer information och exempel på REGEXP_INSTR() funktion.