Trong MariaDB, BINARY toán tử chuyển chuỗi theo sau nó thành một chuỗi nhị phân.
BINARY toán tử cho phép bạn thực hiện so sánh cột từng byte thay vì từng ký tự. Điều này khiến so sánh phân biệt chữ hoa chữ thường ngay cả khi cột không được xác định là BINARY hoặc BLOB . Điều đó cũng có nghĩa là các khoảng trống ở đầu / cuối trở nên quan trọng.
Ví dụ
Đây là một ví dụ đơn giản:
SELECT BINARY 'Cat';Kết quả:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Ví dụ này không thực sự chứng minh cách BINARY toán tử có thể ảnh hưởng đến so sánh chuỗi. Các ví dụ sau đây.
Khoảng trắng đầu / cuối
Như đã đề cập, khoảng trống ở đầu và cuối rất quan trọng khi so sánh các chuỗi từng byte (tức là với BINARY ).
Đầu tiên, đây là một so sánh chuỗi không có bất kỳ dấu cách nào ở đầu hoặc cuối:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Kết quả:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
Chúng tôi nhận được cùng một giá trị trả về cho dù chúng tôi sử dụng BINARY hoặc không.
Nhưng đây là những gì sẽ xảy ra khi chúng tôi thêm dấu cách ở cuối vào một trong các chuỗi:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Kết quả:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
Đầu tiên trả về 1 trong khi những người khác (tức là những người có BINARY ) trả về 0 .
Để chắc chắn, hãy so sánh các chuỗi đều có dấu cách ở cuối:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Kết quả:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Hãy nhớ rằng chúng ta chỉ nói về khoảng trống ở đầu và cuối ở đây. Khái niệm này không áp dụng cho khoảng trắng ở giữa chuỗi.
Ví dụ:hai dấu cách trong một chuỗi không bằng một dấu cách - ngay cả khi không sử dụng BINARY nhà điều hành:
SELECT 'Homer Jay' = 'Homer Jay';Kết quả:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
Trong trường hợp này, chuỗi đầu tiên chứa một khoảng trắng và chuỗi thứ hai chứa hai khoảng trắng. Như vậy là đủ để chúng không bằng nhau, ngay cả khi sử dụng một ký tự bằng cách so sánh ký tự.
Phân biệt chữ hoa chữ thường
BINARY toán tử buộc so sánh phân biệt chữ hoa chữ thường, ngay cả khi đối chiếu không phân biệt chữ hoa chữ thường.
Ví dụ:đây là đối chiếu kết nối của tôi:
SELECT @@collation_connection;Kết quả:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
ci ở cuối có nghĩa là không phân biệt chữ hoa chữ thường .
Dưới đây là một ví dụ về so sánh chuỗi ký tự viết hoa và viết thường:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Kết quả:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
So sánh đầu tiên trả về 1, bởi vì đối chiếu của tôi không phân biệt chữ hoa chữ thường. Cái thứ hai trả về 0 , bởi vì chúng tôi sử dụng BINARY nhà điều hành.
Kết quả bạn nhận được khi so sánh chuỗi như vậy (không có BINARY toán tử) sẽ phụ thuộc vào đối chiếu của bạn. Sử dụng đối chiếu phân biệt chữ hoa chữ thường sẽ trả về cùng một kết quả mà chúng tôi nhận được với BINARY .
Dưới đây là một ví dụ để chứng minh:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Kết quả:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Ở đây, tôi đã chỉ định rõ ràng bộ ký tự và đối chiếu ở cấp độ chuỗi. Cú pháp để làm điều đó giống như sau:
[_charset_name]'string' [COLLATE collation_name]
Chúng ta có thể thấy rằng đối chiếu không phân biệt chữ hoa chữ thường trả về một kết quả khác với đối chiếu phân biệt chữ hoa chữ thường. Và đối chiếu phân biệt chữ hoa chữ thường trả lại kết quả giống như chúng ta nhận được khi sử dụng BINARY nhà điều hành.
