In MySQL is de REGEXP_INSTR() functie retourneert de startindex van een subtekenreeks die overeenkomt met het patroon van de reguliere expressie.
De index begint bij 1 . Als er geen overeenkomst is, is het resultaat 0 .
Syntaxis
De syntaxis gaat als volgt:
REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])
Waar expr is de invoerreeks en pat is het reguliere expressiepatroon voor de subtekenreeks.
De optionele pos argument stelt u in staat om een positie in de tekenreeks op te geven om de zoekopdracht te starten. Indien weggelaten, begint het op positie 1.
Het optionele occurrence argument stelt u in staat om te specificeren naar welk exemplaar van de overeenkomst moet worden gezocht. Indien weggelaten, wordt de eerste instantie gebruikt (gebeurtenis 1).
De optionele return_option argument kunt u specificeren welk type positie moet worden geretourneerd. Als u 0 . gebruikt , retourneert het de positie van het eerste teken in de overeenkomende subtekenreeks. Als u 1 . gebruikt het geeft de positie terug van het eerste teken volgende de overeenkomende subtekenreeks. Indien weggelaten, is de waarde 0 .
Het optionele match_type argument kunt u de reguliere expressie verfijnen. U kunt dit argument bijvoorbeeld gebruiken om hoofdlettergevoelige overeenkomsten op te geven of niet.
Voorbeeld 1 – Basisgebruik
Hier is een eenvoudig voorbeeld:
SELECT REGEXP_INSTR('Cat', 'at') Result; Resultaat:
+--------+ | Result | +--------+ | 2 | +--------+
In dit geval is er een match en begint de substring op positie 2.
Voorbeeld 2 – Geen overeenkomst
Hier is een voorbeeld waarbij er geen overeenkomst is:
SELECT REGEXP_INSTR('Cat', '^at') Result; Resultaat:
+--------+ | Result | +--------+ | 0 | +--------+
Er is geen overeenkomst, dus het resultaat is 0 . Er is geen overeenkomst omdat ik heb opgegeven dat de tekenreeks moet beginnen met de subtekenreeks.
Laten we het veranderen zodat het doet begin met die substring:
SELECT REGEXP_INSTR('at', '^at') Result; Resultaat:
+--------+ | Result | +--------+ | 1 | +--------+
Voorbeeld 3 – De pos Argument
Hier is een voorbeeld van het specificeren van een startpositie:
SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Result; Resultaat:
+--------+ | Result | +--------+ | 5 | +--------+
We krijgen dus de index van het tweede voorkomen.
Merk op dat de index nog steeds begint te tellen vanaf positie 1, ongeacht waar u de startpositie opgeeft.
Het volgende voorbeeld toont dit duidelijker aan:
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'; Resultaat:
+-------+-------+-------+ | Pos 2 | Pos 3 | Pos 5 | +-------+-------+-------+ | 5 | 5 | 5 | +-------+-------+-------+
Afhankelijk van je regex-patroon kan dit natuurlijk de index van totaal verschillende substrings retourneren. Voorbeeld:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6'; Resultaat:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | 1 | 5 | 16 | +-------+-------+-------+
We kunnen de substrings controleren met de REGEXP_SUBSTR() functie:
SELECT
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6'; Resultaat:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cit | Cut | +-------+-------+-------+
Voorbeeld 4 – Het occurrence Argument
Hier is een voorbeeld van het gebruik van de occurrence argument. In alle gevallen beginnen we op positie 1:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3) 'Occurrence 3'; Resultaat:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | +--------------+--------------+--------------+
Als we echter op een andere positie beginnen, is het resultaat anders:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 1) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 2) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 3) 'Occurrence 3'; Resultaat:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 5 | 16 | 0 | +--------------+--------------+--------------+
Dit gebeurde omdat onze startpositie kwam nadat het eerste voorval was begonnen. Daarom werd voorval 2 voorval 1 en voorval 3 werd voorval 2. En omdat er geen voorvallen meer waren, was het resultaat van voorval 3 negatief (d.w.z. er was geen voorval 3).
Voorbeeld 5 – De return_option Argument
Hier is een voorbeeld van het gebruik van de return_option argument:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Option 0',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1) 'Option 1';
Resultaat:
+----------+----------+ | Option 0 | Option 1 | +----------+----------+ | 1 | 4 | +----------+----------+
Optie 0 retourneerde het eerste teken van de overeenkomende subtekenreeks. Optie 1 retourneerde de positie na de overeenkomende subtekenreeks.
Zo ziet het eruit als we het toepassen op het vorige voorbeeld:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 0) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 0) 'Occurrence 3'
UNION ALL
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1),
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 1),
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 1);
Resultaat:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | | 4 | 8 | 19 | +--------------+--------------+--------------+
In dit geval hebben we een set gemaakt met optie 0, en een andere met optie 1, en ze vervolgens samengevoegd met UNION ALL .
Voorbeeld 6 – Het match_type Argument
U kunt een extra argument opgeven om het zoektype te bepalen. Hiermee kunt u dingen specificeren zoals of de overeenkomst hoofdlettergevoelig is, of u lijnafsluitingen wilt opnemen, enz.
Hier is een voorbeeld van het specificeren van een hoofdlettergevoelige overeenkomst en een hoofdletterongevoelige overeenkomst:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive',
REGEXP_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'i') 'Case-Insensitive'; Resultaat:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | 0 | 1 | +----------------+------------------+
Het match_type argument kan de volgende tekens bevatten:
c- Hoofdlettergevoelige overeenkomst.
i- Hoofdletterongevoelige overeenkomst.
m- Modus met meerdere regels. Herken lijnafsluitingen binnen de string. Het standaardgedrag is om regelafsluitingen alleen aan het begin en einde van de tekenreeksuitdrukking te laten overeenkomen.
n- De
.karakter komt overeen met regelafsluitingen. De standaard is voor.overeenkomend om te stoppen aan het einde van een regel. u- Alleen Unix regeleindes. Alleen het teken van de nieuwe regel wordt herkend als een regel die eindigt met de
.,^, en$match operators.