Função REGEXP_INSTR() no Oracle

No Oracle, o REGEXP_INSTR() A função procura uma string por um padrão de expressão regular. Ele retorna um inteiro indicando a posição inicial ou final da substring correspondente (a que você especificar).

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

Sintaxe

A sintaxe fica assim:

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

Onde:

source_char é uma expressão de caractere que serve como valor de pesquisa.
pattern é a expressão regular.
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 número inteiro positivo que especifica qual ocorrência procurar. O padrão é 1 , o que significa que procura a primeira ocorrência.
return_opt especifica se o Oracle deve retornar a posição inicial ou final da substring correspondente. Usar 0 para o início e 1 para o final. O valor padrão é 0 .
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 essa função para obter mais informações.
Para um pattern com subexpressões, subexpr é um inteiro não negativo de 0 a 9 indicando qual subexpressão no pattern deve ser retornado pela função. Este argumento funciona da mesma forma que quando usado com o REGEXP_INSTR() função. Consulte a documentação da Oracle para obter mais informações sobre essa função.

Exemplo

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

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

Resultado:

Nesse caso, há uma correspondência e a posição inicial da substring é retornada.

Expressões regulares podem ser muito poderosas, e este exemplo usa um exemplo muito simples. Para usar REGEXP_INSTR() 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_INSTR('My dogs like dregs', 't.g')
FROM DUAL;

Resultado:

Não há correspondência, então 0 é devolvido.

Várias correspondências

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

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

Resultado:

Ele retornou a posição da primeira ocorrência.

No entanto, você pode especificar qual ocorrência substituir:

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

Resultado:

Observe que 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 procurar. Neste caso, a segunda ocorrência é procurada.

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

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

Resultado:

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

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

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

Resultado:

Retorne a posição final

Você pode passar um quinto argumento de 0 ou 1 para especificar se a função deve retornar a posição inicial ou final da substring.

O valor padrão é 0 (para a posição inicial). Veja o que acontece se especificarmos 1 :

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

Resultado:

Só para ficar claro, aqui está novamente quando comparado com 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;

Resultado:

   Start    End 
________ ______ 
       4      7

Sensibilidade de maiúsculas e minúsculas

O REGEXP_INSTR() 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_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;

Resultado:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

Meu agrupamento parece diferenciar maiúsculas de minúsculas, com base nesses resultados. 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.

Subexpressões

Aqui está um exemplo de uso do sexto argumento para retornar um padrão de subexpressão específico:

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

Resultado:

Nesse caso, retornei a primeira subexpressão.

Aqui está o que acontece se eu especificar a terceira subexpressão:

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

Resultado:

Argumentos nulos

Com exceção do 6º argumento, fornecendo null para um argumento resulta em 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;

Resultado:

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

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_INSTR()
FROM DUAL;

Resultado:

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:

O mesmo se aplica quando passamos muitos argumentos:

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

Resultado:

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:

Mais informações

O REGEXP_INSTR() 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_INSTR() função.