Em SQL, o operador diferente de (
<> ) compara a não igualdade de duas expressões. Ou seja, ele testa se uma expressão não igual a outra expressão. Se um ou ambos os operandos forem
NULL , NULL é devolvido. SQL também tem outro operador diferente de (
!= ), que faz a mesma coisa. Qual deles você usa pode depender do seu DBMS, qual você se sente mais confortável em usar e talvez também se sua organização possui convenções de codificação que determinam qual deve ser usado. Tabela de origem
Imagine que nosso banco de dados contém a tabela a seguir. Esta é a tabela que usaremos para os exemplos nesta página.
SELECT * FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Exemplo
Se quiséssemos pegar todos os animais de estimação que não tem um certo dono, poderíamos fazer isso:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Nossa consulta usa o operador diferente de (
<> ) para testar se o OwnerId coluna não é igual a 3 . A consulta retorna todos os animais de estimação que não possuem o proprietário número 3 como proprietário. Cordas
Ao comparar com um valor de string, use aspas ao redor da string. Por exemplo, se quisermos obter informações sobre todos os animais de estimação que não são chamados de Fluffy, podemos fazer o seguinte:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Várias Condições
Se você tiver várias condições, poderá usar vários operadores (sejam os mesmos operadores ou diferentes).
Assim:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Negando a condição
Se você usar o
NOT operador para negar a condição fornecida pelo operador diferente de, você acabará obtendo os resultados do igual a (= ) operador:SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Nesse caso, é melhor usar o igual a (
= ) operador, assim:SELECT *
FROM Pets
WHERE PetName = 'Fluffy';Claro, isso em si poderia ser negado com o
NOT operador, que nos daria o mesmo resultado que igual a (<> ) operador nos dá:SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Valores NULOS
Você deve ter notado que nossa tabela de amostra original contém algumas
NULL valores na coluna DOB. Uma coluna contendo
NULL significa que não tem valor. Isso é diferente de 0 ou false , ou até mesmo uma string vazia. Você não pode usar o operador diferente de para comparar com
NULL . Na verdade, isso pode depender do seu DBMS e de sua configuração. Mas, por enquanto, vamos ver o que acontece se eu tentar comparar a coluna DOB com NULL . SELECT * FROM Pets
WHERE DOB <> NULL;Resultado:
(0 rows affected)
A maneira de testar não
NULL valores é usar IS NOT NULL . Portanto, precisaríamos reescrever a afirmação acima da seguinte forma.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Agora temos apenas as linhas que não são
NULL no DOB coluna. Se estiver interessado, consulte
SQL Server ANSI_NULLS Explained para ver como você pode alterar o modo NULL os valores são tratados no SQL Server. 
