Database
 sql >> Datenbank >  >> RDS >> Database

SQL Ungleich (!=)-Operator für Anfänger

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 Owners;

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Beispiel

Wenn wir eine Liste aller Eigentümer zurückgeben möchten, die keine OwnerId haben von 3 , könnten wir dies tun:

SELECT *
FROM Owners
WHERE OwnerId != 3;

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Unsere Abfrage verwendet den Ungleich-Operator (!= ), um zu testen, ob die OwnerId Spalte ist nicht gleich 3 . Die Abfrage gibt alle Eigentümer außer Eigentümer Nummer 3 zurück.

Strings

Verwenden Sie beim Vergleichen mit einem Zeichenfolgenwert Anführungszeichen um die Zeichenfolge. Wenn wir beispielsweise Informationen über alle Eigentümer erhalten möchten, deren Vorname nicht Homer ist, könnten wir Folgendes tun:

SELECT *
FROM Owners
WHERE FirstName != 'Homer';

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Mehrere Bedingungen

Wenn Sie mehrere Bedingungen haben, können Sie mehrere Operatoren verwenden (sowohl dieselben als auch unterschiedliche Operatoren).

So:

SELECT * FROM Owners 
WHERE OwnerId != 1 AND OwnerId != 3;

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Sobald Sie beginnen, mehr Bedingungen zu verwenden, sollten Sie die Bedingungen, die Sie zuerst auswerten möchten, in Klammern setzen. Wenn Sie dies nicht tun, erhalten Sie möglicherweise unerwartete Ergebnisse, da die Bedingungen in einer von Ihnen nicht beabsichtigten Reihenfolge ausgewertet werden.

Negieren 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 Owners
WHERE NOT FirstName != 'Homer';

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

In diesem Fall verwenden Sie besser nur die Gleichheit (= )-Operator wie folgt:

SELECT *
FROM Owners
WHERE FirstName = 'Homer';

Dies selbst könnte natürlich mit NOT negiert werden -Operator, der uns dann das gleiche Ergebnis liefern würde wie der ungleich (!= ) Operator gibt uns:

SELECT *
FROM Owners
WHERE NOT FirstName = 'Homer';

NULL-Werte

Sie haben vielleicht bemerkt, dass unsere ursprüngliche Beispieltabelle ein paar NULL enthält Werte in der Email 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 Email zu vergleichen Spalte auf NULL .

SELECT * FROM Owners 
WHERE Email != 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 Owners 
WHERE Email IS NOT NULL;

Ergebnis:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
| 6         | Burt        | Tyson      | (309) 565-0112 | [email protected]  |
+-----------+-------------+------------+----------------+-------------------+

Jetzt erhalten wir nur die Zeilen, die nicht NULL sind in der Email Spalte.

Wenn Sie interessiert sind, lesen Sie SQL Server ANSI_NULLS Explained um zu sehen, wie Sie den Weg NULL ändern können Werte werden in SQL Server behandelt.