Jämförelseoperatörer är en viktig del av de flesta programmeringsspråk.
Jämförelseoperatorer används för att jämföra två uttryck. Resultatet är antingen true eller false . Det kan också vara okänt. Detta kan också representeras av antingen 1 , 0 , eller NULL , beroende på språk. Dessa är vanligtvis kända som "booleska uttryck".
När de används med databaser kan jämförelseoperatorer användas i dina SQL-frågor för att filtrera data till ett visst kriterium.
Vanliga jämförelseoperatörer
De flesta programmeringsspråk stöder följande jämförelseoperatorer i en eller annan form:
| OPERATOR | BETEKNING |
|---|---|
= | Lika med |
> | Större än |
< | Mindre än |
>= | Större än eller lika med |
<= | Mindre än eller lika med |
<> | Inte lika med |
SQL använder samma syntax som anges i tabellen ovan.
Vissa språk använder en annan syntax för att undvika förväxling med tilldelningsoperatorer. Till exempel använder Python och JavaScript == istället för = . ColdFusion å andra sidan använder eq .
Olika datatyper
Vissa språk har en speciell operator för att specificera att båda värdena måste vara av samma datatyp.
Till exempel inkluderar JavaScript även === operator som anger att båda värdena är lika med och att de måste vara av samma datatyp. Men om datatypen är irrelevant, använd == istället.
Exempel
Större än operatör
Här är ett exempel på hur du använder Greater Than-operatorn i en T-SQL-fråga.
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 det här exemplet använde jag operatorn Greater Than (> ) för att endast välja länder med en befolkning som är större än 100000000.
Equal Operator
Här är ett annat exempel, där jag använder lika-operatorn (= ) för att returnera data som är exakt lika med ett givet värde.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Resultat:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
I det här fallet returnerar jag bara de städer vars landskod är lika med AFG .
Detta visar att jämförelseoperatorer inte bara är begränsade till numeriska datatyper.
Datum
Du kan också använda jämförelseoperatorer för datum, till exempel:
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 är de enda resultat som returneras de som är större än (efter) det angivna datumet.
Större än eller lika med operatören
Jag kan använda operatorn Större än eller Lika med för att inkludera det angivna datumet i resultaten.
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 detta fall returneras en extra rad (den sista raden).
Mindre än operatör
Det här är vad som händer om jag ändrar min fråga till att använda en mindre än-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 | +------------+------------------------+--------------+
Jag får alla rader som är mindre än det angivna datumet.
Jämföra NULL-värden
NULL värden kan komplicera saker något när man använder jämförelseoperatorer. I ett nötskal kan du få ett annat resultat, beroende på hur din miljö är konfigurerad.
Till exempel, i SQL Server, om du använder operatorn Equals (= ) eller operatorn Not Equal (<> ) för att testa mot NULL , kommer ditt resultat att bero på din ANSI_NULLS inställning (dvs. om den är ON eller OFF ).
För att testa mot NULL värden, tillhandahåller SQL Server också IS NULL predikat, som fungerar konsekvent, oavsett din ANSI_NULLS miljö. Detta inkluderar även IS NOT NULL variation för testning mot icke-NULL värden.
Nedan är ett exempel som visar vad jag menar.
ANSI_NULLS ON
Först ställer vi in ANSI_NULLS till ON , kör sedan några tester mot 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 OFF
Nu ställer vi in ANSI_NULLS till OFF , kör sedan samma tester.
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)