En SQL, le NOT annule une entrée booléenne (il inverse la valeur de toute expression booléenne). Par conséquent, il renvoie TRUE lorsque l'expression est FALSE .
Tableau des sources
Le tableau suivant est utilisé pour les exemples sur cette page.
SELECT * FROM Pets;Résultat :
+---------+-------------+-----------+-----------+------------+ | 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)
Exemple 1
Voici un exemple simple pour démontrer le NOT opérateur.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Dans ce cas, nous avons utilisé le NOT opérateur pour annuler le résultat de LIKE opérateur. Notre requête renvoie tous les animaux qui ne commencent pas par la lettre F.
Exemple 2 - Utilisation de NOT avec des opérateurs de comparaison
Si vous utilisez le NOT pour annuler un opérateur de comparaison, vous devrez modifier légèrement votre syntaxe par rapport à celle utilisée dans l'exemple précédent.
Par exemple, si vous voulez l'utiliser pour inverser l'opérateur égal (= ), utilisez la syntaxe suivante :
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Cela renvoie tous les animaux dont le nom n'est pas Fluffy.
Dans cet exemple, nous mettons le NOT opérateur devant le nom de la colonne. Si nous n'avions pas fait cela, nous aurions reçu une erreur qui ressemblerait à ceci :
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Résultat :
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Nous aurions également pu obtenir le même résultat en utilisant l'opérateur différent de (soit <> ou != selon votre SGBD).
Par exemple, ceci :
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Ou ceci :
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Exemple 3 - Même syntaxe avec des opérateurs logiques
Il s'avère que nous pouvons également utiliser cette syntaxe lors de l'utilisation d'opérateurs logiques, tels que LIKE opérateur que nous avons utilisé dans le premier exemple.
Par conséquent, nous pourrions réécrire le premier exemple comme suit :
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Au cas où vous ne seriez pas sûr de la différence, nous avons déplacé le NOT opérateur après le PetName colonne, à avant.
Voici les deux déclarations ensemble :
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Exemple 4 – Négation de plusieurs conditions
Le NOT l'opérateur n'annule qu'une seule condition. Si vous avez plusieurs conditions que vous devez annuler, utilisez un NOT séparé opérateur pour chaque condition,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Exemple 5 - Priorité
Lorsque vous utilisez des conditions composées, où vous avez plusieurs opérateurs, le NOT L'opérateur est évalué avant tout opérateur logique, mais après tout. opérateurs de comparaison,
Lorsque deux opérateurs dans une expression ont le même niveau de priorité, ils sont évalués de gauche à droite en fonction de leur position dans l'expression. Cependant, vous pouvez utiliser des parenthèses pour spécifier l'ordre dans lequel vous souhaitez que chaque condition soit évaluée.
Voici un exemple.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Nous n'avons pas utilisé de parenthèses ici, et toutes les conditions ont été annulées avec le NOT opérateur, et donc le AND l'opérateur a préséance sur le OR opérateur.
Cependant, nous pouvons utiliser des parenthèses pour spécifier que le OR la condition doit être évaluée avant le AND état.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
Dans ce cas, nous obtenons un résultat différent.
Exemple 6 – Inverser l'opérateur BETWEEN
Voici un autre exemple, cette fois en utilisant le NOT opérateur pour inverser le résultat de BETWEEN opérateur.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
Dans cet exemple, nous avons renvoyé toutes les lignes où le DOB la colonne n'est pas entre 2018-10-01 et 2020-09-17 .
Dans ce cas, deux lignes correspondaient à ce critère et, par conséquent, deux lignes ont été renvoyées.
C'est le résultat inverse de la requête suivante :
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Dans cet exemple, nous avons renvoyé toutes les lignes où le DOB la colonne est entre 2018-10-01 et 2020-09-17 .
Dans ce cas, quatre lignes correspondaient à ce critère et, par conséquent, quatre lignes ont été renvoyées.
