Jak działa operator binarny w MariaDB

W MariaDB BINARY operator rzutuje ciąg za nim na ciąg binarny.

BINARY Operator umożliwia porównywanie kolumn bajt po bajcie, a nie znak po znaku. Powoduje to, że w porównaniu rozróżniana jest wielkość liter, nawet jeśli kolumna nie jest zdefiniowana jako BINARY lub BLOB . Oznacza to również, że spacje wiodące/końcowe stają się znaczące.

Przykład

Oto prosty przykład:

SELECT BINARY 'Cat';

Wynik:

+--------------+
| BINARY 'Cat' |
+--------------+
| Cat          |
+--------------+

Ten przykład tak naprawdę nie pokazuje, w jaki sposób BINARY operator może wpływać na porównania ciągów. Poniższe przykłady tak.

Przestrzenie wiodące/końcowe

Jak wspomniano, spacje wiodące i końcowe są istotne podczas porównywania ciągów bajt po bajcie (np. z BINARY ).

Po pierwsze, oto porównanie ciągów bez żadnych spacji wiodących ani końcowych:

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

Wynik:

+---------------+----------------------+
| 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' |
+---------------+----------------------+
|             1 |                    1 |
+---------------+----------------------+

Otrzymujemy tę samą zwracaną wartość, niezależnie od tego, czy używamy BINARY czy nie.

Ale oto, co się dzieje, gdy dodamy końcowe spacje do jednego z ciągów:

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

Wynik:

+----------------+-----------------------+-----------------------+------------------------------+
| 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' |
+----------------+-----------------------+-----------------------+------------------------------+
|              1 |                     0 |                     0 |                            0 |
+----------------+-----------------------+-----------------------+------------------------------+

Pierwszy zwraca 1 podczas gdy inne (tj. te z BINARY ) zwróć 0 .

Dla pewności porównajmy ciągi, które mają na końcu spacje:

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

Wynik:

+------------------------+-------------------------------+
| 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' |
+------------------------+-------------------------------+
|                      1 |                             1 |
+------------------------+-------------------------------+

Pamiętaj, że mówimy tutaj tylko o spacjach wiodących i końcowych. Ta koncepcja nie dotyczy spacji w środku ciągu.

Na przykład dwie spacje w ciągu nie są równe jednej spacji — nawet bez użycia BINARY operator:

SELECT 'Homer Jay' = 'Homer  Jay';

Wynik:

+----------------------------+
| 'Homer Jay' = 'Homer  Jay' |
+----------------------------+
|                          0 |
+----------------------------+

W tym przypadku pierwszy ciąg zawiera jedną spację, a drugi dwie spacje. To wystarczy, aby były nierówne, nawet przy porównywaniu postaci.

Wrażliwość na wielkość liter

BINARY operator wymusza porównanie z uwzględnieniem wielkości liter, nawet jeśli w sortowaniu nie jest rozróżniana wielkość liter.

Na przykład, oto moje zestawienie połączeń:

SELECT @@collation_connection;

Wynik:

+------------------------+
| @@collation_connection |
+------------------------+
| utf8_general_ci        |
+------------------------+

ci na końcu oznacza niewrażliwy na wielkość liter .

Oto przykład porównania ciągów wielkich i małych liter:

SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT';

Wynik:

+---------------+----------------------+
| 'cat' = 'CAT' | BINARY 'cat' = 'CAT' |
+---------------+----------------------+
|             1 |                    0 |
+---------------+----------------------+

Pierwsze porównanie zwróciło 1, ponieważ moje sortowanie nie uwzględnia wielkości liter. Drugi zwrócił 0 , ponieważ używamy BINARY operatora.

Wyniki, które otrzymujesz z takimi porównaniami ciągów (bez BINARY operatora) będzie zależeć od Twojego sortowania. Użycie sortowania z rozróżnianiem wielkości liter zwróci ten sam wynik, który otrzymaliśmy w przypadku BINARY .

Oto przykład do zademonstrowania:

SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT';

Wynik:

+------+------+----------------------+
| ci   | cs   | BINARY 'cat' = 'CAT' |
+------+------+----------------------+
|    1 |    0 |                    0 |
+------+------+----------------------+

Tutaj wyraźnie określiłem zestaw znaków i sortowanie na poziomie łańcucha. Składnia do tego wygląda tak:

[_charset_name]'string' [COLLATE collation_name]

Widzimy, że sortowanie bez uwzględniania wielkości liter zwróciło inny wynik niż sortowanie z uwzględnieniem wielkości liter. A sortowanie z uwzględnieniem wielkości liter zwróciło ten sam wynik, jaki otrzymujemy przy użyciu BINARY operatora.