In SQL is de NOT operator negeert een Booleaanse invoer (het keert de waarde van elke Booleaanse uitdrukking om). Daarom retourneert het TRUE wanneer de uitdrukking FALSE . is .
Brontabel
De volgende tabel wordt gebruikt voor de voorbeelden op deze pagina.
SELECT * FROM Pets;Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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)
Voorbeeld 1
Hier is een eenvoudig voorbeeld om de NOT . te demonstreren telefoniste.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
In dit geval gebruikten we de NOT operator om de uitkomst van de LIKE . te negeren exploitant. Onze zoekopdracht retourneert alle huisdieren die niet beginnen met de letter F.
Voorbeeld 2 – NOT gebruiken met vergelijkingsoperators
Als u de NOT . gebruikt operator om een vergelijkingsoperator te negeren, moet u uw syntaxis iets wijzigen ten opzichte van degene die in het vorige voorbeeld werd gebruikt.
Als u het bijvoorbeeld wilt gebruiken om de operator is gelijk aan (= ), gebruik de volgende syntaxis:
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Hiermee worden alle huisdieren geretourneerd wiens naam niet Fluffy is.
In dit voorbeeld plaatsen we de NOT operator voor de kolomnaam. Als we dat niet hadden gedaan, zouden we een foutmelding hebben gekregen die ongeveer als volgt gaat:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Resultaat:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
We hadden hetzelfde resultaat kunnen bereiken door de operator niet gelijk aan te gebruiken (ofwel <> of != afhankelijk van uw DBMS).
Bijvoorbeeld dit:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Of dit:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Voorbeeld 3 – Zelfde syntaxis met logische operators
Het blijkt dat we die syntaxis ook kunnen gebruiken bij het gebruik van logische operatoren, zoals de LIKE operator die we in het eerste voorbeeld gebruikten.
Daarom kunnen we het eerste voorbeeld hiernaar herschrijven:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Als je niet zeker weet wat het verschil is, hebben we de NOT . verplaatst operator van na de PetName kolom, naar ervoor.
Hier zijn de twee uitspraken samen:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Voorbeeld 4 – Meerdere voorwaarden negeren
De NOT operator negeert slechts een enkele voorwaarde. Als je meerdere voorwaarden hebt die je moet negeren, gebruik dan een aparte NOT operator voor elke voorwaarde,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Voorbeeld 5 – Voorrang
Als u samengestelde voorwaarden gebruikt, waarbij u meerdere operatoren heeft, wordt de NOT operator wordt geëvalueerd voorafgaand aan logische operatoren, maar na elke. vergelijkingsoperatoren,
Wanneer twee operators in een uitdrukking hetzelfde prioriteitsniveau hebben, worden ze van links naar rechts geëvalueerd op basis van hun positie in de uitdrukking. U kunt echter haakjes gebruiken om de volgorde aan te geven waarin u elke voorwaarde wilt evalueren.
Hier is een voorbeeld.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
We hebben hier geen haakjes gebruikt en alle voorwaarden werden genegeerd met de NOT operator, en dus de AND operator had voorrang op de OR exploitant.
We kunnen echter haakjes gebruiken om aan te geven dat de OR voorwaarde moet worden geëvalueerd vóór de AND staat.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Resultaat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
In dit geval krijgen we een ander resultaat.
Voorbeeld 6 – Negeer de TUSSEN-operator
Hier is nog een voorbeeld, dit keer met de NOT operator om het resultaat van de BETWEEN . te negeren telefoniste.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Resultaat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
In dit voorbeeld hebben we alle rijen geretourneerd waar de DOB kolom is niet tussen 2018-10-01 en 2020-09-17 .
In dit geval kwamen twee rijen overeen met die criteria en daarom werden er twee rijen geretourneerd.
Dit is het tegenovergestelde resultaat van de volgende zoekopdracht:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
In dit voorbeeld hebben we alle rijen geretourneerd waar de DOB kolom is tussen 2018-10-01 en 2020-09-17 .
In dit geval kwamen vier rijen overeen met die criteria en daarom werden er vier rijen geretourneerd.