Was wird im Allgemeinen für MySQL-Mehrtabellenabfragen verwendet?

MySQL-Mehrtabellenabfragen verwenden im Allgemeinen Cross-Joins, Inner-Joins und Outer-Joins. Der Cross-Join gibt das kartesische Produkt der verbundenen Tabellen zurück. Der innere Join kombiniert Datensätze in zwei Tabellen und gibt Datensätze mit übereinstimmenden zugehörigen Feldern zurück. Das heißt, der äußere Join teilt zuerst die verbundenen Tabellen in Basistabellen und Referenzen auf Tabelle und geben Sie dann Datensätze zurück, die die auf der Basistabelle basierenden Bedingungen erfüllen bzw. nicht erfüllen.

(Empfohlenes Tutorial: MySQL-Video-Tutorial)

In einer relationalen Datenbank besteht eine Beziehung zwischen Tabellen, daher werden in praktischen Anwendungen häufig Abfragen mit mehreren Tabellen verwendet. Bei der Abfrage mehrerer Tabellen werden zwei oder mehr Tabellen gleichzeitig abgefragt.

In MySQL umfassen Abfragen mit mehreren Tabellen hauptsächlich Cross-Joins, Inner-Joins und Outer-Joins.

Cross Join

Cross Join (CROSS JOIN) wird im Allgemeinen verwendet, um das kartesische Produkt der Join-Tabelle zurückzugeben.

Das Syntaxformat der Querverbindung lautet wie folgt:

SELECT <字段名> FROM <表1> CROSS JOIN <表2> [WHERE子句]

oder

SELECT <字段名> FROM <表1>, <表2> [WHERE子句]

Die Syntaxbeschreibung lautet wie folgt:

• Feldname: Der Name des abzufragenden Felds.

• : Der Name der Tabelle, die querverbunden werden muss.

• WHERE-Klausel: Wird zum Festlegen von Abfragebedingungen für Querverbindungen verwendet.

Hinweis: Wenn Sie mehrere Tabellen über Kreuz verbinden, verwenden Sie CROSS JOIN oder fortlaufend nach FROM. Die Rückgabeergebnisse der beiden oben genannten Syntaxen sind gleich, die erste Syntax ist jedoch die offiziell empfohlene Standardschreibmethode.

Wenn zwischen den verbundenen Tabellen keine Beziehung besteht, lassen wir die WHERE-Klausel weg. In diesem Fall ist das zurückgegebene Ergebnis das kartesische Produkt der beiden Tabellen und die Anzahl der zurückgegebenen Ergebnisse ist die Multiplikation der Datenzeilen der zwei Tische. Es ist zu beachten, dass, wenn jede Tabelle 1000 Zeilen hat, die Anzahl der zurückgegebenen Ergebnisse 1000 x 1000 = 1000000 Zeilen beträgt und die Datenmenge sehr groß ist.

Querverbindung kann zwei oder mehr Tabellen abfragen. Um den Lesern ein besseres Verständnis zu ermöglichen, wird im Folgenden die Querverbindungsabfrage von zwei Tabellen erläutert.

Beispiel

Fragen Sie die Studenteninformationstabelle und die Fachinformationstabelle ab und erhalten Sie ein kartesisches Produkt.

Um die Beobachtung der laufenden Ergebnisse nach der Querverbindung der Studenteninformationstabelle und der Fachtabelle zu erleichtern, fragen wir zunächst die Daten dieser beiden Tabellen separat ab und führen dann die Querverbindungsabfrage durch.

1) Fragen Sie die Daten in der Tabelle tb_students_info ab, die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt:

mysql> SELECT * FROM tb_students_info;
+----+--------+------+------+--------+-----------+
| 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 |
+----+--------+------+------+--------+-----------+
10 rows in set (0.00 sec)

2) Fragen Sie die Daten in der Tabelle tb_course ab, die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt:

mysql> SELECT * FROM tb_course;
+----+-------------+
| id | course_name |
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
+----+-------------+
5 rows in set (0.00 sec)

3) Verwenden Sie CROSS JOIN, um die beiden Tabellen abzufragen. Das kartesische Produkt, die SQL-Anweisung und die laufenden Ergebnisse lauten wie folgt:

mysql> SELECT * FROM tb_course CROSS JOIN tb_students_info;
+----+-------------+----+--------+------+------+--------+-----------+
| id | course_name | id | name   | age  | sex  | height | course_id |
+----+-------------+----+--------+------+------+--------+-----------+
|  1 | Java        |  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | MySQL       |  1 | Dany   |   25 | 男   |    160 |         1 |
|  3 | Python      |  1 | Dany   |   25 | 男   |    160 |         1 |
|  4 | Go          |  1 | Dany   |   25 | 男   |    160 |         1 |
|  5 | C++         |  1 | Dany   |   25 | 男   |    160 |         1 |
|  1 | Java        |  2 | Green  |   23 | 男   |    158 |         2 |
|  2 | MySQL       |  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Python      |  2 | Green  |   23 | 男   |    158 |         2 |
|  4 | Go          |  2 | Green  |   23 | 男   |    158 |         2 |
|  5 | C++         |  2 | Green  |   23 | 男   |    158 |         2 |
|  1 | Java        |  3 | Henry  |   23 | 女   |    185 |         1 |
|  2 | MySQL       |  3 | Henry  |   23 | 女   |    185 |         1 |
|  3 | Python      |  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Go          |  3 | Henry  |   23 | 女   |    185 |         1 |
|  5 | C++         |  3 | Henry  |   23 | 女   |    185 |         1 |
|  1 | Java        |  4 | Jane   |   22 | 男   |    162 |         3 |
|  2 | MySQL       |  4 | Jane   |   22 | 男   |    162 |         3 |
|  3 | Python      |  4 | Jane   |   22 | 男   |    162 |         3 |
|  4 | Go          |  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | C++         |  4 | Jane   |   22 | 男   |    162 |         3 |
|  1 | Java        |  5 | Jim    |   24 | 女   |    175 |         2 |
|  2 | MySQL       |  5 | Jim    |   24 | 女   |    175 |         2 |
|  3 | Python      |  5 | Jim    |   24 | 女   |    175 |         2 |
|  4 | Go          |  5 | Jim    |   24 | 女   |    175 |         2 |
|  5 | C++         |  5 | Jim    |   24 | 女   |    175 |         2 |
|  1 | Java        |  6 | John   |   21 | 女   |    172 |         4 |
|  2 | MySQL       |  6 | John   |   21 | 女   |    172 |         4 |
|  3 | Python      |  6 | John   |   21 | 女   |    172 |         4 |
|  4 | Go          |  6 | John   |   21 | 女   |    172 |         4 |
|  5 | C++         |  6 | John   |   21 | 女   |    172 |         4 |
|  1 | Java        |  7 | Lily   |   22 | 男   |    165 |         4 |
|  2 | MySQL       |  7 | Lily   |   22 | 男   |    165 |         4 |
|  3 | Python      |  7 | Lily   |   22 | 男   |    165 |         4 |
|  4 | Go          |  7 | Lily   |   22 | 男   |    165 |         4 |
|  5 | C++         |  7 | Lily   |   22 | 男   |    165 |         4 |
|  1 | Java        |  8 | Susan  |   23 | 男   |    170 |         5 |
|  2 | MySQL       |  8 | Susan  |   23 | 男   |    170 |         5 |
|  3 | Python      |  8 | Susan  |   23 | 男   |    170 |         5 |
|  4 | Go          |  8 | Susan  |   23 | 男   |    170 |         5 |
|  5 | C++         |  8 | Susan  |   23 | 男   |    170 |         5 |
|  1 | Java        |  9 | Thomas |   22 | 女   |    178 |         5 |
|  2 | MySQL       |  9 | Thomas |   22 | 女   |    178 |         5 |
|  3 | Python      |  9 | Thomas |   22 | 女   |    178 |         5 |
|  4 | Go          |  9 | Thomas |   22 | 女   |    178 |         5 |
|  5 | C++         |  9 | Thomas |   22 | 女   |    178 |         5 |
|  1 | Java        | 10 | Tom    |   23 | 女   |    165 |         5 |
|  2 | MySQL       | 10 | Tom    |   23 | 女   |    165 |         5 |
|  3 | Python      | 10 | Tom    |   23 | 女   |    165 |         5 |
|  4 | Go          | 10 | Tom    |   23 | 女   |    165 |         5 |
|  5 | C++         | 10 | Tom    |   23 | 女   |    165 |         5 |
+----+-------------+----+--------+------+------+--------+-----------+
50 rows in set (0.00 sec)

Wie aus den laufenden Ergebnissen ersichtlich ist, wurden nach der Querverbindungsabfrage zwischen den Tabellen tb_course und tb_students_info 50 Datensätze zurückgegeben . Wie Sie sich vorstellen können, sind die erhaltenen Laufergebnisse sehr lang und die erhaltenen Laufergebnisse sind nicht sehr aussagekräftig, wenn die Tabelle viele Daten enthält. Daher wird diese Methode der Mehrtabellenabfrage über Querverbindungen nicht häufig verwendet, und wir sollten versuchen, diese Art von Abfrage zu vermeiden.

Kartesisches Produkt

Kartesisches Produkt bezieht sich auf das Produkt zweier Mengen X und Y.

Zum Beispiel gibt es zwei Mengen A und B. Ihre Werte lauten wie folgt:

A = {1,2}
B = {3,4,5}

Die Ergebnismengen der Mengen A×B und B×A werden jeweils ausgedrückt als:

A×B={(1,3), (1,4), (1,5), (2,3), (2,4), (2,5) };
B×A={(3,1), (3,2), (4,1), (4,2), (5,1), (5,2) };

Die Ergebnisse von A ×B und B×A heißen kartesisches Produkt zweier Mengen.

Und aus den obigen Ergebnissen können wir Folgendes erkennen:

• Die Multiplikation zweier Mengen erfüllt nicht den Wechselkurs, d. h. A×B≠B×A.

• Das kartesische Produkt von Menge A und Menge B ist die Anzahl der Elemente von Menge A × die Anzahl der Elemente von Menge B.

Der Algorithmus, dem die Mehrtabellenabfrage folgt, ist das oben erwähnte kartesische Produkt. Die Verbindung zwischen Tabellen kann als Multiplikationsoperation betrachtet werden. In praktischen Anwendungen sollte die Verwendung des kartesischen Produkts vermieden werden, da das kartesische Produkt leicht eine große Menge unangemessener Daten enthält, was lediglich bedeutet, dass es leicht zu doppelten und verwirrenden Abfrageergebnissen kommen kann.

Inner JOIN

Inner JOIN kombiniert Datensätze in zwei Tabellen und gibt Datensätze mit übereinstimmenden zugehörigen Feldern zurück, indem Verbindungsbedingungen festgelegt werden, d. h. der Schnittpunkt (schattiert) der beiden Tabellen zurückgegeben wird.

Inner Join verwendet das Schlüsselwort INNER JOIN, um zwei Tabellen zu verbinden, und verwendet die ON-Klausel, um die Verbindungsbedingungen festzulegen. Ohne Join-Bedingungen sind INNER JOIN und CROSS JOIN syntaktisch gleichwertig und austauschbar.

Das Syntaxformat des Inner Join lautet wie folgt:

SELECT <字段名> FROM <表1> INNER JOIN <表2> [ON子句]

Die Syntaxbeschreibung lautet wie folgt.

• Feldname: der Name des abzufragenden Feldes.

• : Der Name der Tabelle, die eine innere Verknüpfung erfordert.

• INNER JOIN: Sie können das Schlüsselwort INNER in Inner Joins weglassen und nur das Schlüsselwort JOIN verwenden.

• ON-Klausel: Wird zum Festlegen der Verbindungsbedingungen von Inner Joins verwendet.

• INNER JOIN 也可以使用 WHERE 子句指定连接条件，但是 INNER JOIN ... ON 语法是官方的标准写法，而且 WHERE 子句在某些时候会影响查询的性能。

多个表内连接时，在 FROM 后连续使用 INNER JOIN 或 JOIN 即可。

示例：

在 tb_students_info 表和 tb_course 表之间，使用内连接查询学生姓名和相对应的课程名称，SQL 语句和运行结果如下。

mysql> SELECT s.name,c.course_name FROM tb_students_info s INNER JOIN tb_course c 
    -> ON s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Green  | MySQL       |
| Henry  | Java        |
| Jane   | Python      |
| Jim    | MySQL       |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
+--------+-------------+
10 rows in set (0.00 sec)

在这里的查询语句中，两个表之间的关系通过 INNER JOIN 指定，连接的条件使用 ON 子句给出。

注意：当对多个表进行查询时，要在 SELECT 语句后面指定字段是来源于哪一张表。因此，在多表查询时，SELECT 语句后面的写法是表名.列名。另外，如果表名非常长的话，也可以给表设置别名，这样就可以直接在 SELECT 语句后面写上表的别名.列名。

外连接

外连接会先将连接的表分为基表和参考表，再以基表为依据返回满足和不满足条件的记录。

外连接可以分为左外连接和右外连接，下面根据实例分别介绍左外连接和右外连接。

左连接

左外连接又称为左连接，使用 LEFT OUTER JOIN 关键字连接两个表，并使用 ON 子句来设置连接条件。

左连接的语法格式如下：

SELECT <字段名> FROM <表1> LEFT OUTER JOIN <表2> <ON子句>

语法说明如下。

• 字段名：需要查询的字段名称。

• ：需要左连接的表名。

• LEFT OUTER JOIN：左连接中可以省略 OUTER 关键字，只使用关键字 LEFT JOIN。

• ON 子句：用来设置左连接的连接条件，不能省略。

上述语法中，“表1”为基表，“表2”为参考表。左连接查询时，可以查询出“表1”中的所有记录和“表2”中匹配连接条件的记录。如果“表1”的某行在“表2”中没有匹配行，那么在返回结果中，“表2”的字段值均为空值（NULL）。

示例1

在进行左连接查询之前，我们先查看 tb_course 和 tb_students_info 两张表中的数据。SQL 语句和运行结果如下。

mysql> SELECT * FROM tb_course;
+----+-------------+
| id | course_name |
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
|  6 | HTML        |
+----+-------------+
6 rows in set (0.00 sec)
mysql> SELECT * FROM tb_students_info;
+----+--------+------+------+--------+-----------+
| 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.00 sec)

在 tb_students_info 表和 tb_course 表中查询所有学生姓名和相对应的课程名称，包括没有课程的学生，SQL 语句和运行结果如下。

mysql> SELECT s.name,c.course_name FROM tb_students_info s LEFT OUTER JOIN tb_course c 
    -> ON s.`course_id`=c.`id`;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Henry  | Java        |
| NULL   | Java        |
| Green  | MySQL       |
| Jim    | MySQL       |
| Jane   | Python      |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| LiMing | NULL        |
+--------+-------------+
12 rows in set (0.00 sec)

可以看到，运行结果显示了 12 条记录，name 为 LiMing 的学生目前没有课程，因为对应的 tb_course 表中没有该学生的课程信息，所以该条记录只取出了 tb_students_info 表中相应的值，而从 tb_course 表中取出的值为 NULL。

右连接

右外连接又称为右连接，右连接是左连接的反向连接。使用 RIGHT OUTER JOIN 关键字连接两个表，并使用 ON 子句来设置连接条件。

右连接的语法格式如下：

SELECT <字段名> FROM <表1> RIGHT OUTER JOIN <表2> <ON子句>

语法说明如下。

• 字段名：需要查询的字段名称。

• ：需要右连接的表名。

• RIGHT OUTER JOIN：右连接中可以省略 OUTER 关键字，只使用关键字 RIGHT JOIN。

• ON 子句：用来设置右连接的连接条件，不能省略。

与左连接相反，右连接以“表2”为基表，“表1”为参考表。右连接查询时，可以查询出“表2”中的所有记录和“表1”中匹配连接条件的记录。如果“表2”的某行在“表1”中没有匹配行，那么在返回结果中，“表1”的字段值均为空值（NULL）。

示例2

在 tb_students_info 表和 tb_course 表中查询所有课程，包括没有学生的课程，SQL 语句和运行结果如下。

mysql> SELECT s.name,c.course_name FROM tb_students_info s RIGHT OUTER JOIN tb_course c 
    -> ON s.`course_id`=c.`id`;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Green  | MySQL       |
| Henry  | Java        |
| Jane   | Python      |
| Jim    | MySQL       |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| NULL   | HTML        |
+--------+-------------+
11 rows in set (0.00 sec)

可以看到，结果显示了 11 条记录，名称为 HTML 的课程目前没有学生，因为对应的 tb_students_info 表中并没有该学生的信息，所以该条记录只取出了 tb_course 表中相应的值，而从 tb_students_info 表中取出的值为 NULL。

多个表左/右连接时，在 ON 子句后连续使用 LEFT/RIGHT OUTER JOIN 或 LEFT/RIGHT JOIN 即可。

注：使用外连接查询时，一定要分清需要查询的结果，是需要显示左表的全部记录还是右表的全部记录，然后选择相应的左连接和右连接。

Das obige ist der detaillierte Inhalt vonWas wird im Allgemeinen für MySQL-Mehrtabellenabfragen verwendet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!