V SQL, NOT operátor neguje booleovský vstup (obrátí hodnotu libovolného booleovského výrazu). Proto vrací TRUE když je výraz FALSE .
Tabulka zdrojů
Následující tabulka je použita pro příklady na této stránce.
SELECT * FROM Pets;Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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)
Příklad 1
Zde je jednoduchý příklad, který demonstruje NOT operátor.
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
V tomto případě jsme použili NOT operátor negovat výsledek LIKE operátor. Náš dotaz vrátí všechna domácí zvířata, která nezačínají písmenem F.
Příklad 2 – Použití NOT s porovnávacími operátory
Pokud používáte NOT Chcete-li negovat operátor porovnání, budete muset mírně upravit svou syntaxi oproti syntaxi použité v předchozím příkladu.
Pokud jej například chcete použít k negaci operátoru rovná se (= ), použijte následující syntaxi:
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Tím se vrátí všechna zvířata, jejichž jméno není Fluffy.
V tomto příkladu jsme vložili NOT operátor před názvem sloupce. Pokud bychom to neudělali, dostali bychom chybu, která vypadá asi takto:
SELECT * FROM Pets
WHERE PetName NOT = 'Fluffy';Výsledek:
Msg 102, Level 15, State 1, Line 2 Incorrect syntax near '='.
Stejného výsledku jsme mohli dosáhnout také použitím operátoru nerovná se (buď <> nebo != v závislosti na vašem DBMS).
Například toto:
SELECT * FROM Pets
WHERE PetName <> 'Fluffy';Nebo toto:
SELECT * FROM Pets
WHERE PetName != 'Fluffy';Příklad 3 – Stejná syntaxe s logickými operátory
Jak se ukázalo, můžeme tuto syntaxi použít také při použití logických operátorů, jako je LIKE operátor, který jsme použili v prvním příkladu.
Proto bychom mohli přepsat první příklad na tento:
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
V případě, že si nejste jisti, v čem je rozdíl, přesunuli jsme NOT operátor za PetName sloupec až před něj.
Zde jsou tato dvě prohlášení společně:
SELECT * FROM Pets
WHERE PetName NOT LIKE 'F%';
SELECT * FROM Pets
WHERE NOT PetName LIKE 'F%';Příklad 4 – Negace více podmínek
NOT operátor neguje pouze jednu podmínku. Pokud máte více podmínek, které musíte negovat, použijte samostatný NOT operátor pro každou podmínku,
SELECT * FROM Pets
WHERE NOT PetName = 'Fluffy'
AND NOT PetName = 'Wag';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Příklad 5 – Přednost
Při použití složených podmínek, kde máte více operátorů, NOT operátor je vyhodnocen před jakýmkoli logickým operátorem, ale po kterémkoli. porovnávací operátory,
Když dva operátory ve výrazu mají stejnou úroveň priority, jsou vyhodnoceny zleva doprava na základě jejich pozice ve výrazu. Můžete však použít závorky k určení pořadí, ve kterém má být každá podmínka vyhodnocena.
Zde je příklad.
SELECT * FROM Pets
WHERE
NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag'
AND NOT DOB > '2020-01-01';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Nepoužili jsme zde žádné závorky a všechny podmínky byly negovány pomocí NOT operátor, a tedy AND operátor má přednost před OR operátor.
Můžeme však použít závorky k určení, že OR podmínka by měla být vyhodnocena před AND podmínka.
SELECT * FROM Pets
WHERE
(NOT PetName = 'Fluffy'
OR NOT PetName = 'Wag')
AND NOT DOB > '2020-01-01';Výsledek:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +---------+-------------+-----------+-----------+------------+
V tomto případě dostaneme jiný výsledek.
Příklad 6 – Negace operátora BETWEEN
Zde je další příklad, tentokrát s použitím NOT operátor negovat výsledek BETWEEN operátor.
SELECT * FROM Pets
WHERE DOB NOT BETWEEN '2018-10-01' AND '2020-09-17';Výsledek:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
V tomto příkladu jsme vrátili všechny řádky s DOB sloupec není mezi 2018-10-01 a 2020-09-17 .
V tomto případě tomuto kritériu odpovídaly dva řádky, a proto byly vráceny dva řádky.
Toto je opačný výsledek následujícího dotazu:
SELECT * FROM Pets
WHERE DOB BETWEEN '2018-10-01' AND '2020-09-17';Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
V tomto příkladu jsme vrátili všechny řádky s DOB sloupec je mezi 2018-10-01 a 2020-09-17 .
V tomto případě tomuto kritériu odpovídaly čtyři řádky, a proto byly vráceny čtyři řádky.