Catégories :

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

REGEXP_COUNT

Renvoie le nombre de fois qu’un motif se produit dans une chaîne.

Syntaxe

REGEXP_COUNT( <subject> ,
              <pattern>
                [ , <position>
                  [ , <parameters> ]
                ]
)
Copy

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. La valeur doit être un entier positif.

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

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 d’informations, voir Spécification des paramètres de l’expression régulière.

Renvoie

Renvoie une valeur de type NUMBER. Renvoie NULL si l’un des arguments est NULL.

Notes sur l’utilisation

Reportez-vous aux Notes générales sur l’utilisation pour les fonctions d’expression régulière.

Détails du classement

Arguments with collation specifications currently aren’t supported.

Exemples

L’exemple suivant compte les occurrences du mot was. Vous pouvez utiliser le métacaractère \b pour indiquer une limite de mot. Dans l’exemple suivant, la correspondance commence au premier caractère de la chaîne w et se terminent au dernier caractère de la chaîne s, et ne correspond donc pas aux mots qui contiennent la chaîne (tels que washing) :

SELECT REGEXP_COUNT('It was the best of times, it was the worst of times',
                    '\\bwas\\b',
                    1) AS result;
Copy
+--------+
| RESULT |
|--------|
|      2 |
+--------+

L’exemple suivant utilise le paramètre i pour une correspondance insensible à la casse du caractère e :

SELECT REGEXP_COUNT('Excelence', 'e', 1, 'i') AS e_in_excelence;
Copy
+----------------+
| E_IN_EXCELENCE |
|----------------|
|              4 |
+----------------+

L’exemple suivant illustre des occurrences qui se chevauchent : Créer une table et insérer des données :

CREATE OR REPLACE TABLE overlap (id NUMBER, a STRING);
INSERT INTO overlap VALUES (1,',abc,def,ghi,jkl,');
INSERT INTO overlap VALUES (2,',abc,,def,,ghi,,jkl,');

SELECT * FROM overlap;
Copy
+----+----------------------+
| ID | A                    |
|----+----------------------|
|  1 | ,abc,def,ghi,jkl,    |
|  2 | ,abc,,def,,ghi,,jkl, |
+----+----------------------+

Exécutez une requête qui utilise REGEXP_COUNT pour compter le nombre de fois que le motif suivant est trouvé dans chaque ligne : un signe de ponctuation suivi de chiffres et de lettres, suivi d’un signe de ponctuation.

SELECT id,
       REGEXP_COUNT(a,
                    '[[:punct:]][[:alnum:]]+[[:punct:]]',
                    1,
                    'i') AS result
  FROM overlap;
Copy
+----+--------+
| ID | RESULT |
|----+--------|
|  1 |      2 |
|  2 |      4 |
+----+--------+

Les autres exemples utilisent les données de la table suivante :

CREATE OR REPLACE TABLE regexp_count_demo (dt DATE, messages VARCHAR);

INSERT INTO regexp_count_demo (dt, messages) VALUES
  ('10-AUG-2025','ER-6842,LG-230,LG-150,ER-3379,ER-6210'),
  ('11-AUG-2025','LG-272,LG-605,LG-683,ER-5577'),
  ('12-AUG-2025','ER-2207,LG-551,LG-826,ER-6842');

SELECT * FROM regexp_count_demo;
Copy
+------------+---------------------------------------+
| DT         | MESSAGES                              |
|------------+---------------------------------------|
| 2025-08-10 | ER-6842,LG-230,LG-150,ER-3379,ER-6210 |
| 2025-08-11 | LG-272,LG-605,LG-683,ER-5577          |
| 2025-08-12 | ER-2207,LG-551,LG-826,ER-6842         |
+------------+---------------------------------------+

La requête suivante renvoie le nombre total de messages pour chaque jour en recherchant le délimiteur (,) et en ajoutant un au total :

SELECT dt,
       REGEXP_COUNT(messages, ',') + 1 AS message_count
  FROM regexp_count_demo;
Copy
+------------+---------------+
| DT         | MESSAGE_COUNT |
|------------+---------------|
| 2025-08-10 |             5 |
| 2025-08-11 |             4 |
| 2025-08-12 |             4 |
+------------+---------------+

Supposons que les erreurs commencent toujours par ER suivi d’un trait d’union et d’un nombre à quatre chiffres. La requête suivante compte le nombre d’erreurs pour chaque jour :

SELECT dt,
       REGEXP_COUNT(messages, '\\bER-[0-9]{4}') AS number_of_errors
  FROM regexp_count_demo;
Copy
+------------+------------------+
| DT         | NUMBER_OF_ERRORS |
|------------+------------------|
| 2025-08-10 |                3 |
| 2025-08-11 |                1 |
| 2025-08-12 |                2 |
+------------+------------------+
Langage: Français