In SQL is de operator niet gelijk aan (<> ) vergelijkt de niet-gelijkheid van twee uitdrukkingen. Dat wil zeggen, het test of een uitdrukking niet . is gelijk aan een andere uitdrukking.
Als een of beide operanden NULL zijn , NULL wordt geretourneerd.
SQL heeft ook een andere die niet gelijk is aan operator (!= ), die hetzelfde doet. Welke u gebruikt, hangt mogelijk af van uw DBMS, welke u het prettigst gebruikt en misschien ook of uw organisatie codeerconventies heeft die bepalen welke moet worden gebruikt.
Brontabel
Stel je voor dat onze database de volgende tabel bevat. Dit is de tabel die we zullen gebruiken 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
Als we alle huisdieren wilden hebben die niet een bepaalde eigenaar hebben, kunnen we dit doen:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Onze query gebruikt de operator niet gelijk aan (<> ) om te testen of de OwnerId kolom is niet gelijk aan 3 . De zoekopdracht retourneert alle huisdieren die geen eigenaar nummer 3 als eigenaar hebben.
Snaren
Gebruik aanhalingstekens rond de tekenreeks wanneer u deze vergelijkt met een tekenreekswaarde. Als we bijvoorbeeld informatie willen krijgen over alle huisdieren die niet Fluffy heten, kunnen we het volgende doen:
SELECT *
FROM Pets
WHERE 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 | +---------+-------------+-----------+-----------+------------+
Meerdere voorwaarden
Als u meerdere voorwaarden heeft, kunt u meerdere operators gebruiken (zowel dezelfde operators als verschillende).
Zoals dit:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
De voorwaarde negeren
Als u de NOT . gebruikt operator om de voorwaarde van de operator niet gelijk aan te ontkennen, krijgt u uiteindelijk de resultaten van de gelijk aan (= ) operator:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Resultaat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
In dit geval kunt u beter gewoon de gelijk aan (= . gebruiken) ) operator, als volgt:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Dit kan natuurlijk zelf teniet gedaan worden met de NOT operator, die ons dan hetzelfde resultaat zou geven als gelijk aan (<> ) operator geeft ons:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';NULL-waarden
Het is je misschien opgevallen dat onze originele voorbeeldtabel een paar NULL . bevat waarden in de DOB-kolom.
Een kolom met NULL betekent dat het geen waarde heeft. Dit is anders dan 0 of false , of zelfs een lege string.
U kunt de operator niet gelijk aan gebruiken om te vergelijken met NULL . Dit kan in feite afhangen van uw DBMS en de configuratie ervan. Maar laten we voor nu eens kijken wat er gebeurt als ik de DOB-kolom probeer te vergelijken met NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Resultaat:
(0 rows affected)
De manier om te testen op niet-NULL waarden is om IS NOT NULL te gebruiken .
Daarom zouden we de bovenstaande verklaring als volgt moeten herschrijven.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;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 | +---------+-------------+-----------+-----------+------------+
Nu krijgen we alleen die rijen die niet NULL . zijn in de DOB kolom.
Als je geïnteresseerd bent, bekijk dan SQL Server ANSI_NULLS Explained om te zien hoe je de manier kunt veranderen NULL waarden worden behandeld in SQL Server.