Lige-operatoren (= ) er nok den mest brugte operator i SQL. Den sammenligner ligheden mellem to udtryk. Selvom du kun lige er begyndt på din SQL-rejse, kender du sikkert denne operator.
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 med en bestemt ejer, kunne vi gøre dette:
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 | +---------+-------------+-----------+-----------+------------+
Vores forespørgsel bruger lig-operatoren (= ) for at sammenligne ligheden mellem værdien af OwnerId kolonne og 3 .
I dette tilfælde har ejer nummer 3 3 kæledyr.
Strenge
Når du sammenligner med en strengværdi, skal du bruge anførselstegn omkring strengen. For eksempel, hvis vi ønskede at få oplysninger om alle kæledyr ved navn Fluffy, kunne vi gøre følgende:
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 | +---------+-------------+-----------+-----------+------------+
Vores forespørgsel bruger lig-operatoren (= ) for at sammenligne ligheden mellem værdien af PetName kolonne og strengen Fluffy .
I vores tilfælde kan vi se, at dyrehotellet i øjeblikket har to kæledyr kaldet Fluffy.
Flere betingelser
Hvis du har flere betingelser, kan du bruge flere lig-operatorer.
Sådan:
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, at det returnerede rækkerne, hvor PetName kolonne var enten Fluffy eller Tweet .
Nægter betingelsen
Du kan bruge NOT operatør for at ophæve betingelsen stillet af lige-operatøren. Her er et eksempel:
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 | +---------+-------------+-----------+-----------+------------+
En alternativ måde at gøre dette på er at bruge operatoren ikke lig med, som enten er <> eller != (eller begge) afhængigt af dit DBMS.
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 equals-operatoren 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 NULL er at bruge IS .
Derfor er vi nødt til at omskrive ovenstående erklæring som følger.
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ærdier kan være en vanskelig ting for begyndere at få styr på. Faktisk kan de være en vanskelig ting for erfarne udviklere at få styr på! I SQL, NULL har en lidt anden betydning end NULL på de fleste andre programmeringssprog.
Men det vigtige at huske er, at i SQL, NULL betyder manglen på en værdi. Der er ingen værdi. Derfor kan vi ikke sige, at det er lig med eller ikke er lig med noget andet, for der er ingen værdi at starte med.
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.