Estou trabalhando no código escrito por um desenvolvedor anterior e em uma consulta que diz:

WHERE p.name <=> NULL

O que <=>significa nesta consulta? É algo igual a =? Ou é um erro de sintaxe?

Mas não está mostrando nenhum erro ou exceção. Eu já sei isso <>= !=no MySQL .

TL; DR

É o operador NULLseguro igual .

Como o =operador regular , dois valores são comparados e o resultado é 0(não igual) ou 1(igual); em outras palavras: 'a' <=> 'b'rendimentos 0e 'a' <=> 'a'rendimentos 1.

Diferentemente do =operador regular , os valores de NULLnão têm um significado especial e, portanto, nunca produzem NULLcomo um resultado possível; então: 'a' <=> NULLrendimentos 0e NULL <=> NULLrendimentos 1.

Utilidade

Isso pode ser útil quando os dois operandos podem conter NULL e você precisa de um resultado consistente de comparação entre duas colunas.

Outro caso de uso é com instruções preparadas, por exemplo:

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

Aqui, o espaço reservado pode ser um valor escalar ou NULL sem precisar alterar nada sobre a consulta.

Operadores relacionados

Além disso, <=>existem outros dois operadores que podem ser usados ​​para comparar NULL, a saber IS NULLe IS NOT NULL; eles fazem parte do padrão ANSI e, portanto, são suportados em outros bancos de dados, ao contrário<=> que é específico do MySQL.

Você pode pensar nelas como especializações do MySQL <=>:

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

Com base nisso, sua consulta específica (fragmento) pode ser convertida para a mais portátil:

WHERE p.name IS NULL

Apoio, suporte

O padrão SQL: 2003 introduziu um predicado para isso, que funciona exatamente como o <=>operador do MySQL , da seguinte forma:

IS [NOT] DISTINCT FROM 

O seguinte é universalmente suportado, mas é relativamente complexo:

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

é <=> NULL-safe equal to operator

Este operador executa uma comparação de igualdade como o operador =, mas retorna 1 em vez de NULL se ambos os operandos forem NULL e 0 em vez de NULL se um operando for NULL.

Veja aqui a documentação

Amostra:

você deve usar NÃO É NULL. (Os operadores de comparação = e <> fornecem UNKNOWN com NULL nos dois lados da expressão.)

SELECT * 
FROM table 
WHERE YourColumn IS NOT NULL;

também pode negar o operador de igualdade segura nula, mas esse não é o SQL padrão.

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

É o NULL-safe igual ao operador

O operador é usado para comparar valores NULL com os campos. Se normal = (igual) Os operadores retornam NULL se um dos valores de comparação for NULL. Com <=>, o operador retorna verdadeiro ou falso. O operador é igual a IS NULL.

Do manual: -

<=> executa uma comparação de igualdade como o operador =, mas retorna 1 em vez de NULL se ambos os operandos forem NULL e 0 em vez de NULL se um operando for NULL.

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

Edit: - ( Embora seja tarde demais para adicionar uma nota lateral importante mencionando NOT <=> também )

Em uma nota lateral: -

NÃO <=>

Há mais um ponto NOT <=> que é usado para comparar valores NULL com os campos. Se normal! = Ou <> (não é igual) Os operadores retornam NULL se um dos valores de comparação for NULL. Com NÃO aplicado a <=>, o operador retorna verdadeiro ou falso. NÃO aplicado ao operador <=> é o mesmo que NÃO É NULL.

Exemplo:-

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

<=>é o operador nulo seguro "igual a" do MySQL. Do manual :

NULL-safe igual. Este operador executa uma comparação de igualdade como o operador =, mas retorna 1 em vez de NULL se ambos os operandos forem NULL e 0 em vez de NULL se um operando for 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 igual. Este operador executa uma comparação de igualdade como o operador =, mas retorna 1 em vez de NULL se ambos os operandos forem NULL e 0 em vez de NULL se um operando for NULL.

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

Seu significado:

Ao comparar um valor NULL com um valor não NULL, você obtém NULL. Se você deseja verificar se um valor é nulo.

O operador Igualdade (<=>), que considera NULL como um valor normal, retorna 1 (não NULL) se ambos os valores forem NULL e retorna 0 (não NULL) se um dos valores for NULL:

por exemplo

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

<=>é o operador igual à segurança NULL . a <=> bé o mesmo que escrever:

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

E desculpe, não encontrei um bom motivo para usar esse operador em vez de AND/OR IS (NOT) NULL. Seu exemplo, por exemplo, WHERE p.name <=> NULLé o mesmo que WHERE p.name IS NULL.

Na documentação do MySQL :

NULL-safe igual. Este operador executa uma comparação de igualdade como o operador =, mas retorna 1 em vez de NULL se ambos os operandos forem NULL e 0 em vez de NULL se um operando for NULL.

Um exemplo usando o <=>operador seria:

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

O que retornaria:

1, 1, 0

Um exemplo do =operador regular seria:

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

O que retornaria:

1, NULL, NULL

O <=>operador é muito semelhante ao =operador, exceto <=>que nunca retornaráNULL

É o operador NULL - Safe Igual ao operador. Verifique a descrição .

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 |