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

REGEXP_REPLACE¶

Renvoie le sujet avec le modèle spécifié (ou toutes les occurrences du modèle) soit supprimé soit remplacé par une chaîne de remplacement.

Syntaxe¶

 REGEXP_REPLACE( <subject> ,
                 <pattern>
                   [ , <replacement>
                     [ , <position>
                       [ , <occurrence>
                         [ , <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 :

replacement

Chaîne qui remplace les sous-chaînes correspondant au motif. Si une chaîne vide est spécifiée, la fonction supprime tous les motifs correspondants et renvoie la chaîne résultante.

Valeur par défaut : '' (chaîne vide).

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)

occurrence

Spécifie l’occurrence du modèle devant correspondre. Si 0 est spécifié, toutes les occurrences sont remplacées.

Par défaut : 0 (toutes les occurrences)

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

Si aucune correspondance n’est trouvée, le sujet d’origine est renvoyé.

Renvoie NULL si l’un des arguments est NULL.

Notes sur l’utilisation¶

La chaîne de remplacement peut contenir des références arrière pour capturer des groupes (c’est-à-dire des sous-expressions du modèle). Un groupe de capture est une expression régulière placée entre parenthèses (( )). Le nombre maximal de groupes de capture est 9.

Les références arrières cherchent les expressions correspondantes à l’intérieur d’un groupe de capture. Les références arrière ont la forme n où n est une valeur comprise entre 0 et 9 inclus, qui fait référence à l’instance correspondante du groupe de capture. Pour plus d’informations, voir Exemples (dans cette rubrique).
Les parenthèses (( )) et les crochets ([ ]) doivent actuellement être doublés pour être analysés sous forme de chaînes de littéraux.

L’exemple ci-dessous montre comment supprimer les parenthèses :
```
SELECT REGEXP_REPLACE('Customers - (NY)','\\(|\\)','') AS customers;
```
```
+----------------+
| CUSTOMERS      |
|----------------|
| Customers - NY |
+----------------+
```
Pour des notes d’utilisation supplémentaires, voir 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 remplace tous les espaces de la chaîne par rien (c’est-à-dire que tous les espaces sont supprimés) :

SELECT REGEXP_REPLACE('It was the best of times, it was the worst of times',
                      '( ){1,}',
                      '') AS result;

+------------------------------------------+
| RESULT                                   |
|------------------------------------------|
| Itwasthebestoftimes,itwastheworstoftimes |
+------------------------------------------+

L’exemple suivant correspond à la chaîne times et la remplace par la chaîne days. La correspondance commence au premier caractère de la chaîne et remplace la deuxième occurrence de la sous-chaîne :

SELECT REGEXP_REPLACE('It was the best of times, it was the worst of times',
                      'times',
                      'days',
                      1,
                      2) AS result;

+----------------------------------------------------+
| RESULT                                             |
|----------------------------------------------------|
| It was the best of times, it was the worst of days |
+----------------------------------------------------+

L’exemple suivant utilise des références arrières pour réorganiser la chaîne firstname middlename lastname en tant que lastname, firstname middlename et insérer une virgule entre lastname et firstname :

SELECT REGEXP_REPLACE('firstname middlename lastname',
                      '(.*) (.*) (.*)',
                      '\\3, \\1 \\2') AS name_sort;

+--------------------------------+
| NAME_SORT                      |
|--------------------------------|
| lastname, firstname middlename |
+--------------------------------+

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

CREATE OR REPLACE TABLE regexp_replace_demo(body VARCHAR(255));

INSERT INTO regexp_replace_demo values
  ('Hellooo World'),
  ('How are you doing today?'),
  ('the quick brown fox jumps over the lazy dog'),
  ('PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS');

L’exemple suivant insère le caractère * entre chaque caractère du sujet, y compris le début et la fin, en utilisant un groupe vide (()), qui trouve une correspondance entre deux caractères :

SELECT body,
       REGEXP_REPLACE(body, '()', '*') AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+-----------------------------------------------------------------------------------------+
| BODY                                        | REPLACED                                                                                |
|---------------------------------------------+-----------------------------------------------------------------------------------------|
| Hellooo World                               | *H*e*l*l*o*o*o* *W*o*r*l*d*                                                             |
| How are you doing today?                    | *H*o*w* *a*r*e* *y*o*u* *d*o*i*n*g* *t*o*d*a*y*?*                                       |
| the quick brown fox jumps over the lazy dog | *t*h*e* *q*u*i*c*k* *b*r*o*w*n* *f*o*x* *j*u*m*p*s* *o*v*e*r* *t*h*e* *l*a*z*y* *d*o*g* |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | *P*A*C*K* *M*Y* *B*O*X* *W*I*T*H* *F*I*V*E* *D*O*Z*E*N* *L*I*Q*U*O*R* *J*U*G*S*         |
+---------------------------------------------+-----------------------------------------------------------------------------------------+

L’exemple suivant supprime toutes les voyelles en les remplaçant par rien, quels que soient leur ordre ou leur casse :

SELECT body,
       REGEXP_REPLACE(body, '[aeiou]', '', 1, 0, 'i') AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+----------------------------------+
| BODY                                        | REPLACED                         |
|---------------------------------------------+----------------------------------|
| Hellooo World                               | Hll Wrld                         |
| How are you doing today?                    | Hw r y dng tdy?                  |
| the quick brown fox jumps over the lazy dog | th qck brwn fx jmps vr th lzy dg |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PCK MY BX WTH FV DZN LQR JGS     |
+---------------------------------------------+----------------------------------+

L’exemple suivant supprime tous les mots contenant la lettre minuscule o du sujet en faisant correspondre une limite de mot (\b), suivie de zéro ou de plusieurs caractères de mots (\S), la lettre o, puis zéro ou plusieurs caractères de mot jusqu’à la prochaine limite de mot :

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b') AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+-----------------------------------------+
| BODY                                        | REPLACED                                |
|---------------------------------------------+-----------------------------------------|
| Hellooo World                               |                                         |
| How are you doing today?                    |  are   ?                                |
| the quick brown fox jumps over the lazy dog | the quick   jumps  the lazy             |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS |
+---------------------------------------------+-----------------------------------------+

L’exemple suivant remplace tous les mots contenant la lettre minuscule o, échangeant les lettres devant et derrière la première instance de o, et remplaçant o par la séquence de caractères @@ :

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1') AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+-------------------------------------------------+
| BODY                                        | REPLACED                                        |
|---------------------------------------------+-------------------------------------------------|
| Hellooo World                               | @@Helloo rld@@W                                 |
| How are you doing today?                    | w@@H are u@@y ing@@d day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick wn@@br x@@f jumps ver@@ the lazy g@@d |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS         |
+---------------------------------------------+-------------------------------------------------+

L’exemple suivant est le même que l’exemple précédent, mais le remplacement commence à la position 3 dans le sujet :

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3) AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+-------------------------------------------------+
| BODY                                        | REPLACED                                        |
|---------------------------------------------+-------------------------------------------------|
| Hellooo World                               | He@@lloo rld@@W                                 |
| How are you doing today?                    | How are u@@y ing@@d day@@t?                     |
| the quick brown fox jumps over the lazy dog | the quick wn@@br x@@f jumps ver@@ the lazy g@@d |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS         |
+---------------------------------------------+-------------------------------------------------+

L’exemple suivant est le même que l’exemple précédent, mais seule la troisième occurrence est remplacée, à partir de la position 3 dans le sujet :

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3, 3) AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+----------------------------------------------+
| BODY                                        | REPLACED                                     |
|---------------------------------------------+----------------------------------------------|
| Hellooo World                               | Hellooo World                                |
| How are you doing today?                    | How are you doing day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick brown fox jumps ver@@ the lazy dog |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS      |
+---------------------------------------------+----------------------------------------------+

L’exemple suivant est le même que l’exemple précédent, mais il utilise une correspondance non sensible à la casse :

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3, 3, 'i') AS replaced
  FROM regexp_replace_demo;

+---------------------------------------------+----------------------------------------------+
| BODY                                        | REPLACED                                     |
|---------------------------------------------+----------------------------------------------|
| Hellooo World                               | Hellooo World                                |
| How are you doing today?                    | How are you doing day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick brown fox jumps ver@@ the lazy dog |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN R@@LIQU JUGS     |
+---------------------------------------------+----------------------------------------------+