En MySQL, el LIKE El operador realiza la coincidencia de patrones usando un patrón SQL.
Si la cadena coincide con el patrón proporcionado, el resultado es 1 , de lo contrario es 0 .
El patrón no necesariamente tiene que ser una cadena literal. Esta función se puede utilizar con expresiones de cadena y columnas de tabla.
Sintaxis
La sintaxis es así:
expr LIKE pat [ESCAPE 'escape_char']
Donde expr es la cadena de entrada y pat es el patrón contra el que está probando la cadena.
El ESCAPE opcional cláusula le permite especificar un carácter de escape. El carácter de escape predeterminado es \ , por lo que puede omitir esta cláusula si no necesita cambiarla.
Ejemplo 1:uso básico
Aquí hay un ejemplo de cómo usar este operador en un SELECT declaración:
SELECT 'Charlie' LIKE 'Char%';
Resultado:
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
En este caso, el valor de retorno es 1 lo que significa que la cadena de entrada coincidió con el patrón. En particular, especificamos que la cadena de entrada debe comenzar con Char y terminar con cualquier cosa. El % carácter coincide con cualquier número de caracteres (incluidos cero caracteres).
Esto es lo que sucede si dejamos caer el % :
SELECT 'Charlie' LIKE 'Char';
Resultado:
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
El resultado devuelto es 0 lo que significa que no hay coincidencia. Esto se debe a que no usamos un carácter comodín para especificar ningún otro carácter.
Ejemplo 2:el _ Comodín
También tenemos la opción de usar el _ carácter comodín para especificar un único carácter. He aquí un ejemplo:
SELECT 'Charlie' LIKE 'Ch_rlie';
Resultado:
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
Los dos caracteres comodín se pueden combinar dentro de un patrón si es necesario:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Resultado:
+--------+ | Result | +--------+ | 1 | +--------+
Aquí hay algunos más:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Ch_rlie%nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Ch%rlie %likes %' AS 'Result 3', 'Charlie likes donuts' LIKE '% likes %' AS 'Result 4';
Resultado:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Hagamos algunos cambios en ese ejemplo para que podamos ver algunos ejemplos de cuando no coinciden:
SELECT 'Charlie likes donuts' LIKE 'Ch%rlie_donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Charlie_nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Charlie _likes donuts' AS 'Result 3', 'Charlie likes donuts' LIKE '_ likes _' AS 'Result 4';
Resultado:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Ejemplo 3:un ejemplo de base de datos
El LIKE El operador se usa a menudo dentro de un WHERE cláusula de un SELECT declaración al consultar una base de datos. Cuando se usa de esta manera, reduce los resultados a solo aquellos registros que coinciden, pero vemos los resultados reales (no solo un 1 o 0 ).
Aquí hay un ejemplo de cómo podemos usar este operador dentro de una consulta de base de datos:
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Resultado:
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
En este caso, fue una consulta simple que devuelve todos los artistas cuyos nombres comienzan con la letra B .
Aquí está la lista completa de artistas en esa tabla:
SELECT ArtistId, ArtistName FROM Artists;
Resultado:
+----------+------------------------+ | ArtistId | ArtistName | +----------+------------------------+ | 1 | Iron Maiden | | 2 | AC/DC | | 3 | Allan Holdsworth | | 4 | Buddy Rich | | 5 | Devin Townsend | | 6 | Jim Reeves | | 7 | Tom Jones | | 8 | Maroon 5 | | 9 | The Script | | 10 | Lit | | 11 | Black Sabbath | | 12 | Michael Learns to Rock | | 13 | Carabao | | 14 | Karnivool | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+------------------------+
Ejemplo 4:escapar con el carácter de barra invertida
¿Qué sucede si uno de los caracteres comodín está en su cadena de entrada y necesita realizar una coincidencia con él? Puede escapar con el carácter de barra invertida (\ ). Aquí hay un ejemplo de una búsqueda de este tipo con y sin el carácter de escape:
SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Resultado:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
En este caso, ambos coincidían, pero por razones diferentes. La primera línea coincidió porque el comodín especificó que cualquier carácter coincidirá. La segunda línea también coincidió, pero solo porque la cadena de entrada tenía un guión bajo en el lugar correcto.
Cambiemos ligeramente la cadena de entrada para obtener un resultado diferente:
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Resultado:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
La versión sin escape dio positivo, porque el comodín significaba que podíamos tener cualquier personaje en ese lugar. La versión escapada declaraba explícitamente que solo el carácter de subrayado (_ ) coincidirá. La cadena de entrada no tenía un carácter de subrayado en ese lugar, por lo que el resultado fue negativo.
Ejemplo 5:el ESCAPE Cláusula
También puedes usar el ESCAPE cláusula para especificar su propio carácter de escape personalizado. He aquí un ejemplo:
SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Resultado:
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Ejemplo 6:Expresiones numéricas
La implementación MySQL de LIKE El operador permite utilizar expresiones numéricas. He aquí un ejemplo:
SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Resultado:
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+
