Fonction REGEXP_INSTR() dans Oracle

Dans Oracle, le REGEXP_INSTR() La fonction recherche dans une chaîne un modèle d'expression régulière. Elle renvoie un entier indiquant la position de début ou de fin de la sous-chaîne correspondante (selon celle que vous spécifiez).

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

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_INSTR ( source_char, pattern
               [, position
                  [, occurrence
                     [, return_opt
                        [, 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 positif qui spécifie l'occurrence à rechercher. La valeur par défaut est 1 , ce qui signifie qu'il recherche la première occurrence.
return_opt spécifie si Oracle doit renvoyer la position de début ou de fin de la sous-chaîne correspondante. Utilisez 0 pour le début, et 1 pour la fin. La valeur par défaut est 0 .
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 manière 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_INSTR() dans Oracle :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g')
FROM DUAL;

Résultat :

Dans ce cas, il y a correspondance et la position de début de la sous-chaîne 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_INSTR() 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_INSTR('My dogs like dregs', 't.g')
FROM DUAL;

Résultat :

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

Plusieurs correspondances

Voici un exemple avec plusieurs correspondances :

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

Résultat :

Il a renvoyé la position de la première occurrence.

Cependant, vous pouvez spécifier quelle occurrence remplacer :

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

Résultat :

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_INSTR('My dogs have dags', 'd.g', 8, 2)
FROM DUAL;

Résultat :

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_INSTR('My dogs have dags', 'd.g', 8, 1)
FROM DUAL;

Résultat :

Renvoyer la position finale

Vous pouvez passer un cinquième argument soit 0 ou 1 pour spécifier si la fonction doit renvoyer la position de début ou de fin de la sous-chaîne.

La valeur par défaut est 0 (pour la position de départ). Voici ce qui se passe si nous spécifions 1 :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1)
FROM DUAL;

Résultat :

Juste pour être clair, le voici à nouveau par rapport à 0 :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 0) AS "Start",
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1) AS "End"
FROM DUAL;

Résultat :

   Start    End 
________ ______ 
       4      7

Sensibilité à la casse

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

Résultat :

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

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_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 1
    )
FROM DUAL;

Résultat :

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_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 3
    )
FROM DUAL;

Résultat :

Arguments nuls

À l'exception du 6ème argument, fournir null pour un argument donne null :

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

Résultat :

      1       2       3       4       5    6       7 
_______ _______ _______ _______ _______ ____ _______ 
   null    null    null    null    null    0    null

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_INSTR()
FROM DUAL;

Résultat :

Error starting at line : 1 in command -
SELECT REGEXP_INSTR()
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_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, 'oops')
FROM DUAL;

Résultat :

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