In SQL ist der Ungleich-Operator (<> ) vergleicht die Ungleichheit zweier Ausdrücke. Das heißt, es testet, ob ein Ausdruck nicht ist gleich einem anderen Ausdruck.
Wenn einer oder beide Operanden NULL sind , NULL zurückgegeben wird.
SQL hat auch einen anderen Ungleich-Operator (!= ), was dasselbe tut. Welches Sie verwenden, hängt möglicherweise von Ihrem DBMS ab, welches Sie am liebsten verwenden und vielleicht auch davon, ob Ihre Organisation Codierungskonventionen hat, die vorschreiben, welches verwendet werden sollte.
Quelltabelle
Stellen Sie sich vor, unsere Datenbank enthält die folgende Tabelle. Dies ist die Tabelle, die wir für die Beispiele auf dieser Seite verwenden werden.
SELECT * FROM Pets;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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)
Beispiel
Wenn wir alle Haustiere haben wollten, die nicht einen bestimmten Eigentümer haben, könnten wir Folgendes tun:
SELECT *
FROM Pets
WHERE OwnerId <> 3;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Unsere Abfrage verwendet den Ungleich-Operator (<> ), um zu testen, ob die OwnerId Spalte ist nicht gleich 3 . Die Abfrage gibt alle Haustiere zurück, die nicht die Besitzernummer 3 als Besitzer haben.
Strings
Verwenden Sie beim Vergleichen mit einem Zeichenfolgenwert Anführungszeichen um die Zeichenfolge. Wenn wir beispielsweise Informationen über alle Haustiere erhalten möchten, die nicht Fluffy heißen, könnten wir Folgendes tun:
SELECT *
FROM Pets
WHERE PetName <> 'Fluffy';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Mehrere Bedingungen
Wenn Sie mehrere Bedingungen haben, können Sie mehrere Operatoren verwenden (sowohl dieselben als auch unterschiedliche Operatoren).
So:
SELECT * FROM Pets
WHERE OwnerId <> 1 AND OwnerId <> 3;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Verneinung der Bedingung
Wenn Sie NOT verwenden -Operator verwenden, um die vom Ungleich-Operator bereitgestellte Bedingung zu negieren, erhalten Sie am Ende die Ergebnisse des Gleichheits-Operators (= )-Operator:
SELECT *
FROM Pets
WHERE NOT PetName <> 'Fluffy';Ergebnis:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
In diesem Fall verwenden Sie besser gleich (= )-Operator wie folgt:
SELECT *
FROM Pets
WHERE PetName = 'Fluffy';
Dies selbst könnte natürlich mit NOT negiert werden -Operator, der uns dann dasselbe Ergebnis liefern würde wie das Gleichheitszeichen (<> ) Operator gibt uns:
SELECT *
FROM Pets
WHERE NOT PetName = 'Fluffy';NULL-Werte
Sie haben vielleicht bemerkt, dass unsere ursprüngliche Beispieltabelle ein paar NULL enthält Werte in der DOB-Spalte.
Eine Spalte, die NULL enthält bedeutet, dass es keinen Wert hat. Dies unterscheidet sich von 0 oder false , oder sogar eine leere Zeichenfolge.
Sie können den Ungleich-Operator nicht verwenden, um mit NULL zu vergleichen . Tatsächlich kann dies von Ihrem DBMS und seiner Konfiguration abhängen. Aber jetzt schauen wir uns an, was passiert, wenn ich versuche, die DOB-Spalte mit NULL zu vergleichen .
SELECT * FROM Pets
WHERE DOB <> NULL;Ergebnis:
(0 rows affected)
Die Methode zum Testen auf Nicht-NULL Werten ist IS NOT NULL zu verwenden .
Daher müssten wir die obige Aussage wie folgt umschreiben.
SELECT * FROM Pets
WHERE DOB IS NOT NULL;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Jetzt erhalten wir nur die Zeilen, die nicht NULL sind im DOB Spalte.
Wenn Sie interessiert sind, lesen Sie SQL Server ANSI_NULLS Explained um zu sehen, wie Sie die Art NULL ändern können Werte werden in SQL Server behandelt.
