In MariaDB, il REGEXP viene utilizzato per determinare se una stringa corrisponde o meno a un'espressione regolare.
Se la stringa corrisponde all'espressione regolare fornita, il risultato è 1 , altrimenti è 0 .
Sintassi
La sintassi è questa:
expr REGEXP pat
Dove expr è la stringa di input e pat è l'espressione regolare per la quale stai testando la stringa.
Esempi
Di seguito sono riportati esempi di utilizzo di REGEXP operatore con pattern diversi.
Espressione regolare di base
Cominciamo con l'esempio più semplice. L'espressione regolare più semplice che possiamo usare è quella che non contiene caratteri speciali. Qui, usiamo solo una stringa. Se una qualsiasi parte della stringa di input corrisponde a quella stringa, restituisce una corrispondenza.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Risultato:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Abbina l'inizio di una stringa
In questo esempio, l'espressione regolare specifica che la stringa deve iniziare con Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Risultato:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Abbina la fine di una stringa
In questo esempio, l'espressione regolare specifica che la stringa deve terminare con rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Risultato:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Abbina qualsiasi personaggio
Il . il carattere corrisponde a qualsiasi carattere.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Risultato:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Questo carattere viene in genere utilizzato insieme ad altri caratteri per specificare ulteriori criteri. Ad esempio:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Risultato:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Qui specifichiamo che la stringa deve iniziare con C , che deve essere seguito da un carattere (qualsiasi carattere) e che deve terminare con rn .
Si noti che questo carattere specifica una singola istanza del carattere. Se vuoi specificare più istanze (ad esempio ee invece di solo e ), dovrai aggiungere altro . caratteri.
SELECT
'Tweet' REGEXP '^Tw..t$' AS "Tweet",
'Tweat' REGEXP '^Tw..t$' AS "Tweat",
'Tweet' REGEXP '^Tw.t$' AS "Tweet",
'Twit' REGEXP '^Tw..t$' AS "Twit";Risultato:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Un altro modo per farlo è specificare il numero di occorrenze tra parentesi graffe:
SELECT
'Tweet' REGEXP '^Tw.{2}t$' AS "Tweet",
'Tweat' REGEXP '^Tw.{2}t$' AS "Tweat",
'Tweet' REGEXP '^Tw.{1}t$' AS "Tweet",
'Twit' REGEXP '^Tw.{2}t$' AS "Twit";Risultato:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Tuttavia, se conosci il carattere che stai cercando, puoi specificare quel carattere (invece del . carattere), come illustrato nell'esempio seguente.
Abbina zero o più istanze di un personaggio specifico
Possiamo fare quanto segue per specificare zero o più istanze di e carattere:
SELECT
'Twet' REGEXP '^Twe*t$' AS "Twet",
'Tweet' REGEXP '^Twe*t$' AS "Tweet",
'Tweeet' REGEXP '^Twe*t$' AS "Tweeet",
'Twt' REGEXP '^Twe*t$' AS "Twt",
'Twit' REGEXP '^Twe*t$' AS "Twit",
'Twiet' REGEXP '^Twe*t$' AS "Twiet",
'Tweit' REGEXP '^Twe*t$' AS "Tweit";Risultato:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Le prime quattro combaciano ma le ultime tre no.
Abbina una o più istanze di un personaggio specifico
Possiamo modificare l'esempio precedente in modo da ottenere una corrispondenza solo se uno o più caratteri sono stati trovati (l'esempio precedente ha restituito una corrispondenza se zero o più sono stati trovati). Per fare ciò, utilizziamo semplicemente + invece di * :
SELECT
'Twet' REGEXP '^Twe+t$' AS "Twet",
'Tweet' REGEXP '^Twe+t$' AS "Tweet",
'Tweeet' REGEXP '^Twe+t$' AS "Tweeet",
'Twt' REGEXP '^Twe+t$' AS "Twt",
'Twit' REGEXP '^Twe+t$' AS "Twit",
'Twiet' REGEXP '^Twe+t$' AS "Twiet",
'Tweit' REGEXP '^Twe+t$' AS "Tweit";Risultato:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
In questo caso, la quarta parola restituisce un risultato diverso rispetto all'esempio precedente.
Abbina zero o un'istanza di un personaggio specifico
Possiamo modificare l'esempio precedente in modo da ottenere una corrispondenza solo su zero o su uno dei caratteri desiderati. Per fare ciò, utilizziamo ? :
SELECT
'Twet' REGEXP '^Twe?t$' AS "Twet",
'Tweet' REGEXP '^Twe?t$' AS "Tweet",
'Tweeet' REGEXP '^Twe?t$' AS "Tweeet",
'Twt' REGEXP '^Twe?t$' AS "Twt",
'Twit' REGEXP '^Twe?t$' AS "Twit",
'Twiet' REGEXP '^Twe?t$' AS "Twiet",
'Tweit' REGEXP '^Twe?t$' AS "Tweit";Risultato:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Alternanza
Puoi usare il | carattere per abbinare l'una o l'altra sequenza di caratteri:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Risultato:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Ecco un altro esempio in cui cerco parole intere:
SELECT
'Cat' REGEXP 'Cat|Dog' AS "Cat",
'Dog' REGEXP 'Cat|Dog' AS "Dog",
'Doggone' REGEXP 'Cat|Dog' AS "Doggone",
'Banana' REGEXP 'Cat|Dog' AS "Banana";Risultato:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Otteniamo comunque una corrispondenza anche quando la nostra espressione regolare corrisponde solo a una parte della stringa.
Corrisponde a zero o più istanze di una sequenza
Puoi usare le parentesi insieme all'asterisco ()* per specificare zero o più istanze di una sequenza:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Risultato:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Un altro esempio:
SELECT
'Banana' REGEXP '^B(an)*d$' AS "Banana",
'Band' REGEXP '^B(an)*d$' AS "Band",
'Bald' REGEXP '^B(an)*d$' AS "Bald",
'Bad' REGEXP '^B(an)*d$' AS "Bad";Risultato:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Ripetizione
Come visto in un esempio precedente, puoi usare le parentesi graffe per specificare la ripetizione. Questa notazione fornisce un modo più generale di scrivere espressioni regolari rispetto ad alcuni degli esempi precedenti:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Risultato:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Intervallo
È possibile utilizzare il trattino per specificare un intervallo. Ecco un esempio che specifica un intervallo di numeri:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Risultato:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
E l'esempio seguente specifica un intervallo di lettere:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Risultato:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Ecco cosa succede se limitiamo l'intervallo di numeri:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Risultato:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Non entro un intervallo
Possiamo usare il ^ carattere per modificare l'esempio precedente in modo da escludere l'intervallo di caratteri specificato:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Risultato:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
In questo caso otteniamo il risultato opposto all'esempio precedente.
Valori Nulli
Se l'espressione o il modello sono null , il risultato è null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Risultato:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+
