Jak funguje funkce REGEXP_INSTR() v MySQL

V MySQL je to REGEXP_INSTR() funkce vrací počáteční index podřetězce, který odpovídá vzoru regulárního výrazu.

Index začíná na 1 . Pokud není shoda, výsledek je 0 .

Syntaxe

Syntaxe vypadá takto:

REGEXP_INSTR(výraz, pat[, pozice[, výskyt[, návratová_možnost[, typ_shody]]]])

Kde expr je vstupní řetězec a pat je vzor regulárního výrazu pro podřetězec.

Volitelný pos argument umožňuje zadat pozici v řetězci pro zahájení vyhledávání. Pokud je vynechán, začíná na pozici 1.

Volitelný occurrence argument umožňuje určit, který výskyt shody se má hledat. Pokud je vynechán, použije se první výskyt (výskyt 1).

Volitelný return_option argument umožňuje určit, jaký typ pozice se má vrátit. Pokud použijete 0 , vrátí pozici prvního znaku v odpovídajícím podřetězci. Pokud použijete 1 vrátí pozici prvního znaku následující odpovídající podřetězec. Pokud je vynechán, hodnota je 0 .

Volitelný match_type argument umožňuje upřesnit regulární výraz. Tento argument můžete například použít k určení shody rozlišující malá a velká písmena.

Příklad 1 – Základní použití

Zde je základní příklad:

SELECT REGEXP_INSTR('Kočka', 'v') Výsledek;

Výsledek:

+---------+| Výsledek |+--------+| 2 |+--------+

V tomto případě existuje shoda a podřetězec začíná na pozici 2.

Příklad 2 – Žádná shoda

Zde je příklad, kdy neexistuje žádná shoda:

SELECT REGEXP_INSTR('Cat', '^at') Výsledek;

Výsledek:

+---------+| Výsledek |+--------+| 0 |+--------+

Neexistuje žádná shoda, takže výsledek je 0 . Neexistuje žádná shoda, protože jsem zadal, že řetězec musí začínat podřetězcem.

Pojďme to změnit tak, aby to dělalo začněte tímto podřetězcem:

SELECT REGEXP_INSTR('at', '^at') Výsledek;

Výsledek:

+---------+| Výsledek |+--------+| 1 |+--------+

Příklad 3 – pos Argument

Zde je příklad zadání počáteční pozice:

SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Výsledek;

Výsledek:

+---------+| Výsledek |+--------+| 5 |+--------+

Dostaneme tedy index druhého výskytu.

Všimněte si, že index stále začíná počítat od pozice 1 bez ohledu na to, kde zadáte počáteční pozici.

Následující příklad to ukazuje jasněji:

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

Výsledek:

+-------+-------+-------+| Pozice 2 | Pozice 3 | Poz. 5 |+-------+-------+-------+| 5 | 5 | 5 |+-------+-------+-------+

Samozřejmě, v závislosti na vašem vzoru regulárních výrazů to může vrátit index úplně jiných podřetězců. Příklad:

SELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1) 'Poz. 1', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 2) 'Poz. 2 ', REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6';

Výsledek:

+-------+-------+-------+| Pozice 1 | Pozice 2 | Poz. 6 |+-------+-------+-------+| 1 | 5 | 16 |+-------+-------+-------+

Podřetězce můžeme zkontrolovat pomocí REGEXP_SUBSTR() funkce:

SELECT REGEXP_SUBSTR('Kočičí město je TAK roztomilé!', 'C.t', 1) 'Poz. 1', REGEXP_SUBSTR('Kočičí město je TAK roztomilé!', 'C.t', 2) 'Poz. 2 ', REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6';

Výsledek:

+-------+-------+-------+| Pozice 1 | Pozice 2 | Poz. 6 |+-------+-------+-------+| Kočka | Cit | Vyjmout |+-------+-------+-------+

Příklad 4 – occurrence Argument

Zde je příklad použití occurrence argument. Ve všech případech začínáme na pozici 1:

SELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 1) 'Výskyt 1', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 2 ) 'Výskyt 2', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 3) 'Výskyt 3';

Výsledek:

+--------------+--------------+--------------+| Výskyt 1 | Výskyt 2 | Výskyt 3 |+--------------+--------------+--------------+| 1 | 5 | 16 |+--------------+--------------+--------------+ 

 Pokud však začneme na jiné pozici, výsledek je jiný:
 
SELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 2, 1) 'Výskyt 1', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 2, 2 ) 'Výskyt 2', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 2, 3) 'Výskyt 3';
 

 Výsledek:
 
+--------------+--------------+--------------+| Výskyt 1 | Výskyt 2 | Výskyt 3 |+--------------+--------------+--------------+| 5 | 16 | 0 |+--------------+--------------+--------------+ 

 Stalo se to proto, že naše výchozí pozice přišla poté, co začala první událost. Výskyt 2 se tedy stal výskytem 1 a výskyt 3 se stal výskytem 2. A protože již nebyly žádné další výskyty, výsledek výskytu 3 byl negativní (tj. nedošlo k žádnému výskytu 3).
 
Příklad 5 – return_option Argument
 

 Zde je příklad použití return_option argument:
 
SELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 1, 0) 'Možnost 0', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1 , 1, 1) 'Možnost 1';
 

 Výsledek:
 
+----------+----------+| Možnost 0 | Možnost 1 |+----------+----------+| 1 | 4 |+----------+----------+
 

 Možnost 0 vrátila první znak odpovídajícího podřetězce. Možnost 1 vrátila pozici po odpovídajícím podřetězci.
 

 Když to použijeme na předchozí příklad, vypadá to takto:
 
SELECT REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Výskyt 1', REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1 , 2, 0) 'Výskyt 2', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 3, 0) 'Výskyt 3'UNION ALLSELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 1, 1), REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C.t', 1, 2, 1), REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'C .t', 1, 3, 1);
 

 Výsledek:
 
+--------------+--------------+--------------+| Výskyt 1 | Výskyt 2 | Výskyt 3 |+--------------+--------------+--------------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+--------------+--------------+ 

 V tomto případě jsme udělali jednu sadu pomocí možnosti 0 a další pomocí možnosti 1, pak jsme je spojili pomocí UNION ALL . 
 
Příklad 6 – match_type Argument
 

 Pro určení typu shody můžete zadat další argument. To vám umožňuje určit věci, jako je, zda se ve shodě rozlišují malá a velká písmena, zda mají či nemají obsahovat zakončovací znaky atd.
 

 Zde je příklad zadání shody rozlišující malá a velká písmena a nerozlišující malá a velká písmena:
 
SELECT REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'c.t', 1, 1, 0, 'c') 'Rozlišují se malá a velká písmena', REGEXP_INSTR('Kočičí město je TAK roztomilé!', 'c .t', 1, 1, 0, 'i') 'Nerozlišují se malá a velká písmena';
 

 Výsledek:
 
+----------------+------------------+| Rozlišovat malá a velká písmena | Nerozlišují se malá a velká písmena |+----------------+------------------+| 0 | 1 |+----------------+------------------+
 

 match_type argument může obsahovat následující znaky:
 
c 
 
Rozlišování velkých a malých písmen.
 
i 
 
Shoda nerozlišující malá a velká písmena.
 
m 
 
Režim více řádků. Rozpoznejte zakončení řádku v řetězci. Výchozí chování je přiřazovat zakončení řádků pouze na začátek a konec řetězcového výrazu.
 
n 
 
The . znak se shoduje se zakončením řádku. Výchozí hodnota je . párování se zastaví na konci řádku.
 
u 
 
Koncovky řádků pouze pro Unix. Pouze znak nového řádku je rozpoznán jako řádek končící znakem . , ^ a $ operátory shody.