En MariaDB, el BINARY El operador convierte la cadena que le sigue en una cadena binaria.
El BINARY El operador le permite hacer una comparación de columnas byte por byte en lugar de carácter por carácter. Esto hace que la comparación distinga entre mayúsculas y minúsculas incluso si la columna no está definida como BINARY o BLOB . También significa que los espacios iniciales/posteriores se vuelven significativos.
Ejemplo
He aquí un ejemplo simple:
SELECT BINARY 'Cat';Resultado:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Este ejemplo no demuestra realmente cómo BINARY El operador puede afectar las comparaciones de cadenas. Los siguientes ejemplos lo hacen.
Espacios iniciales/posteriores
Como se mencionó, los espacios iniciales y finales son significativos cuando se comparan cadenas byte a byte (es decir, con BINARY ).
Primero, aquí hay una comparación de cadenas sin espacios iniciales ni finales:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Resultado:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
Obtenemos el mismo valor de retorno si usamos BINARY o no.
Pero esto es lo que sucede cuando agregamos espacios finales a una de las cadenas:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Resultado:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
El primero devuelve 1 mientras que los otros (es decir, los que tienen BINARY ) devuelve 0 .
Solo para estar seguros, comparemos cadenas que tienen espacios finales:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Resultado:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Tenga en cuenta que aquí solo estamos hablando de espacios iniciales y finales. Este concepto no se aplica a los espacios en medio de una cadena.
Por ejemplo, dos espacios en una cadena no es igual a un espacio, incluso sin usar BINARY operador:
SELECT 'Homer Jay' = 'Homer Jay';Resultado:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
En este caso, la primera cadena contiene un espacio y la segunda contiene dos espacios. Eso es suficiente para que sean desiguales, incluso cuando se usa una comparación de carácter por carácter.
Sensibilidad de mayúsculas y minúsculas
El BINARY El operador fuerza una comparación que distingue entre mayúsculas y minúsculas, incluso si la intercalación no distingue entre mayúsculas y minúsculas.
Por ejemplo, aquí está mi intercalación de conexiones:
SELECT @@collation_connection;Resultado:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
El ci al final significa no distingue entre mayúsculas y minúsculas .
Aquí hay un ejemplo de una comparación de cadenas de cadenas en mayúsculas y minúsculas:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Resultado:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
La primera comparación devolvió 1, porque mi intercalación no distingue entre mayúsculas y minúsculas. El segundo devolvió 0 , porque usamos el BINARY operador.
Los resultados que obtiene con dichas comparaciones de cadenas (sin el BINARY operador) dependerá de su intercalación. El uso de una intercalación que distingue entre mayúsculas y minúsculas devolverá el mismo resultado que obtuvimos con BINARY .
Aquí hay un ejemplo para demostrarlo:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Resultado:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Aquí, especifiqué explícitamente el juego de caracteres y la intercalación en el nivel de cadena. La sintaxis para hacerlo es así:
[_charset_name]'string' [COLLATE collation_name]
Podemos ver que la intercalación que no distingue entre mayúsculas y minúsculas devolvió un resultado diferente a la intercalación que distingue entre mayúsculas y minúsculas. Y la intercalación sensible a mayúsculas y minúsculas devolvió el mismo resultado que obtenemos cuando usamos BINARY operador.
