- Catégories :
REGEXP_COUNT¶
Renvoie le nombre de fois qu’un motif se produit dans une chaîne.
Syntaxe¶
REGEXP_COUNT( <subject> ,
<pattern>
[ , <position>
[ , <parameters> ]
]
)
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)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.
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;
+--------+
| 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;
+----------------+
| 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;
+----+----------------------+
| 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;
+----+--------+
| 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;
+------------+---------------------------------------+
| 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;
+------------+---------------+
| 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;
+------------+------------------+
| DT | NUMBER_OF_ERRORS |
|------------+------------------|
| 2025-08-10 | 3 |
| 2025-08-11 | 1 |
| 2025-08-12 | 2 |
+------------+------------------+