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

Fonction REGEXP_SUBSTR() dans Oracle

Dans Oracle, le REGEXP_SUBSTR() La fonction renvoie une sous-chaîne à partir d'une chaîne, basée sur un modèle d'expression régulière.

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

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_SUBSTR ( source_char, pattern
                [, position
                   [, occurrence
                      [, match_param
                         [, subexpr ]
                      ]
                   ]
                ]
              )

Où :

  • source_char est une expression de caractère qui sert de valeur de recherche.
  • pattern est l'expression régulière.
  • 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 à rechercher. La valeur par défaut est 1 , ce qui signifie qu'il recherche la première occurrence.
  • 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 cette fonction pour plus d'informations.
  • Pour un pattern avec des sous-expressions, subexpr est un entier non négatif de 0 à 9 indiquant quelle sous-expression dans pattern doit être retourné par la fonction. Cet argument fonctionne de la même manière que lorsqu'il est utilisé avec le REGEXP_INSTR() une fonction. Consultez la documentation d'Oracle pour plus d'informations sur cette fonction.

Exemple

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

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

Résultat :

dog

Dans ce cas, il y a une correspondance et la première (et dans ce cas, la seule) sous-chaîne correspondante est renvoyée.

Les expressions régulières peuvent être très puissantes, et cet exemple utilise un exemple très simple. Pour utiliser REGEXP_SUBSTR() 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 :

SET NULL 'null';
SELECT REGEXP_SUBSTR('My dogs like dregs', 't.g')
FROM DUAL;

Résultat :

null

Il n'y a pas de correspondance, donc null est renvoyé.

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

Plusieurs correspondances

Voici un exemple avec plusieurs correspondances :

SELECT 
    REGEXP_SUBSTR('My dogs have dags', 'd.g')
FROM DUAL;

Résultat :

dog

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

SELECT 
REGEXP_SUBSTR('My dogs have dags', 'd.g', 1, 2)
FROM DUAL;

Résultat :

dag

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 rechercher. Dans ce cas, la deuxième occurrence est recherchée.

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

SELECT 
REGEXP_SUBSTR('My dogs have dags', 'd.g', 8, 2)
FROM DUAL;

Résultat :

null

Dans ce cas, il n'y a pas de correspondance, car il n'y a qu'une seule occurrence de plus après la position de départ.

Si je change le dernier argument en 1 , nous obtenons alors une correspondance (car c'est la première occurrence après la position de départ spécifiée) :

SELECT 
REGEXP_SUBSTR('My dogs have dags', 'd.g', 8, 1)
FROM DUAL;

Résultat :

dag

Sensibilité à la casse

Le REGEXP_SUBSTR() 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 cinquiè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_SUBSTR('My Cats', 'c.t', 1, 1) AS "Default",
    REGEXP_SUBSTR('My Cats', 'c.t', 1, 1, 'i') AS "Case Insensitive",
    REGEXP_SUBSTR('My Cats', 'c.t', 1, 1, 'c') AS "Case Sensitive"
FROM DUAL;

Résultat :

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
null       Cat                 null

Ma collation semble être sensible à la casse, sur la base de ces résultats. Les deux autres chaînes ont été forcées à une correspondance insensible à la casse et sensible à la casse respectivement.

Sous-expressions

Voici un exemple d'utilisation du sixième argument pour renvoyer un modèle de sous-expression spécifique :

SELECT REGEXP_SUBSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 'i', 1
    )
FROM DUAL;

Résultat :

cat

Dans ce cas, j'ai renvoyé la première sous-expression.

Voici ce qui se passe si je spécifie la troisième sous-expression :

SELECT REGEXP_SUBSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 'i', 3
    )
FROM DUAL;

Résultat :

cow

Arguments nuls

Si un argument est null , le résultat est null :

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

Résultat :

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

Mauvais nombre d'arguments

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

SELECT REGEXP_SUBSTR()
FROM DUAL;

Résultat :

Error starting at line : 1 in command -
SELECT REGEXP_SUBSTR()
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:

Il en va de même lorsque nous passons trop d'arguments :

SELECT REGEXP_SUBSTR('Cat', 'c.t', 1, 1, 'i', 1, 'oops')
FROM DUAL;

Résultat :

Error starting at line : 1 in command -
SELECT REGEXP_SUBSTR('Cat', 'c.t', 1, 1, 'i', 1, '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_SUBSTR() 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_SUBSTR() fonction.