MySQL fornisce il pattern matching SQL standard e una forma di pattern matching basata su espressioni regolari estese simili a quelle usate dalle utility Unix come vi, grep e sed.

Il pattern matching SQL permette di usare _ per far corrispondere qualsiasi singolo carattere e % per far corrispondere un numero arbitrario di caratteri (inclusi i caratteri zero). In MySQL, i pattern SQL sono case-insensitive per impostazione predefinita. Alcuni esempi sono mostrati qui. Non usate = o <> quando usate i pattern SQL. Usate invece gli operatori di confronto LIKE o NOT LIKE.

Per trovare nomi che iniziano con b:

mysql> SELECT * FROM pet WHERE name LIKE 'b%';+--------+--------+---------+------+------------+------------+| name | owner | species | sex | birth | death |+--------+--------+---------+------+------------+------------+| Buffy | Harold | dog | f | 1989-05-13 | NULL || Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 |+--------+--------+---------+------+------------+------------+

Per trovare nomi che finiscono con fy:

mysql> SELECT * FROM pet WHERE name LIKE '%fy';+--------+--------+---------+------+------------+-------+| name | owner | species | sex | birth | death |+--------+--------+---------+------+------------+-------+| Fluffy | Harold | cat | f | 1993-02-04 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL |+--------+--------+---------+------+------------+-------+

Per trovare nomi contenenti un w:

mysql> SELECT * FROM pet WHERE name LIKE '%w%';+----------+-------+---------+------+------------+------------+| name | owner | species | sex | birth | death |+----------+-------+---------+------+------------+------------+| Claws | Gwen | cat | m | 1994-03-17 | NULL || Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 || Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |+----------+-------+---------+------+------------+------------+

Per trovare nomi contenenti esattamente cinque caratteri, usa cinque istanze del carattere pattern _:

mysql> SELECT * FROM pet WHERE name LIKE '_____';+-------+--------+---------+------+------------+-------+| name | owner | species | sex | birth | death |+-------+--------+---------+------+------------+-------+| Claws | Gwen | cat | m | 1994-03-17 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL |+-------+--------+---------+------+------------+-------+

L’altro tipo di pattern matching fornito da MySQL usa espressioni regolari estese. Quando cercate una corrispondenza per questo tipo di pattern, usate la funzione REGEXP_LIKE() (o gli operatori REGEXP o RLIKE, che sono sinonimi di REGEXP_LIKE()).

La seguente lista descrive alcune caratteristiche delle espressioni regolari estese:

Per dimostrare come funzionano le espressioni regolari estese, le query LIKE mostrate precedentemente sono riscritte qui per usare REGEXP_LIKE().

Per trovare i nomi che iniziano con b, usate ^ per trovare l’inizio del nome:

mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b');+--------+--------+---------+------+------------+------------+| name | owner | species | sex | birth | death |+--------+--------+---------+------+------------+------------+| Buffy | Harold | dog | f | 1989-05-13 | NULL || Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 |+--------+--------+---------+------+------------+------------+

Per forzare il confronto di un’espressione regolare ad essere sensibile alle maiuscole e alle minuscole, usate un ordinamento sensibile alle maiuscole, o usate la parola chiave BINARY per rendere una delle stringhe una stringa binaria, o specificate il carattere c match-control. Ognuna di queste query corrisponde solo alle minuscole b all’inizio di un nome:

SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b' COLLATE utf8mb4_0900_as_cs);SELECT * FROM pet WHERE REGEXP_LIKE(name, BINARY '^b');SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b', 'c');

Per trovare nomi che finiscono con fy, usate $ per trovare la fine del nome:

mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'fy$');+--------+--------+---------+------+------------+-------+| name | owner | species | sex | birth | death |+--------+--------+---------+------+------------+-------+| Fluffy | Harold | cat | f | 1993-02-04 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL |+--------+--------+---------+------+------------+-------+

Per trovare nomi contenenti un w, usa questa query:

mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'w');+----------+-------+---------+------+------------+------------+| name | owner | species | sex | birth | death |+----------+-------+---------+------+------------+------------+| Claws | Gwen | cat | m | 1994-03-17 | NULL || Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 || Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |+----------+-------+---------+------+------------+------------+

Poiché un pattern di espressione regolare corrisponde se si presenta ovunque nel valore, non è necessario nella query precedente mettere un carattere jolly su entrambi i lati del pattern per farlo corrispondere all’intero valore, come sarebbe vero con un pattern SQL.

Per trovare nomi che contengono esattamente cinque caratteri, usate ^ e $ per trovare l’inizio e la fine del nome, e cinque istanze di . nel mezzo:

mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.....$');+-------+--------+---------+------+------------+-------+| name | owner | species | sex | birth | death |+-------+--------+---------+------+------------+-------+| Claws | Gwen | cat | m | 1994-03-17 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL |+-------+--------+---------+------+------------+-------+

Si potrebbe anche scrivere la query precedente usando l’operatore {n} (“repeat-n-times”):

mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.{5}$');+-------+--------+---------+------+------------+-------+| name | owner | species | sex | birth | death |+-------+--------+---------+------+------------+-------+| Claws | Gwen | cat | m | 1994-03-17 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL |+-------+--------+---------+------+------------+-------+

Per maggiori informazioni sulla sintassi delle espressioni regolari, vedi Sezione 12.8.2, “Espressioni regolari”.