REGEXP_REPLACE¶

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.

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	POSIX wildcard character . matches \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 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;
  

  Copy

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