I SQL, NOT operatorn negerar en boolesk indata (den vänder värdet på valfritt booleskt uttryck). Därför returnerar den TRUE när uttrycket är FALSE .
Källtabell
Följande tabell används för exemplen på den här sidan.
SELECT * FROM Pets;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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)
Exempel 1
Här är ett enkelt exempel för att demonstrera NOT operatör.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
I det här fallet använde vi NOT operatorn för att förneka resultatet av LIKE operatör. Vår fråga returnerar alla husdjur som inte börjar med bokstaven F.
Exempel 2 – Användning av INTE med jämförelseoperatörer
Om du använder NOT för att förneka en jämförelseoperator, måste du ändra din syntax något från den som användes i föregående exempel.
Till exempel, om du vill använda den för att negera lika-operatorn (= ), använd följande syntax:
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Detta returnerar alla husdjur vars namn inte är Fluffy.
I det här exemplet sätter vi NOT operatorn framför kolumnnamnet. Om vi inte hade gjort det skulle vi ha fått ett felmeddelande som är ungefär så här:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Resultat:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Vi kunde också ha uppnått samma resultat genom att använda operatorn inte lika med (antingen <> eller != beroende på ditt DBMS).
Till exempel detta:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Eller det här:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Exempel 3 – Samma syntax med logiska operatorer
Som det visar sig kan vi också använda den syntaxen när vi använder logiska operatorer, såsom LIKE operatorn som vi använde i det första exemplet.
Därför skulle vi kunna skriva om det första exemplet till detta:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Om du inte är säker på vad skillnaden är flyttade vi NOT operatör från efter PetName kolumn, till före den.
Här är de två påståendena tillsammans:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Exempel 4 – Negera flera villkor
NOT operatören förnekar bara ett enda villkor. Om du har flera villkor som du behöver förneka, använd en separat NOT operatör för varje villkor,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Exempel 5 – Företräde
När du använder sammansatta villkor, där du har flera operatorer, är NOT operatorn utvärderas före eventuella logiska operatorer, men efter någon. jämförelseoperatorer,
När två operatorer i ett uttryck har samma prioritetsnivå, utvärderas de från vänster till höger baserat på deras position i uttrycket. Du kan dock använda parenteser för att ange i vilken ordning du vill att varje villkor ska utvärderas.
Här är ett exempel.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Vi använde inga parenteser här, och alla villkor upphävdes med NOT operatorn och så AND operatorn hade företräde framför OR operatör.
Vi kan dock använda parenteser för att specificera att OR villkoret bör utvärderas före AND skick.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
I det här fallet får vi ett annat resultat.
Exempel 6 – Negera MELLAN operatören
Här är ett annat exempel, den här gången med NOT operatorn för att negera resultatet av BETWEEN operatör.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
I det här exemplet returnerade vi alla rader där DOB kolumnen är inte mellan 2018-10-01 och 2020-09-17 .
I det här fallet matchade två rader det kriteriet, och därför returnerades två rader.
Detta är det motsatta resultatet av följande fråga:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
I det här exemplet returnerade vi alla rader där DOB kolumn är mellan 2018-10-01 och 2020-09-17 .
I det här fallet matchade fyra rader det kriteriet, och därför returnerades fyra rader.