Em SQL, o
NOT O operador nega uma entrada booleana (inverte o valor de qualquer expressão booleana). Portanto, ele retorna TRUE quando a expressão é FALSE . Tabela de origem
A tabela a seguir é usada 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 1
Aqui está um exemplo simples para demonstrar o
NOT operador. SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 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 | +---------+-------------+-----------+-----------+------------+
Neste caso, usamos o
NOT operador para negar o resultado do LIKE operador. Nossa consulta retorna todos os animais de estimação que não começam com a letra F. Exemplo 2 – Usando NOT com operadores de comparação
Se você estiver usando o
NOT para negar um operador de comparação, você precisará modificar sua sintaxe ligeiramente daquela usada no exemplo anterior. Por exemplo, se você quiser usá-lo para negar o operador igual (
= ), use a seguinte sintaxe:SELECT * FROM Pets
WHERE NOT 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 | +---------+-------------+-----------+-----------+------------+
Isso retorna todos os animais de estimação cujo nome não é Fluffy.
Neste exemplo, colocamos o
NOT operador na frente do nome da coluna. Se não tivéssemos feito isso, teríamos recebido um erro mais ou menos assim:SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Resultado:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Também poderíamos ter alcançado o mesmo resultado usando o operador diferente de (ou
<> ou != dependendo do seu SGBD). Por exemplo, isso:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Ou isto:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Exemplo 3 – Mesma Sintaxe com Operadores Lógicos
Como se vê, também podemos usar essa sintaxe ao usar operadores lógicos, como o
LIKE operador que usamos no primeiro exemplo. Portanto, poderíamos reescrever o primeiro exemplo para isso:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 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 | +---------+-------------+-----------+-----------+------------+
Caso você não tenha certeza de qual é a diferença, movemos o
NOT operador após o PetName coluna, para antes dela. Aqui estão as duas declarações juntas:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Exemplo 4 – Negar várias condições
O
NOT operador apenas nega uma única condição. Se você tiver várias condições que precisa negar, use um NOT separado operador para cada condição, SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Exemplo 5 – Precedência
Ao usar condições compostas, onde você tem vários operadores, o
NOT operador é avaliado antes de qualquer operador lógico, mas depois de qualquer. operadores de comparação, Quando dois operadores em uma expressão têm o mesmo nível de precedência, eles são avaliados da esquerda para a direita com base em sua posição na expressão. No entanto, você pode usar parênteses para especificar a ordem na qual deseja que cada condição seja avaliada.
Aqui está um exemplo.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';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 | +---------+-------------+-----------+-----------+------------+
Não usamos parênteses aqui e todas as condições foram negadas com o
NOT operador, e assim o AND operador teve precedência sobre o OR operador. No entanto, podemos usar parênteses para especificar que o
OR condição deve ser avaliada antes do AND doença. SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
Neste caso obtemos um resultado diferente.
Exemplo 6 – Negar o operador BETWEEN
Aqui está outro exemplo, desta vez usando o
NOT operador para negar o resultado do BETWEEN operador. SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
Neste exemplo, retornamos todas as linhas em que o
DOB coluna é não entre 2018-10-01 e 2020-09-17 . Nesse caso, duas linhas corresponderam a esse critério e, portanto, duas linhas foram retornadas.
Este é o resultado oposto da seguinte consulta:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';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 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Neste exemplo, retornamos todas as linhas em que o
DOB coluna é entre 2018-10-01 e 2020-09-17 . Nesse caso, quatro linhas corresponderam a esse critério e, portanto, quatro linhas foram retornadas.
