Função REGEXP_REPLACE() no Oracle

No Oracle, o REGEXP_REPLACE() A função substitui as ocorrências da substring dentro de uma string que corresponde ao padrão de expressão regular fornecido.

Ele estende a funcionalidade do REPLACE() função, permitindo-nos usar padrões de expressão regular.

Sintaxe

A sintaxe fica assim:

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

Onde:

source_char é uma expressão de caractere que serve como valor de pesquisa.
pattern é a expressão regular.
replace_string é a string de substituição.
position é um número inteiro positivo que especifica onde iniciar a pesquisa. O padrão é 1 , ou seja, inicie a pesquisa no primeiro caractere.
occurrence é um inteiro não negativo que especifica qual ocorrência substituir. O padrão é 0 , o que significa substituir todas as ocorrências.
match_param permite alterar o comportamento de correspondência padrão da função. Por exemplo, ele permite que você especifique a distinção entre maiúsculas e minúsculas, como várias linhas e espaços são tratados, etc. Este argumento funciona da mesma forma que quando usado com o REGEXP_COUNT() função. Consulte a documentação da Oracle para obter mais informações.

Exemplo

Aqui está um exemplo básico de uso de REGEXP_REPLACE() no Oráculo:

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

Resultado:

Cats and birds

Nesse caso, há uma correspondência e a substring é substituída pela string de substituição.

Expressões regulares podem ser muito poderosas, e este exemplo usa um exemplo muito simples. Para usar REGEXP_REPLACE() efetivamente, você precisará saber o padrão correto a ser usado para o resultado desejado.

Sem correspondência

Aqui está um exemplo em que não há correspondência:

SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');

Resultado:

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

Não há correspondência, então a string original é retornada inalterada.

Várias correspondências

Aqui está um exemplo com várias correspondências:

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

Resultado:

My bird likes other birds

No entanto, você pode especificar qual ocorrência substituir, se necessário:

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

Resultado:

My dog likes other birds

Observe que eu adicionei dois argumentos aqui – 1 e 2 . O 1 especifica a localização na string para iniciar a pesquisa (neste caso, no primeiro caractere). O 2 é o que especifica qual ocorrência substituir. Nesse caso, a segunda ocorrência é substituída.

Aqui está o que acontece se eu iniciar a pesquisa após a primeira ocorrência:

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

Resultado:

My dog likes other dogs

Neste caso a string não é atualizada, pois há apenas mais uma ocorrência após a posição inicial.

Se eu alterar o último argumento para 1 , ele é atualizado conforme especificado (porque é a primeira ocorrência após a posição inicial especificada):

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

Resultado:

My dog likes other birds

E caso você esteja se perguntando, 0 especifica todas as ocorrências:

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

Resultado:

My bird likes big birds and small birds

Mas ainda respeita qualquer posição inicial que tenha sido especificada:

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

Resultado:

My dog likes big birds and small birds

Sensibilidade de maiúsculas e minúsculas

O REGEXP_REPLACE() A função segue as regras de determinação e derivação de agrupamento do Oracle, que definem o agrupamento a ser usado ao combinar a string com o padrão.

No entanto, você pode especificar explicitamente a distinção entre maiúsculas e minúsculas com o sexto argumento opcional. Ao fazer isso, ele substitui qualquer distinção entre maiúsculas e minúsculas ou acentos do agrupamento determinado.

Você pode especificar i para correspondência que não diferencia maiúsculas de minúsculas e c para correspondência com distinção entre maiúsculas e minúsculas.

Aqui está um exemplo:

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;

Resultado:

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

Parece a partir desses resultados que meu agrupamento padrão diferencia maiúsculas de minúsculas. As outras duas strings foram forçadas a uma correspondência que não diferencia maiúsculas de minúsculas e diferencia maiúsculas de minúsculas, respectivamente.

Argumentos nulos

Passando null resulta em null para a maioria dos argumentos, exceto para o segundo e sexto argumentos:

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;

Resultado:

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

Por padrão, SQLcl e SQL*Plus retornam um espaço em branco sempre que null ocorre como resultado de um SQL SELECT demonstração.

No entanto, você pode usar SET NULL para especificar uma string diferente a ser retornada. Aqui eu especifiquei que a string null deve ser devolvido.

Número errado de argumentos

Não passar argumentos para a função, ou muito poucos, resulta em um erro:

SELECT REGEXP_REPLACE()
FROM DUAL;

Resultado:

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:

O mesmo com passar muitos argumentos:

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

Resultado:

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:

Mais informações

O REGEXP_REPLACE() A função (assim como a outra implementação de expressões regulares da Oracle) está em conformidade com o padrão de expressão regular IEEE Portable Operating System Interface (POSIX) e com as Diretrizes de Expressão Regular Unicode do Unicode Consortium.

Consulte a documentação do Oracle para obter mais informações e exemplos do REGEXP_REPLACE() função.