In MariaDB, il BINARY operatore esegue il cast della stringa che la segue in una stringa binaria.
Il BINARY consente di eseguire un confronto di colonne byte per byte anziché carattere per carattere. Ciò fa sì che il confronto faccia distinzione tra maiuscole e minuscole anche se la colonna non è definita come BINARY o BLOB . Significa anche che gli spazi iniziali/finali diventano significativi.
Esempio
Ecco un semplice esempio:
SELECT BINARY 'Cat';Risultato:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Questo esempio non dimostra realmente come il BINARY operatore può influenzare i confronti di stringhe. Gli esempi seguenti lo fanno.
Spazi iniziali/finali
Come accennato, gli spazi iniziali e finali sono significativi quando si confrontano le stringhe byte per byte (cioè con BINARY ).
Innanzitutto, ecco un confronto di stringhe senza spazi iniziali o finali:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Risultato:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
Otteniamo lo stesso valore di ritorno se utilizziamo BINARY oppure no.
Ma ecco cosa succede quando aggiungiamo spazi finali a una delle stringhe:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Risultato:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
Il primo restituisce 1 mentre gli altri (cioè quelli con BINARY ) restituisce 0 .
Per sicurezza, confrontiamo le stringhe che hanno entrambe spazi finali:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Risultato:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Tieni presente che qui stiamo parlando solo di spazi iniziali e finali. Questo concetto non si applica agli spazi nel mezzo di una stringa.
Ad esempio, due spazi in una stringa non equivalgono a uno spazio, anche senza utilizzare il BINARY operatore:
SELECT 'Homer Jay' = 'Homer Jay';Risultato:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
In questo caso la prima stringa contiene uno spazio e la seconda contiene due spazi. Questo è sufficiente perché siano disuguali, anche quando si utilizza un confronto carattere per carattere.
Maiuscole/minuscole
Il BINARY operatore forza un confronto con distinzione tra maiuscole e minuscole, anche se le regole di confronto non fanno distinzione tra maiuscole e minuscole.
Ad esempio, ecco la mia raccolta di connessioni:
SELECT @@collation_connection;Risultato:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
Il ci alla fine significa senza distinzione tra maiuscole e minuscole .
Ecco un esempio di confronto tra stringhe maiuscole e minuscole:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Risultato:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
Il primo confronto ha restituito 1, perché le mie regole di confronto non fanno distinzione tra maiuscole e minuscole. Il secondo ha restituito 0 , perché utilizziamo il BINARY operatore.
I risultati che ottieni con tali confronti di stringhe (senza il BINARY operatore) dipenderà dalla tua raccolta. L'utilizzo di regole di confronto case sensitive restituirà lo stesso risultato ottenuto con BINARY .
Ecco un esempio da dimostrare:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Risultato:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Qui, ho specificato esplicitamente il set di caratteri e le regole di confronto a livello di stringa. La sintassi per farlo è questa:
[_charset_name]'string' [COLLATE collation_name]
Possiamo vedere che le regole di confronto senza distinzione tra maiuscole e minuscole hanno restituito un risultato diverso per le regole di confronto con distinzione tra maiuscole e minuscole. E le regole di confronto con distinzione tra maiuscole e minuscole hanno restituito lo stesso risultato che otteniamo quando si utilizza il BINARY operatore.
