Fonctionnement de la fonction REGEXP_SUBSTR() dans MySQL

Dans MySQL, le REGEXP_SUBSTR() renvoie la sous-chaîne qui correspond au modèle d'expression régulière donné.

S'il n'y a pas de correspondance (c'est-à-dire que la chaîne d'entrée ne contient pas la sous-chaîne), le résultat est NULL .

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])

Où expr est la chaîne d'entrée et pat est le modèle d'expression régulière pour la sous-chaîne.

Le pos facultatif L'argument vous permet de spécifier une position dans la chaîne pour lancer la recherche. S'il est omis, il commence à la position 1.

L'option occurrence L'argument vous permet de spécifier l'occurrence de la correspondance à rechercher. Si omis, la première occurrence est utilisée (occurrence 1).

Le match_type facultatif L'argument permet d'affiner l'expression régulière. Par exemple, vous pouvez utiliser cet argument pour spécifier ou non une correspondance sensible à la casse.

Exemple 1 - Utilisation de base

Voici un exemple de base :

SELECT REGEXP_SUBSTR('Thaïlande ou Cambodge', 'l.nd') Résultat ;

Résultat :

+--------+| Résultat |+--------+| terrain |+--------+

Dans ce cas, il y a correspondance et la sous-chaîne est renvoyée.

Exemple 2 – Plusieurs correspondances

Par défaut, s'il y a plusieurs correspondances dans la chaîne, la première est renvoyée (bien que vous puissiez spécifier une autre occurrence si nécessaire. Nous y reviendrons bientôt) :

SELECT REGEXP_SUBSTR('Lend for land', 'l.nd') Résultat ;

Résultat :

+--------+| Résultat |+--------+| Prêter |+--------+

Exemple 3 – Aucune correspondance

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

SELECT REGEXP_SUBSTR('Prêt pour un terrain', '^C') Résultat ;

Résultat :

+--------+| Résultat |+--------+| NULL |+--------+

Il n'y a pas de correspondance, donc le résultat est NULL .

Exemple 4 – Le pos Argumentation

Voici un exemple de spécification d'une position de départ :

SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) Résultat ;

Résultat :

+--------+| Résultat |+--------+| Couper |+--------+

Nous avons commencé à la position 2, qui vient après le début de la première occurrence, donc la prochaine occurrence est renvoyée à la place.

Voici un autre exemple :

SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) 'Pos 2', REGEXP_SUBSTR('Cat Coupe Cot', 'C.t', 6) 'Pos 6';

Résultat :

+-------+-------+-------+| Poste 1 | Pos 2 | Pos 6 |+-------+-------+-------+| Chat | Couper | Lit |+-------+-------+-------+

Exemple 5 – L'occurrence Argumentation

Voici un exemple d'utilisation de l'occurrence argument. Dans tous les cas, on commence à la position 1 :

SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 1) 'Occurrence 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 2) 'Occurrence 2', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 3) 'Occurrence 3';

Résultat :

+--------------+-------------+--------------+| Occurrence 1 | Occurrence 2 | Occurrence 3 |+--------------+-------------+--------------+| Chat | Couper | Lit bébé |+--------------+-------------+--------------+ 

 Cependant, si nous commençons à une position différente, le résultat est différent :
 
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 1) 'Occurrence 1', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 2) 'Occurrence 2', REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 3) 'Occurrence 3';
 

 Résultat :
 
+--------------+-------------+--------------+| Occurrence 1 | Occurrence 2 | Occurrence 3 |+--------------+-------------+--------------+| Couper | Lit bébé | NULL |+--------------+--------------+--------------+ 

 Cela s'est produit parce que notre position de départ est survenue après le début de la première occurrence. Par conséquent, l'occurrence 2 est devenue l'occurrence 1 et l'occurrence 3 est devenue l'occurrence 2. Et comme il n'y avait plus d'occurrences, le résultat de l'occurrence 3 était NULL (c'est-à-dire qu'il n'y avait pas d'occurrence 3).
 
Exemple 6 – Le match_type Argumentation
 

 Vous pouvez fournir un argument supplémentaire pour déterminer le type de correspondance. Cela vous permet de spécifier des choses comme si la correspondance est ou non sensible à la casse, s'il faut ou non inclure des fins de ligne, etc.
 

 Voici un exemple de spécification d'une correspondance sensible à la casse et d'une correspondance insensible à la casse :
 
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'c') 'Sensible à la casse', REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'i') 'Insensible à la casse' ;
 

 Résultat :
 
+----------------+------------------+| Sensible à la casse | Insensible à la casse |+----------------+------------------+| NUL | Chat |+-----------------+------------------+
 

 Le match_type l'argument peut contenir les caractères suivants :
 
c 
 
Correspondance sensible à la casse.
 
i 
 
Correspondance insensible à la casse.
 
m 
 
Mode multiligne. Reconnaître les terminaisons de ligne dans la chaîne. Le comportement par défaut consiste à faire correspondre les fins de ligne uniquement au début et à la fin de l'expression de chaîne.
 
n 
 
Le . caractère correspond aux fins de ligne. La valeur par défaut est pour . correspondant à s'arrêter à la fin d'une ligne.
 
u 
 
Fin de ligne UNIX uniquement. Seul le caractère de nouvelle ligne est reconnu comme une ligne se terminant par le . , ^ , et $ opérateurs de correspondance.