Как работи операторът BINARY в MariaDB

В MariaDB, BINARY оператор прехвърля низа, който го следва, към двоичен низ.

BINARY Операторът ви позволява да правите сравнение на колони байт по байт, а не символ по знак. Това кара сравнението да бъде чувствително към главни и малки букви, дори ако колоната не е дефинирана като BINARY или BLOB . Това също означава, че водещите/завършващите интервали стават значителни.

Пример

Ето един прост пример:

SELECT BINARY 'Cat'; 

Резултат:

+--------------+| БИНАРЕН 'Котка' |+--------------+| Котка |+--------------+

Този пример всъщност не демонстрира как BINARY операторът може да повлияе на сравненията на низове. Следните примери са подходящи.

Начални/завършващи интервали

Както бе споменато, началните и крайните интервали са важни при сравняване на низове байт по байт (т.е. с BINARY ).

Първо, ето сравнение на низове без начални или крайни интервали:

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

Резултат:

+--------------+---------------------+| 'Котка' ='Котка' | ДВОИЧНО 'Котка' ='Котка' |+---------------+---------------------+| 1 | 1 |+--------------+---------------------+

Получаваме същата върната стойност, независимо дали използваме BINARY или не.

Но ето какво се случва, когато добавим крайни интервали към един от низовете:

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

Резултат:

+----------------+--------------------------------+----- ------------------+------------------------------+ | 'Котка' ='Котка' | BINARY 'Cat' ='Cat' | 'Котка' =ДВОИЧНО 'Котка' | БИНАРЕН 'Котка' =ДВОИЧЕН 'Котка' |+----------------+--------------------- -+-----------------------+----------------------- ------+| 1 | 0 | 0 | 0 |+----------------+-----------------------+------ -----------------+------------------------------+ 

 Първият връща 1 докато останалите (т.е. тези с BINARY ) върне 0 .
 

 Само за да сме сигурни, нека сравним низове, които имат крайни интервали:
 
SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat '; 
 

 Резултат:
 
+-----------------------+--------------------- ----------+| 'Котка' =ДВОИЧНО 'Котка' | БИНАРЕН 'Котка' =ДВОИЧЕН 'Котка' |+------------------------+-------------- -----------------+| 1 | 1 |+-----------------------+--------------------- ---------+
 

 Имайте предвид, че тук говорим само за водещи и последващи интервали. Тази концепция не се прилага за интервали в средата на низ. 
 

 Например, две интервали в низ не са равни на един интервал – дори без да използвате BINARY оператор:
 
SELECT 'Homer Jay' = 'Homer  Jay'; 
 

 Резултат:
 
+----------------------------+| 'Homer Jay' ='Homer Jay' |+----------------------------+| 0 |+----------------------------+
 

 В този случай първият низ съдържа един интервал, а вторият съдържа два интервала. Това е достатъчно, за да бъдат неравностойни, дори когато използват сравнение символ по знак.
 
Чувствителност на регистрите
 

 BINARY операторът принуждава сравнение, чувствително към малки и големи букви, дори ако съпоставянето не е чувствително.
 

 Например, ето моето съпоставяне на връзки:
 
SELECT @@collation_connection; 
 

 Резултат:
 
+-----------------------+| @@collation_connection |+-----------------------+| utf8_general_ci |+-----------------------+
 

 ci в края означава нечувствителност на главни букви .
 

 Ето пример за сравнение на низове на низове с главни и малки букви:
 
SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT'; 
 

 Резултат:
 
+--------------+---------------------+| 'cat' ='CAT' | БИНАРЕН 'cat' ='CAT' |+---------------+---------------------+| 1 | 0 |+--------------+---------------------+
 

 Първото сравнение върна 1, тъй като съпоставянето ми не е чувствително към главни букви. Вторият върна 0 , защото използваме BINARY оператор.
 

 Резултатите, които получавате с подобни сравнения на низове (без BINARY оператор) ще зависи от вашето съпоставяне. Използването на съпоставяне, чувствително към малки и големи букви, ще върне същия резултат, който получихме с BINARY . 
 

 Ето пример за демонстрация:
 
SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT'; 
 

 Резултат:
 
+------+------+---------------------+| ci | cs | БИНАРЕН 'cat' ='CAT' |+------+------+---------------------+| 1 | 0 | 0 |+------+------+---------------------+
 

 Тук изрично посочих набора от знаци и сортиране на ниво низ. Синтаксисът за това е следният:
 
[_charset_name]'string' [COLLATE collation_name] 
 

 Можем да видим, че съпоставянето, независимо от главните и малки букви, е върнало различен резултат от съпоставянето, което е чувствително. И съпоставянето, чувствително към малки и големи букви, върна същия резултат, както получаваме, когато използваме BINARY оператор.