In MySQL, il REGEXP_SUBSTR() funzione restituisce la sottostringa che corrisponde al modello di espressione regolare specificato.
Se non c'è corrispondenza (ovvero la stringa di input non contiene la sottostringa), il risultato è NULL .
Sintassi
La sintassi è questa:
REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, 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).
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_SUBSTR('Thailand or Cambodia', 'l.nd') Result; Risultato:
+--------+ | Result | +--------+ | land | +--------+
In questo caso c'è una corrispondenza e viene restituita la sottostringa.
Esempio 2 – Corrispondenze multiple
Per impostazione predefinita, se sono presenti più corrispondenze all'interno della stringa, viene restituita la prima (sebbene sia possibile specificare un'altra occorrenza se necessario. Ci arriveremo presto):
SELECT REGEXP_SUBSTR('Lend for land', 'l.nd') Result; Risultato:
+--------+ | Result | +--------+ | Lend | +--------+
Esempio 3 – Nessuna corrispondenza
Ecco un esempio in cui non c'è corrispondenza:
SELECT REGEXP_SUBSTR('Lend for land', '^C') Result; Risultato:
+--------+ | Result | +--------+ | NULL | +--------+
Non c'è corrispondenza, quindi il risultato è NULL .
Esempio 4 – Il pos Argomento
Ecco un esempio di specifica di una posizione iniziale:
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) Result; Risultato:
+--------+ | Result | +--------+ | Cut | +--------+
Abbiamo iniziato dalla posizione 2, che viene dopo l'inizio della prima occorrenza, quindi viene restituita l'occorrenza successiva.
Ecco un altro esempio:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1) 'Pos 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) 'Pos 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 6) 'Pos 6'; Risultato:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cut | Cot | +-------+-------+-------+
Esempio 5 – Il occurrence Argomento
Ecco un esempio di utilizzo di occurrence discussione. In tutti i casi, partiamo dalla posizione 1:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 1) 'Occurrence 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 2) 'Occurrence 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 3) 'Occurrence 3'; Risultato:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | Cat | Cut | Cot | +--------------+--------------+--------------+
Tuttavia, se partiamo da una posizione diversa, il risultato è diverso:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 1) 'Occurrence 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 2) 'Occurrence 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 3) 'Occurrence 3'; Risultato:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | Cut | Cot | NULL | +--------------+--------------+--------------+
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 NULL (cioè non c'era l'occorrenza 3).
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_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'c') 'Case-Sensitive',
REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'i') 'Case-Insensitive'; Risultato:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | NULL | Cat | +----------------+------------------+
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.
