Esempi di MySQL REGEXP

In MySQL, il REGEXP viene utilizzato per determinare se una stringa corrisponde o meno a un'espressione regolare. È sinonimo di REGEXP_LIKE() .

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.

Esempio 1 – Espressione regolare di base

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 |
+------+-------+--------+--------+

Esempio 2 – 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 |
+------+-------+--------+

Esempio 3 – 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 |
+------+-------+--------+

Esempio 4: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.

Esempio 5 – 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.

Esempio 6 – 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.

Esempio 7 – 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 |
+------+-------+--------+-----+------+-------+-------+

Esempio 8 – 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.

Esempio 9 – Abbina 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 |
+--------+------+------+-----+

Esempio 10 – 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 |
+--------+-------+

Esempio 11 – 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:

+--------+-------+
| Tweeet | Tweet |
+--------+-------+
|      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 |
+-----+-----+-----+

Esempio 12 – Non all'interno di 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 |
+-----+-----+-----+

Quindi otteniamo il risultato opposto all'esempio precedente.