In MySQL, il REGEXP_INSTR() La funzione restituisce l'indice iniziale di una sottostringa che corrisponde al modello di espressione regolare.
L'indice inizia da 1 . Se non c'è corrispondenza, il risultato è 0 .
Sintassi
La sintassi è questa:
REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])
Dove expr è la stringa di input e pat è il modello di espressione regolare per la sottostringa.
Il pos facoltativo argomento consente di specificare una posizione all'interno della stringa per avviare la ricerca. Se omesso, inizia dalla posizione 1.
Il occurrence facoltativo argomento consente di specificare quale occorrenza della corrispondenza cercare. Se omessa, viene utilizzata la prima occorrenza (occorrenza 1).
L'opzione return_option argomento consente di specificare quale tipo di posizione restituire. Se usi 0 , restituirà la posizione del primo carattere nella sottostringa corrispondente. Se usi 1 restituisce la posizione del primo carattere seguente la sottostringa corrispondente. Se omesso, il valore è 0 .
Il match_type facoltativo argomento consente di perfezionare l'espressione regolare. Ad esempio, puoi utilizzare questo argomento per specificare o meno la corrispondenza con distinzione tra maiuscole e minuscole.
Esempio 1 – Utilizzo di base
Ecco un esempio di base:
SELECT REGEXP_INSTR('Cat', 'at') Result; Risultato:
+--------+ | Result | +--------+ | 2 | +--------+
In questo caso c'è una corrispondenza e la sottostringa inizia dalla posizione 2.
Esempio 2 – Nessuna corrispondenza
Ecco un esempio in cui non c'è corrispondenza:
SELECT REGEXP_INSTR('Cat', '^at') Result; Risultato:
+--------+ | Result | +--------+ | 0 | +--------+
Non c'è corrispondenza, quindi il risultato è 0 . Non c'è corrispondenza perché ho specificato che la stringa deve iniziare con la sottostringa.
Cambiamolo in modo che lo faccia inizia con quella sottostringa:
SELECT REGEXP_INSTR('at', '^at') Result; Risultato:
+--------+ | Result | +--------+ | 1 | +--------+
Esempio 3 – Il pos Argomento
Ecco un esempio di specifica di una posizione iniziale:
SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Result; Risultato:
+--------+ | Result | +--------+ | 5 | +--------+
Quindi otteniamo l'indice della seconda occorrenza.
Si noti che l'indice continua a contare dalla posizione 1 indipendentemente da dove si specifica la posizione iniziale.
L'esempio seguente lo dimostra più chiaramente:
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'; Risultato:
+-------+-------+-------+ | Pos 2 | Pos 3 | Pos 5 | +-------+-------+-------+ | 5 | 5 | 5 | +-------+-------+-------+
Naturalmente, a seconda del modello di espressione regolare, questo può restituire l'indice di sottostringhe completamente diverse. Esempio:
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'; Risultato:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | 1 | 5 | 16 | +-------+-------+-------+
Possiamo controllare le sottostringhe con REGEXP_SUBSTR() funzione:
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'; Risultato:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cit | Cut | +-------+-------+-------+
Esempio 4 – Il occurrence Argomento
Ecco un esempio di utilizzo di occurrence discussione. In tutti i casi, partiamo dalla posizione 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'; Risultato:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | +--------------+--------------+--------------+
Tuttavia, se partiamo da una posizione diversa, il risultato è diverso:
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'; Risultato:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 5 | 16 | 0 | +--------------+--------------+--------------+
Questo è successo perché la nostra posizione di partenza è arrivata dopo che era iniziata la prima occorrenza. Pertanto, l'occorrenza 2 è diventata l'occorrenza 1 e l'occorrenza 3 è diventata l'occorrenza 2. E poiché non c'erano più occorrenze, il risultato dell'occorrenza 3 era negativo (cioè non c'era l'occorrenza 3).
Esempio 5 – Il return_option Argomento
Ecco un esempio di utilizzo di return_option argomento:
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';
Risultato:
+----------+----------+ | Option 0 | Option 1 | +----------+----------+ | 1 | 4 | +----------+----------+
L'opzione 0 ha restituito il primo carattere della sottostringa corrispondente. L'opzione 1 ha restituito la posizione dopo la sottostringa corrispondente.
Ecco come appare se lo applichiamo all'esempio precedente:
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);
Risultato:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | | 4 | 8 | 19 | +--------------+--------------+--------------+
In questo caso abbiamo fatto un set usando l'opzione 0 e un altro usando l'opzione 1, quindi li abbiamo uniti insieme usando UNION ALL .
Esempio 6 – Il match_type Argomento
È possibile fornire un argomento aggiuntivo per determinare il tipo di corrispondenza. Ciò ti consente di specificare cose come se la corrispondenza fa distinzione tra maiuscole e minuscole, se includere o meno i terminatori di riga, ecc.
Ecco un esempio di specifica di una corrispondenza con distinzione tra maiuscole e minuscole e una corrispondenza senza distinzione tra maiuscole e minuscole:
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'; Risultato:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | 0 | 1 | +----------------+------------------+
Il match_type argomento può contenere i seguenti caratteri:
c- Corrispondenza con distinzione tra maiuscole e minuscole.
i- Corrispondenza senza distinzione tra maiuscole e minuscole.
m- Modalità a più righe. Riconosci i terminatori di riga all'interno della stringa. Il comportamento predefinito prevede la corrispondenza dei terminatori di riga solo all'inizio e alla fine dell'espressione stringa.
n- Il
.il carattere corrisponde ai terminatori di riga. L'impostazione predefinita è.corrispondenza per fermarsi alla fine di una riga. u- Finiture di riga solo Unix. Solo il carattere di nuova riga viene riconosciuto come riga che termina con il
.,^e$operatori di corrispondenza.
