Mysql
 sql >> Base de Dados >  >> RDS >> Mysql

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


No MySQL, o REGEXP_SUBSTR() A função retorna a substring que corresponde ao padrão de expressão regular fornecido.

Se não houver correspondência (ou seja, a string de entrada não contém a substring), o resultado é NULL .


Sintaxe


A sintaxe fica assim:
REGEXP_SUBSTR(expr, pat[, pos[, ocorrência[, 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).

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_SUBSTR('Tailândia ou Camboja', 'l.nd') Resultado;

Resultado:
+--------+| Resultado |+--------+| terra |+--------+

Nesse caso, há uma correspondência e a substring é retornada.

Exemplo 2 – Várias correspondências


Por padrão, se houver várias correspondências na string, a primeira será retornada (embora você possa especificar outra ocorrência, se necessário. Chegaremos a isso em breve):
SELECT REGEXP_SUBSTR('Lend for land', 'l.nd') Resultado;

Resultado:
+--------+| Resultado |+--------+| Emprestar |+--------+

Exemplo 3 – Sem correspondência


Aqui está um exemplo em que não há correspondência:
SELECT REGEXP_SUBSTR('Lend for land', '^C') Resultado;

Resultado:
+--------+| Resultado |+--------+| NULO |+--------+

Não há correspondência, então o resultado é NULL .

Exemplo 4 – O pos Argumento


Aqui está um exemplo de especificação de uma posição inicial:
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) Resultado;

Resultado:
+--------+| Resultado |+--------+| Cortar |+--------+

Começamos na posição 2, que vem após o início da primeira ocorrência, então a próxima ocorrência é retornada.

Aqui está outro exemplo:
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) 'Pos 2', REGEXP_SUBSTR('Cat Berço de Corte', 'C.t', 6) 'Pos 6';

Resultado:
+-------+-------+-----------+| Posição 1 | Posição 2 | Pos 6 |+-------+-------+-----------+| Gato | Corte | Berço |+-------+-------+-----------+

Exemplo 5 – 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_SUBSTR('Cat Cut Cot', 'C.t', 1, 1) 'Ocorrência 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 2) 'Ocorrência 2', REGEXP_SUBSTR('Cat Cut Berço', 'C.t', 1, 3) 'Ocorrência 3';

Resultado:
+--------------+-----------+--------------+| Ocorrência 1 | Ocorrência 2 | Ocorrência 3 |+--------------+--------------+--------------+| Gato | Corte | Berço |+--------------+--------------+--------------+ 
 No entanto, se começarmos em uma posição diferente, o resultado é diferente:
 
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 1) 'Ocorrência 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 2) 'Ocorrência 2', REGEXP_SUBSTR('Cat Cut Berço', 'C.t', 2, 3) 'Ocorrência 3';
 
 Resultado:
 
+--------------+-----------+--------------+| Ocorrência 1 | Ocorrência 2 | Ocorrência 3 |+--------------+--------------+--------------+| Corte | Berço | NULL |+--------------+--------------+--------------+ 
 Isso aconteceu porque nossa posição inicial veio depois que a primeira ocorrência começou. Portanto, a ocorrência 2 tornou-se ocorrência 1 e a ocorrência 3 tornou-se ocorrência 2. E como não houve mais ocorrências, o resultado da ocorrência 3 foi NULL (ou seja, não houve ocorrência 3). 
 
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_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'c') 'Case-Sensitive', REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, '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 |+----------------+------------------+| NULO | Gato |+----------------+------------------+
 
 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.