Hur den BINÄRA operatören fungerar i MariaDB

I MariaDB är BINARY operatorn kastar strängen efter den till en binär sträng.

Den BINARY operatorn gör att du kan göra en kolumnjämförelse byte för byte snarare än tecken för tecken. Detta gör att jämförelsen är skiftlägeskänslig även om kolumnen inte är definierad som BINARY eller BLOB . Det betyder också att ledande/släpande utrymmen blir betydande.

Exempel

Här är ett enkelt exempel:

SELECT BINARY 'Cat';

Resultat:

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

Det här exemplet visar inte riktigt hur BINARY operatör kan påverka strängjämförelser. Följande exempel gör det.

Leading/Trailing Spaces

Som nämnts är inledande och efterföljande mellanslag betydelsefulla när man jämför strängar byte för byte (d.v.s. med BINARY ).

Först, här är en strängjämförelse utan några inledande eller efterföljande mellanslag:

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

Resultat:

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

Vi får samma returvärde oavsett om vi använder BINARY eller inte.

Men här är vad som händer när vi lägger till efterföljande mellanslag till en av strängarna:

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örsta returnerar 1 medan de andra (dvs de med BINARY). ) returnera 0 .

Bara för att vara säker, låt oss jämföra strängar som båda har efterföljande mellanslag:

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

Resultat:

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

Tänk på att vi bara pratar om ledande och efterföljande utrymmen här. Det här konceptet gäller inte mellanslag i mitten av en sträng.

Till exempel är två blanksteg i en sträng inte lika med ett blanksteg – även utan att använda BINARY operatör:

SELECT 'Homer Jay' = 'Homer  Jay';

Resultat:

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

I det här fallet innehåller den första strängen ett mellanslag och den andra innehåller två mellanslag. Det räcker för att de ska vara ojämlika, även när man använder en karaktär för teckenjämförelse.

Skaftkänslighet

Den BINARY operatorn tvingar fram en skiftlägeskänslig jämförelse, även om sorteringen är skiftlägesokänslig.

Till exempel, här är min anslutningssamling:

SELECT @@collation_connection;

Resultat:

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

ci i slutet betyder skiftlägesokänslig .

Här är ett exempel på en strängjämförelse mellan versaler och gemener:

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

Resultat:

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

Den första jämförelsen gav 1, eftersom min sortering är skiftlägesokänslig. Den andra returnerade 0 , eftersom vi använder BINARY operatör.

Resultaten du får med sådana strängjämförelser (utan BINARY operatör) beror på din sortering. Att använda en skiftlägeskänslig sortering kommer att returnera samma resultat som vi fick med BINARY .

Här är ett exempel att visa:

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 |
+------+------+----------------------+

Här specificerade jag uttryckligen teckenuppsättningen och sorteringen på strängnivå. Syntaxen för att göra det ser ut så här:

[_charset_name]'string' [COLLATE collation_name]

Vi kan se att den skiftlägesokänsliga sammanställningen gav ett annat resultat än den skiftlägeskänsliga sammanställningen. Och den skiftlägeskänsliga sorteringen gav samma resultat som vi får när vi använder BINARY operatör.