SQL-WHERE-Anweisung Einführung
- WHERE-Klausel wird verwendet, um beim Abrufen von Daten aus Tabellen eine Bedingung einzufügen.
- Wenn Sie eine Bedingung angeben müssen, die befolgt werden muss, während Daten aus Tabellen abgerufen werden, wird in diesem Fall die Where-Klausel verwendet.
- Where-Klausel wird verwendet, um die Datensätze zu filtern, die Sie von der Select-Anweisung abrufen, sodass Sie eine kleinere Teilmenge von Daten erhalten.
- Where-Klausel wird auch verwendet, um Join-Vorgänge auszuführen.
- Where-Klausel gibt nur die Datensätze aus der Tabelle zurück, die die mit ihr angegebene Bedingung erfüllen.
- Diese Klausel wird nicht nur mit SELECT-Abfragen verwendet, sondern kann auch mit UPDATE- und DELETE-Abfragen verwendet werden.
- Where-Klausel mit SELECT-Abfrage verwenden
- Where-Klausel mit SELECT-Abfrage, um alle Spalten aus einer Tabelle abzurufen.
- Um alle Datensätze aus einer Tabelle abzurufen, Sternchen (*) Symbol wird verwendet.
Syntax:
SELECT *FROM TABLE_NAME WHERE condition;
Beispiel:
Zuerst erstellen wir eine Datenbank mit dem Namen „bookdb“. Dann erstellen wir in dieser Datenbank ein Tabellen-„Buch“ und fügen Datensätze in die Tabelle ein. Wir werden dieselbe Datenbank und auch dieselbe Tabelle für nachfolgende Beispiele betrachten.
Jetzt wenden wir die where-Klausel mit der SELECT-Abfrage an, um alle Spalten aus der Tabelle abzurufen, in denen der Buchpreis gleich 200 ist.
mysql> CREATE DATABASE bookdb;
Query OK, 1 row affected (0.07 sec)
mysql> USE bookdb;
Database changed
mysql> CREATE TABLE book(Book_ID INT NOT NULL AUTO_INCREMENT, Book_Name VARCHAR(100) NOT NULL, Book_Author VARCHAR(40) NOT NULL, Book_Price INT NOT NULL, PRIMARY KEY(Book_ID));
Query OK, 0 rows affected (0.24 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Learn MySQL","Abdul S", 180);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Explained","Andrew Comeau", 150);
Query OK, 1 row affected (0.04 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Cookbook","Paul DuBois", 250);
Query OK, 1 row affected (0.08 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("murach's MySQL","Joel Murach", 200);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Head First SQL","Lynn Beighley", 300);
Query OK, 1 row affected (0.07 sec)
mysql> SELECT *FROM book;
+---------+-----------------------------+--------------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+-----------------------------+--------------------+------------+
| 1 | Learn MySQL | Abdul S | 180 |
| 2 | MySQL Explained | Andrew Comeau | 150 |
| 3 | Database Management Systems | Raghu Ramakrishnan | 250 |
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+-----------------------------+--------------------+------------+
4 rows in set (0.00 sec)
mysql> SELECT *FROM book WHERE Book_Price=200;
+---------+----------------+-------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+----------------+-------------+------------+
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+----------------+-------------+------------+
1 row in set (0.00 sec) 
Es gibt nur einen Datensatz mit Book_ID =4, dessen Preis gleich 200 ist. Daher werden alle Spalten dieses bestimmten Datensatzes angezeigt.
- Where-Klausel mit SELECT-Abfrage, um eine oder mehrere spezifische Spalten aus einer Tabelle abzurufen.
- Um bestimmte Spalten aus einer Tabelle abzurufen, sollten die Namen aller abzurufenden Spalten in der Abfrage selbst angegeben werden.
- Die spezifischen Spaltennamen, die abgerufen werden sollen, werden durch Komma getrennt.
Syntax:
SELECT COLUMN_NAME1,….,COLUMN_NAMEn FROM TABLE_NAME WHERE condition;
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um bestimmte Spalten (Book_ID, Book_Price) aus dem Buch abzurufen Tisch, wo der Preis des Buches gleich 200 ist.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT Book_ID,Book_Price FROM book where Book_Price=200; +---------+------------+ | Book_ID | Book_Price | +---------+------------+ | 4 | 200 | +---------+------------+ 1 row in set (0.00 sec)
Es gibt nur einen Datensatz mit Book_ID =4, dessen Preis gleich 200 ist. Daher werden Book_ID und Book_Price dieses bestimmten Datensatzes angezeigt.
- Where-Klausel mit UPDATE-Abfrage verwenden
Syntax:
UPDATE TABLE_NAME SET column_name = newvalue WHERE column_name1 = value1;
Beispiel:
Wir wenden die where-Klausel mit der UPDATE-Abfrage auf die Buchtabelle an, um Book_Name und Book_Author eines bestimmten Datensatzes zu aktualisieren, indem wir die Book_ID als Bedingung in der where-Klausel angeben.
mysql> SELECT *FROM book; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | MySQL Cookbook | Paul DuBois | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------+---------------+------------+ 5 rows in set (0.00 sec) mysql> UPDATE book SET Book_name="Database Management Systems", Book_Author="Raghu Ramakrishnan" WHERE Book_ID=3; Query OK, 1 row affected (0.19 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec)
Es gibt nur einen Datensatz mit Book_ID =3, wir haben Book_name und Book_Author dieses Datensatzes geändert. Daher wird eine aktualisierte Tabelle angezeigt.
- Where-Klausel mit DELETE-Abfrage verwenden
Syntax:
DELETE FROM TABLE_NAME WHERE column_name1 = value1;
Beispiel:
Wir wenden die where-Klausel mit der DELETE-Abfrage auf die Buchtabelle an
Löschen Sie ein Buch mit einer bestimmten Book_ID, indem Sie die Book_ID als Bedingung in der Where-Klausel angeben.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec) mysql> DELETE FROM book WHERE Book_ID=5; Query OK, 1 row affected (0.23 sec) mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Es gibt nur einen Datensatz mit Book_ID =5, wir haben diesen gesamten Datensatz aus der Buchtabelle gelöscht. Daher wird eine aktualisierte Tabelle angezeigt.
Operatoren mit WHERE-Anweisung
Sie können Operatoren mit der where-Klausel verwenden. Diese Operatoren können zusammen mit der where-Klausel in SELECT-, UPDATE- und DELETE-Abfragen verwendet werden.
- Gleich (=)
Wenn der Gleichheitsoperator (=) mit der Where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in einer Tabelle vorhandenen Spaltennamens gleich dem Wert des in der Abfrage angegebenen Spaltennamens ist.
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis gleich 200 ist.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT *FROM book WHERE Book_Price=200; +---------+----------------+-------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+----------------+-------------+------------+ | 4 | murach's MySQL | Joel Murach | 200 | +---------+----------------+-------------+------------+ 1 row in set (0.00 sec)
Es gibt nur einen Datensatz mit Book_ID =4, dessen Preis gleich 200 ist. Daher werden alle Spalten dieses bestimmten Datensatzes angezeigt.
- Größer als (>)
Wenn der Größer-als-Operator (>) mit der Where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in einer Tabelle vorhandenen Spaltennamens größer ist als der Wert des in der Abfrage angegebenen Spaltennamens.
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis größer als 150 ist.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price > 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 3 rows in set (0.00 sec)
Es gibt drei Datensätze mit Book_ID =1, 3 und 4, deren Preise größer als 150 sind. Daher werden alle Spalten dieser Datensätze angezeigt.
- Kleiner als (<)
Wenn der Kleiner-als(<)-Operator mit der Where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in einer Tabelle vorhandenen Spaltennamens kleiner ist als der Wert des in der Abfrage angegebenen Spaltennamens.
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis weniger als 200 beträgt.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price < 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | +---------+-----------------+---------------+------------+ 2 rows in set (0.00 sec)
Es gibt zwei Datensätze mit Book_ID =1 und 2, deren Preise kleiner als 200 sind. Daher werden alle Spalten dieser Datensätze angezeigt.
- Größer als oder gleich (>=)
Wenn der Operator größer oder gleich (>=) mit der where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in einer Tabelle vorhandenen Spaltennamens größer oder gleich dem Wert des in der angegebenen Spaltennamens ist Abfrage.
Beispiel:
Wir wenden die where-Klausel mit der SELECT-Abfrage an, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis größer oder gleich 150 ist.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price >= 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Wir können sehen, dass es vier Datensätze mit Book_ID =1, 2, 3 und 4 gibt, deren Preise größer oder gleich 150 sind. Daher werden alle Spalten dieser Datensätze angezeigt.
- Kleiner als oder gleich (<=)
Wenn der Kleiner-gleich-Operator (<=) mit der Where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in einer Tabelle vorhandenen Spaltennamens kleiner oder gleich dem Wert des angegebenen Spaltennamens ist die Abfrage.
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis kleiner oder gleich 200 ist.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <= 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Es gibt drei Datensätze mit Book_ID =1, 2 und 4, deren Preise kleiner oder gleich 200 sind. Daher werden alle Spalten dieser Datensätze angezeigt.
- Ungleich (<>)
Wenn der Operator ungleich (<>) mit der where-Klausel verwendet wird, werden diese Datensätze aus der Tabelle abgerufen, wenn der Wert des in der Abfrage angegebenen Spaltennamens nicht mit dem Wert des in einer Tabelle vorhandenen Spaltennamens übereinstimmt.
Beispiel:
Wir werden die where-Klausel mit der SELECT-Abfrage anwenden, um die Datensätze aus der Tabelle abzurufen, bei denen der Buchpreis nicht gleich 250 ist.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <> 250; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Es gibt drei Datensätze mit Book_ID =1, 2 und 4, deren Preise ungleich 250 sind. Daher werden alle Spalten dieser Datensätze angezeigt.
