Fonctionnement de l'opérateur BINARY dans MariaDB

Dans MariaDB, le BINARY l'opérateur convertit la chaîne qui le suit en une chaîne binaire.

Le BINARY vous permet de faire une comparaison de colonne octet par octet plutôt que caractère par caractère. Cela rend la comparaison sensible à la casse même si la colonne n'est pas définie comme BINARY ou BLOB . Cela signifie également que les espaces de début/de fin deviennent significatifs.

Exemple

Voici un exemple simple :

SELECT BINARY 'Cat'; 

Résultat :

+--------------+| BINAIRE 'Chat' |+--------------+| Chat |+--------------+

Cet exemple ne montre pas vraiment comment le BINARY L'opérateur peut affecter les comparaisons de chaînes. Les exemples suivants le font.

Espaces de début/de fin

Comme mentionné, les espaces de début et de fin sont significatifs lors de la comparaison de chaînes octet par octet (c'est-à-dire avec BINARY ).

Tout d'abord, voici une comparaison de chaînes sans espaces de début ou de fin :

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

Résultat :

+---------------+----------------------+| 'Chat' ='Chat' | BINAIRE 'Chat' ='Chat' |+---------------+----------------------+| 1 | 1 |+---------------+----------------------+

Nous obtenons la même valeur de retour si nous utilisons BINARY ou pas.

Mais voici ce qui se passe lorsque nous ajoutons des espaces à la fin de l'une des chaînes :

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

Résultat :

+----------------+-----------------------+----- ------------------+------------------------------+ | 'Chat' ='Chat ' | BINAIRE 'Chat' ='Chat ' | 'Chat' =BINAIRE 'Chat ' | BINAIRE 'Chat' =BINAIRE 'Chat ' |+----------------+---------------------- -+-----------------------+------------------------ ------+| 1 | 0 | 0 | 0 |+------------+-----------------------+------ -----------------+------------------------------+ 

 Le premier renvoie 1 alors que les autres (c'est-à-dire ceux avec BINARY ) renvoie 0 .
 

 Juste pour être sûr, comparons les chaînes qui ont toutes deux des espaces à la fin :
 
SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat '; 
 

 Résultat :
 
+-----------------------+--------------------- ----------+| 'Chat' =BINAIRE 'Chat' | BINAIRE 'Chat ' =BINAIRE 'Chat ' |+------------------------+-------------- -----------------+| 1 | 1 |+-----------------------+---------------------- ---------+
 

 Gardez à l'esprit que nous ne parlons ici que des espaces de début et de fin. Ce concept ne s'applique pas aux espaces au milieu d'une chaîne. 
 

 Par exemple, deux espaces dans une chaîne ne sont pas égaux à un espace - même sans utiliser le BINARY opérateur :
 
SELECT 'Homer Jay' = 'Homer  Jay'; 
 

 Résultat :
 
+----------------------------+| 'Homer Jay' ='Homer Jay' |+----------------------------------------+| 0 |+----------------------------+
 

 Dans ce cas, la première chaîne contient un espace et la seconde contient deux espaces. Cela suffit pour qu'ils soient inégaux, même en utilisant une comparaison caractère par caractère.
 
Sensibilité à la casse
 

 Le BINARY force une comparaison sensible à la casse, même si le classement est insensible à la casse.
 

 Par exemple, voici mon classement de connexion :
 
SELECT @@collation_connection; 
 

 Résultat :
 
+------------------------+| @@collation_connection |+------------------------+| utf8_general_ci |+-----------------------+
 

 Le ci à la fin signifie insensible à la casse .
 

 Voici un exemple de comparaison de chaînes de chaînes majuscules et minuscules :
 
SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT'; 
 

 Résultat :
 
+---------------+----------------------+| 'chat' ='CHAT' | BINAIRE 'chat' ='CHAT' |+---------------+----------------------+| 1 | 0 |+---------------+----------------------+
 

 La première comparaison a renvoyé 1, car mon classement est insensible à la casse. Le second a renvoyé 0 , car nous utilisons le BINARY opérateur.
 

 Les résultats que vous obtenez avec de telles comparaisons de chaînes (sans le BINARY opérateur) dépendra de votre classement. L'utilisation d'un classement sensible à la casse renverra le même résultat que nous avons obtenu avec BINARY . 
 

 Voici un exemple pour illustrer :
 
SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT'; 
 

 Résultat :
 
+------+------+----------------------+| ci | cs | BINAIRE 'chat' ='CHAT' |+------+------+----------------------+| 1 | 0 | 0 |+------+------+---------------------+
 

 Ici, j'ai explicitement spécifié le jeu de caractères et le classement au niveau de la chaîne. La syntaxe pour faire cela ressemble à ceci :
 
[_charset_name]'string' [COLLATE collation_name] 
 

 Nous pouvons voir que le classement insensible à la casse a renvoyé un résultat différent du classement sensible à la casse. Et le classement sensible à la casse a renvoyé le même résultat que celui que nous obtenons lors de l'utilisation du BINARY opérateur.