REGEXP_INSTR() Funzione in Oracle

In Oracle, il REGEXP_INSTR() La funzione cerca in una stringa un modello di espressione regolare. Restituisce un numero intero che indica la posizione iniziale o finale della sottostringa abbinata (qualunque si specifichi).

Estende la funzionalità di INSTR() funzione consentendoci di utilizzare modelli di espressioni regolari.

Sintassi

La sintassi è questa:

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

Dove:

source_char è un'espressione di carattere che funge da valore di ricerca.
pattern è l'espressione regolare.
position è un numero intero positivo che specifica da dove iniziare la ricerca. L'impostazione predefinita è 1 , ovvero avvia la ricerca dal primo carattere.
occurrence è un numero intero positivo che specifica quale occorrenza cercare. L'impostazione predefinita è 1 , il che significa che cerca la prima occorrenza.
return_opt specifica se Oracle deve restituire la posizione iniziale o finale della sottostringa corrispondente. Usa 0 per l'inizio e 1 per il finale. Il valore predefinito è 0 .
match_param consente di modificare il comportamento di corrispondenza predefinito della funzione. Ad esempio, consente di specificare la distinzione tra maiuscole e minuscole, come vengono gestite più righe e spazi, ecc. Questo argomento funziona allo stesso modo di quando viene utilizzato con REGEXP_COUNT() funzione. Consulta la documentazione di Oracle per quella funzione per ulteriori informazioni.
Per un pattern con sottoespressioni, subexpr è un numero intero non negativo da 0 a 9 che indica quale sottoespressione in pattern deve essere restituito dalla funzione. Questo argomento funziona allo stesso modo di quando viene utilizzato con REGEXP_INSTR() funzione. Consulta la documentazione di Oracle per ulteriori informazioni su tale funzione.

Esempio

Ecco un esempio di base dell'utilizzo di REGEXP_INSTR() in Oracle:

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

Risultato:

In questo caso c'è una corrispondenza e viene restituita la posizione iniziale della sottostringa.

Le espressioni regolari possono essere molto potenti e questo esempio usa un esempio molto semplice. Per utilizzare REGEXP_INSTR() in modo efficace, dovrai conoscere lo schema corretto da utilizzare per il risultato desiderato.

Nessuna corrispondenza

Ecco un esempio in cui non c'è corrispondenza:

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

Risultato:

Non c'è corrispondenza, quindi 0 viene restituito.

Partite multiple

Ecco un esempio con più corrispondenze:

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

Risultato:

Ha restituito la posizione della prima occorrenza.

Tuttavia, puoi specificare quale occorrenza sostituire:

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

Risultato:

Nota che ho aggiunto due argomenti qui; 1 e 2 . Il 1 specifica dove si trova nella stringa per avviare la ricerca (in questo caso, al primo carattere). Il 2 è ciò che specifica quale occorrenza cercare. In questo caso, viene cercata la seconda occorrenza.

Ecco cosa succede se avvio la ricerca dopo la prima occorrenza:

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

Risultato:

In questo caso non c'è corrispondenza, perché c'è solo un'altra occorrenza dopo la posizione di partenza.

Se cambio l'ultimo argomento in 1 , quindi otteniamo una corrispondenza (perché è la prima occorrenza dopo la posizione iniziale specificata):

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

Risultato:

Restituisci la posizione finale

Puoi passare un quinto argomento di 0 o 1 per specificare se la funzione deve restituire la posizione iniziale o finale della sottostringa.

Il valore predefinito è 0 (per la posizione iniziale). Ecco cosa succede se specifichiamo 1 :

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

Risultato:

Giusto per essere chiari, eccolo di nuovo rispetto a 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;

Risultato:

   Start    End 
________ ______ 
       4      7

Maiuscole/minuscole

Il REGEXP_INSTR() segue le regole di determinazione e derivazione delle regole di confronto di Oracle, che definiscono le regole di confronto da utilizzare quando si confronta la stringa con il modello.

Tuttavia, puoi specificare esplicitamente la distinzione tra maiuscole e minuscole con il sesto argomento facoltativo. Quando lo fai, sovrascrive qualsiasi distinzione tra maiuscole e minuscole o sensibilità all'accento delle regole di confronto determinate.

Puoi specificare i per la corrispondenza senza distinzione tra maiuscole e minuscole e c per la corrispondenza con distinzione tra maiuscole e minuscole.

Ecco un esempio:

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;

Risultato:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

La mia raccolta sembra distinguere tra maiuscole e minuscole, sulla base di questi risultati. Le altre due stringhe sono state forzate rispettivamente a una corrispondenza senza distinzione tra maiuscole e minuscole.

Sottoespressioni

Ecco un esempio di utilizzo del sesto argomento per restituire un modello di sottoespressione specifico:

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

Risultato:

In questo caso ho restituito la prima sottoespressione.

Ecco cosa succede se specifico la terza sottoespressione:

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

Risultato:

Argomenti nulli

Con l'eccezione del 6° argomento, fornendo null per un argomento risulta 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;

Risultato:

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

Per impostazione predefinita, SQLcl e SQL*Plus restituiscono uno spazio vuoto ogni volta che null si verifica come risultato di un SQL SELECT dichiarazione.

Tuttavia, puoi utilizzare SET NULL per specificare una stringa diversa da restituire. Qui ho specificato che la stringa null deve essere restituito.

Numero di argomenti errato

Se non si passano argomenti alla funzione, o ne sono troppo pochi, si verifica un errore:

SELECT REGEXP_INSTR()
FROM DUAL;

Risultato:

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:

Lo stesso vale quando passiamo troppi argomenti:

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

Risultato:

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:

Maggiori informazioni

Il REGEXP_INSTR() funzione (così come l'altra implementazione di espressioni regolari di Oracle) è conforme allo standard delle espressioni regolari POSIX (Portable Operating System Interface) IEEE e alle Linee guida per le espressioni regolari Unicode di Unicode Consortium.

Consulta la documentazione Oracle per ulteriori informazioni ed esempi di REGEXP_INSTR() funzione.