En SQL, el NOT El operador niega una entrada booleana (invierte el valor de cualquier expresión booleana). Por lo tanto devuelve TRUE cuando la expresión es FALSE .
Tabla de origen
La siguiente tabla se utiliza para los ejemplos de esta 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)
Ejemplo 1
Aquí hay un ejemplo simple para demostrar el 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 | +---------+-------------+-----------+-----------+------------+
En este caso, usamos el NOT operador para negar el resultado de LIKE operador. Nuestra consulta devuelve todas las mascotas que no comienzan con la letra F.
Ejemplo 2:uso de NOT con operadores de comparación
Si estás usando el NOT operador para negar un operador de comparación, deberá modificar su sintaxis ligeramente de la utilizada en el ejemplo anterior.
Por ejemplo, si desea usarlo para negar el operador igual (= ), use la siguiente sintaxis:
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 | +---------+-------------+-----------+-----------+------------+
Esto devuelve todas las mascotas cuyo nombre no es Fluffy.
En este ejemplo, ponemos el NOT operador delante del nombre de la columna. Si no hubiéramos hecho eso, habríamos recibido un error que dice algo como esto:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Resultado:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
También podríamos haber logrado el mismo resultado usando el operador no igual a (ya sea <> o != dependiendo de su SGBD).
Por ejemplo, esto:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';O esto:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Ejemplo 3:la misma sintaxis con operadores lógicos
Resulta que también podemos usar esa sintaxis cuando usamos operadores lógicos, como LIKE operador que usamos en el primer ejemplo.
Por lo tanto, podríamos reescribir el primer ejemplo así:
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 | +---------+-------------+-----------+-----------+------------+
En caso de que no esté seguro de cuál es la diferencia, movimos el NOT operador de después del PetName columna, antes de ella.
Aquí están las dos declaraciones juntas:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Ejemplo 4:Negación de varias condiciones
El NOT El operador solo niega una sola condición. Si tiene múltiples condiciones que necesita negar, use un NOT separado operador para cada condición,
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 | +---------+-------------+-----------+-----------+------------+
Ejemplo 5:Precedencia
Al usar condiciones compuestas, donde tiene múltiples operadores, el NOT El operador se evalúa antes que cualquier operador lógico, pero después de cualquiera. operadores de comparación,
Cuando dos operadores en una expresión tienen el mismo nivel de precedencia, se evalúan de izquierda a derecha según su posición en la expresión. Sin embargo, puede usar paréntesis para especificar el orden en el que desea que se evalúe cada condición.
He aquí un ejemplo.
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 | +---------+-------------+-----------+-----------+------------+
No usamos ningún paréntesis aquí, y todas las condiciones fueron negadas con NOT operador, por lo que el AND El operador tenía prioridad sobre el OR operador.
Sin embargo, podemos usar paréntesis para especificar que el OR la condición debe evaluarse antes de AND condición.
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 | +---------+-------------+-----------+-----------+------------+
En este caso obtenemos un resultado diferente.
Ejemplo 6:niega el operador BETWEEN
Aquí hay otro ejemplo, esta vez usando el NOT operador para negar el resultado de 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 | +---------+-------------+-----------+-----------+------------+
En este ejemplo, devolvimos todas las filas donde DOB la columna es no entre 2018-10-01 y 2020-09-17 .
En este caso, dos filas coincidieron con ese criterio y, por lo tanto, se devolvieron dos filas.
Este es el resultado opuesto de la siguiente 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 | +---------+-------------+-----------+-----------+------------+
En este ejemplo, devolvimos todas las filas donde DOB columna es entre 2018-10-01 y 2020-09-17 .
En este caso, cuatro filas coincidieron con ese criterio y, por lo tanto, se devolvieron cuatro filas.
