Funktionsweise der Funktion REGEXP_INSTR() in MySQL

In MySQL der REGEXP_INSTR() Die Funktion gibt den Anfangsindex einer Teilzeichenfolge zurück, die dem regulären Ausdrucksmuster entspricht.

Der Index beginnt bei 1 . Wenn es keine Übereinstimmung gibt, ist das Ergebnis 0 .

Syntax

Die Syntax lautet wie folgt:

REGEXP_INSTR(expr, pat[, pos[, Vorkommen[, return_option[, match_type]]]])

Wobei expr ist die Eingabezeichenfolge und pat ist das reguläre Ausdrucksmuster für die Teilzeichenfolge.

Die optionale pos Mit dem Argument können Sie eine Position innerhalb der Zeichenfolge angeben, an der die Suche gestartet werden soll. Wenn weggelassen, beginnt es an Position 1.

Das optionale occurrence Mit dem Argument können Sie angeben, nach welchem ​​Vorkommen der Übereinstimmung gesucht werden soll. Wenn weggelassen, wird das erste Vorkommen verwendet (Vorkommen 1).

Die optionale return_option Mit dem Argument können Sie angeben, welche Art von Position zurückgegeben werden soll. Wenn Sie 0 verwenden , gibt es die Position des ersten Zeichens in der übereinstimmenden Teilzeichenfolge zurück. Wenn Sie 1 verwenden es gibt die Position des ersten folgenden Zeichens zurück die passende Teilzeichenfolge. Wenn weggelassen, ist der Wert 0 .

Der optionale match_type Argument ermöglicht es Ihnen, den regulären Ausdruck zu verfeinern. Beispielsweise können Sie dieses Argument verwenden, um die Groß-/Kleinschreibung zu bestimmen oder nicht.

Beispiel 1 – Grundlegende Verwendung

Hier ist ein einfaches Beispiel:

SELECT REGEXP_INSTR('Cat', 'at') Ergebnis;

Ergebnis:

+--------+| Ergebnis |+--------+| 2 |+--------+

In diesem Fall gibt es eine Übereinstimmung und der Teilstring beginnt an Position 2.

Beispiel 2 – Keine Übereinstimmung

Hier ist ein Beispiel, bei dem es keine Übereinstimmung gibt:

SELECT REGEXP_INSTR('Cat', '^at') Ergebnis;

Ergebnis:

+--------+| Ergebnis |+--------+| 0 |+--------+

Es gibt keine Übereinstimmung, also ist das Ergebnis 0 . Es gibt keine Übereinstimmung, weil ich angegeben habe, dass die Zeichenfolge mit der Teilzeichenfolge beginnen muss.

Ändern wir es so, dass es passt Beginnen Sie mit diesem Teilstring:

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

Ergebnis:

+--------+| Ergebnis |+--------+| 1 |+--------+

Beispiel 3 – Die pos Argument

Hier ist ein Beispiel für die Angabe einer Startposition:

SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Ergebnis;

Ergebnis:

+--------+| Ergebnis |+--------+| 5 |+--------+

So erhalten wir den Index des zweiten Vorkommens.

Beachten Sie, dass der Index immer noch ab Position 1 zu zählen beginnt, unabhängig davon, wo Sie die Startposition angeben.

Das folgende Beispiel demonstriert dies deutlicher:

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

Ergebnis:

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

Abhängig von Ihrem Regex-Muster kann dies natürlich den Index von völlig anderen Teilstrings zurückgeben. Beispiel:

SELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 6) 'Pos 6';

Ergebnis:

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

Wir können die Teilstrings mit dem REGEXP_SUBSTR() prüfen Funktion:

SELECT REGEXP_SUBSTR('Cat City ist SO süß!', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Cat City ist SO süß!', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Cat City ist SO süß!', 'C.t', 6) 'Pos 6';

Ergebnis:

+-------+-------+-------+| Pos. 1 | Pos. 2 | Pos 6 |+-------+-------+-------+| Katze | Zit. | Ausschneiden |+-------+-------+-------+

Beispiel 4 – Das occurrence Argument

Hier ist ein Beispiel für die Verwendung von occurrence Streit. In allen Fällen beginnen wir bei Position 1:

SELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 1) 'Vorkommen 1', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 2 ) 'Vorkommen 2', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 3) 'Vorkommen 3';

Ergebnis:

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

 Wenn wir jedoch an einer anderen Position beginnen, ist das Ergebnis anders:
 
SELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 2, 1) 'Vorkommen 1', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 2, 2 ) 'Vorkommen 2', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 2, 3) 'Vorkommen 3';
 

 Ergebnis:
 
+--------------+-------------+-------------+| Vorkommen 1 | Vorkommen 2 | Vorkommen 3 |+--------------+-------------+--------------+| 5 | 16 | 0 |+-------------+------------+-------------+ 

 Dies geschah, weil unsere Startposition kam, nachdem das erste Ereignis begonnen hatte. Daher wurde Vorkommnis 2 zu Vorkommnis 1 und Vorkommnis 3 zu Vorkommnis 2. Und da es keine Vorkommnisse mehr gab, war das Ergebnis von Vorkommnis 3 negativ (d. h. es gab kein Vorkommnis 3).
 
Beispiel 5 – Die return_option Argument
 

 Hier ist ein Beispiel für die Verwendung der return_option Argument:
 
SELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 1, 0) 'Option 0', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1 , 1, 1) 'Option 1';
 

 Ergebnis:
 
+----------+----------+| Möglichkeit 0 | Möglichkeit 1 |+----------+----------+| 1 | 4 |+----------+----------+
 

 Option 0 gab das erste Zeichen der übereinstimmenden Teilzeichenfolge zurück. Option 1 gab die Position nach der übereinstimmenden Teilzeichenfolge zurück.
 

 So sieht es aus, wenn wir es auf das vorherige Beispiel anwenden:
 
SELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 1, 0) 'Vorkommen 1', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1 , 2, 0) 'Vorkommen 2', REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 3, 0) 'Vorkommen 3'UNION ALLSELECT REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 1, 1), REGEXP_INSTR('Cat City ist SO süß!', 'C.t', 1, 2, 1), REGEXP_INSTR('Cat City ist SO süß!', 'C .t', 1, 3, 1);
 

 Ergebnis:
 
+--------------+-------------+-------------+| Vorkommen 1 | Vorkommen 2 | Vorkommen 3 |+--------------+-------------+--------------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+-------------+-------------+ 

 In diesem Fall haben wir einen Satz mit Option 0 und einen anderen mit Option 1 erstellt und sie dann mit UNION ALL zusammengefügt . 
 
Beispiel 6 – Der match_type Argument
 

 Sie können ein zusätzliches Argument angeben, um den Übereinstimmungstyp zu bestimmen. Auf diese Weise können Sie beispielsweise angeben, ob bei der Übereinstimmung zwischen Groß- und Kleinschreibung unterschieden wird, ob Zeilenabschlüsse eingefügt werden sollen usw.
 

 Hier ist ein Beispiel für die Angabe einer Übereinstimmung mit Berücksichtigung der Groß- und Kleinschreibung und einer Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung:
 
SELECT REGEXP_INSTR('Cat City ist SO süß!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive', REGEXP_INSTR('Cat City ist SO süß!', 'c .t', 1, 1, 0, 'i') 'Groß-/Kleinschreibung';
 

 Ergebnis:
 
+----------------+------------------+| Groß-/Kleinschreibung beachten | Groß-/Kleinschreibung wird nicht beachtet |+----------------+-------------------------------+| 0 | 1 |+----------------+------------------+
 

 Der match_type Das Argument kann die folgenden Zeichen enthalten:
 
c 
 
Groß-/Kleinschreibung beachten.
 
i 
 
Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung.
 
m 
 
Mehrzeiliger Modus. Zeilenabschlusszeichen innerhalb der Zeichenfolge erkennen. Das Standardverhalten besteht darin, Zeilenabschlusszeichen nur am Anfang und am Ende des Zeichenfolgenausdrucks abzugleichen.
 
n 
 
Der . Zeichen stimmt mit Zeilenabschlusszeichen überein. Der Standardwert ist . Anpassung, um am Ende einer Zeile zu stoppen.
 
u 
 
Nur Unix-Zeilenenden. Nur das Newline-Zeichen wird durch den . als Zeilenende erkannt , ^ , und $ Übereinstimmungsoperatoren.