Dans MariaDB, 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(subject, pattern)
Où subject est la chaîne d'entrée et le pattern est le modèle d'expression régulière pour la sous-chaîne.
Notez qu'au moment de la rédaction, la version de MariaDB de REGEXP_INSTR() accepte moins d'arguments que REGEXP_INSTR() de MySQL . La version de MySQL vous permet de fournir des arguments pour la position de départ de la recherche, l'occurrence à rechercher, le type de position à renvoyer, ainsi qu'un moyen d'affiner l'expression régulière.
Exemple
Voici un exemple de base :
SELECT REGEXP_INSTR('Cat', 'at');Résultat :
+---------------------------+
| REGEXP_INSTR('Cat', 'at') |
+---------------------------+
| 2 |
+---------------------------+ Dans ce cas, il y a correspondance et la sous-chaîne commence à la position 2.
Aucune correspondance
Voici un exemple où il n'y a pas de correspondance :
SELECT REGEXP_INSTR('Cat', '^at');Résultat :
+----------------------------+
| REGEXP_INSTR('Cat', '^at') |
+----------------------------+
| 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 :
+---------------------------+
| REGEXP_INSTR('at', '^at') |
+---------------------------+
| 1 |
+---------------------------+
Sensibilité à la casse
Le REGEXP_INSTR() suit les règles de sensibilité à la casse du classement effectif. La correspondance est effectuée de manière insensible à la casse pour les classements insensibles à la casse, et sensible à la casse pour les classements sensibles à la casse et pour les données binaires.
Voici un exemple :
SELECT
REGEXP_INSTR('Cat', 'c') AS "My Default",
REGEXP_INSTR(_latin7'Cat' COLLATE latin7_general_ci, 'c') AS "Case Insensitive",
REGEXP_INSTR(_latin7'Cat' COLLATE latin7_general_cs, 'c') AS "Case Sensitive";Résultat :
+------------+------------------+----------------+ | My Default | Case Insensitive | Case Sensitive | +------------+------------------+----------------+ | 1 | 1 | 0 | +------------+------------------+----------------+
Mon classement par défaut est insensible à la casse. Les deux autres chaînes ont été forcées respectivement à un classement insensible à la casse et à un classement sensible à la casse.
Fournir un BINARY la chaîne est également sensible à la casse (voir ci-dessous).
Chaînes binaires
Par défaut, les positions sont mesurées en caractères plutôt qu'en octets. Cependant, vous pouvez convertir un jeu de caractères multi-octets en BINARY pour obtenir des décalages en octets si nécessaire.
Exemple :
SELECT
REGEXP_INSTR('© Cat', 'C') AS "Character",
REGEXP_INSTR(BINARY '© Cat', 'C') AS "Binary";Résultat :
+-----------+--------+ | Character | Binary | +-----------+--------+ | 3 | 4 | +-----------+--------+
Le symbole de copyright utilise deux octets, et donc dans cet exemple nous obtenons un résultat de 4 lors de la conversion en BINARY , contre 3 que nous obtenons autrement.
Notez bien que le passage d'un BINARY chaîne affecte également la sensibilité à la casse. Avec BINARY chaînes, un caractère majuscule est différent de son homologue minuscule :
SELECT
REGEXP_INSTR('© Cat', 'c') AS "Character",
REGEXP_INSTR(BINARY '© Cat', 'c') AS "Binary";Résultat :
+-----------+--------+ | Character | Binary | +-----------+--------+ | 3 | 0 | +-----------+--------+
Ici, j'ai cherché un c minuscule au lieu d'une majuscule, et le BINARY la chaîne ne correspondait pas.
Arguments nuls
Passer null car tout argument donne null :
SELECT
REGEXP_INSTR(null, 'c') AS "1",
REGEXP_INSTR('Cat', null) AS "2",
REGEXP_INSTR(null, null) AS "3";Résultat :
+------+------+------+ | 1 | 2 | 3 | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
Mauvais nombre d'arguments
Passer le mauvais nombre d'arguments ou aucun argument, entraîne une erreur :
SELECT REGEXP_INSTR('Cat');Résultat :
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_INSTR'
