In MariaDB is de BINARY operator cast de string die erop volgt naar een binaire string.
De BINARY operator stelt u in staat om een kolomvergelijking per byte uit te voeren in plaats van teken voor teken. Dit zorgt ervoor dat de vergelijking hoofdlettergevoelig is, zelfs als de kolom niet is gedefinieerd als BINARY of BLOB . Het betekent ook dat voor- en achterruimten significant worden.
Voorbeeld
Hier is een eenvoudig voorbeeld:
SELECT BINARY 'Cat';Resultaat:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Dit voorbeeld laat niet echt zien hoe de BINARY operator kan stringvergelijkingen beïnvloeden. De volgende voorbeelden doen dat wel.
Leading/Trailing Spaces
Zoals vermeld, zijn voorloop- en volgspaties significant bij het byte voor byte vergelijken van strings (d.w.z. met BINARY ).
Ten eerste, hier is een tekenreeksvergelijking zonder voorloop- of volgspaties:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Resultaat:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
We krijgen dezelfde retourwaarde, of we nu BINARY . gebruiken of niet.
Maar dit is wat er gebeurt als we volgspaties toevoegen aan een van de tekenreeksen:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Resultaat:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
De eerste retourneert 1 terwijl de andere (d.w.z. die met BINARY ) retourneer 0 .
Laten we voor de zekerheid strings vergelijken die beide een volgspatie hebben:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Resultaat:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Houd er rekening mee dat we het hier alleen hebben over voorloop- en volgspaties. Dit concept is niet van toepassing op spaties in het midden van een tekenreeks.
Twee spaties in een string is bijvoorbeeld niet gelijk aan één spatie – zelfs zonder gebruik van de BINARY operator:
SELECT 'Homer Jay' = 'Homer Jay';Resultaat:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
In dit geval bevat de eerste string één spatie en de tweede twee spaties. Dat is genoeg om ongelijk te hebben, zelfs als je een karakter gebruikt door karakter te vergelijken.
Hoofdlettergevoeligheid
De BINARY operator dwingt een hoofdlettergevoelige vergelijking af, zelfs als de sortering niet hoofdlettergevoelig is.
Dit is bijvoorbeeld mijn verbindingsverzameling:
SELECT @@collation_connection;Resultaat:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
De ci aan het einde betekent hoofdlettergevoelig .
Hier is een voorbeeld van een tekenreeksvergelijking van tekenreeksen in hoofdletters en kleine letters:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Resultaat:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
De eerste vergelijking leverde 1 op, omdat mijn sortering niet hoofdlettergevoelig is. De tweede retourneerde 0 , omdat we de BINARY . gebruiken telefoniste.
De resultaten die u krijgt met dergelijke stringvergelijkingen (zonder de BINARY operator) is afhankelijk van uw sortering. Het gebruik van een hoofdlettergevoelige sortering geeft hetzelfde resultaat als met BINARY .
Hier is een voorbeeld om te demonstreren:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Resultaat:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Hier heb ik expliciet de tekenset en sortering op tekenreeksniveau gespecificeerd. De syntaxis om dat te doen gaat als volgt:
[_charset_name]'string' [COLLATE collation_name]
We kunnen zien dat de hoofdletterongevoelige sortering een ander resultaat opleverde dan de hoofdlettergevoelige sortering. En de hoofdlettergevoelige sortering leverde hetzelfde resultaat op als bij het gebruik van de BINARY telefoniste.