Fonctionnement de la fonction REGEXP_INSTR() dans MySQL

Dans MySQL, le REGEXP_INSTR() renvoie l'index de départ d'une sous-chaîne qui correspond au modèle d'expression régulière.

L'index commence à 1 . S'il n'y a pas de correspondance, le résultat est 0 .

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, 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).

L'option return_option facultative L'argument vous permet de spécifier le type de position à renvoyer. Si vous utilisez 0 , il renverra la position du premier caractère dans la sous-chaîne correspondante. Si vous utilisez 1 il renvoie la position du premier caractère suivant la sous-chaîne correspondante. Si omis, la valeur est 0 .

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_INSTR('Cat', 'at') Résultat ;

Résultat :

+--------+| Résultat |+--------+| 2 |+--------+

Dans ce cas, il y a correspondance et la sous-chaîne commence à la position 2.

Exemple 2 – Aucune correspondance

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

SELECT REGEXP_INSTR('Cat', '^at') Résultat ;

Résultat :

+--------+| Résultat |+--------+| 0 |+--------+

Il n'y a pas de correspondance, donc le résultat est 0 . Il n'y a pas de correspondance car j'ai spécifié que la chaîne doit commencer par la sous-chaîne.

Modifions-le pour qu'il le fasse commencer par cette sous-chaîne :

SELECT REGEXP_INSTR('at', '^at') Résultat ;

Résultat :

+--------+| Résultat |+--------+| 1 |+--------+

Exemple 3 – Le pos Argumentation

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

SELECT REGEXP_INSTR('Chat Chat', 'Chat', 2) Résultat ;

Résultat :

+--------+| Résultat |+--------+| 5 |+--------+

Nous obtenons donc l'indice de la deuxième occurrence.

Notez que l'index commence toujours à compter à partir de la position 1, quel que soit l'endroit où vous spécifiez la position de départ.

L'exemple suivant le montre plus clairement :

SELECT REGEXP_INSTR('Chat Chat', 'Chat', 2) AS 'Pos 2', REGEXP_INSTR('Chat Chat', 'Chat', 3) AS 'Pos 3', REGEXP_INSTR('Chat Chat', ' Chat', 5) AS 'Pos 5';

Résultat :

+-------+-------+-------+| Pos 2 | Pos 3 | Pos 5 |+-------+-------+-------+| 5 | 5 | 5 |+-------+-------+-------+

Bien sûr, selon votre modèle regex, cela peut renvoyer l'index de sous-chaînes complètement différentes. Exemple :

SELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 6) 'Pos 6';

Résultat :

+-------+-------+-------+| Poste 1 | Pos 2 | Pos 6 |+-------+-------+-------+| 1 | 5 | 16 |+-------+-------+-------+

Nous pouvons vérifier les sous-chaînes avec le REGEXP_SUBSTR() fonction :

SELECT REGEXP_SUBSTR('Cat City est TELLEMENT mignon !', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat City est TELLEMENT mignon !', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Cat City est TELLEMENT mignon !', 'C.t', 6) 'Pos 6';

Résultat :

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

Exemple 4 - L'occurrence Argumentation

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

SELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 1) 'Occurrence 1', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 2 ) 'Occurrence 2', REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3) 'Occurrence 3';

Résultat :

+--------------+-------------+--------------+| Occurrence 1 | Occurrence 2 | Occurrence 3 |+--------------+-------------+--------------+| 1 | 5 | 16 |+--------------+--------------+-----------------------+ 

 Cependant, si nous commençons à une position différente, le résultat est différent :
 
SELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 2, 1) 'Occurrence 1', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 2, 2 ) 'Occurrence 2', REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 3) 'Occurrence 3';
 

 Résultat :
 
+--------------+-------------+--------------+| Occurrence 1 | Occurrence 2 | Occurrence 3 |+--------------+-------------+--------------+| 5 | 16 | 0 |+--------------+-------------+--------------+ 

 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 négatif (c'est-à-dire qu'il n'y avait pas d'occurrence 3).
 
Exemple 5 – L'return_option Argumentation
 

 Voici un exemple d'utilisation de l'return_option argument :
 
SELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 1, 0) 'Option 0', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1 , 1, 1) 'Option 1';
 

 Résultat :
 
+----------+----------+| Option 0 | Choix 1 |+----------+----------+| 1 | 4 |+----------+----------+
 

 L'option 0 a renvoyé le premier caractère de la sous-chaîne correspondante. L'option 1 a renvoyé la position suivant la sous-chaîne correspondante.
 

 Voici à quoi cela ressemble si nous l'appliquons à l'exemple précédent :
 
SELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 1, 0) 'Occurrence 1', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1 , 2, 0) 'Occurrence 2', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 3, 0) 'Occurrence 3'UNION ALLSELECT REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 1, 1), REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C.t', 1, 2, 1), REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'C .t', 1, 3, 1);
 

 Résultat :
 
+--------------+-------------+--------------+| Occurrence 1 | Occurrence 2 | Occurrence 3 |+--------------+-------------+--------------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+-------------+--------------+ 

 Dans ce cas, nous avons créé un ensemble en utilisant l'option 0 et un autre en utilisant l'option 1, puis nous les avons réunis en utilisant UNION ALL . 
 
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_INSTR('Cat City est TELLEMENT mignon !', 'c.t', 1, 1, 0, 'c') 'Sensible à la casse', REGEXP_INSTR('Cat City est TELLEMENT mignon !', 'c .t', 1, 1, 0, 'i') 'Insensible à la casse' ;
 

 Résultat :
 
+----------------+------------------+| Sensible à la casse | Insensible à la casse |+----------------+------------------+| 0 | 1 |+-----------------+------------------+
 

 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.