REGEXP_SUBSTR_ALL¶

Syntaxe¶

REGEXP_SUBSTR_ALL( <subject> , <pattern> [ , <position> [ , <occurrence> [ , <regex_parameters> [ , <group_num> ] ] ] ] )

Arguments¶

Obligatoire :

subject

La chaîne à rechercher pour les correspondances.

pattern

Modèle devant correspondre.

Pour des directives sur la spécification des modèles, voir Fonctions de chaîne (expressions régulières).

Facultatif :

position

Nombre de caractères depuis le début de la chaîne pour lesquels la fonction commence à rechercher des correspondances.

Par défaut : 1 (la recherche d’une correspondance commence au premier caractère à gauche)

occurrence

Spécifie la première occurrence du modèle à partir de laquelle il faut commencer à renvoyer les correspondances.

La fonction ignore les occurrence - 1 premières correspondances. Par exemple, s’il existe 5 correspondances et que vous spécifiez 3 pour l’argument occurrence, la fonction ignore les deux premières correspondances et renvoie les troisième, quatrième et cinquième correspondances.

Par défaut : 1

regex_parameters

Chaîne d’un ou plusieurs caractères spécifiant les paramètres utilisés pour la recherche de correspondances. Valeurs prises en charge :

Paramètre	Description
c	Correspondance sensible à la casse
i	Correspondance non sensible à la casse
m	Mode multiligne
e	Extraire les sous-correspondances.
s	Le caractère générique . du mode à une ligne POSIX correspond à \n

Par défaut : c

Pour plus de détails, voir Spécification des paramètres de l’expression régulière.

Note

Par défaut, REGEXP_SUBSTR_ALL renvoie la totalité de la partie correspondante du sujet. Toutefois, si le paramètre e est spécifié, REGEXP_SUBSTR_ALL ne renvoie que la partie du sujet qui correspond au premier groupe du motif. Si e est spécifié mais qu’un group_num n’est pas également spécifié, le group_num est défini par défaut sur 1 (le premier groupe). S’il n’y a pas de sous-expression dans le motif, REGEXP_SUBSTR_ALL se comporte comme si e n’était pas défini. Pour des exemples utilisant e, voir Exemples dans cette rubrique.

group_num

Spécifie le groupe à extraire. Les groupes sont spécifiés à l’aide de parenthèses dans l’expression régulière.

Si un group_num est spécifié, Snowflake autorise l’extraction même si l’option 'e' n’a pas été spécifiée. Le 'e' est impliqué.

Snowflake prend en charge jusqu’à 1 024 groupes.

Pour des exemples utilisant group_num, voir les exemples de cette rubrique.

Renvoie¶

La fonction renvoie une valeur de type ARRAY. Le tableau contient un élément pour chaque sous-chaîne correspondante.

Si aucune correspondance n’est trouvée, la fonction renvoie un tableau vide.

La fonction renvoie NULL dans les cas suivants :

• L’un des arguments est NULL.

• Vous spécifiez group_num et le modèle ne spécifie pas de regroupement avec ce numéro. Par exemple, si le motif ne spécifie qu’un seul groupe (par exemple, a(b)c) et que vous utilisez 2 comme group_num, la fonction renvoie NULL.

Notes sur l’utilisation¶

Pour plus d’informations sur l’utilisation d’expressions régulières, voir Fonctions de chaîne (expressions régulières).

Détails du classement¶

Arguments with collation specifications currently aren’t supported.

Exemples¶

Le modèle de l’exemple suivant correspond à un « a » minuscule suivi d’un chiffre. L’exemple renvoie un ARRAY qui contient toutes les correspondances :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]') AS matches;

+---------+
| MATCHES |
|---------|
| [       |
|   "a1", |
|   "a2", |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

L’exemple suivant commence à rechercher des correspondances à partir du deuxième caractère de la chaîne (2) :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 2) AS matches;

+---------+
| MATCHES |
|---------|
| [       |
|   "a2", |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

L’exemple suivant renvoie les correspondances à partir de la troisième occurrence du modèle de la chaîne (3) :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 1, 3) AS matches;

+---------+
| MATCHES |
|---------|
| [       |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

L’exemple suivant cherche une correspondance insensible à la casse (i) :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 1, 1, 'i') AS matches;

+---------+
| MATCHES |
|---------|
| [       |
|   "a1", |
|   "a2", |
|   "a3", |
|   "a4", |
|   "A5", |
|   "a6"  |
| ]       |
+---------+

L’exemple suivant cherche une correspondance insensible à la casse et renvoie la partie de la chaîne qui correspond au premier groupe (ie) :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', '(a)([[:digit:]])', 1, 1, 'ie') AS matches;

+---------+
| MATCHES |
|---------|
| [       |
|   "a",  |
|   "a",  |
|   "a",  |
|   "a",  |
|   "A",  |
|   "a"   |
| ]       |
+---------+

L’exemple suivant montre que la fonction renvoie un tableau vide si aucune correspondance n’est trouvée :

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'b') AS matches;

+---------+
| MATCHES |
|---------|
| []      |
+---------+

Cet exemple montre comment extraire le deuxième mot d’une chaîne des première, deuxième et troisième correspondances d’un motif de deux mots dans lequel le premier mot est A.

Créer une table en premier et insérer des données :

CREATE OR REPLACE TABLE test_regexp_substr_all (string1 VARCHAR);;
INSERT INTO test_regexp_substr_all (string1) VALUES ('A MAN A PLAN A CANAL');

Exécutez la requête :

SELECT REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 2, 'e', 1) AS result2,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 3, 'e', 1) AS result3
  FROM test_regexp_substr_all;

+-----------+-----------+-----------+
| RESULT1   | RESULT2   | RESULT3   |
|-----------+-----------+-----------|
| [         | [         | [         |
|   "MAN",  |   "PLAN", |   "CANAL" |
|   "PLAN", |   "CANAL" | ]         |
|   "CANAL" | ]         |           |
| ]         |           |           |
+-----------+-----------+-----------+

Cet exemple montre comment récupérer les premier, deuxième et troisième groupes au sein de chaque occurrence du motif d’une chaîne. Dans ce cas, les valeurs renvoyées sont chaque lettre individuelle de chaque mot correspondant dans chaque groupe.

SELECT REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 2) AS result2,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 3) AS result3
  FROM test_regexp_substr_all;

+---------+---------+---------+
| RESULT1 | RESULT2 | RESULT3 |
|---------+---------+---------|
| [       | [       | [       |
|   "M",  |   "A",  |   "N",  |
|   "P",  |   "L",  |   "A",  |
|   "C"   |   "A"   |   "N"   |
| ]       | ]       | ]       |
+---------+---------+---------+