Trong SQL, toán tử không bằng (<> ) so sánh tính không bằng nhau của hai biểu thức. Đó là, nó kiểm tra xem một biểu thức có không bằng một biểu thức khác.
Nếu một trong hai hoặc cả hai toán hạng là NULL , NULL được trả lại.
SQL cũng có một toán tử khác không bằng (!= ), làm điều tương tự. Cái nào bạn sử dụng có thể phụ thuộc vào DBMS của bạn, cái nào bạn cảm thấy thoải mái nhất khi sử dụng và có lẽ cả tổ chức của bạn có bất kỳ quy ước mã hóa nào quy định cái nào nên được sử dụng hay không.
Bảng nguồn
Hãy tưởng tượng cơ sở dữ liệu của chúng ta chứa bảng sau. Đây là bảng chúng tôi sẽ sử dụng cho các ví dụ trên trang này.
SELECT * FROM Pets;Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Ví dụ
Nếu chúng tôi muốn nhận tất cả các vật nuôi không không có một chủ sở hữu nhất định, chúng tôi có thể làm điều này:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Truy vấn của chúng tôi sử dụng toán tử không bằng với (<> ) để kiểm tra xem OwnerId cột không bằng 3 . Truy vấn trả về tất cả vật nuôi không có chủ sở hữu số 3 là chủ sở hữu.
Chuỗi
Khi so sánh với một giá trị chuỗi, hãy sử dụng dấu ngoặc kép xung quanh chuỗi. Ví dụ:nếu chúng tôi muốn nhận thông tin về tất cả các vật nuôi không có tên là Fluffy, chúng tôi có thể làm như sau:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Nhiều điều kiện
Nếu bạn có nhiều điều kiện, bạn có thể sử dụng nhiều toán tử (cho dù cả hai toán tử giống nhau hay khác nhau).
Như thế này:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Giảm thiểu điều kiện
Nếu bạn sử dụng NOT để phủ định điều kiện được cung cấp bởi toán tử không bằng với, bạn sẽ nhận được kết quả bằng (= ) toán tử:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Trong trường hợp này, tốt hơn hết bạn chỉ nên sử dụng bằng (= ), như sau:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Tất nhiên, bản thân điều này có thể bị phủ định với NOT toán tử, sau đó sẽ cho chúng ta cùng một kết quả bằng (<> ) nhà điều hành cung cấp cho chúng tôi:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Giá trị NULL
Bạn có thể nhận thấy rằng bảng mẫu ban đầu của chúng tôi chứa một vài NULL trong cột DOB.
Một cột chứa NULL nghĩa là nó không có giá trị. Điều này khác với 0 hoặc false , hoặc thậm chí là một chuỗi trống.
Bạn không thể sử dụng toán tử không bằng với để so sánh với NULL . Trên thực tế, điều này có thể phụ thuộc vào DBMS của bạn và cấu hình của nó. Nhưng bây giờ, hãy xem điều gì sẽ xảy ra nếu tôi cố gắng so sánh cột DOB với NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Kết quả:
(0 rows affected)
Cách kiểm tra không phải NULL các giá trị được sử dụng IS NOT NULL .
Do đó, chúng ta cần viết lại câu lệnh trên như sau.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Kết quả:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Bây giờ chúng tôi chỉ nhận được những hàng không phải là NULL trong DOB cột.
Nếu bạn quan tâm, hãy xem SQL Server ANSI_NULLS Explained để xem cách bạn có thể thay đổi cách NULL các giá trị được xử lý trong SQL Server.
