Vergleichsoperatoren sind ein wichtiger Bestandteil der meisten Programmiersprachen.
Vergleichsoperatoren werden verwendet, um zwei Ausdrücke zu vergleichen. Das Ergebnis ist entweder true oder false . Es könnte auch unbekannt sein. Dies könnte auch durch 1 dargestellt werden , 0 , oder NULL , je nach Sprache. Diese werden normalerweise als „boolesche Ausdrücke“ bezeichnet.
Bei Verwendung mit Datenbanken können Vergleichsoperatoren in Ihren SQL-Abfragen verwendet werden, um Daten nach bestimmten Kriterien zu filtern.
Allgemeine Vergleichsoperatoren
Die meisten Programmiersprachen unterstützen die folgenden Vergleichsoperatoren in der einen oder anderen Form:
| OPERATOR | BEDEUTUNG |
|---|---|
= | Gleich |
> | Größer als |
< | Kleiner als |
>= | Größer als oder gleich |
<= | Kleiner als oder gleich |
<> | Ungleich |
SQL verwendet dieselbe Syntax wie in der obigen Tabelle aufgeführt.
Einige Sprachen verwenden eine andere Syntax, um Verwechslungen mit Zuweisungsoperatoren zu vermeiden. Beispielsweise verwenden Python und JavaScript == statt = . ColdFusion hingegen verwendet eq .
Unterschiedliche Datentypen
Einige Sprachen haben einen speziellen Operator, um anzugeben, dass beide Werte denselben Datentyp haben müssen.
JavaScript enthält beispielsweise auch den === Operator, der angibt, dass beide Werte gleich und sind dass sie vom gleichen Datentyp sein müssen. Aber wenn der Datentyp irrelevant ist, verwenden Sie == stattdessen.
Beispiele
Größer als Operator
Hier ist ein Beispiel für die Verwendung des Größer-als-Operators in einer T-SQL-Abfrage.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Ergebnis:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
In diesem Beispiel habe ich den Größer-als-Operator (> ), um nur Länder mit mehr als 100000000 Einwohnern auszuwählen.
Gleich-Operator
Hier ist ein weiteres Beispiel, bei dem ich den Gleichheitsoperator (= verwende ), um Daten zurückzugeben, die genau einem bestimmten Wert entsprechen.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Ergebnis:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
In diesem Fall gebe ich nur die Städte zurück, deren Ländercode gleich AFG ist .
Dies zeigt, dass Vergleichsoperatoren nicht nur auf numerische Datentypen beschränkt sind.
Termine
Sie können auch Vergleichsoperatoren für Datumsangaben verwenden, zum Beispiel:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Ergebnis:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | +------------+----------------+--------------+
Wie Sie sehen, werden nur Ergebnisse zurückgegeben, die größer als (nach) dem angegebenen Datum sind.
Größer-gleich-Operator
Ich kann den Größer-als- oder Gleich-Operator verwenden, um das angegebene Datum in die Ergebnisse aufzunehmen.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Ergebnis:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+----------------+--------------+
In diesem Fall wird eine zusätzliche Zeile zurückgegeben (die letzte Zeile).
Kleiner als Operator
Folgendes passiert, wenn ich meine Abfrage so ändere, dass sie einen Kleiner-als-Operator verwendet.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Ergebnis:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | +------------+------------------------+--------------+
Ich erhalte alle Zeilen, die kleiner als das angegebene Datum sind.
Vergleich von NULL-Werten
NULL Werte können die Dinge bei der Verwendung von Vergleichsoperatoren etwas komplizieren. Kurz gesagt, Sie erhalten möglicherweise ein anderes Ergebnis, je nachdem, wie Ihre Umgebung konfiguriert ist.
Wenn Sie beispielsweise in SQL Server den Equals-Operator verwenden (= ) oder der Ungleich-Operator (<> ), um gegen NULL zu testen , hängt Ihr Ergebnis von Ihrem ANSI_NULLS ab Einstellung (d.h. ob es ON ist oder OFF ).
Zum Testen gegen NULL -Werten stellt SQL Server auch den IS NULL bereit Prädikat, das konsistent funktioniert, unabhängig von Ihrem ANSI_NULLS Einstellung. Dazu gehört auch IS NOT NULL Variante zum Testen gegen Nicht-NULL Werte.
Unten ist ein Beispiel, das demonstriert, was ich meine.
ANSI_NULLS ON
Zuerst setzen wir ANSI_NULLS auf ON , dann führen Sie ein paar Tests gegen NULL durch .
SET ANSI_NULLS ON;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Ergebnis:
(0 rows affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) (0 rows affected)
ANSI_NULLS OFF
Jetzt setzen wir ANSI_NULLS auf OFF , und führen Sie dann dieselben Tests aus.
SET ANSI_NULLS OFF;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Ergebnis:
+--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected)
