I SQL är operatorn inte lika med (<> ) jämför icke-likheten mellan två uttryck. Det vill säga, det testar om ett uttryck inte är lika med ett annat uttryck.
Om endera eller båda operanderna är NULL , NULL returneras.
SQL har också en annan operator som inte är lika med (!= ), som gör samma sak. Vilken du använder kan bero på ditt DBMS, vilket du är mest bekväm med att använda, och kanske också om din organisation har några kodningskonventioner som dikterar vilken som ska användas.
Källtabell
Föreställ dig att vår databas innehåller följande tabell. Det här är tabellen vi kommer att använda för exemplen på den här sidan.
SELECT * FROM Pets;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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)
Exempel
Om vi ville få alla husdjur som inte gör det har en viss ägare kan vi göra så här:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Vår fråga använder operatorn inte lika med (<> ) för att testa om OwnerId kolumnen är inte lika med 3 . Frågan returnerar alla husdjur som inte har ägare nummer 3 som ägare.
Strängar
När du jämför med ett strängvärde, använd citattecken runt strängen. Om vi till exempel vill få information om alla husdjur som inte heter Fluffy, kan vi göra följande:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Flera villkor
Om du har flera villkor kan du använda flera operatorer (både samma operatorer eller olika).
Så här:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Negerar villkoret
Om du använder NOT Om du vill upphäva villkoret som tillhandahålls av operatorn inte lika med, kommer du att få resultaten av lika med (= ) operatör:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
I det här fallet är det bättre att du bara använder lika med (= )-operator, så här:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Naturligtvis kan detta i sig förnekas med NOT operator, vilket då skulle ge oss samma resultat som lika med (<> ) ger oss:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';NULL-värden
Du kanske har märkt att vår ursprungliga exempeltabell innehåller ett par NULL värden i DOB-kolumnen.
En kolumn som innehåller NULL betyder att det inte har något värde. Detta skiljer sig från 0 eller false , eller till och med en tom sträng.
Du kan inte använda operatorn inte lika med för att jämföra med NULL . Egentligen kan detta bero på ditt DBMS och dess konfiguration. Men nu, låt oss titta på vad som händer om jag försöker jämföra DOB-kolumnen med NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Resultat:
(0 rows affected)
Sättet att testa för icke-NULL värden är att använda IS NOT NULL .
Därför skulle vi behöva skriva om ovanstående uttalande enligt följande.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 får vi bara de rader som inte är NULL i DOB kolumn.
Om du är intresserad, se SQL Server ANSI_NULLS Explained för att se hur du kan ändra sättet NULL värden behandlas i SQL Server.