Fonctions de chaîne (expressions régulières)

Ces fonctions de chaîne effectuent des opérations qui correspondent à une expression régulière (souvent appelée « regex »).

Dans ce chapitre :

Liste des fonctions Regex

Fonction

Notes

REGEXP

Alias pour RLIKE.

REGEXP_COUNT

REGEXP_EXTRACT_ALL

Alias pour REGEXP_SUBSTR_ALL.

REGEXP_INSTR

REGEXP_LIKE

Alias pour RLIKE.

REGEXP_REPLACE

REGEXP_SUBSTR

REGEXP_SUBSTR_ALL

RLIKE

Notes générales sur l’utilisation

Dans ces chapitres, « sujet » désigne la chaîne sur laquelle opérer et « motif » fait référence à l’expression régulière :

  • Le sujet est généralement une colonne variable, alors que le motif est généralement une constante, mais cela n’est pas nécessaire ; chaque argument d’une fonction d’expression régulière peut être une constante ou une variable.

  • Les motifs prennent en charge la syntaxe POSIX ERE (Extended Regular Expression) complète. Pour plus de détails, consultez la section POSIX de base et étendue (sur Wikipedia).

  • Les motifs prennent également en charge les séquences backlash Perl suivantes :

    • \d : chiffre décimal (0-9).

    • \D : pas un chiffre décimal.

    • \s : caractère d’espacement.

    • \S : pas un caractère d’espacement.

    • \w : caractère « mot » (az, AZ, trait de soulignement (« _ ») ou chiffre décimal).

    • \W : pas un caractère de mot.

    • \b : limite de mot.

    • \B : pas une limite de mot.

    Pour plus de détails, voir la section Classes de caractères (Wikipédia) ou la section Séquences backlash (documentation Perl).

    Note

    Dans les constantes de chaînes entre guillemets simples, vous devez échapper le caractère barre oblique inverse dans la séquence avec barre oblique inverse. Par exemple, pour spécifier \d, utilisez \\d. Pour plus de détails, voir Spécification d’expressions régulières dans des constantes de chaîne entre guillemets simples (dans ce chapitre).

    Il n’est pas nécessaire d’échapper les barres obliques inverses si vous délimitez la chaîne avec des paires de signes de dollar ($$) (plutôt qu’avec des guillemets simples).

  • Par défaut, le caractère générique POSIX . (dans le modèle) n’inclut pas de caractères de nouvelle ligne \n (dans le sujet) comme correspondances.

    Pour faire correspondre également les caractères de nouvelle ligne, remplacez . par (.|\n) dans l’argument motif ou utilisez le paramètre s dans l’argument paramètres (décrit ci-dessous).

  • Toutes les fonctions d’expression régulière prennent en charge le format Unicode. Un seul caractère Unicode compte toujours pour un caractère (c’est-à-dire que le métacaractère POSIX . correspond exactement à un seul caractère Unicode), quelle que soit la longueur des octets de la représentation binaire correspondant à ce caractère. De plus, pour les fonctions qui acceptent ou renvoient des décalages de sujet, un seul caractère Unicode compte pour 1.

Spécification des paramètres de l’expression régulière

La plupart des fonctions d’expression régulière acceptent un argument paramètres facultatif comme toute dernière entrée. L’argument paramètres est une chaîne VARCHAR qui spécialise le comportement de correspondance de la fonction d’expression régulière. Les paramètres suivants sont pris en charge :

Paramètre

Effet

c

Permet une correspondance sensible à la casse.

i

Permet une correspondance insensible à la casse.

m

Active le mode multiligne (c’est-à-dire que les métacaractères ^ et $ marquent le début et la fin de toute ligne du sujet). Par défaut, le mode multiligne est désactivé (^ et $ marquent le début et la fin du sujet entier).

e

Extrait des sous-correspondances ; s’applique uniquement à REGEXP_INSTR, REGEXP_SUBSTR, REGEXP_SUBSTR_ALL, et aux alias de ces fonctions.

s

Permet de faire correspondre le caractère générique POSIX . avec \n. Par défaut, la correspondance des caractères génériques est désactivée.

La chaîne par défaut est simplement c, qui spécifie :

  • Reconnaissance sensible à la casse.

  • Mode à une ligne.

  • Pas d’extraction de sous-correspondance, sauf pour REGEXP_REPLACE, qui utilise toujours l’extraction de sous-correspondances.

  • Le caractère générique POSIX . ne correspond pas aux caractères de nouvelle ligne \n.

Lorsque vous spécifiez plusieurs paramètres, la chaîne est saisie sans espaces ni délimiteurs. Par exemple, ims spécifie une correspondance insensible à la casse en mode multiligne avec POSIX comme correspondance de caractère générique.

Si c et i sont inclus dans la chaîne paramètres , celle qui apparaît en dernier dans la chaîne détermine si la fonction effectue une correspondance sensible à la casse ou non. Par exemple, ci spécifie une correspondance non sensible à la casse, car « i » apparaît en dernier dans la chaîne.

Correspondance des caractères qui sont des métacaractères

Dans les expressions régulières, certains caractères sont traités comme des métacaractères qui ont une signification spécifique. Par exemple :

Pour faire correspondre le caractère réel (par exemple, un point, un astérisque ou un point d’interrogation réel), vous devez échapper le métacaractère avec une barre oblique inverse (par exemple, \., \*, \?, etc.).

Note

Si vous utilisez l’expression régulière dans une constante de chaîne entre guillemets simples, vous devez échapper la barre oblique inverse avec une deuxième barre oblique inverse (par exemple, \\., \\*, \\?, etc.). Pour plus de détails, voir Spécification d’expressions régulières dans des constantes de chaîne entre guillemets simples

Par exemple, supposons que vous deviez chercher une parenthèse ouverte (() dans une chaîne. Une façon de le spécifier est d’utiliser une barre oblique inverse pour échapper le caractère dans le modèle (par exemple, \().

Si vous spécifiez le modèle sous la forme d’une constante de chaîne entre guillemets simples, vous devez également échapper la barre oblique inverse avec une deuxième barre oblique inverse.

Le modèle suivant correspond à une séquence de caractères alphanumériques qui apparaissent dedans entre parenthèses (par exemple (NY)) :

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

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

Pour d’autres exemples, voir Exemple d’utilisation de métacaractères dans une constante de chaîne entre guillemets simples.

Notez que vous n’avez pas besoin d’échapper la barre oblique inverse si vous utilisez une constante de chaîne comprise entre des dollars :

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

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

Utilisation de références arrière

Snowflake ne prend pas en charge les références arrière dans des motifs d’expressions régulières (connus comme « carrés » dans la théorie du langage formel) ; cependant, les références arrière sont prises en charge dans la chaîne de remplacement de la fonction REGEXP_REPLACE .

Spécification d’un modèle vide

Dans la plupart des fonctions regexp, un modèle vide (c’est-à-dire '') ne correspond à rien, pas même à un sujet vide.

Les exceptions sont REGEXP_LIKE et ses alias REGEXP et RLIKE , dans lesquelles le motif vide correspond au sujet vide parce que le motif est implicitement ancré aux deux extrémités, c’est-à-dire que '' devient automatiquement '^$' .

Un groupe vide (sous-expression ()) correspond à l’espace entre les caractères, y compris le début et la fin du sujet.

Spécification d’expressions régulières dans des constantes de chaînes comprises entre des dollars

Si vous utilisez une constante de chaîne pour spécifier l’expression régulière d’une fonction, vous pouvez utiliser une constante de chaîne comprise entre des dollars pour éviter d’avoir à échapper les barres obliques inverses dans l’expression régulière. (Si vous utilisez des constantes de chaîne entre guillemets simples, vous devez échapper les barres obliques inverses).

Le contenu d’une constante de chaîne comprise entre des dollars est toujours interprété littéralement.

Par exemple, pour échapper un métacaractère, il suffit d’utiliser une seule barre oblique inverse :

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

Lorsque vous utilisez une référence arrière, vous ne devez utiliser qu’une seule barre oblique inverse :

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

Spécification d’expressions régulières dans des constantes de chaîne entre guillemets simples

Si vous utilisez une expression régulière dans une constante de chaîne entre guillemets simples, vous devez échapper toute barre oblique inverse dans les séquences avec barres obliques inverses à l’aide d’une deuxième barre oblique inverse.

Note

Pour éviter l’échappement des barres obliques inverses dans une expression régulière, vous pouvez utiliser une constante de chaîne comprise entre des dollars, plutôt qu’une constante entre guillemets simples.

Par exemple :

Exemple d’utilisation de métacaractères dans une constante de chaîne entre guillemets simples

Cet exemple utilise la barre oblique inverse comme partie d’une séquence d’échappement dans une expression régulière qui recherche un point d’interrogation (?).

Créez une table et insérez une ligne qui contient une simple barre oblique inversée dans une colonne et un point d’interrogation dans une autre colonne :

create table wildcards (w varchar, w2 varchar);
insert into wildcards (w, w2) values ('\\', '?');

Le SELECT suivant recherche le littéral de point d’interrogation. La recherche utilise une expression régulière, et le point d’interrogation est un méta-caractère dans les expressions régulières. La recherche doit donc échapper le point d’interrogation pour le traiter comme un littéral. Étant donné que la barre oblique inversée apparaît dans une chaîne de caractères littérale, la barre oblique inversée elle-même doit également être échappée, de sorte que la requête se présente comme suit :

select w2
    from wildcards
    where regexp_like(w2, '\\?');
+----+
| W2 |
|----|
| ?  |
+----+

La requête suivante permet de voir plus facilement que l’expression régulière est composée de deux caractères (le caractère d’échappement de barre oblique inverse et le point d’interrogation) :

select w2
    from wildcards
    where regexp_like(w2, '\\' || '?');
+----+
| W2 |
|----|
| ?  |
+----+

Dans l’exemple précédent, la barre oblique inversée supplémentaire n’était nécessaire que parce que le caractère d’échappement faisait partie d’une chaîne littérale, et non pour l’expression régulière elle-même. L’instruction SELECT suivante n’a pas besoin d’analyser un littéral de chaîne de caractères comme partie de la chaîne de commande SQL, et n’a donc pas besoin du caractère d’échappement supplémentaire dont le littéral de chaîne de caractères avait besoin :

select w, w2, w || w2 as escape_sequence, w2
    from wildcards
    where regexp_like(w2, w || w2);
+---+----+-----------------+----+
| W | W2 | ESCAPE_SEQUENCE | W2 |
|---+----+-----------------+----|
| \ | ?  | \?              | ?  |
+---+----+-----------------+----+

Exemple d’utilisation de références arrière dans une constante de chaîne entre guillemets simples

Si vous utilisez une référence arrière (par exemple \1) dans un littéral de chaîne, vous devez échapper la barre oblique inverse qui fait partie de cette référence arrière. Par exemple, pour spécifier la référence arrière \1 dans un littéral de chaîne de remplacement de REGEXP_REPLACE, utilisez \\1.

L’exemple suivant utilise la table créée précédemment. Le SELECT utilise une référence arrière pour remplacer chaque occurrence de l’expression régulière .old par une copie de la chaîne correspondante précédée du mot « very » (très) :

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