W MySQL, REGEXP_INSTR() funkcja zwraca początkowy indeks podłańcucha, który pasuje do wzorca wyrażenia regularnego.
Indeks zaczyna się od 1 . Jeśli nie ma dopasowania, wynikiem jest 0 .
Składnia
Składnia wygląda tak:
REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])
Gdzie expr jest ciągiem wejściowym i pat jest wzorcem wyrażenia regularnego dla podłańcucha.
Opcjonalny pos argument pozwala określić pozycję w ciągu, aby rozpocząć wyszukiwanie. Jeśli zostanie pominięty, zaczyna się od pozycji 1.
Opcjonalne occurrence argument pozwala określić, które wystąpienie dopasowania ma zostać wyszukane. W przypadku pominięcia używane jest pierwsze wystąpienie (wystąpienie 1).
Opcjonalna return_option argument pozwala określić, jaki typ pozycji ma zostać zwrócony. Jeśli używasz 0 , zwróci pozycję pierwszego znaku w pasującym podciągu. Jeśli używasz 1 zwraca pozycję pierwszego znaku po pasujący podciąg. Jeśli zostanie pominięty, wartość to 0 .
Opcjonalny match_type argument umożliwia doprecyzowanie wyrażenia regularnego. Na przykład możesz użyć tego argumentu, aby określić dopasowanie z uwzględnieniem wielkości liter lub nie.
Przykład 1 – Podstawowe użycie
Oto podstawowy przykład:
SELECT REGEXP_INSTR('Cat', 'at') Result; Wynik:
+--------+ | Result | +--------+ | 2 | +--------+
W tym przypadku występuje dopasowanie, a podciąg zaczyna się na pozycji 2.
Przykład 2 – Brak dopasowania
Oto przykład, w którym nie ma dopasowania:
SELECT REGEXP_INSTR('Cat', '^at') Result; Wynik:
+--------+ | Result | +--------+ | 0 | +--------+
Brak dopasowania, więc wynik to 0 . Nie ma dopasowania, ponieważ określiłem, że ciąg musi zaczynać się od podciągu.
Zmieńmy to tak, aby działa zacznij od tego podciągu:
SELECT REGEXP_INSTR('at', '^at') Result; Wynik:
+--------+ | Result | +--------+ | 1 | +--------+
Przykład 3 – pos Argument
Oto przykład określenia pozycji początkowej:
SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Result; Wynik:
+--------+ | Result | +--------+ | 5 | +--------+
Otrzymujemy więc indeks drugiego wystąpienia.
Zauważ, że indeks nadal zaczyna liczyć od pozycji 1, niezależnie od tego, gdzie określisz pozycję początkową.
Poniższy przykład pokazuje to wyraźniej:
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'; Wynik:
+-------+-------+-------+ | Pos 2 | Pos 3 | Pos 5 | +-------+-------+-------+ | 5 | 5 | 5 | +-------+-------+-------+
Oczywiście, w zależności od wzorca wyrażenia regularnego, może to zwrócić indeks zupełnie różnych podciągów. Przykład:
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'; Wynik:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | 1 | 5 | 16 | +-------+-------+-------+
Możemy sprawdzić podciągi za pomocą REGEXP_SUBSTR() funkcja:
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'; Wynik:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cit | Cut | +-------+-------+-------+
Przykład 4 – occurrence Argument
Oto przykład użycia occurrence argument. We wszystkich przypadkach zaczynamy od pozycji 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'; Wynik:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | +--------------+--------------+--------------+
Jeśli jednak zaczniemy od innej pozycji, wynik będzie inny:
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'; Wynik:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 5 | 16 | 0 | +--------------+--------------+--------------+
Stało się tak, ponieważ nasza pozycja wyjściowa pojawiła się po rozpoczęciu pierwszego zdarzenia. Dlatego wystąpienie 2 stało się wystąpieniem 1, a wystąpienie 3 stało się wystąpieniem 2. A ponieważ nie było więcej wystąpień, wynik wystąpienia 3 był ujemny (tj. nie było wystąpienia 3).
Przykład 5 – return_option Argument
Oto przykład użycia 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';
Wynik:
+----------+----------+ | Option 0 | Option 1 | +----------+----------+ | 1 | 4 | +----------+----------+
Opcja 0 zwróciła pierwszy znak dopasowanego podciągu. Opcja 1 zwróciła pozycję po dopasowanym podciągu.
Oto, jak to wygląda, jeśli zastosujemy to do poprzedniego przykładu:
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);
Wynik:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | | 4 | 8 | 19 | +--------------+--------------+--------------+
W tym przypadku zrobiliśmy jeden zestaw za pomocą opcji 0, a drugi za pomocą opcji 1, a następnie połączyliśmy je razem za pomocą UNION ALL .
Przykład 6 – match_type Argument
Możesz podać dodatkowy argument, aby określić typ dopasowania. Pozwala to określić takie rzeczy, jak rozróżnianie wielkości liter w dopasowaniu, uwzględnienie terminatorów linii itp.
Oto przykład określenia dopasowania z rozróżnianiem wielkości liter i dopasowania bez rozróżniania wielkości liter:
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'; Wynik:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | 0 | 1 | +----------------+------------------+
match_type argument może zawierać następujące znaki:
c- Rozróżnianie wielkości liter.
i- Dopasowywanie bez rozróżniania wielkości liter.
m- Tryb wielowierszowy. Rozpoznaj terminatory wiersza w ciągu. Domyślnym zachowaniem jest dopasowywanie terminatorów linii tylko na początku i na końcu wyrażenia łańcuchowego.
n.znak pasuje do terminatorów linii. Wartość domyślna to.dopasowanie, aby zatrzymać się na końcu linii.u- Zakończenia linii tylko dla Uniksa. Tylko znak nowej linii jest rozpoznawany jako linia kończąca się
.,^i$operatory dopasowania.
