Operador SQL diferente de (!=) para iniciantes

No 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 Owners;

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Exemplo

Se quisermos retornar uma lista de todos os proprietários que não possuem um OwnerId de 3 , poderíamos fazer isso:

SELECT *
FROM Owners
WHERE OwnerId != 3;

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Nossa consulta usa o operador diferente de (!= ) para testar se o OwnerId coluna não é igual a 3 . A consulta retorna todos os proprietários, exceto o proprietário número 3.

Strings

Ao comparar com um valor de string, use aspas ao redor da string. Por exemplo, se quisermos obter informações sobre todos os proprietários cujo primeiro nome não seja Homer, poderíamos fazer o seguinte:

SELECT *
FROM Owners
WHERE FirstName != 'Homer';

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

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 Owners 
WHERE OwnerId != 1 AND OwnerId != 3;

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Depois de começar a usar mais condições, você deve usar parênteses para cercar as condições que deseja que sejam avaliadas primeiro. Se você não fizer isso, poderá obter resultados inesperados, devido às condições serem avaliadas em uma ordem que você não pretendia.

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 dos iguais (= ) operador:

SELECT *
FROM Owners
WHERE NOT FirstName != 'Homer';

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

Nesse caso, é melhor usar apenas os iguais (= ) operador, assim:

SELECT *
FROM Owners
WHERE FirstName = 'Homer';

Claro, isso em si poderia ser negado com o NOT operador, que nos daria o mesmo resultado que o diferente de (!= ) operador nos dá:

SELECT *
FROM Owners
WHERE NOT FirstName = 'Homer';

Valores NULOS

Você deve ter notado que nossa tabela de amostra original contém algumas NULL valores no Email coluna.

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 o Email coluna para NULL .

SELECT * FROM Owners 
WHERE Email != 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 Owners 
WHERE Email IS NOT NULL;

Resultado:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Agora temos apenas as linhas que não são NULL no Email 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.