Sådan fungerer REGEXP_INSTR()-funktionen i MySQL

I MySQL er REGEXP_INSTR() funktion returnerer startindekset for en understreng, der matcher det regulære udtryksmønster.

Indekset starter ved 1 . Hvis der ikke er noget match, er resultatet 0 .

Syntaks

Syntaksen ser sådan ud:

REGEXP_INSTR(udtr., pat[, pos[, forekomst[, return_option[, match_type]]]])

Hvor expr er inputstrengen og pat er det regulære udtryksmønster for understrengen.

Den valgfri pos argument giver dig mulighed for at angive en position i strengen for at starte søgningen. Hvis den udelades, starter den ved position 1.

Den valgfri forekomst argument giver dig mulighed for at angive, hvilken forekomst af matchet du skal søge efter. Hvis den udelades, bruges den første forekomst (forekomst 1).

Den valgfri return_option argument giver dig mulighed for at angive, hvilken type position der skal returneres. Hvis du bruger 0 , vil det returnere positionen af ​​det første tegn i den matchende understreng. Hvis du bruger 1 det returnerer positionen for det første tegn efter den matchende understreng. Hvis den udelades, er værdien 0 .

Den valgfri match_type argument giver dig mulighed for at forfine det regulære udtryk. Du kan f.eks. bruge dette argument til at angive overensstemmelse mellem store og små bogstaver eller ej.

Eksempel 1 – Grundlæggende brug

Her er et grundlæggende eksempel:

SELECT REGEXP_INSTR('Kat', 'ved') Resultat;

Resultat:

+--------+| Resultat |+--------+| 2 |+--------+

I dette tilfælde er der et match, og understrengen starter ved position 2.

Eksempel 2 – Ingen match

Her er et eksempel, hvor der ikke er nogen match:

SELECT REGEXP_INSTR('Kat', '^at') Resultat;

Resultat:

+--------+| Resultat |+--------+| 0 |+--------+

Der er ingen match, så resultatet er 0 . Der er ingen match, fordi jeg specificerede, at strengen skal starte med understrengen.

Lad os ændre det, så det gør det start med den understreng:

SELECT REGEXP_INSTR('at', '^at') Resultat;

Resultat:

+--------+| Resultat |+--------+| 1 |+--------+

Eksempel 3 – pos Argument

Her er et eksempel på angivelse af en startposition:

SELECT REGEXP_INSTR('Kat Kat', 'Kat', 2) Resultat;

Resultat:

+--------+| Resultat |+--------+| 5 |+--------+

Så vi får indekset for den anden forekomst.

Bemærk, at indekset stadig begynder at tælle fra position 1, uanset hvor du angiver startpositionen.

Det følgende eksempel viser dette tydeligere:

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

Resultat:

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

Afhængigt af dit regex-mønster kan dette naturligvis returnere indekset for helt forskellige understrenge. Eksempel:

SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 6) 'Pos 6';

Resultat:

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

Vi kan kontrollere understrengene med REGEXP_SUBSTR() funktion:

SELECT REGEXP_SUBSTR('Cat City er SÅ sød!', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat City er SÅ sød!', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Cat City er SÅ sød!', 'C.t', 6) 'Pos 6';

Resultat:

+-------+-------+-------+| Pos 1 | Pos 2 | Pos 6 |+-------+-------+-------+| Kat | Cit | Klip |+-------+-------+-------+

Eksempel 4 – forekomsten Argument

Her er et eksempel på brug af forekomst argument. I alle tilfælde starter vi ved position 1:

SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 1) 'Forekomst 1', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 2 ) 'Forekomst 2', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 3) 'Forekomst 3';

Resultat:

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

 Men hvis vi starter ved en anden position, er resultatet anderledes:
 
SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 2, 1) 'Forekomst 1', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 2, 2 ) 'Forekomst 2', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 2, 3) 'Forekomst 3';
 

 Resultat:
 
+--------------+-------------+--------------+| Forekomst 1 | Forekomst 2 | Forekomst 3 |+--------------------+------+| 5 | 16 | 0 |+--------------+-------------+--------------+ 

 Dette skete, fordi vores startposition kom efter den første forekomst var startet. Derfor blev forekomst 2 til forekomst 1, og forekomst 3 blev til forekomst 2. Og fordi der ikke var flere forekomster, var resultatet af forekomst 3 negativt (dvs. der var ingen forekomst 3).
 
Eksempel 5 – retur_option Argument
 

 Her er et eksempel på brug af return_option argument:
 
SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 1, 0) 'Mulighed 0', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1 , 1, 1) 'Mulighed 1';
 

 Resultat:
 
+----------+--------+| Mulighed 0 | Mulighed 1 |+----------+----------+| 1 | 4 |+----------+----------+
 

 Mulighed 0 returnerede den matchede understrengs første tegn. Mulighed 1 returnerede positionen efter den matchede understreng.
 

 Sådan ser det ud, hvis vi anvender det på det forrige eksempel:
 
SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 1, 0) 'Forekomst 1', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1 , 2, 0) 'Forekomst 2', REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 3, 0) 'Forekomst 3'UNION ALLSELECT REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 1, 1), REGEXP_INSTR('Cat City er SÅ sød!', 'C.t', 1, 2, 1), REGEXP_INSTR('Cat City er SÅ sød!', 'C .t', 1, 3, 1);
 

 Resultat:
 
+--------------+-------------+--------------+| Forekomst 1 | Forekomst 2 | Forekomst 3 |+--------------------+------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+--------------+--------------+ 

 I dette tilfælde lavede vi et sæt ved at bruge mulighed 0, og et andet ved at bruge mulighed 1, og forenede dem derefter ved hjælp af UNION ALL . 
 
Eksempel 6 – match_type Argument
 

 Du kan angive et ekstra argument for at bestemme matchtypen. Dette giver dig mulighed for at specificere ting som om matchet er skelet mellem store og små bogstaver, om der skal inkluderes linjeterminatorer osv.
 

 Her er et eksempel på at angive et match, der skelner mellem store og små bogstaver, og et match, der skelner mellem store og små bogstaver:
 
SELECT REGEXP_INSTR('Cat City er SÅ sød!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive', REGEXP_INSTR('Cat City er SÅ sød!', 'c .t', 1, 1, 0, 'i') 'Uskift mellem store og små bogstaver';
 

 Resultat:
 
+----------------+------------------------+| Versalfølsomt | Skifter ikke på store og små bogstaver |+----------------+------------------------+| 0 | 1 |+----------------+------------------+
 

 match_type argument kan indeholde følgende tegn:
 
c 
 
Skaftfølsom match.
 
i 
 
Tilpasning af store og små bogstaver.
 
m 
 
Flere linjers tilstand. Genkend linjeterminatorer i strengen. Standardadfærden er kun at matche linjeterminatorer i starten og slutningen af ​​strengudtrykket.
 
n 
 
. karakter matcher linjeterminatorer. Standard er for . matcher for at stoppe ved slutningen af ​​en linje.
 
u 
 
Unix-kun linjeafslutninger. Kun tegnet for ny linje genkendes som en linje, der slutter med . , ^ og $ match operatører.