W SQL NOT operator neguje dane wejściowe typu Boolean (odwraca wartość dowolnego wyrażenia Boolean). Dlatego zwraca TRUE gdy wyrażenie to FALSE .
Tabela źródłowa
Poniższa tabela jest używana jako przykłady 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 1
Oto prosty przykład demonstrujący NOT operatora.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 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 | +---------+-------------+-----------+-----------+------------+
W tym przypadku użyliśmy NOT operator do zanegowania wyniku LIKE operator. Nasze zapytanie zwraca wszystkie zwierzęta, które nie zaczynają się na literę F.
Przykład 2 – Używanie NOT z operatorami porównania
Jeśli używasz NOT operatora, aby zanegować operator porównania, będziesz musiał nieznacznie zmodyfikować składnię w stosunku do tej użytej w poprzednim przykładzie.
Na przykład, jeśli chcesz go użyć do zanegowania operatora równości (= ), użyj następującej składni:
SELECT * FROM Pets
WHERE NOT 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 | +---------+-------------+-----------+-----------+------------+
Spowoduje to zwrócenie wszystkich zwierząt, których imię nie brzmi Fluffy.
W tym przykładzie wstawiamy NOT operator przed nazwą kolumny. Gdybyśmy tego nie zrobili, otrzymalibyśmy błąd, który wygląda mniej więcej tak:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Wynik:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Mogliśmy również osiągnąć ten sam wynik, używając operatora nierównego (albo <> lub != w zależności od systemu DBMS).
Na przykład to:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Albo to:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Przykład 3 – ta sama składnia z operatorami logicznymi
Jak się okazuje, możemy również użyć tej składni podczas korzystania z operatorów logicznych, takich jak LIKE operatora, którego użyliśmy w pierwszym przykładzie.
Dlatego możemy przepisać pierwszy przykład do tego:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 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 | +---------+-------------+-----------+-----------+------------+
Jeśli nie jesteś pewien, jaka jest różnica, przenieśliśmy NOT operator po PetName kolumna, do przed nim.
Oto dwa stwierdzenia razem:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Przykład 4 – Negowanie wielu warunków
NOT operator neguje tylko jeden warunek. Jeśli masz wiele warunków, które musisz zanegować, użyj oddzielnego NOT operator dla każdego warunku,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Przykład 5 – Pierwszeństwo
Podczas korzystania z warunków złożonych, w których masz wiele operatorów, NOT operator jest oceniany przed dowolnymi operatorami logicznymi, ale po dowolnym. operatory porównania,
Gdy dwa operatory w wyrażeniu mają ten sam poziom pierwszeństwa, są oceniane od lewej do prawej na podstawie ich pozycji w wyrażeniu. Możesz jednak użyć nawiasów, aby określić kolejność, w jakiej chcesz oceniać każdy warunek.
Oto przykład.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';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 | +---------+-------------+-----------+-----------+------------+
Nie użyliśmy tutaj żadnych nawiasów, a wszystkie warunki zostały zanegowane za pomocą NOT operator, a więc AND operator miał pierwszeństwo przed OR operator.
Możemy jednak użyć nawiasów, aby określić, że OR warunek powinien być oceniany przed AND stan.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
W tym przypadku otrzymujemy inny wynik.
Przykład 6 – Zanegowanie operatora BETWEEN
Oto kolejny przykład, tym razem z użyciem NOT operator do zanegowania wyniku BETWEEN operatora.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Wynik:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
W tym przykładzie zwróciliśmy wszystkie wiersze, w których DOB kolumna nie między 2018-10-01 i 2020-09-17 .
W tym przypadku dwa wiersze spełniały to kryterium, a zatem zostały zwrócone dwa wiersze.
Jest to odwrotny wynik następującego zapytania:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';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 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
W tym przykładzie zwróciliśmy wszystkie wiersze, w których DOB kolumna jest między 2018-10-01 i 2020-09-17 .
W tym przypadku cztery wiersze spełniały te kryteria, a zatem zostały zwrócone cztery wiersze.
