Oracle
 sql >> Base de données >  >> RDS >> Oracle

Fonction REGEXP_REPLACE() dans Oracle

Dans Oracle, le REGEXP_REPLACE() La fonction remplace les occurrences de la sous-chaîne dans une chaîne qui correspond au modèle d'expression régulière donné.

Il étend la fonctionnalité de REPLACE() fonction en nous permettant d'utiliser des modèles d'expressions régulières.

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_REPLACE ( source_char, pattern
                 [, replace_string
                    [, position
                       [, occurrence
                          [, match_param ]
                       ]
                    ]
                 ]
               )

Où :

  • source_char est une expression de caractère qui sert de valeur de recherche.
  • pattern est l'expression régulière.
  • replace_string est la chaîne de remplacement.
  • position est un entier positif qui spécifie où commencer la recherche. La valeur par défaut est 1 , c'est-à-dire lancer la recherche au premier caractère.
  • occurrence est un entier non négatif qui spécifie l'occurrence à remplacer. La valeur par défaut est 0 , ce qui signifie remplacer toutes les occurrences.
  • match_param vous permet de modifier le comportement de correspondance par défaut de la fonction. Par exemple, il vous permet de spécifier la sensibilité à la casse, la façon dont plusieurs lignes et espaces sont traités, etc. Cet argument fonctionne de la même manière que lorsqu'il est utilisé avec le REGEXP_COUNT() une fonction. Consultez la documentation d'Oracle pour plus d'informations.

Exemple

Voici un exemple basique d'utilisation de REGEXP_REPLACE() dans Oracle :

SELECT 
    REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird')
FROM DUAL;

Résultat :

Cats and birds

Dans ce cas, il y a correspondance et la sous-chaîne est remplacée par la chaîne de remplacement.

Les expressions régulières peuvent être très puissantes, et cet exemple utilise un exemple très simple. Pour utiliser REGEXP_REPLACE() efficacement, vous aurez besoin de connaître le modèle correct à utiliser pour le résultat souhaité.

Aucune correspondance

Voici un exemple où il n'y a pas de correspondance :

SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');

Résultat :

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs                                  |
+------------------------------------------------+

Il n'y a pas de correspondance, donc la chaîne d'origine est renvoyée inchangée.

Plusieurs correspondances

Voici un exemple avec plusieurs correspondances :

SELECT 
    REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird')
FROM DUAL;

Résultat :

My bird likes other birds

Cependant, vous pouvez spécifier quelle occurrence remplacer si nécessaire :

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 1, 2)
FROM DUAL;

Résultat :

My dog likes other birds

Notez que j'ai ajouté deux arguments ici - 1 et 2 . Le 1 spécifie la localisation dans la chaîne pour lancer la recherche (dans ce cas, au premier caractère). Le 2 est ce qui spécifie quelle occurrence remplacer. Dans ce cas, la deuxième occurrence est remplacée.

Voici ce qui se passe si je lance la recherche après la première occurrence :

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 7, 2)
FROM DUAL;

Résultat :

My dog likes other dogs

Dans ce cas, la chaîne n'est pas mise à jour, car il n'y a plus qu'une seule occurrence après la position de départ.

Si je change le dernier argument en 1 , il est alors mis à jour comme spécifié (car c'est la première occurrence après la position de départ spécifiée) :

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 7, 1)
FROM DUAL;

Résultat :

My dog likes other birds

Et au cas où vous vous poseriez la question, 0 spécifie toutes les occurrences :

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 1, 0
    )
FROM DUAL;

Résultat :

My bird likes big birds and small birds

Mais il respecte toujours toute position de départ qui a été spécifiée :

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 7, 0
    )
FROM DUAL;

Résultat :

My dog likes big birds and small birds

Sensibilité à la casse

Le REGEXP_REPLACE() suit les règles de détermination et de dérivation du classement d'Oracle, qui définissent le classement à utiliser lors de la mise en correspondance de la chaîne avec le modèle.

Cependant, vous pouvez spécifier explicitement la sensibilité à la casse avec le sixième argument facultatif. Lorsque vous faites cela, il remplace toute sensibilité à la casse ou à l'accent du classement déterminé.

Vous pouvez spécifier i pour la correspondance insensible à la casse et c pour la correspondance sensible à la casse.

Voici un exemple :

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0) AS "Default",
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0, 'i') AS "Case Insensitive",
    REGEXP_REPLACE('My Cats', 'c.t', 'dog', 1, 0, 'c') AS "Case Sensitive"
FROM DUAL;

Résultat :

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
My Cats    My dogs             My Cats

Il ressort de ces résultats que mon classement par défaut est sensible à la casse. Les deux autres chaînes ont été forcées à une correspondance insensible à la casse et sensible à la casse respectivement.

Arguments nuls

Passer null donne null pour la plupart des arguments, à l'exception des deuxième et sixième arguments :

SET NULL 'null';
SELECT 
    REGEXP_REPLACE(null, 'c.t', 'dog', 1, 0, 'i') AS "1",
    REGEXP_REPLACE('Cat', null, 'dog', 1, 0, 'i') AS "2",
    REGEXP_REPLACE('Cat', 'c.t', null, 1, 0, 'i') AS "3",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', null, 0, 'i') AS "4",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, null, 'i') AS "5",
    REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, null) AS "6"
FROM DUAL;

Résultat :

      1      2       3       4       5      6 
_______ ______ _______ _______ _______ ______ 
null    Cat    null    null    null    Cat

Par défaut, SQLcl et SQL*Plus renvoient un espace vide chaque fois que null se produit à la suite d'un SQL SELECT déclaration.

Cependant, vous pouvez utiliser SET NULL pour spécifier une autre chaîne à renvoyer. Ici, j'ai précisé que la chaîne null doit être retourné.

Mauvais nombre d'arguments

Ne passer aucun argument à la fonction, ou trop peu, génère une erreur :

SELECT REGEXP_REPLACE()
FROM DUAL;

Résultat :

Error starting at line : 1 in command -
SELECT REGEXP_REPLACE()
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00938: not enough arguments for function
00938. 00000 -  "not enough arguments for function"
*Cause:    
*Action:

Idem avec le passage de trop d'arguments :

SELECT REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, 'i', 'oops')
FROM DUAL;

Résultat :

Error starting at line : 1 in command -
SELECT REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, 'i', 'oops')
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00939: too many arguments for function
00939. 00000 -  "too many arguments for function"
*Cause:    
*Action:

Plus d'informations

Le REGEXP_REPLACE() La fonction (ainsi que les autres implémentations d'expressions régulières d'Oracle) est conforme à la norme d'expression régulière IEEE Portable Operating System Interface (POSIX) et aux directives d'expression régulière Unicode du consortium Unicode.

Voir la documentation Oracle pour plus d'informations et des exemples de REGEXP_REPLACE() fonction.