En SQL, l'opérateur différent de (<> ) compare la non-égalité de deux expressions. C'est-à-dire qu'il teste si une expression n'est pas égal à une autre expression.
Si l'un des opérandes ou les deux sont NULL , NULL est renvoyé.
SQL a également un autre opérateur différent de (!= ), qui fait la même chose. Celui que vous utilisez peut dépendre de votre SGBD, de celui avec lequel vous êtes le plus à l'aise, et peut-être aussi si votre organisation a des conventions de codage qui dictent laquelle doit être utilisée.
Tableau des sources
Imaginez que notre base de données contient le tableau suivant. C'est le tableau que nous utiliserons 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
Si nous voulions obtenir tous les animaux qui ne le font pas ont un certain propriétaire, nous pourrions faire ceci :
SELECT *
FROM Pets
WHERE OwnerId <> 3;Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Notre requête utilise l'opérateur différent de (<> ) pour tester si le OwnerId la colonne n'est pas égale à 3 . La requête renvoie tous les animaux qui n'ont pas le numéro de propriétaire 3 en tant que propriétaire.
Chaînes
Lors de la comparaison avec une valeur de chaîne, utilisez des guillemets autour de la chaîne. Par exemple, si nous voulions obtenir des informations sur tous les animaux qui ne s'appellent pas Fluffy, nous pourrions procéder comme suit :
SELECT *
FROM Pets
WHERE 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 | +---------+-------------+-----------+-----------+------------+
Plusieurs conditions
Si vous avez plusieurs conditions, vous pouvez utiliser plusieurs opérateurs (qu'ils soient identiques ou différents).
Comme ceci :
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Négation de la condition
Si vous utilisez le NOT pour annuler la condition fournie par l'opérateur différent de, vous obtiendrez les résultats de l'égal à (= ) opérateur :
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Dans ce cas, vous feriez mieux d'utiliser simplement l'égal à (= ) opérateur, comme ceci :
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Bien sûr, cela pourrait être annulé avec le NOT opérateur, qui nous donnerait alors le même résultat que l'égal à (<> ) l'opérateur nous donne :
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Valeurs NULLES
Vous avez peut-être remarqué que notre exemple de table d'origine contient quelques NULL valeurs dans la colonne DOB.
Une colonne contenant NULL signifie qu'il n'a aucune valeur. Ceci est différent de 0 ou false , ou même une chaîne vide.
Vous ne pouvez pas utiliser l'opérateur différent de pour comparer avec NULL . En fait, cela peut dépendre de votre SGBD et de sa configuration. Mais pour l'instant, regardons ce qui se passe si j'essaie de comparer la colonne DOB à NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Résultat :
(0 rows affected)
La façon de tester non-NULL valeurs est d'utiliser IS NOT NULL .
Par conséquent, nous aurions besoin de réécrire la déclaration ci-dessus comme suit.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;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 | +---------+-------------+-----------+-----------+------------+
Maintenant, nous n'obtenons que les lignes qui ne sont pas NULL dans la DOB colonne.
Si vous êtes intéressé, consultez SQL Server ANSI_NULLS Explained pour voir comment vous pouvez changer la façon dont NULL les valeurs sont traitées dans SQL Server.
