V SQL se operátor nerovná operátoru (<> ) porovnává nerovnost dvou výrazů. To znamená, že testuje, zda jeden výraz není rovno jinému výrazu.
Pokud je jeden nebo oba operandy NULL , NULL je vráceno.
SQL má také jiný operátor, který se nerovná operátoru (!= ), který dělá to samé. Který z nich použijete, může záviset na vaší DBMS, kterou z nich používáte nejpohodlněji, a možná také na tom, zda vaše organizace má nějaké konvence kódování, které určují, která z nich by se měla používat.
Tabulka zdrojů
Představte si, že naše databáze obsahuje následující tabulku. Toto je tabulka, kterou použijeme 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
Pokud bychom chtěli získat všechna domácí zvířata, která ne mít určitého vlastníka, mohli bychom udělat toto:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Výsledek:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Náš dotaz používá operátor nerovná se (<> ), abyste otestovali, zda OwnerId sloupec není roven 3 . Dotaz vrátí všechna domácí zvířata, která nemají vlastníka číslo 3 jako vlastníka.
Řetězce
Při porovnávání s hodnotou řetězce použijte kolem řetězce uvozovky. Pokud bychom například chtěli získat informace o všech domácích mazlíčcích, kteří se nejmenují Fluffy, mohli bychom udělat následující:
SELECT *
FROM Pets
WHERE 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 | +---------+-------------+-----------+-----------+------------+
Více podmínek
Pokud máte více podmínek, můžete použít více operátorů (ať už oba stejné operátory nebo různé).
Takhle:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Výsledek:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Negace podmínky
Pokud použijete NOT Chcete-li negovat podmínku poskytnutou operátorem nerovná se, nakonec dostanete výsledky rovného (= ) operátor:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Výsledek:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
V tomto případě je lepší použít rovnou (= ), například takto:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
To samo o sobě lze samozřejmě negovat pomocí NOT operátor, který by nám pak dal stejný výsledek, jako je rovno (<> ) nám operátor dává:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Hodnoty NULL
Možná jste si všimli, že naše původní vzorová tabulka obsahuje několik NULL hodnoty ve sloupci DOB.
Sloupec obsahující NULL znamená, že nemá žádnou hodnotu. To se liší od 0 nebo false nebo dokonce prázdný řetězec.
K porovnání s NULL nelze použít operátor nerovná se . Ve skutečnosti to může záviset na vašem DBMS a jeho konfiguraci. Ale teď se podívejme, co se stane, když se pokusím porovnat sloupec DOB s NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Výsledek:
(0 rows affected)
Způsob testování, zda není NULL hodnoty je použít IS NOT NULL .
Proto bychom museli výše uvedené prohlášení přepsat následovně.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;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 | +---------+-------------+-----------+-----------+------------+
Nyní získáme pouze ty řádky, které nejsou NULL v DOB sloupec.
Pokud máte zájem, přečtěte si SQL Server ANSI_NULLS Explained abyste viděli, jak můžete změnit způsob NULL hodnoty jsou zpracovávány v SQL Server.