Oracle
 sql >> Database >  >> RDS >> Oracle

REGEXP_REPLACE() Funzione in Oracle

In Oracle, il REGEXP_REPLACE() La funzione sostituisce le occorrenze della sottostringa all'interno di una stringa che corrisponde al modello di espressione regolare specificato.

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

Sintassi

La sintassi è questa:

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

Dove:

  • source_char è un'espressione di carattere che funge da valore di ricerca.
  • pattern è l'espressione regolare.
  • replace_string è la stringa sostitutiva.
  • 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 non negativo che specifica quale occorrenza sostituire. L'impostazione predefinita è 0 , il che significa sostituire tutte le occorrenze.
  • 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 ulteriori informazioni.

Esempio

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

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

Risultato:

Cats and birds

In questo caso c'è una corrispondenza e la sottostringa viene sostituita con la stringa sostitutiva.

Le espressioni regolari possono essere molto potenti e questo esempio usa un esempio molto semplice. Per utilizzare REGEXP_REPLACE() 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_REPLACE('Cats and dogs', 't.g', 'bird');

Risultato:

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

Non c'è corrispondenza, quindi la stringa originale viene restituita invariata.

Partite multiple

Ecco un esempio con più corrispondenze:

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

Risultato:

My bird likes other birds

Tuttavia, puoi specificare quale occorrenza sostituire se necessario:

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

Risultato:

My dog likes other birds

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 sostituire. In questo caso, la seconda occorrenza viene sostituita.

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

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

Risultato:

My dog likes other dogs

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

Se cambio l'ultimo argomento in 1 , quindi viene aggiornato come specificato (perché è la prima occorrenza dopo la posizione iniziale specificata):

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

Risultato:

My dog likes other birds

E nel caso te lo stia chiedendo, 0 specifica tutte le occorrenze:

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

Risultato:

My bird likes big birds and small birds

Ma rispetta comunque qualsiasi posizione di partenza che è stata specificata:

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

Risultato:

My dog likes big birds and small birds

Maiuscole/minuscole

Il REGEXP_REPLACE() 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_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;

Risultato:

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

Da questi risultati risulta che le mie regole di confronto predefinite fanno distinzione tra maiuscole e minuscole. Le altre due stringhe sono state forzate rispettivamente a una corrispondenza senza distinzione tra maiuscole e minuscole.

Argomenti nulli

Passaggio null risulta null per la maggior parte degli argomenti, ad eccezione del secondo e del sesto argomento:

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;

Risultato:

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

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 se sono troppo pochi, si verifica un errore:

SELECT REGEXP_REPLACE()
FROM DUAL;

Risultato:

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:

Lo stesso con il passaggio di troppi argomenti:

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

Risultato:

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:

Maggiori informazioni

Il REGEXP_REPLACE() 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_REPLACE() funzione.