Les opérateurs de comparaison sont une partie importante de la plupart des langages de programmation.
Les opérateurs de comparaison sont utilisés pour comparer deux expressions. Le résultat est soit true ou false . Il peut également être inconnu. Cela pourrait également être représenté soit par 1 , 0 , ou NULL , selon la langue. Celles-ci sont généralement appelées "expressions booléennes".
Lorsqu'ils sont utilisés avec des bases de données, les opérateurs de comparaison peuvent être utilisés dans vos requêtes SQL pour filtrer les données selon certains critères.
Opérateurs de comparaison courants
La plupart des langages de programmation prennent en charge les opérateurs de comparaison suivants sous une forme ou une autre :
| OPÉRATEUR | SIGNIFICATION |
|---|---|
= | Égal à |
> | Supérieur à |
< | Moins de |
>= | Supérieur ou égal à |
<= | Inférieur ou égal à |
<> | Pas égal à |
SQL utilise la même syntaxe que celle indiquée dans le tableau ci-dessus.
Certains langages utilisent une syntaxe différente afin d'éviter toute confusion avec les opérateurs d'affectation. Par exemple, Python et JavaScript utilisent == au lieu de = . ColdFusion, d'autre part, utilise eq .
Différents types de données
Certaines langues ont un opérateur spécial pour spécifier que les deux valeurs doivent être du même type de données.
Par exemple, JavaScript inclut également le === opérateur qui spécifie que les deux valeurs sont égales et qu'ils doivent être du même type de données. Mais si le type de données n'est pas pertinent, utilisez == Au lieu.
Exemples
Opérateur supérieur à
Voici un exemple d'utilisation de l'opérateur Supérieur à dans une requête T-SQL.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Résultat :
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
Dans cet exemple, j'ai utilisé l'opérateur Supérieur à (> ) pour sélectionner uniquement les pays dont la population est supérieure à 100000000.
Opérateur égal
Voici un autre exemple, où j'utilise l'opérateur égal (= ) pour renvoyer des données exactement égales à une valeur donnée.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Résultat :
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
Dans ce cas, je renvoie uniquement les villes dont le code pays est égal à AFG .
Cela démontre que les opérateurs de comparaison ne sont pas limités aux seuls types de données numériques.
Dates
Vous pouvez également utiliser des opérateurs de comparaison sur les dates, par exemple :
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Résultat :
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
Comme vous pouvez le voir, les seuls résultats renvoyés sont ceux postérieurs à (après) la date spécifiée.
Opérateur supérieur ou égal à
Je peux utiliser l'opérateur Supérieur ou égal à pour inclure la date spécifiée dans les résultats.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Résultat :
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
Dans ce cas, une ligne supplémentaire est renvoyée (la dernière ligne).
Opérateur inférieur à
Voici ce qui se passe si je modifie ma requête pour utiliser un opérateur Inférieur à.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Résultat :
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Je reçois toutes les lignes qui sont inférieures à la date spécifiée.
Comparer les valeurs NULL
NULL les valeurs peuvent légèrement compliquer les choses lors de l'utilisation d'opérateurs de comparaison. En un mot, vous pouvez obtenir un résultat différent, selon la configuration de votre environnement.
Par exemple, dans SQL Server, si vous utilisez l'opérateur Equals (= ) ou l'opérateur Différent (<> ) pour tester par rapport à NULL , votre résultat dépendra de votre ANSI_NULLS paramètre (c'est-à-dire s'il est ON ou OFF ).
Pour tester par rapport à NULL valeurs, SQL Server fournit également le IS NULL prédicat, qui fonctionne de manière cohérente, quel que soit votre ANSI_NULLS paramètre. Cela inclut également le IS NOT NULL variation pour tester contre non-NULL valeurs.
Voici un exemple qui illustre ce que je veux dire.
ANSI_NULLS ON
Nous définissons d'abord ANSI_NULLS sur ON , puis exécutez quelques tests avec 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;Résultat :
(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
Maintenant, nous définissons ANSI_NULLS sur OFF , puis exécutez les mêmes 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;Résultat :
+--------------------+ | (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)
