Spezifische Verwendung von MySQL-Operatoren (und, oder, in, nicht)

Spezifische Verwendung von MySQL-Operatoren (und, oder, in, nicht)

1. Einleitung

Wenn Sie die Where-Klausel zum Filtern von Abfragedaten in MySQL verwenden, müssen häufig mehrere Filterbedingungen gleichzeitig erfüllt werden oder eine der mehreren Filterbedingungen erfüllt werden. Zu diesem Zeitpunkt können wir Operatoren verwenden, um die Where-Klauseln zu verbinden.

Die Funktionen mehrerer Operatoren:

Betreiber Wirkung
Und Und die Bedingungen in der Where-Klausel müssen gleichzeitig erfüllt sein
oder Oder es muss nur eine Bedingung in mehreren Where-Klauseln erfüllt sein
In Wird verwendet, um den Umfang der Where-Klausel-Abfrage anzugeben
nicht Nicht, normalerweise verwendet mit in, zwischen und, existiert, um eine Verneinung anzuzeigen

2. Haupttext

Bereiten Sie zunächst eine Benutzertabelle vor. Die DDL- und Tabellendaten sind wie folgt und können direkt kopiert und verwendet werden.

Namen festlegen utf8mb4;
Setzen Sie FOREIGN_KEY_CHECKS = 0;
 
-- ----------------------------
-- Tabellenstruktur für Benutzer
-- ----------------------------
DROP TABLE, WENN `Benutzer` EXISTIERT;
CREATE TABLE `Benutzer` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel',
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'Benutzername',
  `Alter` int(11) NICHT NULL KOMMENTAR 'Alter',
  `sex` smallint(6) NOT NULL COMMENT 'Geschlecht',
  PRIMÄRSCHLÜSSEL (`id`) MIT BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamisch;
 
-- ----------------------------
-- Aufzeichnungen des Benutzers
-- ----------------------------
INSERT INTO `user` VALUES (1, 'Benutzername', 18, 1);
INSERT INTO `user` VALUES (2, 'Benutzer', 22, 1);
INSERT INTO `user` VALUES (3, 'Benutzer', 38, 1);
INSERT INTO `user` VALUES (4, 'Benutzer', 25, 1);
INSERT INTO `user` VALUES (5, 'Benutzername', 13, 0);
INSERT INTO `user` VALUES (6, 'Benutzer', 37, 1);
INSERT INTO `Benutzer` VALUES (7, 'Danke', 18, 0);
 
Setzen Sie FOREIGN_KEY_CHECKS = 1;

Die anfängliche Reihenfolge der Daten ist wie folgt:

mysql> wähle * vom Benutzer aus;
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 5 | Liu Mazi | 13 | 0 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
7 Zeilen im Satz (0,00 Sek.)

2.1 und Betreiber

Wenn die Abfrage gleichzeitig die Bedingungen in der Where-Klausel erfüllen muss, können Sie den Operator „und“ verwenden. Die „und“-Bedingungen stehen in einer „und“-Beziehung.

brauchen:
Abfrage von Benutzern, die 18 Jahre alt und männlich sind (Hinweis: Geschlecht=1 steht für männlich).
Stellungnahme:

mysql> select * from user where age = 18 und sex = 1;

Ergebnis:

+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
+----+--------+-----+-----+
1 Zeile im Satz (0,00 Sek.)

An diesem Punkt können Sie sehen, dass nur Benutzer abgefragt werden, die sowohl das Alter von 18 Jahren als auch das Geschlecht von 1 erfüllen. Analog dazu können mehrere „unds“ gleichzeitig existieren. Wenn Sie beispielsweise basierend auf dem obigen nach **name=李子柒** suchen müssen, müssen Sie nur einen weiteren „und“-Operator folgen lassen.

mysql> select * from user where age = 18 and sex =1 and name = 'Benutzername';
Leerer Satz (0,00 Sek.)

2.2 oder Betreiber

Anders als „und“ muss „oder“ nur eine der mehreren Where-Bedingungen erfüllen, nicht alle. Die Bedingungen stehen in einer „oder“-Beziehung.

brauchen:
Abfrage von Benutzern mit einem Alter von 18 Jahren oder männlichem Geschlecht (Hinweis: Geschlecht = 1 steht für männlich).
Stellungnahme:

mysql> select * from user where age = 18 oder sex = 1;

Ergebnis:

+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
6 Zeilen im Satz (0,00 Sek.)

An diesem Punkt können Sie sehen, dass alle Benutzer gefunden werden, die das Alter von 18 Jahren oder das Geschlecht von 1 erfüllen. Der gleiche „or“-Operator kann auch auf mehrere Where-Klauseln gleichzeitig angewendet werden.

2.3 im Operator

Der In-Operator wird verwendet, um den Abfragebereich der Where-Klausel anzugeben. Es bedeutet Einschluss und kann mit mehreren „oder“-Operatoren umgesetzt werden.

brauchen:
Fragen Sie die Benutzerinformationen ab, deren Name Zhang San, Li Si und Wang Wu entspricht.
Stellungnahme:
Verwenden des Operators „oder“

mysql> select * from user where name = 'Benutzer' oder name = 'Benutzername' oder name = 'Benutzername';
+----+------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+------+-----+-----+
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
+----+------+-----+-----+
3 Zeilen im Satz (0,00 Sek.)

Verwenden des in-Operators

mysql> select * from user where name in ('Benutzername', 'Benutzername', 'Benutzername');
+----+------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+------+-----+-----+
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
+----+------+-----+-----+
3 Zeilen im Satz (0,00 Sek.)

Die oben genannten Anforderungen können durch die Verwendung des „or“-Operators und des „in“-Operators erreicht werden, aber der „in“-Operator verkürzt die SQL-Anweisung offensichtlich.​

2.4 nicht Betreiber

Wenn wir abfragen müssen, ob ein Wert nicht innerhalb eines bestimmten Bereichs liegt oder nicht existiert, können wir den Operator not verwenden. Der Operator not wird nicht allein verwendet, sondern oft zusammen mit dem Operator in, wie z. B. Operator, between and, exists usw.​

nicht in
brauchen:
Fragen Sie Benutzerinformationen ab, deren Namen nicht Zhang San, Li Si oder Wang Wu lauten.
Stellungnahme:

mysql> select * from user where name not in ('Benutzername', 'Benutzername', 'Benutzername');
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 5 | Liu Mazi | 13 | 0 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
4 Zeilen im Satz (0,00 Sek.)

nicht mögen
brauchen:
Abfrage des Benutzers, dessen Name nicht mit „lizi“ beginnt:

mysql> select * from user, wobei der Name nicht wie '李子%' ist;
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 5 | Liu Mazi | 13 | 0 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
6 Zeilen im Satz (0,00 Sek.)

nicht zwischen und
brauchen:
So fragen Sie Benutzer ab, deren Alter nicht zwischen 20 und 30 liegt:

mysql> select * from user, wobei das Alter nicht zwischen 20 und 30 liegt;
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 3 | Li Si | 38 | 1 |
| 5 | Liu Mazi | 13 | 0 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
5 Zeilen im Satz (0,00 Sek.)

​existiert nicht

Die Tabelle „not exists“ wird auf die gleiche Weise wie „exists“ verwendet und dient dazu, zu bestimmen, ob das Ergebnis der aktuellen Where-Klausel zurückgegeben werden soll. „nicht existiert“ und „existiert“ wirken auf eine Unterabfrage und geben „true“ und „false“ an das übergeordnete Element zurück.
Beispielsyntax:

SELECT ... FROM Tabelle WHERE EXISTS (Unterabfrage)
SELECT ... FROM Tabelle WHERE NOT EXISTS (Unterabfrage)

Um den Effekt zu demonstrieren, erstellen wir eine einfache Bestelltabelle, deren Tabellenerstellungsanweisung und Daten wie folgt lauten:

Namen festlegen utf8mb4;
Setzen Sie FOREIGN_KEY_CHECKS = 0;
 
-- ----------------------------
-- Tabellenstruktur für die Bestellung
-- ----------------------------
Tabelle löschen, wenn `Reihenfolge` vorhanden ist;
CREATE TABLE `Reihenfolge` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel',
  `Nummer` varchar(255) ZEICHENSATZ utf8 COLLATE utf8_general_ci NOT NULL KOMMENTAR 'Bestellnummer',
  `user_id` bigint(20) NULL DEFAULT NULL COMMENT 'Benutzer-ID',
  `Preis` Dezimalzahl (10, 2) NULL DEFAULT NULL KOMMENTAR 'Betrag',
  `create_date` datetime(0) NULL DEFAULT NULL COMMENT 'Erstellungsdatum',
  PRIMÄRSCHLÜSSEL (`id`) MIT BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamisch;
 
-- ----------------------------
-- Auftragsaufzeichnungen
-- ----------------------------
INSERT INTO `Bestellung` VALUES (1, 'DD-20211110-000001', 1, 250.00, '2021-11-10 22:37:19');
 
Setzen Sie FOREIGN_KEY_CHECKS = 1;

Hinweis: Da „order“ ein MySQL-Schlüsselwort ist, ist es nicht empfehlenswert, die Tabelle beim Erstellen direkt „order“ zu benennen. Ich nenne sie hier „order“, um zu erklären, wie man dieses Problem löst.

mysql> wähle * aus „Reihenfolge“;
+----+--------------------+---------+--------+---------------------+
| ID | Nummer | Benutzer-ID | Preis | Erstellungsdatum |
+----+--------------------+---------+--------+---------------------+
| 1 | DD-20211110-000001 | 1 | 250,00 | 10.11.2021 22:37:19 |
+----+--------------------+---------+--------+---------------------+
1 Zeile im Satz (0,00 Sek.)

Wenn Sie genau hinschauen, können Sie feststellen, dass die Reihenfolge mit ` geändert wird, sodass MySQL sie nicht als Schlüsselwort analysiert. Wenn Sie MySQL nicht hinzufügen, wird eine Ausnahme ausgelöst.

Zurück zum Thema, wir verwenden nun exists um die Anforderungen abzufragen:
Abfrage der Benutzerinformationen der getätigten Bestellung:

mysql> wähle * vom Benutzer, wo vorhanden ist (wähle ID aus „Bestellung“, wobei Benutzer-ID = Benutzer-ID);
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
+----+--------+-----+-----+
1 Zeile im Satz (0,00 Sek.)

Wenn wir derzeit die Benutzerinformationen abfragen möchten, die keine Bestellung aufgegeben haben, müssen wir nur „not exists“ verwenden.

mysql> select * from user, wo nicht vorhanden (select id from `order` where user_id = user.id);
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 5 | Liu Mazi | 13 | 0 |
| 6 | Tianqi | 37 | 1 |
| 7 | Danke | 18 | 0 |
+----+--------+-----+-----+
6 Zeilen im Satz (0,00 Sek.)

2.5 Betreiberauftrag

Oben wurden mehrere Operatoren erwähnt, aber in vielen Fällen müssen mehrere Operatoren zusammen verwendet werden. Dabei müssen wir auf die Reihenfolge der Operatoren achten.

Beispielsweise folgende Anforderungen:
Fragen Sie die Benutzertabelle nach Benutzern ab, die älter als 20 Jahre oder männlich sind und deren Namen nicht mit Zhang San übereinstimmen.
Stellungnahme:

mysql> select * from user where age > 20 or sex = 1 and name != 'Name des Benutzers';
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 2 | Zhang San | 22 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 6 | Tianqi | 37 | 1 |
+----+--------+-----+-----+
5 Zeilen im Satz (0,00 Sek.)

Zu diesem Zeitpunkt wurde festgestellt, dass die Abfrageergebnisse tatsächlich Zhang San enthalten. Dies liegt daran, dass und eine höhere Priorität hat als oder. Der SQL-Parser am Ende von MySQL analysiert das obige SQL in Geschlecht = 1 und Name != „Zhang San“ oder Alter > 20; Zhang San wird auch herausgefunden, weil Alter > 20. Um dieses Problem zu lösen, schließen Sie die „oder“-Anweisung einfach in Klammern ein.

mysql> select * from user where (Alter > 20 oder Geschlecht = 1) und Name != 'Name';
+----+--------+-----+-----+
| ID | Name | Alter | Geschlecht |
+----+--------+-----+-----+
| 1 | Pflaume 8 | 18 | 1 |
| 3 | Li Si | 38 | 1 |
| 4 | Wang Wu | 25 | 1 |
| 6 | Tianqi | 37 | 1 |
+----+--------+-----+-----+
4 Zeilen im Satz (0,00 Sek.)

Zu diesem Zeitpunkt ist Zhang San nicht mehr in den zurückgegebenen Daten der Abfrage enthalten.

Daher können wir uns beim Schreiben von SQL angewöhnen, Klammern zu verwenden. Durch die Gruppierung von Operatoren in Klammern können wir das Risiko von Fehlern vermeiden, die durch die Verwendung der Standardreihenfolge verursacht werden.

Damit ist dieser Artikel über die spezifische Verwendung von MySQL-Operatoren (und, oder, in, nicht) abgeschlossen. Weitere relevante MySQL-Operatorinhalte finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!

Das könnte Sie auch interessieren:
  • MySQL-Datenbankterminal – allgemeine Befehlscodes für Vorgänge
  • Aggregatabfrage- und Union-Abfragevorgänge für MySQL-Datenbanken
  • Detaillierte grundlegende Operationen an Datentabellen in der MySQL-Datenbank
  • MySQL-Datenbankoperationen und Datentypen
  • Fallanalyse mehrerer MySQL-Aktualisierungsvorgänge
  • MySQL 8.0 kann jetzt JSON verarbeiten
  • Zusammenfassung der erweiterten MySQL-Bedienungsanleitung

<<:  Eine kurze Diskussion über die Platzierung von Skripten in HTML

>>:  Lösen Sie das Problem beim Laden der Vektorkartenquelle in OpenLayers 3

Artikel empfehlen

js zur Realisierung eines einfachen Werbefensters

In diesem Artikel wird der spezifische Code von j...

Vue + Element UI realisiert Ankerpositionierung

In diesem Artikelbeispiel wird der spezifische Co...

Erläuterung von JavaScript-Mikrotasks und Makrotasks

Vorwort: js ist eine Single-Thread-Sprache, daher...

Detaillierte Erklärung der allgemeinen For-Schleife in JavaScript-Anweisungen

Es gibt viele Schleifenanweisungen in JavaScript,...

Detaillierte Erklärung der Lösung für das beim Start hängengebliebene Ubuntu-Dualsystem

Lösung für das Problem, dass das Ubuntu-Dualsyste...

So verweisen Sie direkt auf Vue und Element-UI in HTML

Der Code sieht folgendermaßen aus: <!DOCTYPE h...

Docker startet im Status „Beendet“

Nach dem Docker-Lauf ist der Status immer „Beende...

MySQL 8.0 MIT Abfragedetails

Inhaltsverzeichnis Informationen zu WITH-Abfragen...

Analyse des Unterschieds zwischen „Platzieren auf“ und „Wo“ in MySQL-Abfragebedingungen

Einführung Beim Schreiben von SQL bin ich heute a...

js-Objekt, um einen Daten-Paging-Effekt zu erzielen

In diesem Artikelbeispiel wird der spezifische Co...

Samba-Serverkonfiguration unter Centos7 (tatsächlicher Kampf)

Samba Übersicht Samba ist eine kostenlose Softwar...

Beispiel für die Generierung von Zufallszahlen und die Verkettung von Zeichenfolgen in MySQL

Dieser Artikel beschreibt anhand eines Beispiels,...

Beispiel für das Hinzufügen von Attributen mithilfe von Stilen in HTML

Fügen Sie den erforderlichen Links Inline-Stile hi...

So starten Sie die RabbitMq-Software automatisch, wenn CentOS gestartet wird

1. Erstellen Sie ein neues Rabbitmq im Verzeichni...

Detaillierte Erläuterung von acht Methoden zum Korrigieren des CSS-Seitenendes

Beim Schreiben einer Seite kommt es häufig vor, d...