Como a função REGEXP_INSTR() funciona no MySQL

No MySQL, o REGEXP_INSTR() A função retorna o índice inicial de uma substring que corresponde ao padrão de expressão regular.

O índice começa em 1 . Se não houver correspondência, o resultado será 0 .

Sintaxe

A sintaxe fica assim:

REGEXP_INSTR(expr, pat[, pos[, ocorrência[, return_option[, match_type]]]])

Onde expr é a string de entrada e pat é o padrão de expressão regular para a substring.

O opcional pos O argumento permite que você especifique uma posição dentro da string para iniciar a pesquisa. Se omitido, começa na posição 1.

A occurrence opcional O argumento permite especificar qual ocorrência da correspondência procurar. Se omitido, a primeira ocorrência é usada (ocorrência 1).

A return_option opcional O argumento permite especificar qual tipo de posição retornar. Se você usar 0 , ele retornará a posição do primeiro caractere na substring correspondente. Se você usar 1 retorna a posição do primeiro caractere seguindo a substring correspondente. Se omitido, o valor é 0 .

O opcional match_type O argumento permite refinar a expressão regular. Por exemplo, você pode usar esse argumento para especificar ou não a correspondência com distinção entre maiúsculas e minúsculas.

Exemplo 1 – Uso básico

Segue um exemplo básico:

SELECT REGEXP_INSTR('Cat', 'at') Resultado;

Resultado:

+--------+| Resultado |+--------+| 2 |+--------+

Nesse caso, há uma correspondência e a substring começa na posição 2.

Exemplo 2 – Sem correspondência

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

SELECT REGEXP_INSTR('Gato', '^at') Resultado;

Resultado:

+--------+| Resultado |+--------+| 0 |+--------+

Não há correspondência, então o resultado é 0 . Não há correspondência porque especifiquei que a string deve começar com a substring.

Vamos alterá-lo para que faça comece com essa substring:

SELECT REGEXP_INSTR('at', '^at') Resultado;

Resultado:

+--------+| Resultado |+--------+| 1 |+--------+

Exemplo 3 – O `pos` Argumento

Aqui está um exemplo de especificação de uma posição inicial:

SELECT REGEXP_INSTR('Gato Gato', 'Gato', 2) Resultado;

Resultado:

+--------+| Resultado |+--------+| 5 |+--------+

Assim, obtemos o índice da segunda ocorrência.

Observe que o índice ainda começa a contar da posição 1, independentemente de onde você especifica a posição inicial.

O exemplo a seguir demonstra isso mais claramente:

SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) AS 'Pos 2', REGEXP_INSTR('Cat Cat', 'Cat', 3) AS 'Pos 3', REGEXP_INSTR('Cat Cat', ' Cat', 5) AS 'Pos 5';

Resultado:

+-------+-------+-----------+| Posição 2 | Posição 3 | Pos 5 |+-------+-------+-----------+| 5 | 5 | 5 |+-------+-------+-----------+

Claro, dependendo do seu padrão regex, isso pode retornar o índice de substrings completamente diferentes. Exemplo:

SELECT REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 6) 'Pos 6';

Resultado:

+-------+-------+-----------+| Posição 1 | Posição 2 | Pos 6 |+-------+-------+-----------+| 1 | 5 | 16 |+-------+-------+-----------+

Podemos verificar as substrings com o REGEXP_SUBSTR() função:

SELECT REGEXP_SUBSTR('Cat City é TÃO Fofo!', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat City é TÃO Fofo!', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Cat City is TÃO Cute!', 'C.t', 6) 'Pos 6';

Resultado:

+-------+-------+-----------+| Posição 1 | Posição 2 | Pos 6 |+-------+-------+-----------+| Gato | Cit | Cortar |+-------+-------+-----------+

Exemplo 4 – A `occurrence` Argumento

Aqui está um exemplo de como usar a occurrence argumento. Em todos os casos, começamos na posição 1:

SELECT REGEXP_INSTR('Cat City é TÃO Fofo!', 'C.t', 1, 1) 'Ocorrência 1', REGEXP_INSTR('Cat City é TÃO Fofo!', 'C.t', 1, 2 ) 'Ocorrência 2', REGEXP_INSTR('Cidade dos gatos é tão fofa!', 'C.t', 1, 3) 'Ocorrência 3';

Resultado:

+--------------+-----------+--------------+| Ocorrência 1 | Ocorrência 2 | Ocorrência 3 |+--------------+--------------+--------------+| 1 | 5 | 16 |+--------------+--------------+--------------+ 
 No entanto, se começarmos em uma posição diferente, o resultado é diferente:
 SELECT REGEXP_INSTR('Cidade do Gato é TÃO Fofo!', 'C.t', 2, 1) 'Ocorrência 1', REGEXP_INSTR('Cidade do Gato é TÃO Fofo!', 'C.t', 2, 2 ) 'Ocorrência 2', REGEXP_INSTR('Cidade dos gatos é tão fofa!', 'C.t', 2, 3) 'Ocorrência 3';
 
 Resultado:
 +--------------+-----------+--------------+| Ocorrência 1 | Ocorrência 2 | Ocorrência 3 |+--------------+--------------+--------------+| 5 | 16 | 0 |+--------------+--------------+--------------+ 
 Isso aconteceu porque nossa posição inicial veio depois que a primeira ocorrência começou. Portanto, a ocorrência 2 passou a ser a ocorrência 1 e a ocorrência 3 passou a ser a ocorrência 2. E como não houve mais ocorrências, o resultado da ocorrência 3 foi negativo (ou seja, não houve ocorrência 3). 
 Exemplo 5 – A return_option Argumento
 
 Aqui está um exemplo de como usar a return_option argumento:
 SELECT REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1, 1, 0) 'Option 0', REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1 , 1, 1) 'Opção 1';
 
 Resultado:
 +----------+----------+| Opção 0 | Opção 1 |+----------+----------+| 1 | 4 |+----------+----------+
 
 A opção 0 retornou o primeiro caractere da substring correspondente. A opção 1 retornou a posição após a substring correspondente. 
 
 Aqui está o que parece se aplicarmos ao exemplo anterior:
 SELECT REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1, 1, 0) 'Ocorrência 1', REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1 , 2, 0) 'Ocorrência 2', REGEXP_INSTR('Cidade dos Gatos é TÃO Fofo!', 'C.t', 1, 3, 0) 'Ocorrência 3'UNION ALLSELECT REGEXP_INSTR('Cidade dos Gatos é TÃO Fofo!', 'C.t', 1, 1, 1), REGEXP_INSTR('Cat City is TÃO Cute!', 'C.t', 1, 2, 1), REGEXP_INSTR('Cat City is TÃO Cute!', 'C .t', 1, 3, 1);
 
 Resultado:
 +--------------+-----------+--------------+| Ocorrência 1 | Ocorrência 2 | Ocorrência 3 |+--------------+--------------+--------------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+--------------+--------------+ 
 Neste caso, fizemos um conjunto usando a opção 0 e outro usando a opção 1, depois os juntamos usando UNION ALL . 
 Exemplo 6 – O match_type Argumento
 
 Você pode fornecer um argumento adicional para determinar o tipo de correspondência. Isso permite que você especifique coisas como se a correspondência diferencia maiúsculas de minúsculas, se deve ou não incluir terminadores de linha, etc. 
 
 Aqui está um exemplo de especificação de uma correspondência que diferencia maiúsculas de minúsculas e uma correspondência que não diferencia maiúsculas de minúsculas:
 SELECT REGEXP_INSTR('Cidade dos Gatos é TÃO Fofo!', 'c.t', 1, 1, 0, 'c') 'Diferencia maiúsculas de minúsculas', REGEXP_INSTR('Cidade dos Gatos é TÃO Fofo!', 'c .t', 1, 1, 0, 'i') 'Não diferencia maiúsculas de minúsculas';
 
 Resultado:
 +----------------+------------------+| Sensível a maiúsculas e minúsculas | Não diferencia maiúsculas de minúsculas |+----------------+------------------+| 0 | 1 |+----------------+------------------+
 
 O match_type argumento pode conter os seguintes caracteres:
 c 
 Correspondência com distinção entre maiúsculas e minúsculas.
 i 
 Correspondência sem distinção entre maiúsculas e minúsculas.
 m 
 Modo de várias linhas. Reconhecer terminadores de linha dentro da string. O comportamento padrão é combinar terminadores de linha apenas no início e no final da expressão de string.
 n 
 O . caractere corresponde aos terminadores de linha. O padrão é para . correspondência para parar no final de uma linha.
 u 
 Finalizações de linha somente para Unix. Apenas o caractere de nova linha é reconhecido como uma linha que termina com . , ^ e $ operadores de correspondência.