Es igual a (=) frente a ME GUSTA
Al usar SQL, ¿hay algún beneficio al usarlo =en una WHEREcláusula en lugar de LIKE?
Sin ningún operador especial, LIKEy =son iguales, ¿no?
Diferentes operadores
LIKEy =son operadores diferentes. La mayoría de las respuestas aquí se centran en la compatibilidad con comodines, ¡que no es la única diferencia entre estos operadores!
=es un operador de comparación que opera con números y cadenas. Al comparar cadenas, el operador de comparación compara cadenas enteras .
LIKEes un operador de cadena que compara carácter por carácter .
Para complicar las cosas, ambos operadores utilizan una intercalación que puede tener efectos importantes en el resultado de la comparación.
Ejemplo motivador
Primero identifiquemos un ejemplo en el que estos operadores producen resultados obviamente diferentes. Permítanme citar del manual de MySQL:
Según el estándar SQL, LIKE realiza coincidencias por carácter, por lo que puede producir resultados diferentes del operador de comparación =:
mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
| 0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
| 1 |
+--------------------------------------+
Tenga en cuenta que esta página del manual de MySQL se llama Funciones de comparación de cadenas y =no se analiza, lo que implica que =no es estrictamente una función de comparación de cadenas.
¿Cómo =funciona?
El Estándar SQL § 8.2 describe cómo =se comparan cadenas:
La comparación de dos cadenas de caracteres se determina de la siguiente manera:
a) Si la longitud en caracteres de X no es igual a la longitud en caracteres de Y, entonces la cadena más corta se reemplaza efectivamente, a efectos de comparación, con una copia de sí misma que se ha extendido a la longitud de la cadena más larga. mediante concatenación a la derecha de uno o más caracteres de pad, donde el carácter de pad se elige en función de CS. Si CS tiene el atributo NO PAD, entonces el carácter de relleno es un carácter dependiente de la implementación diferente de cualquier carácter en el conjunto de caracteres de X e Y que clasifica menos que cualquier cadena en CS. De lo contrario, el carácter del pad es un <espacio>.
b) El resultado de la comparación de X e Y viene dado por la secuencia de clasificación CS.
c) Dependiendo de la secuencia de clasificación, dos cadenas pueden compararse como iguales incluso si tienen diferentes longitudes o contienen diferentes secuencias de caracteres. Cuando las operaciones MAX, MIN, DISTINCT hacen referencia a una columna de agrupación y los operadores UNION, EXCEPT e INTERSECT hacen referencia a cadenas de caracteres, el valor específico seleccionado por estas operaciones de un conjunto de valores iguales depende de la implementación.
(Énfasis añadido.)
¿Qué quiere decir esto? Significa que al comparar cadenas, el =operador es solo una fina envoltura alrededor de la clasificación actual. Una intercalación es una biblioteca que tiene varias reglas para comparar cadenas. Aquí hay un ejemplo de una intercalación binaria de MySQL :
static int my_strnncoll_binary(const CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, size_t slen,
const uchar *t, size_t tlen,
my_bool t_is_prefix)
{
size_t len= MY_MIN(slen,tlen);
int cmp= memcmp(s,t,len);
return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
}
Esta clasificación en particular compara byte por byte (por eso se llama "binaria": no le da ningún significado especial a las cadenas). Otras intercalaciones pueden proporcionar comparaciones más avanzadas.
Por ejemplo, aquí hay una intercalación UTF-8 que admite comparaciones que no distinguen entre mayúsculas y minúsculas. El código es demasiado largo para pegarlo aquí, pero vaya a ese enlace y lea el cuerpo del archivo my_strnncollsp_utf8mb4(). Esta intercalación puede procesar varios bytes a la vez y puede aplicar varias transformaciones (como una comparación que no distingue entre mayúsculas y minúsculas). El =operador está completamente abstraído de los caprichos del cotejo.
¿Cómo LIKEfunciona?
El Estándar SQL § 8.5 describe cómo LIKEse comparan cadenas:
El <predicado>
M LIKE Pes cierto si existe una partición de M en subcadenas tal que:
i) Una subcadena de M es una secuencia de 0 o más <representaciones de caracteres> contiguas y cada <representación de caracteres> de M es parte de exactamente una subcadena.
ii) Si el i-ésimo especificador de subcadena de P es un especificador de carácter arbitrario, la i-ésima subcadena de M es cualquier <representación de carácter> única.
iii) Si el i-ésimo especificador de subcadena de P es un especificador de cadena arbitrario, entonces la i-ésima subcadena de M es cualquier secuencia de 0 o más <representaciones de caracteres>.
iv) Si el i-ésimo especificador de subcadena de P no es un especificador de carácter arbitrario ni un especificador de cadena arbitrario, entonces la i-ésima subcadena de M es igual a ese especificador de subcadena de acuerdo con la secuencia de clasificación del <predicado similar>, sin la adición de caracteres <espacio> a M, y tiene la misma longitud que ese especificador de subcadena.
v) El número de subcadenas de M es igual al número de especificadores de subcadenas de P.
(Énfasis añadido.)
Esto es bastante complejo, así que analicémoslo. Los puntos ii y iii se refieren a los comodines _y %, respectivamente. Si Pno contiene ningún comodín, sólo se aplica el punto iv. Este es el caso de interés que plantea el OP.
En este caso, compara cada "subcadena" (caracteres individuales) con Mcada subcadena al Putilizar la clasificación actual.
Conclusiones
La conclusión es que al comparar cadenas, =se compara la cadena completa y LIKEse compara un carácter a la vez. Ambas comparaciones utilizan la clasificación actual. Esta diferencia conduce a resultados diferentes en algunos casos, como se evidencia en el primer ejemplo de esta publicación.
¿Cual deberías usar? Nadie puede decirte eso: debes usar el que sea correcto para tu caso de uso. No optimice prematuramente cambiando de operador de comparación.
El operador igual (=) es un "operador de comparación que compara dos valores para determinar la igualdad". En otras palabras, en una declaración SQL, no devolverá verdadero a menos que ambos lados de la ecuación sean iguales. Por ejemplo:
SELECT * FROM Store WHERE Quantity = 200;
El operador LIKE "implementa una comparación de coincidencia de patrones" que intenta hacer coincidir "un valor de cadena con una cadena de patrón que contiene caracteres comodín". Por ejemplo:
SELECT * FROM Employees WHERE Name LIKE 'Chris%';
LIKE generalmente se usa solo con cadenas y es igual (creo) que es más rápido. El operador igual trata los caracteres comodín como caracteres literales. La diferencia en los resultados devueltos es la siguiente:
SELECT * FROM Employees WHERE Name = 'Chris';
Y
SELECT * FROM Employees WHERE Name LIKE 'Chris';
Devolvería el mismo resultado, aunque usar LIKE generalmente llevaría más tiempo ya que coincide con un patrón. Sin embargo,
SELECT * FROM Employees WHERE Name = 'Chris%';
Y
SELECT * FROM Employees WHERE Name LIKE 'Chris%';
Devolvería resultados diferentes, donde el uso de "=" da como resultado solo resultados con "Chris%" y el operador LIKE devolverá cualquier cosa que comience con "Chris".
Se puede encontrar buena información aquí .
Esta es una copia y pegado de otra respuesta mía para la pregunta SQL 'me gusta' vs '=' rendimiento :
Un ejemplo personal usando mysql 5.5: tenía una unión interna entre 2 tablas, una de 3 millones de filas y otra de 10 mil filas.
Cuando se usa un me gusta en un índice como se muestra a continuación (sin comodines), tomó aproximadamente 30 segundos:
where login like '12345678'
usando 'explicar' obtengo:
Al usar un '=" en la misma consulta, tomó aproximadamente 0,1 segundos:
where login ='12345678'
Usando 'explicar' obtengo:
Como puede ver, la likebúsqueda de índice se canceló por completo, por lo que la consulta tomó 300 veces más tiempo.
LIKEy =son diferentes. LIKEes lo que usarías en una consulta de búsqueda. También permite comodines como _(comodín de carácter simple) y %(comodín de varios caracteres).
=debe usarse si desea coincidencias exactas y será más rápido.
Este sitio explicaLIKE
Depende del sistema de base de datos.
Generalmente sin caracteres especiales, sí, = y LIKE son lo mismo.
Sin embargo, algunos sistemas de bases de datos pueden tratar la configuración de clasificación de manera diferente con los diferentes operadores.
Por ejemplo, en MySQL las comparaciones con = en cadenas siempre no distinguen entre mayúsculas y minúsculas de forma predeterminada, por lo que LIKE sin caracteres especiales es lo mismo. En algunos otros RDBMS, LIKE no distingue entre mayúsculas y minúsculas, mientras que = no lo es.
