web-dev-qa-db-fra.com

Quel est cet opérateur <=> dans MySQL?

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

WHERE p.name <=> NULL

Qu'est-ce que <=> _ signifie dans cette requête? Est-ce quelque chose d'égale à =? Ou est-ce une erreur de syntaxe?

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

mysqlsqloperatorsspaceship-operator
147
zzlalani

Similarité avec = opérateur

Comme les habitués = _ opérateur, deux valeurs sont comparées et le résultat est soit 0 (différent de) ou 1 (égal); en d'autres termes: 'a' <=> 'b' _ donne 0 et 'a' <=> 'a' _ donne 1.

Différence avec = opérateur

Contrairement à la normale = opérateur, les valeurs de NULL n’ont pas de signification particulière et ne donnent donc jamais NULL comme résultat possible; alors: 'a' <=> NULL _ donne 0 et NULL <=> NULL _ donne 1.

Contrairement à =, par lequel 'a' = NULL _ donne NULL et même NULL = NULL donne NULL; BTW, presque tous les opérateurs et fonctions de MySQL fonctionnent de cette manière, car la comparaison avec NULL est fondamentalement indéfinie.

Utilité

Ceci est très utile lorsque les deux opérandes peuvent contenir NULL et 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 soit une valeur scalaire, soit NULL sans rien changer à la requête.

Opérateurs associés

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

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

'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 une plus portable:

WHERE p.name IS NULL
214
Ja͢ck

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 le documentation

Échantillon :

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

SELECT * 
FROM table 
WHERE YourColumn IS NOT NULL;

peut également nier l'opérateur d'égalité de sécurité NULL, mais il ne s'agit pas d'un code SQL standard.

SELECT *
FROM table 
WHERE NOT (YourColumn <=> NULL);
55
Drixson Oseña

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.

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 qu'il soit très tard pour ajouter une note latérale importante mentionnant NOT <=> aussi)

Sur une note latérale: -

NOT <=>

Il y a encore un point NOT <=> utilisé pour comparer les valeurs NULL aux champs. Si normal! = Ou <> (non égal à), les opérateurs renvoient NULL si l'une des valeurs de comparaison est NULL. Avec NOT appliqué à <=>, l'opérateur renvoie true ou false. NON appliqué à <=> l'opérateur est identique à IS NON NULL.

Exemple: - 

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

<=> est l'opérateur nul de MySQL "égal à". Extrait 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
18
Ed Cottrell

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

signification:

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

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

par exemple

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

<=> Est le opérateur égal à NULL-safe . a <=> b Est identique à l'écriture:

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 trouvé aucune bonne raison d’utiliser cet opérateur à la place de AND/OR IS (NOT) NULL. Votre exemple, par exemple, WHERE p.name <=> NULL est identique à WHERE p.name IS NULL.

10
Salman A

Depuis le 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 d'eux est NULL.

Un exemple utilisant le <=> opérateur serait:

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

Ce qui reviendrait:

1, 1, 0

Un exemple de la normale = opérateur serait:

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

Ce qui reviendrait:

1, NULL, NULL

Le <=> L’opérateur est très similaire au = opérateur, sauf <=> ne reviendra jamais NULL

9
Jojodmo

C'est le NULL - Safe Equal to. Vérifier description .

5
MusicLovingIndianGirl
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 |
1
zloctb