Jak funguje BINARY Operator v MariaDB

V MariaDB, BINARY operátor přetypuje řetězec, který za ním následuje, na binární řetězec.

BINARY operátor umožňuje porovnávat sloupce bajt po bajtu místo znaku po znaku. To způsobí, že se v porovnání rozlišují malá a velká písmena, i když sloupec není definován jako BINARY nebo BLOB . Znamená to také, že přední/koncové prostory se stanou významnými.

Příklad

Zde je jednoduchý příklad:

SELECT BINARY 'Cat'; 

Výsledek:

+---------------+| BINÁRNÍ 'Kočka' |+--------------+| Kočka |+--------------+

Tento příklad ve skutečnosti neukazuje, jak BINARY operátor může ovlivnit porovnání řetězců. Následující příklady ano.

Vedoucí/koncové mezery

Jak již bylo zmíněno, úvodní a koncové mezery jsou důležité při porovnávání řetězců bajt po bajtu (tj. s BINARY ).

Nejprve je zde porovnání řetězců bez jakýchkoli úvodních nebo koncových mezer:

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

Výsledek:

+---------------+----------------------+| 'Kočka' ='Kočka' | BINÁRNÍ 'Kočka' ='Kočka' |+---------------+----------------------+| 1 | 1 |+---------------+----------------------+

Dostaneme stejnou návratovou hodnotu, pokud použijeme BINARY nebo ne.

Ale co se stane, když k jednomu z řetězců přidáme koncové mezery:

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

Výsledek:

+----------------+-----------------------+----- ------------------+------------------------------+ | 'Kočka' ='Kočka' | BINARY 'Cat' ='Cat' | 'Kočka' =BINARY 'Kočka' | BINÁRNÍ 'Kočka' =BINÁRNÍ 'Kočka ' |+----------------+----------------------- -+-----------------------+------------------------ ------+| 1 | 0 | 0 | 0 |+----------------+-----------------------+------ -----------------+------------------------------+ 

 První vrátí 1 zatímco ostatní (tj. ty s BINARY ) vrátí 0 .
 

 Pro jistotu porovnejme řetězce, které mají oba koncové mezery:
 
SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat '; 
 

 Výsledek:
 
+------------------------+--------------------- ----------+| 'Kočka' =BINÁRNÍ 'Kočka' | BINÁRNÍ 'Kočka ' =BINÁRNÍ 'Kočka ' |+-------------------------+--------------- ------------------+| 1 | 1 |+------------------------+----------------------- ---------+
 

 Mějte na paměti, že zde mluvíme pouze o předních a koncových prostorech. Tento koncept se nevztahuje na mezery uprostřed řetězce. 
 

 Například dvě mezery v řetězci se nerovnají jedné mezeře – i bez použití BINARY operátor:
 
SELECT 'Homer Jay' = 'Homer  Jay'; 
 

 Výsledek:
 
+----------------------------+| 'Homer Jay' ='Homer Jay' |+----------------------------+| 0 |+----------------------------+
 

 V tomto případě první řetězec obsahuje jednu mezeru a druhý obsahuje dvě mezery. To stačí k tomu, aby byly nerovné, i když používají srovnání znak po znaku.
 
Rozlišovat malá a velká písmena
 

 BINARY Operátor si vynutí srovnání rozlišující malá a velká písmena, i když řazení nerozlišuje malá a velká písmena.
 

 Zde je například moje řazení připojení:
 
SELECT @@collation_connection; 
 

 Výsledek:
 
+------------------------+| @@collation_connection |+------------------------+| utf8_general_ci |+------------------------+
 

 ci na konci znamená nerozlišují se malá a velká písmena .
 

 Zde je příklad porovnání řetězců velkých a malých písmen:
 
SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT'; 
 

 Výsledek:
 
+---------------+----------------------+| 'kočka' ='KOČKA' | BINARY 'cat' ='CAT' |+---------------+----------------------+| 1 | 0 |+---------------+----------------------+
 

 První srovnání vrátilo 1, protože moje řazení nerozlišuje malá a velká písmena. Druhý vrátil 0 , protože používáme BINARY operátor.
 

 Výsledky, které získáte s takovými porovnáními řetězců (bez BINARY operátor) bude záviset na vašem řazení. Použití řazení rozlišující malá a velká písmena vrátí stejný výsledek, jaký jsme získali pomocí BINARY . 
 

 Zde je příklad k demonstraci:
 
SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT'; 
 

 Výsledek:
 
+------+------+----------------------+| ci | cs | BINÁRNÍ 'kočka' ='KOČKA' |+------+------+----------------------+| 1 | 0 | 0 |+------+------+----------------------+
 

 Zde jsem výslovně specifikoval znakovou sadu a řazení na úrovni řetězce. Syntaxe pro to vypadá takto:
 
[_charset_name]'string' [COLLATE collation_name] 
 

 Vidíme, že třídění bez rozlišení malých a velkých písmen vrátilo jiný výsledek než třídění s rozlišováním malých a velkých písmen. A řazení rozlišující malá a velká písmena vrátilo stejný výsledek, jaký získáme při použití BINARY operátor.