Hur REGEXP_INSTR()-funktionen fungerar i MySQL

I MySQL, REGEXP_INSTR() funktion returnerar startindexet för en delsträng som matchar det reguljära uttrycksmönstret.

Indexet börjar vid 1 . Om det inte finns någon matchning är resultatet 0 .

Syntax

Syntaxen ser ut så här:

REGEXP_INSTR(expr, pat[, pos[, förekomst[, returalternativ[, matchningstyp]]]])

Där expr är inmatningssträngen och pat är det reguljära uttrycksmönstret för delsträngen.

Den valfria pos argument låter dig ange en position inom strängen för att starta sökningen. Om den utelämnas börjar den vid position 1.

Den valfria förekomsten argument låter dig ange vilken förekomst av matchningen du ska söka efter. Om den utelämnas används den första förekomsten (förekomst 1).

Den valfria return_option argument låter dig specificera vilken typ av position som ska returneras. Om du använder 0 , kommer det att returnera positionen för det första tecknet i den matchande delsträngen. Om du använder 1 den returnerar positionen för det första tecknet som följer den matchande delsträngen. Om det utelämnas är värdet 0 .

Den valfria match_type argument låter dig förfina det reguljära uttrycket. Du kan till exempel använda detta argument för att ange skiftlägeskänslig matchning eller inte.

Exempel 1 – Grundläggande användning

Här är ett grundläggande exempel:

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

Resultat:

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

I det här fallet finns det en matchning och delsträngen börjar vid position 2.

Exempel 2 – Ingen matchning

Här är ett exempel där det inte finns någon matchning:

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

Resultat:

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

Det finns ingen matchning, så resultatet är 0 . Det finns ingen matchning eftersom jag angav att strängen måste börja med understrängen.

Låt oss ändra det så att det gör det börja med den delsträngen:

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

Resultat:

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

Exempel 3 – pos Argument

Här är ett exempel på hur du anger en startposition:

SELECT REGEXP_INSTR('Kattkatt', 'Katt', 2) Resultat;

Resultat:

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

Så vi får indexet för den andra förekomsten.

Observera att indexet fortfarande börjar räknas från position 1 oavsett var du anger startpositionen.

Följande exempel visar detta tydligare:

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

Resultat:

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

Naturligtvis, beroende på ditt regexmönster, kan detta returnera indexet för helt olika delsträngar. Exempel:

SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 6) 'Pos 6';

Resultat:

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

Vi kan kontrollera delsträngarna med REGEXP_SUBSTR() funktion:

SELECT REGEXP_SUBSTR('Cat City är SÅ söt!', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat City är SÅ söt!', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Cat City är SÅ söt!', 'C.t', 6) 'Pos 6';

Resultat:

+-------+-------+-------+| Pos 1 | Pos 2 | Pos 6 |+-------+-------+-------+| Katt | Cit | Klipp |+-------+-------+-------+

Exempel 4 – förekomsten Argument

Här är ett exempel på hur du använder förekomst argument. I alla fall börjar vi på position 1:

SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 1) 'Förekomst 1', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 2 ) 'Förekomst 2', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 3) 'Förekomst 3';

Resultat:

+--------------+-------------+--------------+| Förekomst 1 | Förekomst 2 | Förekomst 3 |+---------------+----------+-------+| 1 | 5 | 16 |+--------------+-------------+--------------+ 

 Men om vi börjar på en annan position blir resultatet ett annat:
 
SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 2, 1) 'Förekomst 1', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 2, 2 ) 'Förekomst 2', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 2, 3) 'Förekomst 3';
 

 Resultat:
 
+--------------+-------------+--------------+| Förekomst 1 | Förekomst 2 | Förekomst 3 |+---------------+----------+-------+| 5 | 16 | 0 |+--------------+--------------+--------------+ 

 Detta hände för att vårt startläge kom efter att den första händelsen hade startat. Därför blev förekomst 2 till förekomst 1 och förekomst 3 blev till förekomst 2. Och eftersom det inte fanns fler förekomster blev resultatet av förekomst 3 negativt (dvs. det fanns ingen förekomst 3).
 
Exempel 5 – return_option Argument
 

 Här är ett exempel på hur du använder return_option argument:
 
SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 1, 0) 'Alternativ 0', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1 , 1, 1) 'Alternativ 1';
 

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

 Alternativ 0 returnerade den matchade delsträngens första tecken. Alternativ 1 returnerade positionen efter den matchade delsträngen.
 

 Så här ser det ut om vi tillämpar det på föregående exempel:
 
SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 1, 0) 'Förekomst 1', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1 , 2, 0) 'Förekomst 2', REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 3, 0) 'Förekomst 3'UNION ALLSELECT REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 1, 1), REGEXP_INSTR('Cat City är SÅ söt!', 'C.t', 1, 2, 1), REGEXP_INSTR('Cat City är SÅ söt!', 'C .t', 1, 3, 1);
 

 Resultat:
 
+--------------+-------------+--------------+| Förekomst 1 | Förekomst 2 | Förekomst 3 |+---------------+----------+-------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+-------------+--------------+ 

 I det här fallet gjorde vi en uppsättning med alternativ 0 och en annan med alternativ 1, och slog sedan ihop dem med UNION ALL . 
 
Exempel 6 – match_type Argument
 

 Du kan ange ytterligare ett argument för att bestämma matchningstypen. Detta låter dig specificera saker som om matchningen är skiftlägeskänslig eller inte, om linjeavslutare ska inkluderas eller inte, etc.
 

 Här är ett exempel på hur du anger en skiftlägeskänslig matchning och en skiftlägesokänslig matchning:
 
SELECT REGEXP_INSTR('Cat City är SÅ söt!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive', REGEXP_INSTR('Cat City är SÅ söt!', 'c .t', 1, 1, 0, 'i') 'skiftlägeokänslig';
 

 Resultat:
 
+----------------+------------------------+| Skiftlägeskänslig | Skiftlägeskänslig |+----------------+------------------------+| 0 | 1 |+----------------+------------------------+
 

 match_type argument kan innehålla följande tecken:
 
c 
 
Skaftkänslig matchning.
 
i 
 
Verkskiftsokänslig matchning.
 
m 
 
Flerradsläge. Känn igen linjeavslutare i strängen. Standardbeteendet är att matcha linjeavslutare endast i början och slutet av stränguttrycket.
 
n 
 
. tecken matchar radavslutare. Standard är för . matchar för att stanna i slutet av en rad.
 
u 
 
Enbart Unix-radändelser. Endast nyradstecknet känns igen som en rad som slutar med . , ^ och $ matcha operatorer.