I SQL er operatoren ikke lig med (<> ) sammenligner uligheden mellem to udtryk. Det vil sige, det tester, om et udtryk ikke er lig med et andet udtryk.
Hvis den ene eller begge operander er NULL , NULL er returneret.
SQL har også en anden ikke lig med operator (!= ), som gør det samme. Hvilken du bruger kan afhænge af dit DBMS, hvilken du er mest komfortabel med at bruge, og måske også om din organisation har nogle kodningskonventioner, der dikterer, hvilken der skal bruges.
Kildetabel
Forestil dig, at vores database indeholder følgende tabel. Dette er den tabel, vi vil bruge til eksemplerne på denne side.
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)
Eksempel
Hvis vi ønskede at få alle kæledyr, der ikke gør har en bestemt ejer, kunne vi gøre dette:
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 | +---------+-------------+-----------+-----------+------------+
Vores forespørgsel bruger operatoren ikke lig med (<> ) for at teste, om OwnerId kolonne er ikke lig med 3 . Forespørgslen returnerer alle kæledyr, der ikke har ejer nummer 3 som ejer.
Strenge
Når du sammenligner med en strengværdi, skal du bruge anførselstegn omkring strengen. For eksempel, hvis vi ønskede at få information om alle kæledyr, der ikke hedder Fluffy, kunne vi gøre følgende:
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 | +---------+-------------+-----------+-----------+------------+
Flere betingelser
Hvis du har flere betingelser, kan du bruge flere operatorer (både de samme operatorer eller forskellige).
Sådan:
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 | +---------+-------------+-----------+-----------+------------+
Nægter betingelsen
Hvis du bruger NOT operatør for at ophæve betingelsen givet af ikke lig med operatoren, vil du ende med at få resultaterne af lig 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 dette tilfælde er du bedre stillet blot at bruge lig med (= ) operatør, som denne:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Selvfølgelig kan dette i sig selv blive negeret med NOT operator, hvilket så ville give os det samme resultat som lig med (<> ) giver os:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';NULL-værdier
Du har måske bemærket, at vores originale eksempeltabel indeholder et par NULL værdier i DOB-kolonnen.
En kolonne, der indeholder NULL betyder, at det ikke har nogen værdi. Dette er anderledes end 0 eller falsk , eller endda en tom streng.
Du kan ikke bruge operatoren ikke lig med til at sammenligne med NULL . Faktisk kan dette afhænge af dit DBMS og dets konfiguration. Men for nu, lad os se på, hvad der sker, hvis jeg prøver at sammenligne DOB-kolonnen med NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Resultat:
(0 rows affected)
Måden at teste for ikke-NULL værdier er at bruge IS NOT NULL .
Derfor er vi nødt til at omskrive ovenstående erklæring som følger.
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 kun de rækker, der ikke er NULL i DOB kolonne.
Hvis du er interesseret, se SQL Server ANSI_NULLS Forklaret for at se, hvordan du kan ændre måden NULL på værdier behandles i SQL Server.