In SQL ist das NOT -Operator negiert eine boolesche Eingabe (er kehrt den Wert eines beliebigen booleschen Ausdrucks um). Daher gibt es TRUE zurück wenn der Ausdruck FALSE ist .
Quelltabelle
Die folgende Tabelle wird für die Beispiele auf dieser Seite verwendet.
SELECT * FROM Pets;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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)
Beispiel 1
Hier ist ein einfaches Beispiel, um NOT zu demonstrieren Betreiber.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 diesem Fall haben wir den NOT verwendet Operator, um das Ergebnis von LIKE zu negieren Operator. Unsere Abfrage gibt alle Haustiere zurück, die nicht mit dem Buchstaben F beginnen.
Beispiel 2 – Verwendung von NOT mit Vergleichsoperatoren
Wenn Sie NOT verwenden -Operator verwenden, um einen Vergleichsoperator zu negieren, müssen Sie Ihre Syntax geringfügig von der im vorherigen Beispiel verwendeten ändern.
Wenn Sie ihn beispielsweise verwenden möchten, um den Gleichheitsoperator zu negieren (= ), verwenden Sie die folgende Syntax:
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Dies gibt alle Haustiere zurück, deren Name nicht Fluffy ist.
In diesem Beispiel setzen wir den NOT Operator vor dem Spaltennamen. Wenn wir das nicht getan hätten, hätten wir eine Fehlermeldung erhalten, die ungefähr so lautet:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Ergebnis:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Wir hätten dasselbe Ergebnis auch erzielen können, indem wir den Ungleich-Operator verwendet hätten (entweder <> oder != abhängig von Ihrem DBMS).
Zum Beispiel dies:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Oder dies:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Beispiel 3 – Gleiche Syntax mit logischen Operatoren
Wie sich herausstellt, können wir diese Syntax auch verwenden, wenn wir logische Operatoren wie LIKE verwenden Operator, den wir im ersten Beispiel verwendet haben.
Daher könnten wir das erste Beispiel folgendermaßen umschreiben:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Falls Sie sich nicht sicher sind, was der Unterschied ist, haben wir den NOT verschoben Operator von nach dem PetName Spalte, bis davor.
Hier sind die beiden Anweisungen zusammen:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Beispiel 4 – Negation mehrerer Bedingungen
Das NOT Operator negiert nur eine einzige Bedingung. Wenn Sie mehrere Bedingungen haben, die Sie negieren müssen, verwenden Sie ein separates NOT Operator für jede Bedingung,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Beispiel 5 – Vorrang
Wenn Sie zusammengesetzte Bedingungen verwenden, bei denen Sie mehrere Operatoren haben, wird NOT Operator wird vor allen logischen Operatoren ausgewertet, aber nach allen. Vergleichsoperatoren,
Wenn zwei Operatoren in einem Ausdruck die gleiche Prioritätsstufe haben, werden sie basierend auf ihrer Position im Ausdruck von links nach rechts ausgewertet. Sie können jedoch Klammern verwenden, um die Reihenfolge anzugeben, in der die einzelnen Bedingungen ausgewertet werden sollen.
Hier ist ein Beispiel.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Wir haben hier keine Klammern verwendet und alle Bedingungen wurden mit dem NOT negiert Operator, also das AND Operator hatte Vorrang vor dem OR Operator.
Wir können jedoch Klammern verwenden, um anzugeben, dass das OR Bedingung sollte vor dem AND ausgewertet werden Zustand.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
In diesem Fall erhalten wir ein anderes Ergebnis.
Beispiel 6 – Negiere den BETWEEN-Operator
Hier ist ein weiteres Beispiel, diesmal mit NOT Operator, um das Ergebnis von BETWEEN zu negieren Betreiber.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
In diesem Beispiel haben wir alle Zeilen zurückgegeben, in denen DOB Spalte ist nicht zwischen 2018-10-01 und 2020-09-17 .
In diesem Fall stimmten zwei Zeilen mit diesen Kriterien überein und daher wurden zwei Zeilen zurückgegeben.
Dies ist das entgegengesetzte Ergebnis der folgenden Abfrage:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 diesem Beispiel haben wir alle Zeilen zurückgegeben, in denen DOB Spalte ist zwischen 2018-10-01 und 2020-09-17 .
In diesem Fall stimmten vier Zeilen mit diesen Kriterien überein und daher wurden vier Zeilen zurückgegeben.
