Lika-operatorn (= ) är förmodligen den mest använda operatorn i SQL. Den jämför likheten mellan två uttryck. Även om du precis har börjat din SQL-resa, känner du förmodligen den här operatorn.
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 med en viss ägare kunde vi göra detta:
SELECT *
FROM Pets
WHERE OwnerId = 3;Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 4 | 3 | 3 | Wag | 2020-03-15 | +---------+-------------+-----------+-----------+------------+
Vår fråga använder operatorn equals (= ) för att jämföra likheten mellan värdet på OwnerId kolumn och 3 .
I det här fallet har ägare nummer 3 3 husdjur.
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 heter Fluffy, kan vi göra följande:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Vår fråga använder operatorn equals (= ) för att jämföra likheten mellan värdet på PetName kolumn och strängen Fluffy .
I vårt fall kan vi se att djurhotellet för närvarande har två husdjur som heter Fluffy.
Flera villkor
Om du har flera villkor kan du använda flera lika-operatorer.
Så här:
SELECT * FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Tweet';Resultat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Vi kan se att det returnerade raderna där PetName kolumnen var antingen Fluffig eller Tweet .
Negerar villkoret
Du kan använda NOT operatör för att upphäva villkoret som tillhandahålls av lika-operatören. Här är ett exempel:
SELECT *
FROM Pets
WHERE NOT 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 | +---------+-------------+-----------+-----------+------------+
Ett alternativt sätt att göra detta är att använda operatorn inte lika med, som antingen är <> eller != (eller båda) beroende på ditt DBMS.
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 lika-operatorn 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 NULL är att använda IS .
Därför skulle vi behöva skriva om ovanstående uttalande enligt följande.
SELECT * FROM Pets
WHERE DOB IS NULL;Resultat:
+---------+-------------+-----------+-----------+-------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+-------| | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+-------+
NULL värderingar kan vara en svår sak för nybörjare att få reda på. Egentligen kan de vara en knepig sak för erfarna utvecklare att få reda på! I SQL, NULL har en något annan betydelse än NULL i de flesta andra programmeringsspråk.
Men det viktiga att komma ihåg är att i SQL, NULL betyder avsaknaden av ett värde. Det finns inget värde. Därför kan vi inte säga att det är lika eller inte lika med något annat, eftersom det inte finns något värde att börja med.
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.