Sammenligningsoperatører er en vigtig del af de fleste programmeringssprog.
Sammenligningsoperatorer bruges til at sammenligne to udtryk. Resultatet er enten true eller falsk . Det kan også være ukendt. Dette kan også repræsenteres af enten 1 , 0 eller NULL , afhængigt af sproget. Disse er typisk kendt som "boolske udtryk".
Når det bruges sammen med databaser, kan sammenligningsoperatorer bruges i dine SQL-forespørgsler til at filtrere data til et bestemt kriterium.
Almindelige sammenligningsoperatører
De fleste programmeringssprog understøtter følgende sammenligningsoperatører i en eller anden form:
| OPERATOR | BETYDNING |
|---|---|
= | Lige med |
> | Større end |
< | Mindre end |
>= | Større end eller lig med |
<= | Mindre end eller lig med |
<> | Ikke lig med |
SQL bruger den samme syntaks som angivet i ovenstående tabel.
Nogle sprog bruger en anden syntaks for at undgå forveksling med tildelingsoperatorer. For eksempel bruger Python og JavaScript == i stedet for = . ColdFusion på den anden side bruger eq .
Forskellige datatyper
Nogle sprog har en speciel operator til at angive, at begge værdier skal være af samme datatype.
For eksempel inkluderer JavaScript også === operator, der angiver, at begge værdier er lig med og at de skal være af samme datatype. Men hvis datatypen er irrelevant, skal du bruge == i stedet.
Eksempler
Større end operatør
Her er et eksempel på brug af Greater Than-operatoren i en T-SQL-forespørgsel.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Resultat:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
I dette eksempel brugte jeg operatoren Greater Than (> ) for kun at vælge lande med en befolkning på over 100000000.
Er lig med operatør
Her er et andet eksempel, hvor jeg bruger lig-operatoren (= ) for at returnere data, der er nøjagtigt lig med en given værdi.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Resultat:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
I dette tilfælde returnerer jeg kun de byer, hvis landekode er lig med AFG .
Dette viser, at sammenligningsoperatører ikke kun er begrænset til numeriske datatyper.
Datoer
Du kan også bruge sammenligningsoperatorer på datoer, for eksempel:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Resultat:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | +------------+----------------+--------------+
Som du kan se, er de eneste resultater, der returneres, dem, der er større end (efter) den angivne dato.
Større end eller lig med operatøren
Jeg kan bruge operatoren Større end eller Lige til til at inkludere den angivne dato i resultaterne.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Resultat:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+----------------+--------------+
I dette tilfælde returneres en ekstra række (den sidste række).
Mindre end operatør
Her er, hvad der sker, hvis jeg ændrer min forespørgsel til at bruge en mindre end-operator.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Resultat:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | +------------+------------------------+--------------+
Jeg får alle rækker, der er mindre end den angivne dato.
Sammenligning af NULL-værdier
NULL værdier kan komplicere tingene lidt, når du bruger sammenligningsoperatorer. I en nøddeskal kan du få et andet resultat, afhængigt af hvordan dit miljø er konfigureret.
For eksempel, i SQL Server, hvis du bruger Equals-operatoren (= ) eller Not Equal-operatoren (<> ) for at teste mod NULL , vil dit resultat afhænge af din ANSI_NULLS indstilling (dvs. om den er ON eller OFF ).
For at teste mod NULL værdier, giver SQL Server også IS NULL prædikat, som fungerer konsekvent, uanset din ANSI_NULLS indstilling. Dette inkluderer også IS NOT NULL variation til test mod ikke-NULL værdier.
Nedenfor er et eksempel, der viser, hvad jeg mener.
ANSI_NULLS TIL
Først indstiller vi ANSI_NULLS til ON , kør derefter et par test mod NULL .
SET ANSI_NULLS ON;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Resultat:
(0 rows affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) (0 rows affected)
ANSI_NULLS FRA
Nu indstiller vi ANSI_NULLS til OFF , og kør derefter de samme tests.
SET ANSI_NULLS OFF;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Resultat:
+--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected)