In SQL, l'operatore diverso da (<> ) confronta la non uguaglianza di due espressioni. Cioè, verifica se un'espressione è non uguale a un'altra espressione.
Se uno o entrambi gli operandi sono NULL , NULL viene restituito.
SQL ha anche un altro operatore diverso da (!= ), che fa la stessa cosa. Quale usi può dipendere dal tuo DBMS, quale ti senti più a tuo agio nell'usare e forse anche se la tua organizzazione ha delle convenzioni di codifica che stabiliscono quale dovrebbe essere utilizzato.
Tabella delle sorgenti
Immagina che il nostro database contenga la seguente tabella. Questa è la tabella che useremo 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
Se volessimo ottenere tutti gli animali domestici che non avere un certo proprietario, potremmo farlo:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
La nostra query utilizza l'operatore diverso da (<> ) per verificare se il OwnerId la colonna non è uguale a 3 . La query restituisce tutti gli animali domestici che non hanno il numero di proprietario 3 come proprietario.
Stringhe
Quando si confronta con un valore stringa, utilizzare le virgolette attorno alla stringa. Ad esempio, se volessimo ottenere informazioni su tutti gli animali domestici che non si chiamano Fluffy, potremmo fare quanto segue:
SELECT *
FROM Pets
WHERE 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 | +---------+-------------+-----------+-----------+------------+
Condizioni multiple
Se hai più condizioni, puoi utilizzare più operatori (sia gli stessi operatori che diversi).
In questo modo:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Negazione della condizione
Se usi il NOT per negare la condizione fornita dall'operatore diverso da, finirai per ottenere i risultati di uguale a (= ) operatore:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Risultato:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
In questo caso, è meglio usare semplicemente l'uguale a (= ) operatore, in questo modo:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Naturalmente, questo stesso potrebbe essere negato con NOT operatore, che ci darebbe lo stesso risultato di uguale a (<> ) l'operatore ci fornisce:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';Valori NULL
Potresti aver notato che la nostra tabella di esempio originale contiene un paio di NULL valori nella colonna DOB.
Una colonna contenente NULL significa che non ha valore. Questo è diverso da 0 o false o anche una stringa vuota.
Non puoi utilizzare l'operatore diverso da per confrontare con NULL . In realtà, questo potrebbe dipendere dal tuo DBMS e dalla sua configurazione. Ma per ora, diamo un'occhiata a cosa succede se provo a confrontare la colonna DOB con NULL .
SELECT * FROM Pets
WHERE DOB <> NULL;Risultato:
(0 rows affected)
Il modo per verificare se non NULL valori consiste nell'usare IS NOT NULL .
Pertanto, dovremmo riscrivere la dichiarazione di cui sopra come segue.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;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 | +---------+-------------+-----------+-----------+------------+
Ora otteniamo solo quelle righe che non sono NULL nel DOB colonna.
Se sei interessato, vedi SQL Server ANSI_NULLS Explained per vedere come puoi cambiare il modo NULL i valori vengono trattati in SQL Server.
