Funções de cadeia de caracteres (expressões regulares)¶

Essas funções de cadeia de caracteres realizam operações que correspondem a uma expressão regular (muitas vezes referida como “regex”).

Neste tópico:

Lista de funções regex¶

Função	Notas
REGEXP	Alias para RLIKE.
REGEXP_COUNT
REGEXP_EXTRACT_ALL	Alias para REGEXP_SUBSTR_ALL.
REGEXP_INSTR
REGEXP_LIKE	Alias para RLIKE.
REGEXP_REPLACE
REGEXP_SUBSTR
REGEXP_SUBSTR_ALL
RLIKE

Notas de uso geral¶

Nestas notas, “sujeito” refere-se à cadeia de caracteres a ser operada e “padrão” refere-se à expressão regular:

O sujeito é geralmente uma coluna variável, enquanto o padrão é geralmente uma constante, mas isso não é necessário; cada argumento para uma função de expressão regular pode ser uma constante ou uma variável.
Os padrões oferecem suporte à sintaxe POSIX ERE (Extended Regular Expression, ou expressão regular estendida) completa. Para obter mais detalhes, consulte a seção POSIX básica e estendida (na Wikipédia).
Os padrões também oferecem suporte às seguintes sequências de barra invertida do Perl:
- \d: dígito decimal (0-9).
- \D: não dígito decimal.
- \s: caractere de espaço em branco.
- \S: não caractere de espaço em branco.
- \w: caractere “palavra” (a-z, A-Z, sublinhado (“_”) ou dígito decimal).
- \W: não caractere “palavra”.
- \b: limite de palavras.
- \B: não limite de palavras.
Para obter mais detalhes, consulte a seção Classes de caracteres (na Wikipédia) ou a seção Sequências de barra invertida (na documentação do Perl).

Nota

Em constantes de cadeias de caracteres entre aspas simples, você deve obter o escape do caractere de barra invertida na sequência de barra invertida. Por exemplo, para especificar \d, use \\d. Para obter mais detalhes, consulte Especificação de expressões regulares em constantes de cadeias de caracteres entre aspas simples (neste tópico).

Você não precisa obter o escape das barras invertidas se estiver delimitando a cadeia de caracteres com pares de cifrões ($$) (em vez de aspas simples).
Por padrão, o caractere curinga POSIX . (no modelo) não inclui caracteres de nova linha \n (no sujeito) como correspondências.

Para também corresponder a caracteres de nova linha, substitua . por (.|\n) no argumento pattern ou use o parâmetro s no argumento parameters (descrito abaixo).
Todas as funções de expressão regular aceitam Unicode. Um único caractere Unicode sempre conta como um caractere (isto é, o metacaractere POSIX . corresponde exatamente a um caractere Unicode), independentemente do comprimento em bytes da representação binária correspondente daquele caractere. Além disso, para funções que tomam ou retornam deslocamentos de sujeito, um único caractere Unicode conta como 1.

Especificação dos parâmetros para a expressão regular¶

A maioria das funções de expressão regular aceita um argumento parameters opcional como a última entrada. O argumento parameters é uma cadeia de caracteres VARCHAR que especifica o comportamento de correspondência da função de expressão regular. Os seguintes parâmetros são aceitos:

Parâmetro	Efeito
`c`	Habilita uma correspondência que diferencia maiúsculas e minúsculas.
`i`	Habilita uma correspondência que não diferencia maiúsculas e minúsculas.
`m`	Habilita o modo multilinhas (ou seja, metacaracteres `^` e `$` marcam o início e o fim de qualquer linha do sujeito). Por padrão, o modo multilinhas está desativado (isto é, `^` e `$` marcam o início e o fim de todo o sujeito).
`e`	Extrai subcorrespondências; aplica-se somente a REGEXP_INSTR, REGEXP_SUBSTR, REGEXP_SUBSTR_ALL e os aliases para estas funções.
`s`	Permite que o caractere curinga POSIX `.` corresponda a `\n`. Por padrão, a correspondência de caracteres curinga está desativada.

A cadeia de caracteres padrão é simplesmente c, que especifica:

Correspondência que diferencia maiúsculas e minúsculas.
Modo de linha única.
Nenhuma extração de subcorrespondências, exceto REGEXP_REPLACE, que sempre usa a extração de subcorrespondências.
O caractere curinga POSIX . não corresponde a caracteres de nova linha \n.

Ao especificar múltiplos parâmetros, a cadeia de caracteres é inserida sem espaços ou delimitadores. Por exemplo, ims especifica a correspondência sem distinção de maiúsculas e minúsculas no modo multilinhas com correspondência do curinga POSIX.

Se c e i estiverem incluídos na cadeia de caracteres parameters, aquele que ocorre por último na cadeia dita se a função realiza uma correspondência com ou sem distinção de maiúsculas e minúsculas. Por exemplo, ci especifica a correspondência sem distinção de maiúsculas e minúsculas porque “i” ocorre por último na cadeia de caracteres.

Caracteres correspondentes que são metacaracteres¶

Em expressões regulares, alguns caracteres são tratados como metacaracteres que têm um significado específico. Por exemplo:

. é um metacaractere que corresponde a qualquer caractere único.
* é um quantificador que corresponde a zero ou mais instâncias do elemento anterior. Por exemplo, BA* corresponde a B, BA, BAA etc.
? é um quantificador que corresponde a zero ou a uma instância do elemento anterior.

Para corresponder ao caractere real (por exemplo, um ponto final, asterisco ou ponto de interrogação), você deve obter o escape do metacaractere com uma barra invertida (por exemplo, \., \*, \? etc.).

Nota

Se você estiver usando a expressão regular em uma constante de cadeia de caracteres entre aspas simples, você deve obter o escape da barra invertida com uma segunda barra invertida (por exemplo, \\., \\*, \\? etc.). Para obter mais detalhes, consulte Especificação de expressões regulares em constantes de cadeias de caracteres entre aspas simples.

Por exemplo, suponha que você precise encontrar um parêntese aberto (() em uma cadeia de caracteres. Para especificar isso, você pode usar uma barra invertida para o escape do caractere no padrão (por exemplo, \().

Se você estiver especificando o padrão como uma constante de cadeia de caracteres entre aspas simples, você deve também obter o escape dessa barra invertida com uma segunda barra invertida.

O seguinte padrão corresponde a uma sequência de caracteres alfanuméricos que aparecem dentro de parênteses (por exemplo, (NY)):

SELECT REGEXP_SUBSTR('Customers - (NY)','\\([[:alnum:]]+\\)') as customers;

  +-----------+
  | CUSTOMERS |
  |-----------|
  | (NY)      |
  +-----------+

Copy

Para exemplos adicionais, consulte Exemplo de uso de metacaracteres em uma constante de cadeias de caracteres entre aspas simples.

Observe que você não precisa obter o escape do caractere de barra invertida se estiver usando uma constante de cadeia de caracteres entre cifrões:

SELECT REGEXP_SUBSTR('Customers - (NY)',$$\([[:alnum:]]+\)$$) as customers;

  +-----------+
  | CUSTOMERS |
  |-----------|
  | (NY)      |
  +-----------+

Copy

Utilização de referências inversas¶

O Snowflake não oferece suporte a referências inversas em padrões de expressão regular (conhecidos como “quadrados” na teoria da linguagem formal); no entanto, as referências inversas são aceitas na cadeia de caracteres de substituição da função REGEXP_REPLACE.

Especificação de um padrão vazio¶

Na maioria das funções regexp, um padrão vazio (ou seja, '') não corresponde a nada, nem mesmo a um sujeito vazio.

As exceções são REGEXP_LIKE e seus aliases REGEXP e RLIKE, nos quais o padrão vazio corresponde ao sujeito vazio porque o padrão está implicitamente ancorado em ambas as extremidades (ou seja, '' torna-se automaticamente '^$').

Um grupo vazio (ou seja, subexpressão ()), corresponde ao espaço entre os caracteres, incluindo o início e o fim do sujeito.

Especificação de expressões regulares em constantes de cadeias de caracteres entre cifrões¶

Se você estiver usando uma constante de cadeia de caracteres para especificar a expressão regular para uma função, você pode usar uma constante de cadeia de caracteres entre cifrões para evitar obter o escape dos caracteres de barra invertida na expressão regular. (Se você estiver usando constantes de cadeia de caracteres entre aspas simples, você precisa obter o escape das barras invertidas).

O conteúdo de uma constante de cadeia de caracteres entre cifrões é sempre interpretado literalmente.

Por exemplo, ao obter escape de um metacaractere, você só precisa usar uma única barra invertida:

SELECT w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, $$\?$$);

Copy

Ao utilizar uma referência inversa, você só precisa usar uma única barra invertida:

SELECT w2, REGEXP_REPLACE(w2, '(.old)', $$very \1$$)
  FROM wildcards
  ORDER BY w2;

Copy

Especificação de expressões regulares em constantes de cadeias de caracteres entre aspas simples¶

Se você estiver usando a expressão regular em uma constante de cadeia de caracteres entre aspas simples, você deve obter o escape das barras invertidas em sequências de barra invertida com uma segunda barra invertida.

Nota

Para evitar o escape de barras invertidas em uma expressão regular, você pode usar uma constante de cadeia de caracteres entre cifrões, em vez de uma constante de cadeia de caracteres entre aspas simples.

Por exemplo:

Se você quiser obter o escape de um metacaractere com uma barra invertida, você deve obter o escape da barra invertida com uma segunda barra invertida. Consulte Exemplo de uso de metacaracteres em uma constante de cadeias de caracteres entre aspas simples.
Se você estiver usando uma sequência de barra invertida, você deve obter o escape da barra invertida na sequência.
Se você estiver usando uma referência inversa, você deve obter o escape da barra invertida na referência inversa. Consulte Exemplo de uso de referências inversas em uma constante de cadeias de caracteres entre aspas simples.

Exemplo de uso de metacaracteres em uma constante de cadeias de caracteres entre aspas simples¶

Este exemplo usa a barra invertida como parte de uma sequência de escape em uma expressão regular que busca um ponto de interrogação (?).

Crie uma tabela e insira uma linha que contenha uma única barra invertida em uma coluna e um ponto de interrogação em outra coluna:
create table wildcards (w varchar, w2 varchar);
insert into wildcards (w, w2) values ('\\', '?');
Copy
O SELECT seguinte procura o ponto de interrogação literal. A busca usa uma expressão regular, e o ponto de interrogação é um metacaractere em expressões regulares, portanto a busca deve obter o escape do ponto de interrogação para tratá-lo como um literal. Como a barra invertida aparece em um literal de cadeia de caracteres, a barra invertida em si também deve ter escape, de modo que a consulta fique semelhante a:
select w2
    from wildcards
    where regexp_like(w2, '\\?');
+----+
| W2 |
|----|
| ?  |
+----+
Copy
A consulta a seguir facilita observar que a expressão regular é composta de dois caracteres (o caractere de escape de barra invertida e o ponto de interrogação):
select w2
    from wildcards
    where regexp_like(w2, '\\' || '?');
+----+
| W2 |
|----|
| ?  |
+----+
Copy
No exemplo anterior, a barra invertida extra era necessária apenas porque o caractere de escape era parte de um literal de cadeia de caracteres, e não necessária para a expressão regular em si. A seguinte instrução SELECT não precisa analisar um literal de cadeia de caracteres como parte da cadeia de comando SQL, e portanto não precisa do caractere de escape extra de que o literal de cadeia de caracteres precisava:
select w, w2, w || w2 as escape_sequence, w2
    from wildcards
    where regexp_like(w2, w || w2);
+---+----+-----------------+----+
| W | W2 | ESCAPE_SEQUENCE | W2 |
|---+----+-----------------+----|
| \ | ?  | \?              | ?  |
+---+----+-----------------+----+
Copy

Exemplo de uso de referências inversas em uma constante de cadeias de caracteres entre aspas simples¶

Se você usar uma referência inversa (por exemplo, \1) em um literal de cadeia de caracteres, você deve obter o escape da barra invertida que faz parte dessa referência inversa. Por exemplo, para especificar a referência inversa \1 em um literal de cadeia de caracteres substituto de REGEXP_REPLACE, use \\1.

O exemplo a seguir utiliza a tabela criada anteriormente. SELECT usa uma referência inversa para substituir cada ocorrência da expressão regular .old por uma cópia da cadeia de caracteres correspondente precedida da palavra “very” (muito):

insert into wildcards (w, w2) values (NULL, 'When I am cold, I am bold.');

Copy

select w2, regexp_replace(w2, '(.old)', 'very \\1')
    from wildcards
    order by w2;
+----------------------------+------------------------------------------+
| W2                         | REGEXP_REPLACE(W2, '(.OLD)', 'VERY \\1') |
|----------------------------+------------------------------------------|
| ?                          | ?                                        |
| When I am cold, I am bold. | When I am very cold, I am very bold.     |
+----------------------------+------------------------------------------+

Copy