Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonction REGEXP\$1SUBSTR
Renvoie les caractères d’une chaîne en y recherchant un modèle d’expression régulière. REGEXP\$1SUBSTR est similaire à la fonction [Fonction SUBSTRING](SUBSTRING.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne. Si la fonction ne trouve pas correspondance entre l’expression régulière et aucun caractère de la chaîne, elle renvoie une chaîne vide.
## Syntaxe
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieure au nombre de caractères de *source\$1string*, le résultat est une chaîne vide ("").
*occurrence*
Nombre entier positif qui indique quelle occurrence du modèle utiliser. REGEXP\$1SUBSTR ignore les *occurrence* -1 premières correspondances. La valeur par défaut est 1. Si *occurrence* est inférieur à 1 ou supérieur au nombre de caractères de la chaîne *source\$1string*, la recherche est ignorée et le résultat est NULL.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ e : extraire une sous-chaîne à l’aide d’une sous-expression.
Si *pattern* inclut une sous-expression, REGEXP\$1SUBSTR met en correspondance une sous-chaîne à l’aide de la première sous-expression incluse dans *pattern*. Une sous-expression est une expression dans le modèle qui est mise entre parenthèses. Par exemple, le modèle `'This is a (\\w+)'` met en correspondance la première expression avec la chaîne `'This is a '` suivie d’un mot. Au lieu de renvoyer le *modèle*, REGEXP\$1SUBSTR avec le paramètre `e` renvoie uniquement la chaîne contenue dans la sous-expression.
REGEXP\$1SUBSTR considère uniquement la première sous-expression ; les autres sous-expressions sont ignorées. Si le modèle n’inclut pas de sous-expression, REGEXP\$1SUBSTR ignore le paramètre « e ».
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
VARCHAR
## exemple
L’exemple suivant renvoie la partie d’une adresse e-mail comprise entre le caractère @ et l’extension du domaine.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
L'exemple suivant renvoie la partie de l'entrée correspondant à la première occurrence de la chaîne `FOX`, à l'aide d'une correspondance avec respect de la casse.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
L'exemple suivant renvoie la première partie de l'entrée qui commence par des lettres minuscules. Il est fonctionnellement identique à la même instruction SELECT sans le paramètre `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l’opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type, mais diffère de l’exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
L’exemple suivant utilise une sous-expression pour rechercher la deuxième chaîne correspondant au modèle `'this is a (\\w+)'` à l’aide d’une correspondance avec respect de la casse. Il renvoie la sous-expression entre parenthèses.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```