I MariaDB er BINARY operatoren kaster strengen efter den til en binær streng.
Den BINARY operatoren giver dig mulighed for at lave en kolonnesammenligning byte for byte i stedet for tegn for tegn. Dette får sammenligningen til at skelne mellem store og små bogstaver, selvom kolonnen ikke er defineret som BINARY eller BLOB . Det betyder også, at førende/slæbende rum bliver væsentlige.
Eksempel
Her er et simpelt eksempel:
SELECT BINARY 'Cat';Resultat:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Dette eksempel viser ikke rigtig, hvordan BINARY operatør kan påvirke strengsammenligninger. Det gør de følgende eksempler.
Leading/Trailing Spaces
Som nævnt er førende og efterfølgende mellemrum signifikante, når man sammenligner strenge byte for byte (dvs. med BINARY ).
For det første er her en strengsammenligning uden indledende eller efterfølgende mellemrum:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Resultat:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
Vi får den samme returværdi, uanset om vi bruger BINARY eller ej.
Men her er, hvad der sker, når vi tilføjer efterfølgende mellemrum til en af strengene:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Resultat:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
Den første returnerer 1 mens de andre (dvs. dem med BINARY). ) returner 0 .
Bare for at være sikker, lad os sammenligne strenge, der begge har efterfølgende mellemrum:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Resultat:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Husk, at vi kun taler om førende og efterfølgende rum her. Dette koncept gælder ikke for mellemrum i midten af en streng.
For eksempel er to mellemrum i en streng ikke lig med et mellemrum – selv uden brug af BINARY operatør:
SELECT 'Homer Jay' = 'Homer Jay';Resultat:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
I dette tilfælde indeholder den første streng et mellemrum, og den anden indeholder to mellemrum. Det er nok til, at de er ulige, selv når man bruger et tegn for tegn sammenligning.
Skrivar og bogstaver
Den BINARY operatør fremtvinger en sammenligning, der skelner mellem store og små bogstaver, selvom sorteringen er ufølsom.
For eksempel, her er min forbindelsessamling:
SELECT @@collation_connection;Resultat:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
ci i slutningen betyder ufølsomme for store og små bogstaver .
Her er et eksempel på en strengsammenligning af store og små bogstaver:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Resultat:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
Den første sammenligning gav 1, fordi min sortering ikke skelner mellem store og små bogstaver. Den anden returnerede 0 , fordi vi bruger BINARY operatør.
De resultater, du får med sådanne strengsammenligninger (uden BINARY operatør) vil afhænge af din sortering. Brug af en versalfølsom sortering vil returnere det samme resultat, som vi fik med BINARY .
Her er et eksempel til demonstration:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Resultat:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Her specificerede jeg eksplicit tegnsættet og sorteringen på strengniveau. Syntaksen for at gøre det lyder sådan her:
[_charset_name]'string' [COLLATE collation_name]
Vi kan se, at den store og små bogstavs-ufølsomme sortering gav et andet resultat end den store og små bogstaver. Og den store og små bogstavsfølsomme sortering returnerede det samme resultat, som vi får ved brug af BINARY operatør.