Dalam SQL, tidak sama dengan operator (<> ) membandingkan ketidaksetaraan dua ekspresi. Artinya, ini menguji apakah satu ekspresi tidak sama dengan ekspresi lain.
Jika salah satu atau kedua operan adalah NULL , NULL dikembalikan.
SQL juga memiliki operator lain yang tidak sama (!= ), yang melakukan hal yang sama. Yang mana yang Anda gunakan mungkin bergantung pada DBMS Anda, mana yang paling nyaman Anda gunakan, dan mungkin juga apakah organisasi Anda memiliki konvensi pengkodean yang menentukan mana yang harus digunakan.
Tabel Sumber
Bayangkan database kami berisi tabel berikut. Ini adalah tabel yang akan kita gunakan untuk contoh di halaman ini.
SELECT * FROM Pets;Hasil:
+---------+-------------+-----------+-----------+------------+ | 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)
Contoh
Jika kami ingin mendapatkan semua hewan peliharaan yang tidak memiliki pemilik tertentu, kita bisa melakukan ini:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Hasil:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Kueri kami menggunakan operator yang tidak sama dengan (<> ) untuk menguji apakah OwnerId kolom tidak sama dengan 3 . Kueri mengembalikan semua hewan peliharaan yang tidak memiliki pemilik nomor 3 sebagai pemilik.
String
Saat membandingkan dengan nilai string, gunakan tanda kutip di sekitar string. Misalnya, jika kita ingin mendapatkan informasi tentang semua hewan peliharaan yang tidak bernama Fluffy, kita dapat melakukan hal berikut:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Hasil:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Beberapa Kondisi
Jika Anda memiliki beberapa kondisi, Anda dapat menggunakan beberapa operator (baik operator yang sama atau berbeda).
Seperti ini:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Hasil:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Meniadakan Kondisi
Jika Anda menggunakan NOT operator untuk meniadakan kondisi yang diberikan oleh operator yang tidak sama dengan, Anda akan mendapatkan hasil yang sama dengan (= ) operator:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Hasil:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Dalam hal ini, Anda sebaiknya menggunakan sama dengan (= ) operator, seperti ini:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Tentu saja, ini sendiri dapat dinegasikan dengan NOT operator, yang kemudian akan memberi kita hasil yang sama dengan (<> ) operator memberi kami:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Nilai NULL
Anda mungkin telah memperhatikan bahwa tabel sampel asli kami berisi beberapa NULL nilai di kolom DOB.
Kolom yang berisi NULL berarti tidak ada nilainya. Ini berbeda dengan 0 atau false , atau bahkan string kosong.
Anda tidak dapat menggunakan operator yang tidak sama dengan untuk membandingkan dengan NULL . Sebenarnya, ini mungkin tergantung pada DBMS Anda dan konfigurasinya. Tapi untuk sekarang, mari kita lihat apa yang terjadi jika saya mencoba membandingkan kolom DOB dengan NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Hasil:
(0 rows affected)
Cara menguji non-NULL nilainya adalah menggunakan IS NOT NULL .
Oleh karena itu, kita perlu menulis ulang pernyataan di atas sebagai berikut.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Hasil:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Sekarang kita hanya mendapatkan baris yang bukan NULL di DOB kolom.
Jika Anda tertarik, lihat SQL Server ANSI_NULLS Explained untuk melihat bagaimana Anda dapat mengubah cara NULL nilai diperlakukan di SQL Server.
