En MariaDB, el REGEXP El operador se utiliza para determinar si una cadena coincide o no con una expresión regular.
Si la cadena coincide con la expresión regular proporcionada, el resultado es 1 , de lo contrario es 0 .
Sintaxis
La sintaxis es así:
expr REGEXP pat
Donde expr es la cadena de entrada y pat es la expresión regular para la que está probando la cadena.
Ejemplos
A continuación se muestran ejemplos del uso de REGEXP operador con diferentes patrones.
Expresión regular básica
Comencemos con el ejemplo más simple. La expresión regular más simple que podemos usar es una que no tiene caracteres especiales. Aquí, solo usamos una cadena. Si alguna parte de la cadena de entrada coincide con esa cadena, devuelve una coincidencia.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Resultado:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Hacer coincidir el principio de una cadena
En este ejemplo, la expresión regular especifica que la cadena debe comenzar con Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Resultado:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Hacer coincidir el final de una cadena
En este ejemplo, la expresión regular especifica que la cadena debe terminar con rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Resultado:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Haz coincidir cualquier personaje
El . carácter coincide con cualquier carácter.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Resultado:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Este carácter se suele utilizar junto con otros caracteres para especificar criterios adicionales. Por ejemplo:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Resultado:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Aquí especificamos que la cadena debe comenzar con C , que debe ir seguido de un carácter (cualquier carácter), y que debe terminar con rn .
Tenga en cuenta que este carácter especifica una sola instancia del carácter. Si desea especificar varias instancias (por ejemplo, ee en lugar de solo e ), deberá agregar más . personajes.
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";Resultado:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Otra forma de hacer esto es especificar el número de ocurrencias entre corchetes:
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";Resultado:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Sin embargo, si conoce el carácter que está buscando, puede especificar ese carácter (en lugar de .) carácter), como se demuestra en el siguiente ejemplo.
Coincide con cero o más instancias de un personaje específico
Podemos hacer lo siguiente para especificar cero o más instancias de e carácter:
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";Resultado:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Los primeros cuatro coinciden pero los últimos tres no.
Haz coincidir una o más instancias de un personaje específico
Podemos modificar el ejemplo anterior para que solo obtengamos una coincidencia si uno o más caracteres (el ejemplo anterior devolvió una coincidencia si cero o más fueron encontrados). Para hacer esto, simplemente usamos + en lugar de * :
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";Resultado:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
En este caso, la cuarta palabra devuelve un resultado diferente al ejemplo anterior.
Coincide con cero o una instancia de un personaje específico
Podemos modificar el ejemplo anterior para que solo obtengamos una coincidencia en cero o uno de los caracteres deseados. Para hacer esto, usamos ? :
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";Resultado:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Alternancia
Puedes usar el | carácter para que coincida con una u otra secuencia de caracteres:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Resultado:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Aquí hay otro ejemplo donde busco palabras completas:
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";Resultado:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Todavía obtenemos una coincidencia incluso cuando nuestra expresión regular coincide solo con una parte de la cadena.
Coincide con cero o más instancias de una secuencia
Puede usar corchetes junto con el asterisco ()* para especificar cero o más instancias de una secuencia:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Resultado:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Otro ejemplo:
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";Resultado:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Repetición
Como se vio en un ejemplo anterior, puede usar corchetes para especificar la repetición. Esta notación proporciona una forma más general de escribir expresiones regulares que algunos de los ejemplos anteriores:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Resultado:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Alcance
Puede utilizar el carácter de guión para especificar un rango. Aquí hay un ejemplo que especifica un rango de números:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Resultado:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Y el siguiente ejemplo especifica un rango de letras:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Resultado:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Esto es lo que sucede si limitamos el rango de números:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Resultado:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
No dentro de un rango
Podemos usar el ^ carácter para modificar el ejemplo anterior de modo que se excluya el rango de caracteres especificado:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Resultado:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
En este caso obtenemos el resultado contrario al ejemplo anterior.
Valores nulos
Si la expresión o el patrón es null , el resultado es null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Resultado:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+
