Como o operador BINARY funciona no MariaDB

No MariaDB, o BINARY O operador converte a string que a segue para uma string binária.

O BINARY O operador permite que você faça uma comparação de coluna byte por byte em vez de caractere por caractere. Isso faz com que a comparação faça distinção entre maiúsculas e minúsculas, mesmo que a coluna não esteja definida como BINARY ou BLOB . Isso também significa que os espaços à esquerda/à direita se tornam significativos.

Exemplo

Aqui está um exemplo simples:

SELECT BINARY 'Cat';

Resultado:

+--------------+| BINÁRIO 'Gato' |+--------------+| Gato |+--------------+

Este exemplo não demonstra realmente como o BINARY O operador pode afetar as comparações de strings. Os exemplos a seguir sim.

Espaços à frente/à direita

Como mencionado, os espaços iniciais e finais são significativos ao comparar strings byte por byte (ou seja, com BINARY ).

Primeiro, aqui está uma comparação de strings sem espaços à esquerda ou à direita:

SELECT 
    'Cat' = 'Cat',
    BINARY 'Cat' = 'Cat';

Resultado:

+---------------+-----------+| 'Gato' ='Gato' | BINÁRIO 'Gato' ='Gato' |+---------------+----------------------+| 1 | 1 |+---------------+----------------------+

Obtemos o mesmo valor de retorno se usarmos BINARY ou não.

Mas aqui está o que acontece quando adicionamos espaços à direita a uma das strings:

SELECT 
    'Cat' = 'Cat ',
    BINARY 'Cat' = 'Cat ',
    'Cat' = BINARY 'Cat ',
    BINARY 'Cat' = BINARY 'Cat ';

Resultado:

+----------------+-----------------------+----- ------------------+-----------------------------+ | 'Gato' ='Gato' | BINÁRIO 'Gato' ='Gato' | 'Gato' =BINÁRIO 'Gato' | BINÁRIO 'Gato' =BINÁRIO 'Gato' |+----------------+---------------------- -+-----------------------+------------------------ ------+| 1 | 0 | 0 | 0 |+----------------+-----------------------+------ ---+------------------------------+ 
 O primeiro retorna 1 enquanto os outros (ou seja, aqueles com BINARY ) retornar 0 . 
 
 Só para ter certeza, vamos comparar strings que têm espaços à direita:
 SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat '; 
 
 Resultado:
 +------------------------+--------------------- ----------+| 'Gato' =BINÁRIO 'Gato' | BINÁRIO 'Gato' =BINÁRIO 'Gato' |+------------------------+-------------- ------------------+| 1 | 1 |+------------------------+---------------------- ---------+
 
 Tenha em mente que estamos falando apenas de espaços à esquerda e à direita aqui. Esse conceito não se aplica a espaços no meio de uma string. 
 
 Por exemplo, dois espaços em uma string não são iguais a um espaço – mesmo sem usar o BINARY operador:
 SELECT 'Homer Jay' = 'Homer  Jay'; 
 
 Resultado:
 +----------------------------+| 'Homer Jay' ='Homer Jay' |+----------------------------+| 0 |+----------------------------+
 
 Nesse caso, a primeira string contém um espaço e a segunda contém dois espaços. Isso é o suficiente para que sejam desiguais, mesmo ao usar um caractere por comparação de caracteres. 
 Sensibilidade de maiúsculas e minúsculas
 
 O BINARY O operador força uma comparação com distinção entre maiúsculas e minúsculas, mesmo que a ordenação não faça distinção entre maiúsculas e minúsculas. 
 
 Por exemplo, aqui está meu agrupamento de conexões:
 SELECT @@collation_connection; 
 
 Resultado:
 +------------------------+| @@collation_connection |+------------------------+| utf8_general_ci |+------------------------+
 
 O ci no final significa não diferencia maiúsculas de minúsculas . 
 
 Aqui está um exemplo de uma comparação de strings de strings maiúsculas versus minúsculas:
 SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT'; 
 
 Resultado:
 +---------------+-----------+| 'gato' ='GATO' | BINÁRIO 'gato' ='GATO' |+---------------+----------------------+| 1 | 0 |+---------------+----------------------+
 
 A primeira comparação retornou 1, porque meu agrupamento não diferencia maiúsculas de minúsculas. O segundo retornou 0 , porque usamos o BINARY operador. 
 
 Os resultados que você obtém com essas comparações de strings (sem o BINARY operador) dependerá do seu agrupamento. Usar um agrupamento com diferenciação de maiúsculas e minúsculas retornará o mesmo resultado que obtivemos com BINARY . 
 
 Segue um exemplo para demonstrar:
 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 | BINÁRIO 'gato' ='GATO' |+------+------+----------------------+| 1 | 0 | 0 |+------+------+----------------------+
 
 Aqui, especifiquei explicitamente o conjunto de caracteres e o agrupamento no nível da string. A sintaxe para fazer isso é assim:
 [_charset_name]'string' [COLLATE collation_name] 
 
 Podemos ver que a ordenação que não diferencia maiúsculas de minúsculas retornou um resultado diferente da ordenação que diferencia maiúsculas de minúsculas. E o agrupamento com distinção entre maiúsculas e minúsculas retornou o mesmo resultado que obtemos ao usar o BINARY operador.