Bagaimana Operator BINARY Bekerja di MariaDB

Di MariaDB, BINARY operator melemparkan string yang mengikutinya ke string biner.

BINARY operator memungkinkan Anda untuk melakukan perbandingan kolom byte demi byte daripada karakter demi karakter. Hal ini menyebabkan perbandingan menjadi peka huruf besar/kecil meskipun kolom tidak didefinisikan sebagai BINARY atau BLOB . Ini juga berarti bahwa ruang depan/belakang menjadi signifikan.

Contoh

Berikut ini contoh sederhananya:

SELECT BINARY 'Cat'; 

Hasil:

+-------------+| 'Kucing' BINARY |+--------------+| Kucing |+-------------+

Contoh ini tidak benar-benar menunjukkan bagaimana BINARY operator dapat mempengaruhi perbandingan string. Contoh berikut ini.

Ruang Terdepan/Tertinggal

Seperti disebutkan, spasi awal dan akhir sangat penting saat membandingkan string byte demi byte (yaitu dengan BINARY ).

Pertama, inilah perbandingan string tanpa spasi awal atau akhir:

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

Hasil:

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

Kami mendapatkan nilai pengembalian yang sama apakah kami menggunakan BINARY atau tidak.

Tapi inilah yang terjadi saat kita menambahkan spasi tambahan ke salah satu string:

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

Hasil:

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

 Yang pertama mengembalikan 1 sedangkan yang lain (yaitu yang memiliki BINARY ) kembalikan 0 .
 

 Untuk memastikannya, mari kita bandingkan string yang keduanya memiliki spasi tambahan:
 
SELECT
    'Cat ' = BINARY 'Cat ',
    BINARY 'Cat ' = BINARY 'Cat '; 
 

 Hasil:
 
+------------------------+--------------------- ----------+| 'Kucing' =BINER 'Kucing' | BINARY 'Cat' =BINARY 'Cat' |+------------------------+-------------- -----------------+| 1 | 1 |+------------------------+---------------------- ---------+
 

 Ingatlah bahwa kita hanya berbicara tentang spasi awal dan akhir di sini. Konsep ini tidak berlaku untuk spasi di tengah string. 
 

 Misalnya, dua spasi dalam string tidak sama dengan satu spasi – bahkan tanpa menggunakan BINARY operator:
 
SELECT 'Homer Jay' = 'Homer  Jay'; 
 

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

 Dalam hal ini string pertama berisi satu spasi dan yang kedua berisi dua spasi. Itu sudah cukup bagi mereka untuk menjadi tidak setara, bahkan ketika menggunakan perbandingan karakter demi karakter.
 
Sensitivitas Huruf Besar
 

 BINARY operator memaksa perbandingan peka huruf besar/kecil, meskipun susunan tidak peka huruf besar/kecil.
 

 Misalnya, inilah susunan koneksi saya:
 
SELECT @@collation_connection; 
 

 Hasil:
 
+------------------------+| @@collation_connection |+------------------------+| utf8_general_ci |+------------------------+
 

 ci di akhir berarti tidak peka huruf besar/kecil .
 

 Berikut adalah contoh perbandingan string string huruf besar vs huruf kecil:
 
SELECT 
    'cat' = 'CAT',
    BINARY 'cat' = 'CAT'; 
 

 Hasil:
 
+---------------+-----------------------+| 'kucing' ='KUcing' | BINARY 'cat' ='CAT' |+---------------+----------------------+| 1 | 0 |+---------------+------------+
 

 Perbandingan pertama menghasilkan 1, karena susunan saya tidak peka huruf besar-kecil. Yang kedua mengembalikan 0 , karena kita menggunakan BINARY operator.
 

 Hasil yang Anda dapatkan dengan perbandingan string tersebut (tanpa BINARY operator) akan tergantung pada pemeriksaan Anda. Menggunakan susunan peka huruf besar/kecil akan mengembalikan hasil yang sama dengan yang kita dapatkan dengan BINARY . 
 

 Berikut ini contoh untuk didemonstrasikan:
 
SELECT 
    _latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
    _latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
    BINARY 'cat' = 'CAT'; 
 

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

 Di sini, saya secara eksplisit menentukan set karakter dan susunan pada level string. Sintaks untuk melakukannya seperti ini:
 
[_charset_name]'string' [COLLATE collation_name] 
 

 Kita dapat melihat bahwa susunan case-sensitive menghasilkan hasil yang berbeda dengan susunan case-sensitive. Dan susunan peka huruf besar/kecil mengembalikan hasil yang sama seperti yang kita dapatkan saat menggunakan BINARY operator.