Vergelijkingsoperators zijn een belangrijk onderdeel van de meeste programmeertalen.
Vergelijkingsoperatoren worden gebruikt om twee uitdrukkingen te vergelijken. Het resultaat is ofwel true of false . Het kan ook onbekend zijn. Dit kan ook worden weergegeven door 1 , 0 , of NULL , afhankelijk van de taal. Deze staan meestal bekend als "Booleaanse uitdrukkingen".
Bij gebruik met databases kunnen vergelijkingsoperators worden gebruikt in uw SQL-query's om gegevens op bepaalde criteria te filteren.
Veelgebruikte vergelijkingsoperators
De meeste programmeertalen ondersteunen de volgende vergelijkingsoperatoren in een of andere vorm:
| OPERATOR | BETEKENIS |
|---|---|
= | Gelijk aan |
> | Groter dan |
< | Minder dan |
>= | Groter dan of gelijk aan |
<= | Minder dan of gelijk aan |
<> | Niet gelijk aan |
SQL gebruikt dezelfde syntaxis als vermeld in de bovenstaande tabel.
Sommige talen gebruiken een andere syntaxis om verwarring met toewijzingsoperatoren te voorkomen. Python en JavaScript gebruiken bijvoorbeeld == in plaats van = . ColdFusion daarentegen gebruikt eq .
Verschillende gegevenstypen
Sommige talen hebben een speciale operator om aan te geven dat beide waarden van hetzelfde gegevenstype moeten zijn.
JavaScript bevat bijvoorbeeld ook de === operator die aangeeft dat beide waarden gelijk zijn en dat ze van hetzelfde gegevenstype moeten zijn. Maar als het gegevenstype niet relevant is, gebruik dan == in plaats van.
Voorbeelden
Groter dan operator
Hier is een voorbeeld van het gebruik van de operator Groter dan in een T-SQL-query.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Resultaat:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
In dit voorbeeld heb ik de operator Groter dan gebruikt (> ) om alleen landen te selecteren met een bevolking van meer dan 100000000.
Is gelijk aan operator
Hier is nog een voorbeeld, waarbij ik de equals-operator (= .) gebruik ) om gegevens terug te geven die exact gelijk zijn aan een bepaalde waarde.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Resultaat:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
In dit geval retourneer ik alleen die steden waarvan de landcode gelijk is aan AFG .
Dit toont aan dat vergelijkingsoperatoren niet alleen beperkt zijn tot numerieke gegevenstypen.
Datums
U kunt ook vergelijkingsoperatoren gebruiken voor datums, bijvoorbeeld:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Resultaat:
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
Zoals u kunt zien, zijn de enige resultaten die worden geretourneerd die groter zijn dan (na) de opgegeven datum.
Groter dan of gelijk aan operator
Ik kan de operator Groter dan of Gelijk aan gebruiken om de opgegeven datum in de resultaten op te nemen.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Resultaat:
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
In dit geval wordt één extra rij geretourneerd (de laatste rij).
Minder dan operator
Dit is wat er gebeurt als ik mijn zoekopdracht wijzig om een kleiner dan-operator te gebruiken.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Resultaat:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Ik krijg alle rijen die minder zijn dan de opgegeven datum.
NULL-waarden vergelijken
NULL waarden kunnen de zaken enigszins compliceren bij het gebruik van vergelijkingsoperatoren. In een notendop, u krijgt mogelijk een ander resultaat, afhankelijk van hoe uw omgeving is geconfigureerd.
Als u bijvoorbeeld in SQL Server de operator Gelijk aan (= ) of de operator Niet gelijk (<> ) om te testen tegen NULL , hangt uw resultaat af van uw ANSI_NULLS instelling (d.w.z. of het ON is) of OFF ).
Testen tegen NULL waarden, biedt SQL Server ook de IS NULL predikaat, dat consistent werkt, ongeacht uw ANSI_NULLS instelling. Dit omvat ook de IS NOT NULL variatie voor testen tegen niet-NULL waarden.
Hieronder is een voorbeeld dat laat zien wat ik bedoel.
ANSI_NULLS ON
Eerst stellen we ANSI_NULLS . in naar ON , en voer vervolgens een paar tests uit tegen 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;Resultaat:
(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 stellen we ANSI_NULLS in naar OFF en voer vervolgens dezelfde tests uit.
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;Resultaat:
+--------------------+ | (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)