13.1.3 Opérateurs de comparaison

MySQL effectue les comparaisons suivant les règles suivantes :

• Si l'un ou les deux arguments sont NULL , le résultat de la comparaison est NULL , exception faite pour l'opérateur <=> .
• Si les deux arguments de la comparaison sont des chaînes, ils seront comparés en tant que chaînes.
• Si les deux arguments sont des entiers, ils sont comparés en tant qu'entiers.
• Les valeurs hexadécimales sont traitées en tant que chaînes binaires si elles ne sont pas comparées à un nombre.
• Si l'un des arguments est une colonne de type TIMESTAMP ou DATETIME et que l'autre est une constante, celle ci est convertie en timestamp avant que la comparaison ne s'opère. Cela est fait pour être mieux compatible avec ODBC.
• Dans tous les autres cas, les arguments sont comparés en tant que nombres à décimale flottante. (réels)

Si vous comparez des chaînes insensibles à la chasse, avec les opérateurs standards ( = , <> ..., mais pas avec LIKE ) les espaces terminaux seront ignorés (espaces, tabulations et nouvelles lignes).

mysql> SELECT "a" ="A \n";
        -> 1

mysql> SELECT 1 > '6x';
         -> 0
mysql> SELECT 7 > '6x';
         -> 1
mysql> SELECT 0 > 'x6';
         -> 0
mysql> SELECT 0 = 'x6';
         -> 1

=

Egal :

mysql> SELECT 1 = 0;         -> 0 mysql> SELECT '0' = 0;         -> 1 mysql> SELECT '0.0' = 0;         -> 1 mysql> SELECT '0.01' = 0;         -> 0 mysql> SELECT '.01' = 0.01;         -> 1

<=>

Comparaison compatible avec NULL . Cet opérateur fait une comparaison d'égalité comme l'opérateur = , mais retourne 1 plutôt que NULL si les deux opérandes sont NULL , et 0 plutôt que NULL si un opérande est NULL .

mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;         -> 1, 1, 0 mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;         -> 1, NULL, NULL

<=> a été ajouté en MySQL 3.23.0.

<>

!=

Différent :

mysql> SELECT '.01' <> '0.01';         -> 1 mysql> SELECT .01 <> '0.01';         -> 0 mysql> SELECT 'zapp' <> 'zappp';         -> 1

<=

Inférieur ou égal :

mysql> SELECT 0.1 <= 2;         -> 1

<

Strictement inférieur :

mysql> SELECT 2 < 2;         -> 0

>=

Supérieur ou égal :

mysql> SELECT 2 >= 2;         -> 1

>

Strictement supérieur :

mysql> SELECT 2 > 2;         -> 0

IS NULL

IS NOT NULL

Tester si une valeur est ou n'est pas NULL :

mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;         -> 0 0 1 mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;         -> 1 1 0

Pour être compatible avec les autres programmes, MySQL gère les appels qui utilisent IS NULL de la façon suivante :

Vous pouvez trouver le dernier enregistrement inséré en utilisant :
SELECT * FROM nom_de_table WHERE auto_col IS NULL
Cela peut être interdit en mettant SQL_AUTO_IS_NULL=0 . Syntaxe de SET .
Pour les colonnes NOT NULL DATE et DATETIME , vous pouvez sélectionner lignes ayant la date spéciale 0000-00-00 avec :
SELECT * FROM nom_de_table WHERE date_column IS NULL
C'est une fonctionnalité nécessaire pour que certaines applications ODBC fonctionnent (car ODBC ne supporte pas les dates 0000-00-00 )

expression BETWEEN min AND max

Si expression est supérieure ou égale à min et expression est inférieure ou égale à max , BETWEEN retourne 1 , sinon 0 . Ceci est équivalent à l'expression (min <= expression AND expression <= max) si tous les arguments sont du même type. Dans tous les autres cas, la conversion de type prends place, selon les règles suivantes, mais appliquée aux trois arguments. Notez que avant la 4.0.5, les arguments étaient convertis au type de expr .

mysql> SELECT 1 BETWEEN 2 AND 3;         -> 0 mysql> SELECT 'b' BETWEEN 'a' AND 'c';         -> 1 mysql> SELECT 2 BETWEEN 2 AND '3';         -> 1 mysql> SELECT 2 BETWEEN 2 AND 'x-3';         -> 0

expr NOT BETWEEN min AND max

Même chose que NOT (expr BETWEEN min AND max) .

COALESCE(list)

Retourne le premier élément non- NULL de la liste :

mysql> SELECT COALESCE(NULL,1);         -> 1 mysql> SELECT COALESCE(NULL,NULL,NULL);         -> NULL

GREATEST(value1,value2,...)

Avec deux ou plusieurs arguments, retourne la valeur la plus grande. Les arguments sont comparés en utilisant les mêmes règles que pour LEAST() .

mysql> SELECT GREATEST(2,0);         -> 2 mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);         -> 767.0 mysql> SELECT GREATEST('B','A','C');         -> 'C'

Avant MySQL 3.22.5, vous pouvez utiliser MAX() au lieu de GREATEST() .

expr IN (valeur,...)

Retourne 1 si expr est l'une des valeurs dans la liste IN , sinon retourne 0 . Si toutes les valeurs sont des constantes, toutes les valeurs sont évaluées avec le type de expr et triées. La recherche de l'élément est alors faite en utilisant la recherche binaire. Cela signifie que IN est très rapide si les valeurs contenues dans la liste IN sont toutes des constantes. Si expr est une chaîne sensible à la casse, la comparaison est faite dans un contexte sensible à la casse :

mysql> SELECT 2 IN (0,3,5,'wefwf');         -> 0 mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');         -> 1

Depuis MySQL version 4.1, une clause IN() peut aussi contenir une sous-requête. Sous-requêtes avec ANY , IN et SOME .

expr NOT IN (value,...)

Même chose que NOT (expr IN (valeur,...)) .

ISNULL(expr)

Si expr est NULL , ISNULL() retourne 1 , sinon il retourne 0 :

mysql> SELECT ISNULL(1+1);         -> 0 mysql> SELECT ISNULL(1/0);         -> 1

Notez que la comparaison de deux valeurs NULL en utilisant = donnera toujours false !

INTERVAL(N,N1,N2,N3,...)

Retourne 0 si N < N1 , 1 si N < N2 etc... Tous les arguments sont traités en tant qu'entiers. Il est requis que N1 < N2 < N3 < ... < Nn pour que cette fonction fonctionne correctement. Cela est due à la recherche binaire utilisée (très rapide) :

mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);         -> 3 mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);         -> 2 mysql> SELECT INTERVAL(22, 23, 30, 44, 200);         -> 0

LEAST(value1,value2,...)

Avec deux arguments ou plus, retourne la plus petite valeur. Les arguments sont comparés avec les règles suivantes :

Si la valeur retournée est utilisée dans un contexte INTEGER ou que tous les arguments sont des entiers, ils sont comparés comme des entiers.
Si la valeur retournée est utilisée dans un contexte REAL ou que tous les arguments sont des entiers, ils sont comparés comme des entiers.
Si un des arguments est une chaîne sensible à la casse, les arguments sont comparés comme des chaînes sensibles à la casse.
Dans les autres cas, les arguments sont comparés comme des chaînes insensibles à la casse.

mysql> SELECT LEAST(2,0);         -> 0 mysql> SELECT LEAST(34.0,3.0,5.0,767.0);         -> 3.0 mysql> SELECT LEAST('B','A','C');         -> 'A'

Avant MySQL 3.22.5, vous pouvez utiliser MIN() au lieu de LEAST() .

Notez que les conversions précédentes peuvent produire des résultats étranges dans certains cas limites :

mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);         -> -9223372036854775808

Cela arrive parce que MySQL lit 9223372036854775808.0 dans un contexte d'entier. La représentation entière n'est pas suffisante pour contenir la valeur, alors elle est transformée en entier signé.