MySQL posee capacidades estándar para utilizar patrones así
como también una forma de patrones basada en expresiones
regulares extendidas similares a las que se encuentran en
utilidades de UNIX, como ser vi
,
grep
, y sed
.
Los patrones SQL permiten emplear el caracter
'_
' para representar coincidencia con un
carácter individual y '%
' En MySQL, por
defecto, los patrones SQL no son case-sensitive. Abajo se
muestran algunos ejemplos. Advierta que no se emplean los
operadores =
o <>
para trabajar con patrones SQL, en lugar de eso se usan los
operadores de comparación LIKE
o
NOT LIKE
.
Para encontrar nombres que comiencen 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 | +--------+--------+---------+------+------------+------------+
Para encontrar nombres que terminen 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 | +--------+--------+---------+------+------------+-------+
Para encontrar nombres que contengan '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 | +----------+-------+---------+------+------------+------------+
Para encontrar nombres que contengan exactamente 5 caracteres,
use 5 veces el caracter patrón '_
':
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 | +-------+--------+---------+------+------------+-------+
Los otros patrones que pueden emplearse con MySQL usan
expresiones regulares extendidas. Cuando busque coincidencias
con este tipo de patrones, use los operadores
REGEXP
y NOT REGEXP
(o
bien los sinónimos RLIKE
y NOT
RLIKE
).
Algunas características de las expresiones regulares extendidas:
'.
' detecta coincidencia con cualquier
carácter individual.
Una clase de carácter '[...]
' detecta
coincidencia con cualquier caracter entre los corchetes.
Por ejemplo, '[abc]
' coincidirá con
'a
', 'b
', o
'c
'. Para hacer referencia a un rango
de caracteres, use un guión. '[a-z]
'
detecta coincidencia con cualquier letra, mientras que
'[0-9]
' lo hace con cualquier dígito.
'*
' detecta coincidencia con cero o
más apariciones de los caracteres que lo preceden. Por
ejemplo, 'x*
' detecta cualquier número
de caracteres 'x
',
'[0-9]*
' detecta cualquier cantidad de
dígitos, y '.*
' coincidirá con
cualquier número de cualquier carácter.
REGEXP
tendrá éxito si el patrón
suministrado encuentra coincidencia en cualquier parte del
valor examinado (esto difiere de LIKE
en que este último solo tiene éxito si el patrón
concuerda con todo el valor).
Para lograr que un patrón detecte coincidencias solamente
al principio o al final del valor examinado, utilice
'^
' al principio o
'$
' al final del patrón.
Para demostrar el funcionamiento de las expresiones regulares
extendidas, las consultas con LIKE
expuestas anteriormente se han reescrito utilizando
REGEXP
.
Para hallar nombres que comiencen con 'b
',
use '^
' para buscar coincidencia al
principio del valor:
mysql> SELECT * FROM pet WHERE name REGEXP '^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 | +--------+--------+---------+------+------------+------------+
En MySQL 5.0, si realmente quiere forzar a que la comparación
realizada por REGEXP
sea case sensitive,
utilice la palabra clave BINARY
para
convertir a una de las cadenas en una cadena binaria. Esta
consulta solamente encontrará coincidencia con
'b
' minúsculas al comienzo de un nombre:
mysql> SELECT * FROM pet WHERE name REGEXP BINARY '^b';
Para hallar nombres finalizados en 'fy
',
emplee '$
' para buscar la coincidencia en
el final del nombre:
mysql> SELECT * FROM pet WHERE name REGEXP 'fy$'; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+
Para encontrar nombres conteniendo una 'w
',
utilice esta consulta:
mysql> SELECT * FROM pet WHERE name REGEXP '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 | +----------+-------+---------+------+------------+------------+
Debido a que un patrón de expresión regular encuentra coincidencia sin importar el lugar del valor donde se produce, en la consulta previa no es necesario colocar un comodín a cada lado del patrón para obtener coincidencia en cualquier parte del valor, como hubiera sucedido de utilizar un patrón SQL
Para hallar nombres conteniendo exactamente cinco caracteres,
use '^
' y '$
' para
obligar a que la coincidencia deba estar al principio y al
final del nombre, y cinco instancias de '.
'
entre ellas.
mysql> SELECT * FROM pet WHERE name REGEXP '^.....$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
La consulta anterior también se podría haber escrito
empleando el operador '{n}
'
“repetir-n
-veces”:
mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
Ésta es una traducción del manual de referencia de MySQL, que puede encontrarse en dev.mysql.com. El manual de referencia original de MySQL está escrito en inglés, y esta traducción no necesariamente está tan actualizada como la versión original. Para cualquier sugerencia sobre la traducción y para señalar errores de cualquier tipo, no dude en dirigirse a mysql-es@vespito.com.