Categorias:: Funções de cadeia de caracteres (expressões regulares)

REGEXP_LIKE¶

Executa uma comparação para determinar se uma cadeia de caracteres corresponde a um padrão especificado. Ambas as entradas devem ser expressões de texto.

REGEXP_LIKE é semelhante à função LIKE, mas com expressões regulares estendidas POSIX em vez da sintaxe do padrão SQL LIKE. REGEXP_LIKE aceita condições de correspondência mais complexas do que LIKE.

Dica

Você pode usar o serviço de otimização de pesquisa para melhorar o desempenho de consultas que chamam essa função. Para obter mais detalhes, consulte Serviço de otimização de pesquisa.

Aliases:: RLIKE (1ª sintaxe)

Sintaxe¶

REGEXP_LIKE( <subject> , <pattern> [ , <parameters> ] )

Argumentos¶

Obrigatório:

subject

A cadeia de caracteres a ser procurada por correspondências.

pattern

Padrão a atender.

Para diretrizes sobre como especificar padrões, consulte Funções de cadeia de caracteres (expressões regulares).

Opcional:

parameters

Cadeia de caracteres de um ou mais caracteres que especifica os parâmetros usados para a busca de correspondências. Valores com suporte:


Parâmetro	Descrição
`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 multilinha
`e`	Extração de subcorrespondências
`s`	O caractere curinga POSIX do modo de linha única `.` corresponde a `\n`

Padrão: c

Para obter mais informações, consulte Especificação dos parâmetros para a expressão regular.

Retornos¶

Retorna um valor BOOLEAN ou NULL:

Retorna TRUE se há uma correspondência.
Retorna FALSE se não há uma correspondência.
Retorna NULL se algum argumento for NULL.

Notas de uso¶

A função ancora implicitamente um padrão em ambas as extremidades (por exemplo, '' automaticamente se torna '^$', e 'ABC' automaticamente se torna '^ABC$'). Por exemplo, para corresponder a qualquer cadeia de caracteres que comece com ABC, o padrão é 'ABC.*'.
O caractere de barra invertida (\) é o caractere de escape. Para obter mais informações, consulte Especificação de expressões regulares em constantes de cadeias de caracteres entre aspas simples.
Para obter mais notas de uso, consulte o Notas de uso geral para funções de expressão regular.

Detalhes do agrupamento¶

Arguments with collation specifications currently aren’t supported.

Exemplos¶

Os exemplos a seguir usam a função REGEXP_LIKE:

Executar consultas básicas de expressões regulares em cadeias de caracteres
Executar consultas de expressões regulares em cadeias de caracteres com caracteres especiais

Para ver exemplos adicionais de expressões regulares, consulte REGEXP.

Executar consultas básicas de expressões regulares em cadeias de caracteres¶

Criar uma tabela com nomes de cidades:

CREATE OR REPLACE TABLE cities(city VARCHAR(20));

INSERT INTO cities VALUES
  ('Sacramento'),
  ('San Francisco'),
  ('San Luis Obispo'),
  ('San Jose'),
  ('Santa Barbara'),
  ('Palo Alto'),
  (NULL);

Você pode usar .* como curinga para corresponder ao máximo de caracteres possível. O exemplo a seguir corresponde ao padrão Fran em qualquer lugar do valor da cadeia de caracteres:

SELECT * FROM cities WHERE REGEXP_LIKE(city, '.*Fran.*');

+---------------+
| CITY          |
|---------------|
| San Francisco |
+---------------+

O exemplo a seguir usa o parâmetro i para correspondência sem distinção entre maiúsculas e minúsculas:

SELECT * FROM cities WHERE REGEXP_LIKE(city, '.*fran.*', 'i');

+---------------+
| CITY          |
|---------------|
| San Francisco |
+---------------+

Para encontrar um padrão que corresponda ao início de um valor de cadeia de caracteres, execute uma consulta que use um curinga:

SELECT * FROM cities WHERE REGEXP_LIKE(city, 'san.*', 'i');

+-----------------+
| CITY            |
|-----------------|
| San Francisco   |
| San Luis Obispo |
| San Jose        |
| Santa Barbara   |
+-----------------+

Para executar uma consulta com diferenciação entre maiúsculas e minúsculas com um curinga, omita o parâmetro i:

SELECT * FROM cities WHERE REGEXP_LIKE(city, 'san.*');

+------+
| CITY |
|------|
+------+

Você pode usar o metacaractere \w+ para corresponder a uma palavra e o metacaractere \s para corresponder a um caractere de espaço em branco, como um espaço ou uma tabulação. A consulta a seguir procura os valores que incluem uma palavra, seguida por um caractere de espaço em branco, seguido por uma palavra:

SELECT * FROM cities WHERE REGEXP_LIKE(city, '\\w+\\s\\w+');

+---------------+
| CITY          |
|---------------|
| San Francisco |
| San Jose      |
| Santa Barbara |
| Palo Alto     |
+---------------+

A saída da consulta não inclui San Luis Obispo porque esse valor tem três palavras com um espaço entre a primeira e a segunda palavras, em vez de apenas duas palavras com um espaço entre elas.

Em uma expressão regular, geralmente é possível usar um metacaractere maiúsculo para anular o significado de um metacaractere minúsculo. Por exemplo, execute uma consulta que busque valores que não incluam um espaço em branco entre duas palavras usando o metacaractere \S:

SELECT * FROM cities WHERE REGEXP_LIKE(city, '\\w+\\S\\w+');

+------------+
| CITY       |
|------------|
| Sacramento |
+------------+

Executar consultas de expressões regulares em cadeias de caracteres com caracteres especiais¶

Os exemplos desta seção buscam valores com caracteres especiais, que são caracteres diferentes de a-z, A-Z, sublinhado («_») ou dígito decimal.

Para buscar um metacaractere, aplique o escape do metacaractere. Para obter mais informações, consulte Especificação de expressões regulares em constantes de cadeias de caracteres entre aspas simples.

Crie uma tabela e insira alguns valores com caracteres especiais:

CREATE OR REPLACE TABLE regex_special_characters(v VARCHAR(20));

INSERT INTO regex_special_characters VALUES
  ('Snow'),
  ('Sn.ow'),
  ('Sn@ow'),
  ('Sn$ow'),
  ('Sn\\ow');

O primeiro valor inserido não contém caracteres especiais.

Para exibir os dados, consulte a tabela:

SELECT * FROM regex_special_characters;

+-------+
| V     |
|-------|
| Snow  |
| Sn.ow |
| Sn@ow |
| Sn$ow |
| Sn\ow |
+-------+

Você pode buscar qualquer caractere especial usando a sequência de barras invertidas \W do Perl, que busca caracteres que não sejam de «palavras». Por exemplo, a consulta a seguir busca os valores na tabela que têm caracteres especiais:

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*\\W.*');

+-------+
| V     |
|-------|
| Sn.ow |
| Sn@ow |
| Sn$ow |
| Sn\ow |
+-------+

Para procurar por metacaracteres em uma constante de cadeia de caracteres entre aspas simples , aplique o escape do metacaractere com duas barras invertidas. Por exemplo, a consulta a seguir busca os valores que contêm o metacaractere $:

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*\\$.*');

+-------+
| V     |
|-------|
| Sn$ow |
+-------+

Se você procurar por uma barra invertida, será necessário um caractere de escape de barra invertida adicional. Por exemplo, a consulta a seguir busca os valores que contêm o metacaractere \ ou .:

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*(\\.|\\\\).*');

+-------+
| V     |
|-------|
| Sn.ow |
| Sn\ow |
+-------+