MySQL 4

已于 2023-06-15 00:22:22 修改
阅读量225 收藏
点赞数
分类专栏： Linux # mysql 文章标签： mysql linux
于 2022-07-27 19:17:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64735681/article/details/126021472
版权

文章目录

多表联合查询

多表查询就是同时查询两个或两个以上的表。
在 MySQL 中，多表查询主要有交叉连接、内连接、外连接、分组查询与子查询等 5 种。

1. 交叉连接（CROSS JOIN）

笛卡尔积

交叉连接（CROSS JOIN）：有两种，显式的和隐式的 2 种，一般用来返回连接表的笛卡尔积。
笛卡尔积（Cartesian product）是指两个集合 X 和 Y 的乘积。
例如，有 A 和 B 两个集合，它们的值如下：

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

集合 A×B 和 B×A 的结果集分别表示为：

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) };

以上 A×B 和 B×A 的结果就叫做两个集合的笛卡尔积。

并且，从以上结果我们可以看出：

  • 两个集合相乘，不满足交换率，即 A×B≠B×A。
  • A 集合和 B 集合的笛卡尔积是 A 集合的元素个数 × B 集合的元素个数。
mysql> select * from tb_course,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)

多表查询遵循的算法就是以上提到的笛卡尔积，表与表之间的连接可以看成是在做乘法运算。在实际应用中，应避免使用笛卡尔积，因为笛卡尔积中容易存在大量的不合理数据，简单来说就是容易导致查询结果重复、混乱。

交叉连接

交叉连接的语法格式如下：

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

或

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

语法说明如下：

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要交叉连接的表名。
  • WHERE 子句：用来设置交叉连接的查询条件。

**注意：**多个表交叉连接时，在 FROM 后连续使用 CROSS JOIN 或,即可。以上两种语法的返回结果是相同的，但是第一种语法才是官方建议的标准写法。

当连接的表之间没有关系时，我们会省略掉 WHERE 子句，这时返回结果就是两个表的笛卡尔积，返回结果数量就是两个表的数据行相乘。需要注意的是，如果每个表有 1000 行，那么返回结果的数量就有 1000×1000 = 1000000 行，数据量是非常巨大的。

交叉连接可以查询两个或两个以上的表。

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

如果在交叉连接时使用 WHERE 子句，MySQL 会先生成两个表的笛卡尔积，然后再选择满足 WHERE 条件的记录。因此，表的数量较多时，交叉连接会非常非常慢。一般情况下不建议使用交叉连接。

在 MySQL 中，多表查询一般使用内连接和外连接，它们的效率要高于交叉连接。

2. 内连接

内连接（INNER JOIN）主要通过设置连接条件的方式，来移除查询结果中某些数据行的交叉连接。简单来说，就是利用条件表达式来消除交叉连接的某些数据行。

内连接使用 INNER JOIN 关键字连接两张表，并使用 ON 子句来设置连接条件。如果没有连接条件，INNER JOIN 和 CROSS JOIN 在语法上是等同的，两者可以互换。

内连接的语法格式如下：

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

语法说明如下。

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要内连接的表名。
  • INNER JOIN ：内连接中可以省略 INNER 关键字，只用关键字 JOIN。
  • ON 子句：用来设置内连接的连接条件。

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

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

内连接可以查询两个或两个以上的表。

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.01 sec)

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

3. 外连接

内连接的查询结果都是符合连接条件的记录，而外连接会先将连接的表分为基表和参考表，再以基表为依据返回满足和不满足条件的记录。

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

左连接

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

左连接的语法格式如下：

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

语法说明如下：

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要左连接的表名。
  • LEFT OUTER JOIN：左连接中可以省略 OUTER 关键字，只使用关键字 LEFT JOIN。
  • ON 子句：用来设置左连接的连接条件，不能省略。

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

mysql> insert tb_course(course_name) value('HTML');
Query OK, 1 row affected (0.00 sec)

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> insert tb_students_info(name,age,sex,height,course_id) values('LiMing',22,' 男',180,7);
Query OK, 1 row affected (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)

mysql> select s.name,c.course_name from tb_students_info s left outer join tb_coursee 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++         |
| LiMing | NULL        |
+--------+-------------+
11 rows in set (0.00 sec)

右连接

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

右连接的语法格式如下：

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

语法说明如下：

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要右连接的表名。
  • RIGHT OUTER JOIN：右连接中可以省略 OUTER 关键字，只使用关键字 RIGHT JOIN。
  • ON 子句：用来设置右连接的连接条件，不能省略。
    与左连接相反，右连接以"表2"为基表，"表1"为参考表。右连接查询时，可以查询出"表2"中的所有记录和"表1"中匹配连接条件的记录。如果"表2"的某行在"表1"中没有匹配行，那么在返回结果中，"表1"的字段值均为空值（NULL）。
mysql> select s.name,c.course_name from tb_students_info s right outer join tb_coursse 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)

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

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

分组查询

在 MySQL 中，GROUP BY 关键字可以根据一个或多个字段对查询结果进行分组。

使用 GROUP BY 关键字的语法格式如下：

GROUP BY  <字段名>

其中，"字段名"表示需要分组的字段名称，多个字段时用逗号隔开。

1. GROUP BY 单独使用

单独使用 GROUP BY 关键字时，查询结果会只显示每个分组的第一条记录。

mysql> set sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION' ;
Query OK, 0 rows affected (0.00 sec)

mysql> select name,sex from tb_students_info group by sex;
+-------+------+
| name  | sex  |
+-------+------+
| Henry | 女   |
| Dany  | 男   |
+-------+------+
2 rows in set (0.00 sec)

参考博客：MySql 出现错误：ERROR 1055 (42000) 和 MYSQL的WARNINGS 和 ERRORS 查询细节

2. GROUP BY 与 GROUP_CONCAT()

GROUP BY 关键字可以和 GROUP_CONCAT() 函数一起使用。GROUP_CONCAT() 函数会把每个分组的字段值都显示出来。

mysql> select sex,group_concat(name),age from tb_students_info group by sex,age;
+------+--------------------+------+
| sex  | group_concat(name) | age  |
+------+--------------------+------+
| 女   | John               |   21 |
| 女   | Thomas             |   22 |
| 女   | Henry,Tom          |   23 |
| 女   | Jim                |   24 |
| 男   | Jane,Lily,LiMing   |   22 |
| 男   | Green,Susan        |   23 |
| 男   | Dany               |   25 |
+------+--------------------+------+
7 rows in set (0.02 sec)

多个字段分组查询时，会先按照第一个字段进行分组。如果第一个字段中有相同的值，MySQL 才会按照第二个字段进行分组。如果第一个字段中的数据都是唯一的，那么 MySQL 将不再对第二个字段进行分组。

3. GROUP BY 与聚合函数

在数据统计时，GROUP BY 关键字经常和聚合函数一起使用。

聚合函数包括 COUNT()，SUM()，AVG()，MAX() 和 MIN()。其中，COUNT() 用来统计记录的条数；SUM() 用来计算字段值的总和；AVG() 用来计算字段值的平均值；MAX() 用来查询字段的最大值；MIN() 用来查询字段的最小值。

mysql> select c.course_name,sum(s.age) from tb_students_info s inner join tb_course c on s.course_id = c.id and c.course_name = 'Java';
+-------------+------------+
| course_name | sum(s.age) |
+-------------+------------+
| Java        |         48 |
+-------------+------------+
1 row in set (0.00 sec)

mysql> select c.course_name,avg(s.age) from tb_students_info s inner join tb_course c on s.course_id = c.id and c.course_name = 'Java';
+-------------+------------+
| course_name | avg(s.age) |
+-------------+------------+
| Java        |    24.0000 |
+-------------+------------+
1 row in set (0.00 sec)

mysql> select c.course_name,min(s.age) from tb_students_info s inner join tb_course c on s.course_id = c.id and c.course_name = 'Java';
+-------------+------------+
| course_name | min(s.age) |
+-------------+------------+
| Java        |         23 |
+-------------+------------+
1 row in set (0.00 sec)

mysql> select c.course_name,max(s.age) from tb_students_info s inner join tb_course c on s.course_id = c.id and c.course_name = 'Java';
+-------------+------------+
| course_name | max(s.age) |
+-------------+------------+
| Java        |         25 |
+-------------+------------+
1 row in set (0.00 sec)
  • count(*) 包括了所有的列，相当于行数，在统计结果的时候，不会忽略列值为 NULL。
  • count(1) 包括了忽略所有列，用 1 代表代码行，在统计结果的时候，不会忽略列值为 NULL。
  • count(列名) 只包括列名那一列，在统计结果的时候，会忽略列值为空（这里的空不是指空字符串或者 0 ，而是表示 null）的计数， 即某个字段值为 NULL 时，不统计。
mysql> update tb_students_info set age = null where id = 11;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

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 | NULL | 男   |    180 |         7 |
+----+--------+------+------+--------+-----------+
11 rows in set (0.01 sec)

mysql> select count(*) from tb_students_info;
+----------+
| count(*) |
+----------+
|       11 |
+----------+
1 row in set (0.00 sec)

mysql> select count(1) from tb_students_info;
+----------+
| count(1) |
+----------+
|       11 |
+----------+
1 row in set (0.00 sec)

mysql> select count(age) from tb_students_info;
+------------+
| count(age) |
+------------+
|         10 |
+------------+
1 row in set (0.00 sec)

4. GROUP BY 与 WITH ROLLUP

WITH POLLUP 关键字用来在所有记录的最后加上一条记录，这条记录是上面所有记录的总和，即统计记录数量。

mysql> select sex,group_concat(name) from tb_students_info group by sex;
+------+-----------------------------------+
| sex  | group_concat(name)                |
+------+-----------------------------------+
| 女   | Henry,Jim,John,Thomas,Tom         |
| 男   | Dany,Green,Jane,Lily,Susan,LiMing |
+------+-----------------------------------+
2 rows in set (0.00 sec)

mysql> select sex,group_concat(name) from tb_students_info group by sex with rollup;
+------+-------------------------------------------------------------+
| sex  | group_concat(name)                                          |
+------+-------------------------------------------------------------+
| 女   | Henry,Jim,John,Thomas,Tom                                   |
| 男   | Dany,Green,Jane,Lily,Susan,LiMing                           |
| NULL | Henry,Jim,John,Thomas,Tom,Dany,Green,Jane,Lily,Susan,LiMing |
+------+-------------------------------------------------------------+
3 rows in set (0.00 sec)

子查询

子查询是 MySQL 中比较常用的查询方法，通过子查询可以实现多表查询。子查询指将一个查询语句嵌套在另一个查询语句中。子查询可以在 SELECT、UPDATE 和 DELETE 语句中使用，而且可以进行多层嵌套。在实际开发时，子查询经常出现在 WHERE 子句中。

子查询在 WHERE 中的语法格式如下：

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

其中，操作符可以是比较运算符和 IN、NOT IN、EXISTS、NOT EXISTS 等关键字。

1）IN | NOT IN （等于 | 不等于）
当表达式与子查询返回的结果集中的某个值相等时，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回值正好相反。
不等于：!= 或 <> 或 NOT IN 。

2）EXISTS | NOT EXISTS
用于判断子查询的结果集是否为空，若子查询的结果集不为空，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回的值正好相反。

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.00 sec)

mysql> select name from tb_students_info where course_id not in (select id from tb_ccourse where course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.00 sec)

mysql> select name from tb_students_info where course_id <> (select id from tb_coursse where course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.00 sec)

mysql> select name from tb_students_info where exists (select id from tb_course where course_name = 'Java');
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
11 rows in set (0.00 sec)

mysql> select name from tb_students_info where not exists (select id from tb_course where course_name = 'Java');
Empty set (0.00 sec)

习惯上，外层的 SELECT 查询称为父查询，圆括号中嵌入的查询称为子查询（子查询必须放在圆括号内）。MySQL 在处理 SELECT 语句时，执行流程为：先执行子查询，再执行父查询。

子查询的功能也可以通过表连接完成，但是子查询会使 SQL 语句更容易阅读和编写。

一般来说，表连接（内连接和外连接等）都可以用子查询替换，但反过来却不一定，有的子查询不能用表连接来替换。子查询比较灵活、方便、形式多样，适合作为查询的筛选条件，而表连接更适合于查看连接表的数据。

附录：创建 tb_students_info 、tb_course

[root@localhost ~]# mysql -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.38 MySQL Community Server (GPL)

Copyright (c) 2000, 2022, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.01 sec)

mysql> create database exercise;
Query OK, 1 row affected (0.00 sec)

mysql> use exercise;
Database changed
mysql> create table tb_students_info(
    -> id int not null primary key auto_increment,
    -> name varchar(50),
    -> age tinyint,
    -> sex varchar(4),
    -> height float,
    -> course_id int) 
    -> DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
Query OK, 0 rows affected (0.04 sec)

mysql> insert tb_students_info(name,age,sex,height,course_id) values 
    -> ('Dany',25,'男',160,1),
    -> ('Green',23,'男',158,2),
    -> ('Henry',23,'女',185,1),
    -> ('Jane',22,'男',162,3),
    -> ('Jim',24,'女',175,2),
    -> ('John',21,'女',172,4),
    -> ('Lily',22,'男',165,4),
    -> ('Susan',23,'男',170,5),
    -> ('Thomas',22,'女',178,5),
    -> ('Tom',23,'女',165,5);
Query OK, 10 rows affected (0.01 sec)
Records: 10  Duplicates: 0  Warnings: 0

mysql> create table tb_course(id int not null primary key auto_increment,course_name varchar(50));
Query OK, 0 rows affected (0.00 sec)

mysql> insert tb_course(course_name) value('Java'),('MySQL'),('Python'),('Go'),('C++');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> desc tb_students_info;
+-----------+-------------+------+-----+---------+----------------+
| Field     | Type        | Null | Key | Default | Extra          |
+-----------+-------------+------+-----+---------+----------------+
| id        | int(11)     | NO   | PRI | NULL    | auto_increment |
| name      | varchar(50) | YES  |     | NULL    |                |
| age       | tinyint(4)  | YES  |     | NULL    |                |
| sex       | varchar(4)  | YES  |     | NULL    |                |
| height    | float       | YES  |     | NULL    |                |
| course_id | int(11)     | YES  |     | NULL    |                |
+-----------+-------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

mysql> desc tb_course;
+-------------+-------------+------+-----+---------+----------------+
| Field       | Type        | Null | Key | Default | Extra          |
+-------------+-------------+------+-----+---------+----------------+
| id          | int(11)     | NO   | PRI | NULL    | auto_increment |
| course_name | varchar(50) | YES  |     | NULL    |                |
+-------------+-------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)
Cristal.木
关注
专栏目录
MySQL超详细安装配置教程(亲测有效)
wer24_25的博客
06-25 5万+
目录1.下载mysql 2.环境配置3.安装mysql​4.navicat工具下载与连接​5总结mysql下载--MySQL ：： 下载 MySQL 社区服务器下载的时候这里直接逃过就行 我这里的版本是最新的mysql8.0.37下载完成之后,将压缩包进行解压 这里我建议大家把自己的mysql放到D盘根目录下,防止后面出现问题,自己找的时候也方便(我就踩过这个坑)打开电脑系统环境变量在系统变量中找到Path,点击进入编辑 加上自己mysql中bin文件夹的路径然后确定退出即可编辑创建好的my.ini文件，用
Linux-安装MySQL（详细教程）
xhmico的博客
06-09 11万+
本文的主要内容是在 Linux 上安装 MySQL，以下内容是源于 B站 - MySQL数据库入门到精通 整理而来。MySQL是一种关系型数据库管理系统，所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型和大型网站的开发都选择 MySQL 作为网站数据库。官网：https://www.mysql.com/ 进入官网之后点击 进入页面这里选择 进入页面，选择 根据你服务器
windows 彻底卸载 mysql
桃李不言下自成蹊
09-25 4万+
1.关闭MySQL服务 2.删除MySQL文件夹 3.删除MySQL注册表项 4.清理环境变量 5.删除服务 6.重启电脑
【MySQL系列】MySQL 字符集的演变与选择
檀越的博客
06-21 3万+
💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨。
MySQL 8.0.19安装教程(windows 64位)
热门推荐
日日言谧
08-15 98万+
话不多说直接开干 目录 1-先去官网下载点击的MySQL的下载​ 2-配置初始化的my.ini文件的文件 3-初始化MySQL 4-安装MySQL服务 + 启动MySQL 服务 5-连接MySQL + 修改密码 先去官网下载点击的MySQL的下载 下载完成后解压 解压完是这个样子 配置初始化的my.ini文件的文件 ...
MYSQL增加索引
qq_37837461的博客
02-01 2万+
mysql新建删除索引
MySQL设置时区
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
09-08 1万+
MySQL时区设置对于数据库的处理时间值非常重要，可以让不同的时区用户正确的处理时间值。本文从设置时区的方法、时区转换和时区的影响三个方面详细说明了MySQL的时区设置，在实际开发中需要根据实际需要进行设置和使用。
MySQL主从复制详解
qq_52645134的博客
12-18 7356
在实际应用中，合理配置和持续监控主从复制的状态，有助于保障数据的安全和稳定性，提高数据库整体的可用性。MySQL主从复制基于主从模型工作，其中主服务器（Master）负责处理写操作（INSERT、UPDATE、DELETE等），而从服务器（Slave）则复制主服务器的数据变更。：主服务器将二进制日志发送给从服务器，从服务器接收并应用这些日志，以重放主服务器上的写操作，保持数据同步。：连接到主服务器，并从其获取二进制日志文件，然后将这些日志应用到自身的数据上，保持与主服务器数据的同步。
Ubuntu deb文件 安装 MySQL
桃李不言下自成蹊
11-15 7万+
sudo apt -y install vim net-tools wget gcc make cmake lrzsz sudo apt -y install libmecab2 libjson-perl
ubuntu 安装mysql
志存高远
02-26 3387
根据提示进行操作，包括设置root账户的新密码（如果尚未设置）、禁止远程登录（如果不希望允许）、删除匿名用户、清空权限表、加载这些更改到MySQL服务器等。在Ubuntu系统上安装MySQL数据库，可以使用命令行方式进行操作。请确保替换上述命令中的“mysql”为适合你Ubuntu版本的实际MySQL软件包名称，因为随着时间推移，软件包名称和结构可能会有所变化。如果你遇到MySQL 8.0以上版本，初始用户认证方式可能会有所不同，可能需要使用。另外，在实际环境中，可能还需要安装其他相关工具或客户端库，如。
mysql驱动jar 文件适用MySQL5.7
01-18
MySQL驱动jar文件是Java应用程序与MySQL数据库之间通信的关键组件，主要功能是提供Java Database Connectivity (JDBC) API，使得Java开发者能够通过编写Java代码来执行SQL语句，从而操作MySQL数据库。标题提到的...
Mysql5.6、Mysql5.7 JDBC驱动
12-29
4. **执行SQL**：调用Statement或PreparedStatement的executeQuery()或executeUpdate()方法执行SQL。 5. **处理结果**：如果执行的是查询，可以通过ResultSet获取结果；如果是更新操作，可以获取影响的行数。 6. **...
mysql jdbc连接驱动jar包（适用于mysql5.7版本，亲测可用）
08-17
4. 建立连接：使用`DriverManager.getConnection()`方法创建到MySQL服务器的连接。参数通常包括URL、用户名和密码： ```java String url = "jdbc:mysql://localhost:3306/mydatabase"; String username = "myuser...
mysql索引详解
学Java，找哪吒
07-07 10万+
MySQL的存储引擎架构将查询处理与数据的存储/提取相分离
MySQL安装配置教程（超级详细、保姆级）
Soloversion的博客
03-26 42万+
一、 下载MySQL Mysql官网下载地址https://downloads.mysql.com/archives/installer/ 1. 选择想要安装的版本，本篇文章选择的是5.7.31版本，下面的那个文件，点击Download下载 二、 安装MySQL 1. 选择设置类型 双击运行mysql-installer-community-5.7.31.0.msi 这里选择是自定义安装，所以直接选择“Custom”，点击“Next” “Developer Default”是开发者默认
MySQL中字段类型和Java对象中的数据类型对应关系
Zhuxiaoyu_91的博客
11-12 338
MySQL中字段类型和Java对象中的数据类型对应关系
./mysqld: error while loading shared libraries: libaio.so.1: cannot open sha
qq_42112846的博客
11-12 282
使用离线方式安装：rpm -ivh --nodeps mysql* ，执行 systemctl start mysqld.service发现启动不了，通过vi /var/log/mysql.log看到如下关键字：libraries: libaio.so.1，之前也是按照网上帖子各种修改都没有解决问题，库是Linux异步I/O库，这个库对MySQL是必需的，因为它依赖于这个库来进行异步I/O操作。2，如果执行了whereis libaio.so.1，没有找到该文件，就要手动安装下libaio。
MySQL库操作
zgwnb666的博客
11-08 955
MySQL库操作
MySQL分区
最新发布
这个人很懒，什么都没有留下。
11-12 587
分区实际上是提供了一种物理上的数据组织方式，使得查询操作能够更加聚焦于相关的数据段，避免了全表扫描，从而提升了查询效率，特别是在数据量非常大的情况下。这种方式特别适合于那些可以根据某些明显的业务逻辑（如时间、地区等）被分割的大表。
MySQL密码重置教程
例如，如果你的MySQL安装在`C:\Program Files\MySQL\MySQL Server 5.7`，则`my.ini`就在这里。 - 在Linux系统中，配置文件是`/etc/my.cnf`。 接下来，我们将修改配置文件以禁用权限检查： - 使用文本编辑器打开对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值