Resumo : neste tutorial, você aprenderá sobre expressões regulares do MySQL e como usar as funções e operadores de expressões regulares.
Introdução às expressões regulares do MySQL
Expressões regulares são strings especiais que descrevem padrões de pesquisa. É uma ferramenta poderosa que oferece uma maneira concisa e flexível de identificar sequências de texto, como caracteres e palavras, com base em padrões.
Por exemplo, você pode usar expressões regulares para pesquisar e-mails, endereços IP, números de telefone, números de previdência social ou qualquer coisa com um padrão específico.
As expressões regulares têm sua própria sintaxe que um processador de expressões regulares pode interpretar. Expressões regulares são amplamente utilizadas em diversas plataformas, desde linguagens de programação até bancos de dados, incluindo MySQL.
A vantagem de usar expressões regulares é que você não está limitado a pesquisar uma string com base em um padrão fixo com o sinal de porcentagem (%) e sublinhado (_) no LIKEoperador. As expressões regulares oferecem uma ampla gama de metacaracteres para criar padrões flexíveis.
A desvantagem de usar expressões regulares é que pode ser difícil compreendê-las e mantê-las, especialmente com padrões tão complicados. Portanto, é aconselhável fornecer um comentário na instrução SQL para explicar o propósito da expressão regular. Além disso, em alguns casos, padrões complexos podem levar à diminuição da velocidade de recuperação de dados.
MySQL usa componentes internacionais para Unicode (ICU) para suportar expressões regulares. Isso garante que o Unicode e a compatibilidade com caracteres multibyte sejam totalmente suportados.
Observe que antes do MySQL 8.0.4, o MySQL implementava expressões regulares usando o método de Henry Spencer, que funcionava com bytes e não era seguro para multibyte.
Funções e operadores de expressões regulares do MySQL
A tabela a seguir ilustra as funções e operadores de expressões regulares no MySQL:
| Nome | Descrição |
|---|---|
| REGEXP | Retorna 1 se uma string corresponder a uma expressão regular ou 0 caso contrário. |
| REGEXP_INSTR() | Retorna o índice inicial de uma substring que corresponde a uma expressão regular. |
| REGEXP_LIKE() | Teste se uma string corresponde a uma expressão regular. |
| REGEXP_REPLACE() | Substitua substrings que correspondam a uma expressão regular. |
| REGEXP_SUBSTR() | Extraia uma substring que corresponda a uma expressão regular. |
| CURTIR | Determine se uma string corresponde a uma expressão regular. |
Sintaxe de expressão regular
Nesta seção, cobriremos apenas a sintaxe básica da expressão regular.
1) Literais
Para formar uma expressão regular no MySQL, você usa uma string regular. Por exemplo:
'MySQL'Linguagem de código: JavaScript ( javascript )Esta é uma expressão simples que corresponde à string MySQL. Se a string de entrada for 'MySQL is awesome', terá uma correspondência.
2) Classes de personagens
As classes de caracteres são conjuntos de caracteres, por exemplo, dígitos (0-9) e alfabetos (az). Expressões regulares usam classes de caracteres para corresponder a conjuntos de caracteres.
Aqui estão algumas classes de personagens comuns:
| Classe de personagem | Descrição |
|---|---|
| \d | corresponde a um único dígito de 0 a 9. |
| \c | corresponde a um conjunto de caracteres de palavras que inclui alfabeto, dígito e sublinhado. |
| \s | corresponde a um espaço em branco incluindo um espaço, uma tabulação, uma nova linha, um retorno de carro e uma tabulação vertical. |
Cada classe de personagem possui uma classe de personagem inversa. Por exemplo, \D corresponde a um único caractere, exceto um dígito. Da mesma forma, \W corresponde a um único caractere que não é um caractere de palavra e \S corresponde a um único caractere, exceto espaço em branco.
3) Âncoras
As âncoras correspondem à posição do personagem. As âncoras incluem ^o que corresponde ao início de uma string e $o que corresponde ao final de uma string.
Por exemplo, ^\dcombine um dígito no início de uma string. Corresponderá ao número 1 na string ‘1 golfinho’.
4) Quantificadores
Os quantificadores definem quantas vezes um caracter ou caractere deve ocorrer dentro de um padrão. A tabela a seguir exibe os quantificadores em expressões regulares:
| Quantificador | Descrição |
|---|---|
| * | Corresponde a zero ou mais ocorrências do caractere ou classe anterior. |
| + | Corresponde a uma ou mais ocorrências do caractere ou classe anterior. |
| ? | Corresponde a zero ou uma ocorrência do caractere ou classe anterior. |
| {n} | Corresponde exatamente a n ocorrências do caractere ou classe anterior. |
| {n,} | Corresponde a n ou mais ocorrências do caractere ou classe anterior. |
| {n,m} | Corresponde entre n e m ocorrências do caractere ou classe anterior. |
Exemplos de expressões regulares MySQL
Vejamos alguns exemplos de uso de funções e operadores de expressões regulares do MySQL.
1) Verificando se uma string corresponde a uma expressão regular
Para determinar se uma string corresponde a uma expressão regular, use o REGEXPoperador:
expression REGEXP patternLinguagem de código: SQL (linguagem de consulta estruturada) ( sql )Retorna REGEXP1 se a expressão corresponder à expressão regular especificada pelo padrão, 0 caso contrário.
Se a expressão ou padrão for NULL, o REGEXPoperador retornará 0.
Por exemplo, a consulta a seguir usa o REGEPXoperador para verificar se a string MySQL 8 corresponde à expressão regular especificada pelo padrão "\\d+":
SELECT 'MySQL 8' REGEXP '\\d+';Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+-------------------------+
| 'MySQL 8' REGEXP '\\d+' |
+-------------------------+
| 1 |
+-------------------------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )O padrão “\\d+” corresponde a um ou mais dígitos em uma string. Portanto, REGEXPretorna 1 neste exemplo.
Se você remover o número 8, ele retornará 0 porque a string MySQLnão possui dígitos:
SELECT 'MySQL' REGEXP '\\d+';Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+-----------------------+
| 'MySQL' REGEXP '\\d+' |
+-----------------------+
| 0 |
+-----------------------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )O RLIKEfunciona da mesma forma que o REGPEXoperador:
SELECT 'MySQL 8' RLIKE '\\d+';Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+------------------------+
| 'MySQL 8' RLIKE '\\d+' |
+------------------------+
| 1 |
+------------------------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Observe que REGEXP e RLIKE são sinônimos de REGEXP_LIKE().
2) Obtendo o índice da substring que corresponde a uma expressão regular
Para obter a posição da substring que corresponde a uma expressão regular, você usa a REGEXP_INSTR()função.
Aqui está a sintaxe básica da REGEXP_INSTR()função:
REGEXP_INSTR(expression, patttern)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Observe que REGEXP_INSTR()a função possui mais parâmetros que abordaremos no tutorial REGEXP_INSTR .
O exemplo a seguir usa a REGEXP_INSTR()função para encontrar a posição do primeiro dígito na string 'MySQL 8.0 Release':
SELECT
REGEXP_INSTR('MySQL 8.0 Release', '\\d+') position;Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+----------+
| position |
+----------+
| 7 |
+----------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Ele retorna o índice 7, que é a posição do número 8 na string de entrada.
3) Extraindo as correspondências
Para retornar a substring que corresponde a uma expressão regular, você usa a REGEXP_SUBSTR()função:
REGEXP_SUBSTR(expression, patttern)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Por exemplo, o seguinte retorna o primeiro número da string 'MySQL 8.0 Release':
SELECT
REGEXP_SUBSTR('MySQL 8.0 Release', '\\d+') version;Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+---------+
| version |
+---------+
| 8 |
+---------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )4) Substituindo os fósforos
Para substituir a correspondência por um novo padrão, você usa a REGEXP_REPLACE()função:
REGEXP_REPLACE(
expression,
pattern,
replacement
)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Por exemplo, o seguinte usa a REGEXP_REPLACE()função para substituir a correspondência pelo número 9:
SELECT
REGEXP_REPLACE('MySQL 8 Release', '\\d+', 9);Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )Saída:
+----------------------------------------------+
| REGEXP_REPLACE('MySQL 8 Release', '\\d+', 9) |
+----------------------------------------------+
| MySQL 9 Release |
+----------------------------------------------+
1 row in set (0.00 sec)Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
