W SQL operator nierówny (<> ) porównuje nierówność dwóch wyrażeń. Oznacza to, że sprawdza, czy jedno wyrażenie nie równa się innemu wyrażeniu.
Jeśli jeden lub oba operandy są NULL , NULL jest zwracany.
SQL ma również inny operator nierówny (!= ), który robi to samo. To, którego używasz, może zależeć od Twojego DBMS, z którego korzystasz najwygodniej, a być może także od tego, czy Twoja organizacja ma jakieś konwencje kodowania, które dyktują, który z nich powinien być używany.
Tabela źródłowa
Wyobraź sobie, że nasza baza danych zawiera poniższą tabelę. To jest tabela, której użyjemy dla przykładów na tej stronie.
SELECT * FROM Pets;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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)
Przykład
Gdybyśmy chcieli zdobyć wszystkie zwierzęta, które nie mieć określonego właściciela, możemy to zrobić:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Nasze zapytanie używa operatora nierównego (<> ), aby sprawdzić, czy OwnerId kolumna nie jest równa 3 . Zapytanie zwraca wszystkie zwierzęta, które nie mają właściciela nr 3.
Struny
Porównując z wartością ciągu, użyj cudzysłowów wokół ciągu. Na przykład, jeśli chcielibyśmy uzyskać informacje o wszystkich zwierzętach domowych, które nie mają imienia Puszysty, możemy wykonać następujące czynności:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Wiele warunków
Jeśli masz wiele warunków, możesz użyć wielu operatorów (zarówno tych samych, jak i różnych).
Tak:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Negowanie warunku
Jeśli używasz NOT operatora, aby zanegować warunek dostarczony przez operator nierówny, otrzymasz wyniki równe (= ) operator:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
W takim przypadku lepiej jest po prostu użyć równego (= ) operator, na przykład:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Oczywiście samo to można zanegować za pomocą NOT operator, który dałby nam ten sam wynik, co równanie (<> ) operator daje nam:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Wartości NULL
Być może zauważyłeś, że nasza oryginalna przykładowa tabela zawiera kilka NULL wartości w kolumnie DOB.
Kolumna zawierająca NULL oznacza, że nie ma wartości. Różni się to od 0 lub false , a nawet pusty ciąg.
Nie możesz użyć operatora nierównego do porównania z NULL . W rzeczywistości może to zależeć od twojego DBMS i jego konfiguracji. Ale na razie spójrzmy, co się stanie, jeśli spróbuję porównać kolumnę DOB z NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Wynik:
(0 rows affected)
Sposób na testowanie pod kątem NULL wartości to użycie IS NOT NULL .
Dlatego musielibyśmy przepisać powyższe stwierdzenie w następujący sposób.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Teraz otrzymujemy tylko te wiersze, które nie są NULL w DOB kolumna.
Jeśli jesteś zainteresowany, zobacz SQL Server ANSI_NULLS Explained aby zobaczyć, jak możesz zmienić sposób, w jaki NULL wartości są traktowane w SQL Server.
