Hướng dẫn mysql binary like - nhị phân mysql như

12.8.1 & NBSP; Chức năng so sánh chuỗi và toán tử

Bảng & NBSP; 12.13 & NBSP; Chức năng so sánh chuỗi và toán tử

TênSự mô tả
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
3
Phù hợp với mô hình đơn giản
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
4
Sự phủ định của kết hợp mô hình đơn giản
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
5
So sánh hai chuỗi

Nếu một hàm chuỗi được cung cấp một chuỗi nhị phân như một đối số, chuỗi kết quả cũng là một chuỗi nhị phân. Một số được chuyển đổi thành một chuỗi được coi là một chuỗi nhị phân. Điều này chỉ ảnh hưởng đến so sánh.

Thông thường, nếu bất kỳ biểu thức nào trong so sánh chuỗi là nhạy cảm trường hợp, thì so sánh được thực hiện theo kiểu nhạy cảm trường hợp.

Nếu một hàm chuỗi được gọi từ bên trong máy khách MySQL, hiển thị chuỗi nhị phân bằng cách sử dụng ký hiệu thập lục phân, tùy thuộc vào giá trị của

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
6. Để biết thêm thông tin về tùy chọn đó, hãy xem Phần & NBSP; 4.5.1, MYSQL-Máy khách dòng lệnh MySQL.mysql client, binary strings display using hexadecimal notation, depending on the value of the
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
6. For more information about that option, see Section 4.5.1, “mysql — The MySQL Command-Line Client”.

  • mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    7 như
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    8 [Escape '
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    9']]

    Kết hợp mẫu bằng cách sử dụng mẫu SQL. Trả về

    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    0 (
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    1) hoặc
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    2 (
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    3). Nếu
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    4 hoặc
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    8 là
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6, kết quả là
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6.

    Các mẫu không cần phải là một chuỗi theo nghĩa đen. Ví dụ: nó có thể được chỉ định là một biểu thức chuỗi hoặc cột bảng. Trong trường hợp sau, cột phải được định nghĩa là một trong các loại chuỗi MySQL (xem Phần & NBSP; 11.3, các loại dữ liệu chuỗi chuỗi).

    Theo tiêu chuẩn SQL,

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    3 thực hiện phù hợp trên cơ sở peracter, do đó nó có thể tạo ra kết quả khác với toán tử so sánh
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    9:

    mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
    +-----------------------------------------+
    | 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
    +-----------------------------------------+
    |                                       0 |
    +-----------------------------------------+
    mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
    +--------------------------------------+
    | 'ä' = 'ae' COLLATE latin1_german2_ci |
    +--------------------------------------+
    |                                    1 |
    +--------------------------------------+

    Đặc biệt, không gian theo dõi luôn luôn có ý nghĩa. Điều này khác với các so sánh được thực hiện với toán tử

    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    9, trong đó tầm quan trọng của các không gian dấu vết trong các chuỗi không phải là (
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    1,
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    2 và
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    3) phụ thuộc vào thuộc tính PAD của đối chiếu được sử dụng để so sánh. Để biết thêm thông tin, xem xử lý không gian theo dõi trong so sánh.

    Với

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    3, bạn có thể sử dụng hai ký tự ký tự đại diện sau trong mẫu:

    • mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
              -> 1
      5 khớp với bất kỳ số lượng ký tự nào, thậm chí không có ký tự.

    • mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
              -> 1
      6 khớp với chính xác một ký tự.

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1

    Để kiểm tra các trường hợp theo nghĩa đen của một nhân vật ký tự đại diện, đi trước nó bởi nhân vật thoát hiểm. Nếu bạn không chỉ định ký tự

    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    7,
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    8 sẽ được giả định, trừ khi chế độ
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    9 SQL được bật. Trong trường hợp đó, không có ký tự thoát nào được sử dụng.

    • mysql> SELECT 'abc' LIKE 'ABC';
              -> 1
      mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
              -> 0
      mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
              -> 0
      mysql> SELECT 'abc' LIKE BINARY 'ABC';
              -> 0
      0 khớp với một ký tự
      mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
              -> 1
      5.

    • mysql> SELECT 'abc' LIKE 'ABC';
              -> 1
      mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
              -> 0
      mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
              -> 0
      mysql> SELECT 'abc' LIKE BINARY 'ABC';
              -> 0
      2 khớp với một ký tự
      mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
              -> 1
      6.

    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1

    Để chỉ định một ký tự thoát khác nhau, hãy sử dụng mệnh đề

    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    7:

    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1

    Trình tự thoát nên là một ký tự dài để chỉ định ký tự thoát hoặc trống để chỉ định rằng không có ký tự thoát nào được sử dụng. Biểu thức phải đánh giá như một hằng số tại thời điểm thực hiện. Nếu chế độ

    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    9 SQL được bật, chuỗi không thể trống.

    Hai câu sau đây minh họa rằng các so sánh chuỗi không nhạy cảm với trường hợp trừ khi một trong các toán hạng nhạy cảm trường hợp (sử dụng đối chiếu nhạy cảm trường hợp hoặc là chuỗi nhị phân):

    mysql> SELECT 'abc' LIKE 'ABC';
            -> 1
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
            -> 0
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
            -> 0
    mysql> SELECT 'abc' LIKE BINARY 'ABC';
            -> 0

    Là một phần mở rộng cho SQL tiêu chuẩn, MySQL cho phép

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    3 trên các biểu thức số.

    mysql> SELECT 10 LIKE '1%';
            -> 1

    Ghi chú

    MySQL sử dụng C Escape Cú pháp trong chuỗi (ví dụ:

    mysql> SELECT 'abc' LIKE 'ABC';
            -> 1
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
            -> 0
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
            -> 0
    mysql> SELECT 'abc' LIKE BINARY 'ABC';
            -> 0
    7 để biểu thị ký tự dòng mới). Nếu bạn muốn một chuỗi
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    3 chứa một
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    8 theo nghĩa đen, bạn phải nhân đôi nó. (Trừ khi chế độ
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    9 SQL được bật, trong trường hợp đó không sử dụng ký tự thoát.) Để tìm kiếm
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    8, chỉ định nó là
    mysql> SELECT 10 LIKE '1%';
            -> 1
    4; Điều này là do các dấu gạch chéo ngược bị loại bỏ một lần bởi trình phân tích cú pháp và một lần nữa khi kết quả phù hợp với mẫu, để lại một dấu gạch chéo ngược để được khớp với.

    Ngoại lệ: Ở cuối chuỗi mẫu, Backslash có thể được chỉ định là

    mysql> SELECT 10 LIKE '1%';
            -> 1
    5. Ở cuối chuỗi, Backslash là tự đứng vì không có gì theo sau để trốn thoát. Giả sử rằng một bảng chứa các giá trị sau:

    mysql> SELECT filename FROM t1;
    +--------------+
    | filename     |
    +--------------+
    | C:           |
    | C:\          |
    | C:\Programs  |
    | C:\Programs\ |
    +--------------+

    Để kiểm tra các giá trị kết thúc bằng dấu gạch chéo ngược, bạn có thể khớp các giá trị bằng một trong các mẫu sau:

    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+

  • mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    7 không thích
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    8 [Escape '
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    9']]

    Điều này giống như không (

    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    4 như
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    8 [Escape '
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    9']).NOT (
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    4 LIKE
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    8 [ESCAPE '
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    9'])
    .

    Ghi chú

    MySQL sử dụng C Escape Cú pháp trong chuỗi (ví dụ:

    mysql> SELECT 'abc' LIKE 'ABC';
            -> 1
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
            -> 0
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
            -> 0
    mysql> SELECT 'abc' LIKE BINARY 'ABC';
            -> 0
    7 để biểu thị ký tự dòng mới). Nếu bạn muốn một chuỗi
    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    3 chứa một
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    8 theo nghĩa đen, bạn phải nhân đôi nó. (Trừ khi chế độ
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    9 SQL được bật, trong trường hợp đó không sử dụng ký tự thoát.) Để tìm kiếm
    mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
            -> 1
    8, chỉ định nó là
    mysql> SELECT 10 LIKE '1%';
            -> 1
    4; Điều này là do các dấu gạch chéo ngược bị loại bỏ một lần bởi trình phân tích cú pháp và một lần nữa khi kết quả phù hợp với mẫu, để lại một dấu gạch chéo ngược để được khớp với.

    CREATE TABLE foo (bar VARCHAR(10));
    
    INSERT INTO foo VALUES (NULL), (NULL);

    Ngoại lệ: Ở cuối chuỗi mẫu, Backslash có thể được chỉ định là

    mysql> SELECT 10 LIKE '1%';
            -> 1
    5. Ở cuối chuỗi, Backslash là tự đứng vì không có gì theo sau để trốn thoát. Giả sử rằng một bảng chứa các giá trị sau:NULL NOT LIKE
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    4
    always returns
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6, regardless of the value of
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    4. The same is true for aggregate queries involving
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6 and comparisons using
    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    3 or
    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    4. In such cases, you must test explicitly for
    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    5 using
    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    6 (and not
    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    7), as shown here:

    SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%' OR bar IS NULL;

  • ________ 78, ________ 79)

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    5 trả về
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    2 Nếu các chuỗi giống nhau,
    CREATE TABLE foo (bar VARCHAR(10));
    
    INSERT INTO foo VALUES (NULL), (NULL);
    2 nếu đối số đầu tiên nhỏ hơn thứ hai theo thứ tự sắp xếp hiện tại và
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6 nếu một trong hai đối số là
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    6.Nó trả về
    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    0 nếu không.

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    0

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    5 thực hiện so sánh bằng cách sử dụng đối chiếu các đối số.

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    1

    Nếu các đối chiếu không tương thích, một trong những đối số phải được chuyển đổi để tương thích với các đối số khác.Xem phần & nbsp; 10.8.4, sự ép buộc đối chiếu trong các biểu thức.

    mysql> SELECT 'David!' LIKE 'David_';
            -> 1
    mysql> SELECT 'David!' LIKE '%D%v%';
            -> 1
    2