Je travaille sur du code écrit par un développeur précédent et dans une requête il dit,

WHERE p.name <=> NULL

Que <=>signifie cette requête? Est-ce quelque chose d'égal à =? Ou est-ce une erreur de syntaxe?

Mais il ne montre aucune erreur ou exception. Je sais déjà que <>= !=dans MySQL .

TL; DR

C'est l' opérateur NULLégal sûr .

Comme l' =opérateur régulier , deux valeurs sont comparées et le résultat est soit 0(différent) soit 1(égal); en d'autres termes: 'a' <=> 'b'rendements 0et 'a' <=> 'a'rendements 1.

Contrairement à l' =opérateur régulier , les valeurs de NULLn'ont pas de signification particulière et ne donnent donc jamais NULLde résultat possible; donc: 'a' <=> NULLrendements 0et NULL <=> NULLrendements 1.

Utilité

Cela peut être utile lorsque les deux opérandes peuvent contenir NULLet que vous avez besoin d'un résultat de comparaison cohérent entre deux colonnes.

Un autre cas d'utilisation concerne les instructions préparées, par exemple:

... WHERE col_a <=> ? ...

Ici, l'espace réservé peut être une valeur scalaire ou NULLsans avoir à modifier quoi que ce soit dans la requête.

Opérateurs associés

En outre, <=>il existe également deux autres opérateurs qui peuvent être utilisés pour comparer NULL, à savoir IS NULLet IS NOT NULL; ils font partie de la norme ANSI et sont donc pris en charge sur d'autres bases de données, contrairement à <=>ce qui est spécifique à MySQL.

Vous pouvez les considérer comme des spécialisations de MySQL <=>:

'a' IS NULL     ==> 'a' <=> NULL
'a' IS NOT NULL ==> NOT('a' <=> NULL)

Sur cette base, votre requête particulière (fragment) peut être convertie en la plus portable:

WHERE p.name IS NULL

Soutien

La norme SQL: 2003 a introduit un prédicat pour cela, qui fonctionne exactement comme l' <=>opérateur de MySQL , sous la forme suivante:

IS [NOT] DISTINCT FROM 

Ce qui suit est universellement pris en charge, mais est relativement complexe:

CASE WHEN (a = b) or (a IS NULL AND b IS NULL)
     THEN 1
     ELSE 0
END = 1

est <=> NULL-safe equal to operator

Cet opérateur effectue une comparaison d'égalité comme l'opérateur =, mais renvoie 1 plutôt que NULL si les deux opérandes sont NULL et 0 plutôt que NULL si l'un des opérandes est NULL.

Voir ici pour la documentation

Échantillon :

vous devez utiliser IS NOT NULL. (Les opérateurs de comparaison = et <> donnent tous deux INCONNU avec NULL de chaque côté de l'expression.)

SELECT * 
FROM table 
WHERE YourColumn IS NOT NULL;

peut également annuler l'opérateur d'égalité sûre nul mais ce n'est pas du SQL standard.

SELECT *
FROM table 
WHERE NOT (YourColumn <=> NULL);

C'est le NULL-safe égal à l'opérateur

<=> L'opérateur est utilisé pour comparer les valeurs NULL avec les champs. Si normal = (égal) Les opérateurs renvoient NULL si l'une des valeurs de comparaison est NULL. Avec <=>, l'opérateur renvoie vrai ou faux. <=> L'opérateur est identique à IS NULL.

À partir du manuel: -

<=> effectue une comparaison d'égalité comme l'opérateur =, mais renvoie 1 plutôt que NULL si les deux opérandes sont NULL et 0 plutôt que NULL si l'un des opérandes est NULL.

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

Edit: - ( Bien que très tard pour ajouter une note latérale importante mentionnant PAS <=> également )

Sur une note latérale: -

PAS <=>

Il y a un autre point NOT <=> qui est utilisé pour comparer les valeurs NULL avec les champs. Si normal! = Ou <> (différent de) Les opérateurs renvoient NULL si l'une des valeurs de comparaison est NULL. Avec NOT appliqué à <=>, l'opérateur renvoie vrai ou faux. NOT appliqué à <=> Operator est identique à IS NOT NULL.

Exemple:-

SELECT NULL != NULL,         //--Result is NULL
   NOT NULL <=> NULL,        //--Result is 0
   NULL IS NOT NULL;         //--Result is 0

<=>est l'opérateur "égal à" de MySQL sans aucun contrôle. À partir du manuel :

NULL-safe égal. Cet opérateur effectue une comparaison d'égalité comme l'opérateur =, mais renvoie 1 plutôt que NULL si les deux opérandes sont NULL et 0 plutôt que NULL si l'un des opérandes est NULL.

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

NULL-safe égal. Cet opérateur effectue une comparaison d'égalité comme l'opérateur =, mais renvoie 1 plutôt que NULL si les deux opérandes sont NULL et 0 plutôt que NULL si l'un des opérandes est NULL.

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

Cela signifie:

Lorsque vous comparez une valeur NULL avec une valeur non NULL, vous obtenez NULL. Si vous souhaitez vérifier si une valeur est nulle.

L'opérateur d'égalité (<=>) qui considère NULL comme une valeur normale, donc il renvoie 1 (pas NULL) si les deux valeurs sont NULL et retourne 0 (et non NULL) si l'une des valeurs est NULL:

par exemple

 SELECT NULL <=> NULL -- 1
 SELECT TRUE <=> TRUE -- 1
 SELECT col1 <=> col2 FROM myTable

<=>est l' opérateur égal de sécurité NULL . a <=> béquivaut à écrire:

CASE
    WHEN a IS NULL AND b IS NULL THEN 1 -- both operands null then 1
    WHEN a IS NULL OR  b IS NULL THEN 0 -- one operand is null then 0
    ELSE a = b                          -- else behave like normal = operator
END

Et désolé, je n'ai pas trouvé une seule bonne raison d'utiliser cet opérateur à la place de AND/OR IS (NOT) NULL. Votre exemple, par exemple, WHERE p.name <=> NULLest le même que WHERE p.name IS NULL.

De la documentation MySQL :

NULL-safe égal. Cet opérateur effectue une comparaison d'égalité comme l'opérateur =, mais renvoie 1 plutôt que NULL si les deux opérandes sont NULL et 0 plutôt que NULL si l'un des opérandes est NULL.

Un exemple utilisant l' <=>opérateur serait:

SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;

Ce qui reviendrait:

1, 1, 0

Un exemple de l' =opérateur régulier serait:

SELECT 1 = 1, NULL = NULL, 1 = NULL;

Ce qui reviendrait:

1, NULL, NULL

L' <=>opérateur est très similaire à l' =opérateur, sauf <=>qu'il ne retournera jamaisNULL

Il s'agit de l'opérateur NULL - Safe Equal to. Vérifiez la description .

mysql> SELECT * FROM t JOIN t2 WHERE t2.ids = t.ids;
+----+------+----+------+
| id | ids  | id | ids  |
+----+------+----+------+
|  1 |    1 |  1 |    1 |
|  2 |    2 |  2 |    2 |
|  5 |    6 |  5 |    6 |
|  6 |    7 |  6 |    7 |
+----+------+----+------+
4 rows in set (0.00 sec)

mysql> SELECT * FROM t JOIN t2 WHERE t2.ids <=> t.ids;
+----+------+----+------+
| id | ids  | id | ids  |
+----+------+----+------+
|  1 |    1 |  1 |    1 |
|  2 |    2 |  2 |    2 |
|  3 | NULL |  3 | NULL |
|  4 | NULL |  3 | NULL |
|  3 | NULL |  4 | NULL |
|  4 | NULL |  4 | NULL |
|  5 |    6 |  5 |    6 |
|  6 |    7 |  6 |    7 |