In SQL, il NOT nega un input booleano (inverte il valore di qualsiasi espressione booleana). Pertanto restituisce TRUE quando l'espressione è FALSE .
Tabella delle sorgenti
La tabella seguente viene utilizzata per gli esempi in questa pagina.
SELECT * FROM Pets;Risultato:
+---------+-------------+-----------+-----------+------------+ | 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)
Esempio 1
Ecco un semplice esempio per dimostrare il NOT operatore.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
In questo caso, abbiamo usato NOT operatore per negare il risultato del LIKE operatore. La nostra query restituisce tutti gli animali domestici che non iniziano con la lettera F.
Esempio 2 – Utilizzo di NOT con operatori di confronto
Se stai usando il NOT per negare un operatore di confronto, dovrai modificare leggermente la tua sintassi rispetto a quella utilizzata nell'esempio precedente.
Ad esempio, se vuoi usarlo per negare l'operatore uguale (= ), utilizza la seguente sintassi:
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Questo restituisce tutti gli animali il cui nome non è Fluffy.
In questo esempio, mettiamo NOT operatore davanti al nome della colonna. Se non lo avessimo fatto, avremmo ricevuto un errore simile a questo:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Risultato:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Avremmo potuto ottenere lo stesso risultato anche utilizzando l'operatore diverso da (o <> o != a seconda del tuo DBMS).
Ad esempio, questo:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';O questo:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Esempio 3 – Stessa sintassi con operatori logici
A quanto pare, possiamo anche usare quella sintassi quando utilizziamo operatori logici, come LIKE operatore che abbiamo usato nel primo esempio.
Pertanto, potremmo riscrivere il primo esempio in questo:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Nel caso in cui non sei sicuro di quale sia la differenza, abbiamo spostato NOT operatore dopo il PetName colonna, prima di essa.
Ecco le due affermazioni insieme:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Esempio 4:negazione di più condizioni
Il NOT operatore nega solo una singola condizione. Se hai più condizioni che devi negare, usa un NOT separato operatore per ogni condizione,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Esempio 5 – Precedenza
Quando si utilizzano condizioni composte, in cui sono presenti più operatori, NOT viene valutato prima di qualsiasi operatore logico, ma dopo qualsiasi operatore. operatori di confronto,
Quando due operatori in un'espressione hanno lo stesso livello di precedenza, vengono valutati da sinistra a destra in base alla loro posizione nell'espressione. Tuttavia, puoi utilizzare le parentesi per specificare l'ordine in cui desideri che ogni condizione venga valutata.
Ecco un esempio.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Non abbiamo usato parentesi qui e tutte le condizioni sono state negate con NOT operatore, e quindi il AND l'operatore ha la precedenza su OR operatore.
Tuttavia, possiamo usare le parentesi per specificare che OR la condizione dovrebbe essere valutata prima di AND condizione.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Risultato:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
In questo caso otteniamo un risultato diverso.
Esempio 6 – Annulla l'operatore BETWEEN
Ecco un altro esempio, questa volta usando il NOT operatore per negare il risultato di BETWEEN operatore.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Risultato:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
In questo esempio, abbiamo restituito tutte le righe in cui DOB la colonna non tra il 2018-10-01 e 2020-09-17 .
In questo caso, due righe corrispondevano a quel criterio e, pertanto, sono state restituite due righe.
Questo è il risultato opposto della seguente query:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
In questo esempio, abbiamo restituito tutte le righe in cui DOB la colonna è tra il 2018-10-01 e 2020-09-17 .
In questo caso, quattro righe corrispondevano a quel criterio e, pertanto, sono state restituite quattro righe.
