Wie erstelle ich eine Unterabfrage in MySQL?

In MySQL bezieht sich eine Unterabfrage auf die Verschachtelung einer Abfrageanweisung in einer anderen Abfrageanweisung. Sie kann mit der WHERE-Klausel in den SELECT-, UPDATE- und DELETE-Anweisungen implementiert werden. Das Syntaxformat der WHERE-Klausel ist „WHERE < Ausdruck> < ;Operator> (eine weitere Abfrageanweisung)".

(Empfohlenes Tutorial: MySQL-Video-Tutorial)

Unterabfrage ist eine häufig verwendete Abfragemethode in MySQL, die durch Unterabfrage realisiert werden kann. Unter Unterabfrage versteht man die Verschachtelung einer Abfrageanweisung in einer anderen Abfrageanweisung. Unterabfragen können in SELECT-, UPDATE- und DELETE-Anweisungen verwendet und auf mehreren Ebenen verschachtelt werden. In der tatsächlichen Entwicklung erscheinen Unterabfragen häufig in der WHERE-Klausel.

Das Syntaxformat der Unterabfrage in WHERE lautet wie folgt:

WHERE <表达式> <操作符> (子查询语句)

Dabei können Operatoren Vergleichsoperatoren und Schlüsselwörter wie IN, NOT IN, EXISTS, NOT EXISTS sein.

1) IN |. NOT IN

Wenn der Ausdruck einem Wert in der von der Unterabfrage zurückgegebenen Ergebnismenge entspricht, wird TRUE zurückgegeben, andernfalls wird FALSE zurückgegeben, wenn das Schlüsselwort NOT verwendet wird das Gegenteil.

2) EXISTS |. NOT EXISTS

wird verwendet, um festzustellen, ob die Ergebnismenge der Unterabfrage leer ist, wird TRUE zurückgegeben, andernfalls wird FALSE zurückgegeben verwendet wird, wird der Wert zurückgegeben. Ganz im Gegenteil.

Beispiel 1

Verwenden Sie eine Unterabfrage, um die Namen von Studenten abzufragen, die Java-Kurse in den Tabellen tb_students_info und tb_course belegen. Die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.01 sec)

Die Ergebnisse zeigen, dass nur Dany und Henry den Java-Kurs belegen. Der obige Abfragevorgang kann auch in die folgenden zwei Schritte unterteilt werden, um den gleichen Effekt zu erzielen.

1) Führen Sie zunächst die innere Abfrage separat aus, um die ID des Kurses Java in der Tabelle tb_course herauszufinden. Die SQL-Anweisung und die Ausführungsergebnisse lauten wie folgt.

mysql> SELECT id FROM tb_course 
    -> WHERE course_name = 'Java';
+----+
| id |
+----+
|  1 |
+----+
1 row in set (0.00 sec)

Sie können sehen, dass der Wert des qualifizierten ID-Felds 1 ist.

2) Führen Sie dann die äußere Abfrage aus, um die Namen der Studenten abzufragen, deren Kurs-ID in der Tabelle tb_students_info gleich 1 ist. Die SQL-Anweisungen und Ausführungsergebnisse lauten wie folgt.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id IN (1);
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.00 sec)

Herkömmlicherweise wird die äußere SELECT-Abfrage als übergeordnete Abfrage bezeichnet, und die in Klammern eingebettete Abfrage wird als Unterabfrage bezeichnet (Unterabfragen müssen in Klammern gesetzt werden). Wenn MySQL im obigen Beispiel die SELECT-Anweisung verarbeitet, lautet der Ausführungsablauf: Führen Sie zuerst die Unterabfrage und dann die übergeordnete Abfrage aus.

Beispiel 2

Verwenden Sie ähnlich wie in Beispiel 1 das Schlüsselwort NOT IN in der SELECT-Anweisung, um die Namen von Studenten abzufragen, die keine Java-Kurse besucht haben. Die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id NOT IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.01 sec)

Es ist ersichtlich, dass die laufenden Ergebnisse genau das Gegenteil von Beispiel 1 sind. Die Studenten, die keine Java-Kurse studiert haben, sind andere Studenten als Dany und Henry.

Beispiel 3

Verwenden Sie den =-Operator, um die Namen aller Studenten, die Python-Kurse studieren, in den Tabellen tb_course und tb_students_info abzufragen. Die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt.

mysql> SELECT name FROM tb_students_info
    -> WHERE course_id = (SELECT id FROM tb_course WHERE course_name = 'Python');
+------+
| name |
+------+
| Jane |
+------+
1 row in set (0.00 sec)

Die Ergebnisse zeigen, dass Jane die einzige Studentin ist, die den Python-Kurs belegt.

Beispiel 4

Verwenden Sie den Operator <>, um die Namen von Studenten abzufragen, die keine Python-Kurse in den Tabellen tb_course und tb_students_info belegt haben. Die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt.

mysql> SELECT name FROM tb_students_info
    -> WHERE course_id <> (SELECT id FROM tb_course WHERE course_name = &#39;Python&#39;);
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
10 rows in set (0.00 sec)

Es ist ersichtlich, dass das laufende Ergebnis genau das Gegenteil von Beispiel 3 ist. Die Studenten, die den Python-Kurs nicht studiert haben, sind andere Studenten als Jane.

Beispiel 5

Fragen Sie ab, ob der Kurs mit der ID=1 in der Tabelle tb_course vorhanden ist. Fragen Sie die Datensätze in der Tabelle tb_students_info ab. Die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt.

mysql> SELECT * FROM tb_students_info
    -> WHERE EXISTS(SELECT course_name FROM tb_course WHERE id=1);
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
| 11 | LiMing |   22 | 男   |    180 |         7 |
+----+--------+------+------+--------+-----------+
11 rows in set (0.01 sec)

Sie können den Ergebnissen entnehmen, dass es einen Datensatz mit der ID=1 in der Tabelle tb_course gibt, sodass der EXISTS-Ausdruck TRUE zurückgibt. Nach dem Empfang von TRUE fragt die äußere Abfrageanweisung die Tabelle tb_students_info ab und gibt alle Datensätze zurück.

Das Schlüsselwort EXISTS kann zusammen mit anderen Abfragebedingungen verwendet werden, und der bedingte Ausdruck und das Schlüsselwort EXISTS werden durch UND und ODER verbunden.

Beispiel 6

Fragen Sie ab, ob der Kurs mit der ID=1 in der Tabelle tb_course vorhanden ist. Wenn er vorhanden ist, fragen Sie die Datensätze mit dem Altersfeld größer als 24 in der Tabelle tb_students_info ab .

mysql> SELECT * FROM tb_students_info
    -> WHERE age>24 AND EXISTS(SELECT course_name FROM tb_course WHERE id=1);
+----+------+------+------+--------+-----------+
| id | name | age  | sex  | height | course_id |
+----+------+------+------+--------+-----------+
|  1 | Dany |   25 | 男   |    160 |         1 |
+----+------+------+------+--------+-----------+
1 row in set (0.01 sec)

Die Ergebnisse zeigen, dass ein Datensatz aus der Tabelle tb_students_info abgefragt wurde und der Feldwert „Alter“ dieses Datensatzes 25 beträgt. Die innere Abfrageanweisung ruft Datensätze aus der Tabelle tb_course ab und gibt TRUE zurück. Die äußere Abfrageanweisung startet die Abfrage. Fragen Sie gemäß den Abfragebedingungen die Datensätze mit einem Alter über 24 Jahren aus der Tabelle tb_students_info ab.

Erweitert

Die Funktion einer Unterabfrage kann auch durch Tabellenverknüpfungen vervollständigt werden, Unterabfragen erleichtern jedoch das Lesen und Schreiben von SQL-Anweisungen.

Im Allgemeinen können Tabellenverknüpfungen (innere Verknüpfungen, äußere Verknüpfungen usw.) durch Unterabfragen ersetzt werden, aber das Gegenteil ist nicht unbedingt der Fall. Einige Unterabfragen können nicht durch Tabellenverknüpfungen ersetzt werden. Unterabfragen sind flexibler, praktischer und vielfältiger in der Form und eignen sich als Filterbedingungen für Abfragen, während Tabellenverknüpfungen besser zum Anzeigen von Daten in verbundenen Tabellen geeignet sind.

Das obige ist der detaillierte Inhalt vonWie erstelle ich eine Unterabfrage in MySQL?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!