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

Lista de funções regex¶

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 (ou seja, o metacaractere POSIX . corresponde exatamente a um caractere Unicode), independentemente do comprimento em bytes da representação binária correspondente desse 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 oferece suporte a um argumento opcional parameters. 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:

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

• Correspondência que diferencia maiúsculas e minúsculas.

• Modo de linha única.

• Nenhuma extração de subcorrespondência, exceto para REGEXP_REPLACE, que sempre usa extração de subcorrespondência.

• O caractere curinga POSIX . não corresponde a caracteres de nova linha \n.

Ao especificar vários parâmetros, insira a cadeia de caracteres 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 que não diferencia maiúsculas de minúsculas porque i ocorre por último na cadeia de caracteres.

O exemplo a seguir mostra como os resultados podem ser diferentes para correspondências com e sem diferenciação de maiúsculas e minúsculas. A função REGEXP_COUNT não retorna nenhuma correspondência para snow e SNOW para correspondência com distinção entre maiúsculas e minúsculas (parâmetro c, o padrão) e uma correspondência para correspondência sem distinção entre maiúsculas e minúsculas (parâmetro i):

SELECT REGEXP_COUNT('snow', 'SNOW', 1, 'c') AS case_sensitive_matching,
       REGEXP_COUNT('snow', 'SNOW', 1, 'i') AS case_insensitive_matching;

+-------------------------+---------------------------+
| CASE_SENSITIVE_MATCHING | CASE_INSENSITIVE_MATCHING |
|-------------------------+---------------------------|
|                       0 |                         1 |
+-------------------------+---------------------------+

Use a função REGEXP_SUBSTR com o parâmetro e para procurar a palavra Release, seguida por um ou mais caracteres não pertencentes à palavra, seguidos por um ou mais dígitos e, em seguida, retorne a substring que corresponde aos dígitos:

SELECT REGEXP_SUBSTR('Release 24', 'Release\\W+(\\d+)', 1, 1, 'e') AS release_number;

+----------------+
| RELEASE_NUMBER |
|----------------|
| 24             |
+----------------+

Para mais exemplos que usam parâmetros, veja REGEXP_INSTR, REGEXP_LIKE, REGEXP_SUBSTR, REGEXP_SUBSTR_ALL e [ NOT ] RLIKE.

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 período final, asterisco ou ponto de interrogação), é necessário escapar o metacaractere com uma barra invertida (por exemplo, \., \*, \? etc.).

Por exemplo, suponha que você precise encontrar um parêntese aberto (() em uma cadeia de caracteres. Uma maneira de especificar isso é usar uma barra invertida para escapar o 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 padrão a seguir corresponde a uma sequência de caracteres alfanuméricos que aparecem entre parênteses (por exemplo, (NY)):

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

+----------+
| LOCATION |
|----------|
| (NY)     |
+----------+

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 location;

+----------+
| LOCATION |
|----------|
| (NY)     |
+----------+

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 [ NOT ] REGEXP e [ NOT ] RLIKE, nos quais o padrão vazio corresponde ao sujeito vazio porque o padrão é implicitamente ancorado em ambas as extremidades (ou seja, '' torna-se automaticamente '^$').

Um grupo vazio (ou seja, a 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 estiver usando uma constante de cadeia de caracteres para especificar a expressão regular de uma função, é possível usar uma constante de cadeia de caracteres entre aspas para evitar escapar os 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, $$\?$$);

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;

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.

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, é necessário escapar a barra invertida na referência inversa. Consulte Exemplo de uso de referências inversas em uma constante de cadeias de caracteres entre aspas simples.

CREATE OR REPLACE TABLE wildcards (w VARCHAR, w2 VARCHAR);
INSERT INTO wildcards (w, w2) VALUES ('\\', '?');

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

+----+
| W2 |
|----|
| ?  |
+----+

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

+----+
| W2 |
|----|
| ?  |
+----+

SELECT w, w2, w || w2 AS escape_sequence, w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, w || w2);

+---+----+-----------------+----+
| W | W2 | ESCAPE_SEQUENCE | W2 |
|---+----+-----------------+----|
| \ | ?  | \?              | ?  |
+---+----+-----------------+----+

INSERT INTO wildcards (w, w2) VALUES (NULL, 'When I am cold, I am bold.');

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.     |
+----------------------------+------------------------------------------+