I SQL er NOT operator negerer et boolsk input (det vender værdien af ethvert boolsk udtryk). Derfor returnerer den TRUE når udtrykket er FALSE .
Kildetabel
Følgende tabel bruges til eksemplerne på denne side.
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)
Eksempel 1
Her er et simpelt eksempel til at demonstrere 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 dette tilfælde brugte vi NOT operatør for at afvise resultatet af LIKE operatør. Vores forespørgsel returnerer alle kæledyr, der ikke starter med bogstavet F.
Eksempel 2 – Brug af IKKE med sammenligningsoperatører
Hvis du bruger NOT operator for at afvise en sammenligningsoperator, skal du ændre din syntaks lidt fra den, der blev brugt i det foregående eksempel.
For eksempel, hvis du vil bruge det til at negere lig-operatoren (= ), brug følgende syntaks:
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 | +---------+-------------+-----------+-----------+------------+
Dette returnerer alle kæledyr, hvis navn ikke er Fluffy.
I dette eksempel sætter vi NOT operator foran kolonnenavnet. Hvis vi ikke havde gjort det, ville vi have modtaget en fejl, der lyder sådan her:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Resultat:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Vi kunne også have opnået det samme resultat ved at bruge operatoren ikke lig med (enten <> eller != afhængigt af dit DBMS).
For eksempel dette:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Eller denne:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Eksempel 3 – Samme syntaks med logiske operatorer
Som det viser sig, kan vi også bruge den syntaks, når vi bruger logiske operatorer, såsom LIKE operator, som vi brugte i det første eksempel.
Derfor kunne vi omskrive det første eksempel til dette:
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 | +---------+-------------+-----------+-----------+------------+
Hvis du ikke er sikker på, hvad forskellen er, flyttede vi NOT operatør fra efter PetName kolonne, til før den.
Her er de to udsagn sammen:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Eksempel 4 – Negering af flere betingelser
NOT operatør ophæver kun en enkelt betingelse. Hvis du har flere betingelser, som du skal afvise, skal du bruge en separat NOT operatør for hver betingelse,
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 | +---------+-------------+-----------+-----------+------------+
Eksempel 5 – Forrang
Når du bruger sammensatte betingelser, hvor du har flere operatorer, er NOT operator evalueres før eventuelle logiske operatorer, men efter evt. sammenligningsoperatører,
Når to operatorer i et udtryk har samme forrangsniveau, evalueres de fra venstre mod højre baseret på deres placering i udtrykket. Du kan dog bruge parenteser til at angive den rækkefølge, du ønsker, at hver betingelse skal evalueres i.
Her er et eksempel.
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 brugte ingen parentes her, og alle betingelser blev negeret med NOT operator, og så AND operatoren havde forrang over OR operatør.
Vi kan dog bruge parenteser til at angive, at OR betingelse skal evalueres før AND tilstand.
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 dette tilfælde får vi et andet resultat.
Eksempel 6 – Forkast MELLEM operatøren
Her er endnu et eksempel, denne gang ved at bruge NOT operatør for at negere resultatet af 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 dette eksempel returnerede vi alle rækker, hvor DOB kolonne er ikke mellem 2018-10-01 og 2020-09-17 .
I dette tilfælde matchede to rækker dette kriterium, og derfor blev to rækker returneret.
Dette er det modsatte resultat af følgende forespørgsel:
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 dette eksempel returnerede vi alle rækker, hvor DOB kolonne er mellem 2018-10-01 og 2020-09-17 .
I dette tilfælde matchede fire rækker dette kriterium, og derfor blev fire rækker returneret.