REGEXP_INSTR() Funktion i Oracle

I Oracle er REGEXP_INSTR() funktion søger i en streng efter et regulært udtryksmønster. Det returnerer et heltal, der angiver start- eller slutpositionen for den matchede understreng (afhængig af hvilken du angiver).

Det udvider funktionaliteten af INSTR() funktion ved at tillade os at bruge regulære udtryksmønstre.

Syntaks

Syntaksen ser sådan ud:

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

Hvor:

source_char er et tegnudtryk, der tjener som søgeværdi.
pattern er det regulære udtryk.
position er et positivt heltal, der angiver, hvor søgningen skal begynde. Standarden er 1 , hvilket betyder, start søgningen ved det første tegn.
occurrence er et positivt heltal, der angiver, hvilken forekomst der skal søges efter. Standarden er 1 , hvilket betyder søgninger efter den første forekomst.
return_opt angiver, om Oracle skal returnere start- eller slutpositionen for den matchede understreng. Brug 0 for begyndelsen og 1 for slutningen. Standardværdien er 0 .
match_param lader dig ændre funktionens standardmatch-adfærd. For eksempel giver det dig mulighed for at specificere store og små bogstaver, hvordan flere linjer og mellemrum behandles osv. Dette argument fungerer på samme måde, som når det bruges med REGEXP_COUNT() fungere. Se Oracles dokumentation for den funktion for at få flere oplysninger.
For et pattern med underudtryk, subexpr er et ikke-negativt heltal fra 0 til 9, der angiver hvilket underudtryk i pattern skal returneres af funktionen. Dette argument fungerer på samme måde, som når det bruges med REGEXP_INSTR() fungere. Se Oracles dokumentation for den funktion for flere oplysninger.

Eksempel

Her er et grundlæggende eksempel på brug af REGEXP_INSTR() i Oracle:

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

Resultat:

I dette tilfælde er der et match, og startpositionen for understrengen returneres.

Regulære udtryk kan være meget kraftfulde, og dette eksempel bruger et meget simpelt eksempel. For at bruge REGEXP_INSTR() effektivt, skal du kende det korrekte mønster til at bruge til det ønskede resultat.

Ingen match

Her er et eksempel, hvor der ikke er nogen match:

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

Resultat:

Der er ingen match, så 0 er returneret.

Flere match

Her er et eksempel med flere matches:

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

Resultat:

Det returnerede positionen for den første forekomst.

Du kan dog angive, hvilken forekomst der skal erstattes:

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

Resultat:

Bemærk, at jeg tilføjede to argumenter her; 1 og 2 . 1 angiver opholdssted i strengen for at starte søgningen (i dette tilfælde ved det første tegn). 2 er det, der specificerer, hvilken forekomst der skal søges efter. I dette tilfælde søges der efter den anden forekomst.

Her er, hvad der sker, hvis jeg starter søgningen efter den første forekomst:

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

Resultat:

I dette tilfælde er der ingen kamp, fordi der kun er én forekomst mere efter startpositionen.

Hvis jeg ændrer det sidste argument til 1 , så får vi et match (fordi det er den første forekomst efter den angivne startposition):

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

Resultat:

Returnér slutpositionen

Du kan sende et femte argument af enten 0 eller 1 for at angive, om funktionen skal returnere start- eller slutpositionen af understrengen.

Standardværdien er 0 (til startposition). Her er, hvad der sker, hvis vi angiver 1 :

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

Resultat:

Bare for at være klar, her er den igen sammenlignet 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

Skrivar og bogstaver

REGEXP_INSTR() funktionen følger Oracles sorteringsbestemmelse og afledningsregler, som definerer den sortering, der skal bruges, når strengen matches med mønsteret.

Du kan dog udtrykkeligt angive følsomhed mellem store og små bogstaver med det valgfri sjette argument. Når du gør dette, tilsidesætter det enhver følsomhed mellem store og små bogstaver eller accentfølsomhed for den bestemte sortering.

Du kan angive i til forskellen mellem store og små bogstaver og c for store og små bogstaver.

Her er et eksempel:

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 ser ud til at skelne mellem store og små bogstaver, baseret på disse resultater. De to andre strenge blev tvunget til en matchning, der skelner mellem store og små bogstaver, og en matchning, der skelner mellem store og små bogstaver.

Underudtryk

Her er et eksempel på brug af det sjette argument til at returnere et specifikt underudtryksmønster:

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

Resultat:

I dette tilfælde returnerede jeg det første underudtryk.

Her er, hvad der sker, hvis jeg angiver det tredje underudtryk:

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

Resultat:

Nul-argumenter

Med undtagelse af det 6. argument, der giver null for et argument resulterer 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 returnerer SQLcl og SQL*Plus et tomt mellemrum, når null opstår som et resultat af en SQL SELECT udmelding.

Du kan dog bruge SET NULL for at angive en anden streng, der skal returneres. Her specificerede jeg, at strengen null skal returneres.

Forkert antal argumenter

Hvis der ikke sendes nogen argumenter til funktionen, eller for få, resulterer det i en fejl:

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:

Det samme gælder, når vi sender for mange argumenter:

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:

Flere oplysninger

REGEXP_INSTR() funktion (såvel som Oracles øvrige implementering af regulære udtryk) er i overensstemmelse med IEEE Portable Operating System Interface (POSIX) regulære udtryksstandard og Unicode Regular Expression Guidelines fra Unicode Consortium.

Se Oracle-dokumentationen for mere information og eksempler på REGEXP_INSTR() funktion.