当前位置：首页 > news >正文

MySQL 进阶：多表联合查询与数据备份恢复

news 2025/9/18 7:22:35

MySQL 进阶：多表联合查询与数据备份恢复

多表联合查询

在实际应用中，数据通常分布在多个表中。多表查询能够同时从两个或更多表中检索数据。MySQL 支持多种多表查询方式，包括交叉连接、内连接、外连接、分组查询与子查询。

交叉连接（CROSS JOIN）

交叉连接返回连接表的笛卡尔积。例如，若表 A 有 m 行，表 B 有 n 行，结果集将包含 m × n 行。

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

语法

SELECT 字段名 FROM 表1 CROSS JOIN 表2 [WHERE 子句];
-- 或
SELECT 字段名 FROM 表1, 表2 [WHERE 子句];-- 字段名：需要查询的字段名称
-- <表1><表2>：需要交叉连接的表名
-- WHERE 子句：用来设置交叉连接的查询条件

示例

-- 查询 student123 表中的数据，SQL 语句和运行结果如下
SELECT * FROM course student123;
+----+--------+------+------+--------+-----------+
| 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)
-- 查询 course 表中的数据，SQL 语句和运行结果如下
SELECT * FROM course;
+----+-------------+
| id | course_name |
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
+----+-------------+5 rows in set (0.00 sec)
-- 使用 CROSS JOIN 查询出两张表中的笛卡尔积，SQL 语句和运行结果如下
SELECT * FROM course CROSS JOIN student123;
+----+-------------+----+--------+------+------+--------+-----------+
| 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)-- 查询 course 表中的 id 字段和 student123 表中的 course_id 字段相等的内容， SQL 语句和运行结果如下
SELECT * FROM course CROSS JOIN students123-> WHERE student123.course_id = 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.01 sec)

注意：笛卡尔积可能导致结果集庞大且无意义，应谨慎使用。

内连接（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 子句在某些时候会影响查询的性能

示例

-- 在 student123 表和 course 表之间，使用内连接查询学生姓名和相对应的课程名称，SQL 语句和运行结果如下
SELECT s.name, c.course_name FROM students123 s INNER JOIN 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)

外连接（OUTER JOIN）

外连接除返回匹配行外，还返回某些未匹配行，分为左外连接和右外连接。

左连接（LEFT JOIN）

返回左表全部记录及右表匹配记录，无匹配则右表字段为 NULL。

语法

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）

示例

-- 查看 course 和 student123 两张表中的数据。SQL 语句和运行结果如下
SELECT * FROM course;
+----+-------------+
| id | course_name |
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
|  6 | HTML        |
+----+-------------+6 rows in set (0.00 sec)SELECT * FROM student123;
+----+--------+------+------+--------+-----------+
| 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)-- 在 student123 表和 course 表中查询所有学生姓名和相对应的课程名称，包括没有课程的学生，SQL 语句和运行结果如下
SELECT s.name, c.course_name FROM student123 s LEFT JOIN 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 的学生目前没有课程，因为对应的 course 表中没有该学生的课程信息，所以该条记录只取出了 student123 表中相应的值，而从 course 表中取出的值为 NULL

右连接（RIGHT JOIN）

返回右表全部记录及左表匹配记录，无匹配则左表字段为 NULL。

语法

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）

示例

-- 在 student123 表和 course 表中查询所有课程，包括没有学生的课程，SQL 语句和运行结果如下
SELECT s.name, c.course_name FROM student123 s RIGHT JOIN 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 的课程目前没有学生，因为对应的student123 表中并没有该学生的信息，所以该条记录只取出了 course 表中相应的值，而从 student123 表中取出的值为 NULL。

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

分组查询（GROUP BY）

GROUP BY 根据一个或多个字段对结果集分组，常与聚合函数（如 COUNT, SUM, AVG 等）联用。

语法

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

示例

-- 根据 student123 表中的 sex 字段进行分组查询，SQL 语句和运行结果如下
SELECT sex, COUNT(*) FROM student123 GROUP BY sex;
+-------+------+
| sex  | sex  |
+-------+------+
| 男   | 6   |
| 女   | 5   |
+-------+------+2 rows in set (0.01 sec)SELECT sex, GROUP_CONCAT(name) FROM student123 GROUP BY sex;
+------+----------------------------+
| sex  | GROUP_CONCAT(name)         |	
+------+----------------------------+
| 女   | Henry,Jim,John,Thomas,Tom  |
| 男   | Dany,Green,Jane,Lily,Susan |
+------+----------------------------+2 rows in set (0.00 sec)-- 根据 student123 表中的 age 和 sex 字段进行分组查询。SQL 语句和运行结果如下
SELECT age,sex,GROUP_CONCAT(name) FROM student123 -> GROUP BY age,sex;
+------+------+--------------------+
| age  | sex  | GROUP_CONCAT(name) |
+------+------+--------------------+
|   21 | 女   | John               |
|   22 | 女   | Thomas             |
|   22 | 男   | Jane,Lily          |
|   23 | 女   | Henry,Tom          |
|   23 | 男   | Green,Susan        |
|   24 | 女   | Jim                |
|   25 | 男   | Dany               |
+------+------+--------------------+7 rows in set (0.00 sec)

在数据统计时，GROUP BY 关键字经常和聚合函数一起使用。
聚合函数包括 COUNT()，SUM()，AVG()，MAX() 和 MIN()。其中，COUNT() 用来统计记录的条数；SUM() 用来计算字段值的总和；AVG() 用来计算字段值的平均值；MAX() 用来查询字段的最大值；MIN() 用来查询字段的最小值。

-- 根据 student123 表的 sex 字段进行分组查询，使用 COUNT() 函数计算每一组的记录数
SELECT sex,COUNT(sex) FROM student123-> GROUP BY sex;
+------+------------+
| sex  | COUNT(sex) |
+------+------------+
| 女   |          5 |
| 男   |          5 |
+------+------------+2 rows in set (0.00 sec)
-- 结果显示，sex 字段值为"女"的记录是一组，有 5 条记录；sex 字段值为"男"的记录是一组，有 5 条记录

使用 WITH ROLLUP

-- 根据 student123 表中的 sex 字段进行分组查询，并使用 WITH ROLLUP 显示记录的总和
SELECT sex, GROUP_CONCAT(name) FROM student123 GROUP BY sex WITH ROLLUP;
+------+------------------------------------------------------+
| sex  | GROUP_CONCAT(name)                                   |
+------+------------------------------------------------------+
| 女   | Henry,Jim,John,Thomas,Tom                            |
| 男   | Dany,Green,Jane,Lily,Susan                           |
| NULL | Henry,Jim,John,Thomas,Tom,Dany,Green,Jane,Lily,Susan |
+------+------------------------------------------------------+3 rows in set (0.00 sec)
-- 查询结果显示，GROUP_CONCAT(name) 显示了每个分组的 name 字段值。同时，最后一条记录的 GROUP_CONCAT(name) 字段的值刚好是上面分组 name 字段值的总和

子查询

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

语法

WHERE <表达式> <操作符> (子查询)
-- 其中，操作符可以是比较运算符和 IN、NOT IN、EXISTS、NOT EXISTS 等关键字
IN | NOT IN
-- 当表达式与子查询返回的结果集中的某个值相等时，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回值正好相反
EXISTS | NOT EXISTS
-- 用于判断子查询的结果集是否为空，若子查询的结果集不为空，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回的值正好相反

示例

-- 使用子查询在 student123 表和 course 表中查询学习 Java 课程的学生姓名，SQL 语句和运行结果如下
SELECT name FROM student123 WHERE course_id IN (SELECT id FROM course WHERE course_name = 'Java');
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+2 rows in set (0.01 sec)
-- 结果显示，学习 Java 课程的只有 Dany 和 Henry。上述查询过程也可以分为以下 2 步执行，实现效果是相同的-- 首先单独执行内查询，查询出 tb_course 表中课程为 Java 的 id，SQL 语句和运行结果如下
SELECT id FROM course WHERE course_name = 'Java';
+----+
| id |
+----+
|  1 |
+----+1 row in set (0.00 sec)
-- 可以看到，符合条件的 id 字段的值为 1-- 然后执行外层查询，在 tb_students_info 表中查询 course_id 等于 1 的学生姓名。SQL 语句和运行结果如下
SELECT name FROM student123 WHERE course_id IN (1);
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+2 rows in set (0.00 sec)
-- 外层的 SELECT 查询称为父查询，圆括号中嵌入的查询称为子查询（子查询必须放在圆括号内）。MySQL 在处理上例的 SELECT 语句时，执行流程为：先执行子查询，再执行父查询-- 在 SELECT 语句中使用 NOT IN 关键字，查询没有学习 Java 课程的学生姓名，SQL 语句和运行结果如下
SELECT name FROM student123 WHERE course_id NOT IN (SELECT id FROM course WHERE course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+9 rows in set (0.01 sec)
-- 运行结果与上面的例子刚好相反，没有学习 Java 课程的是除了 Dany 和 Henry 之外的学生-- 使用=运算符，在 tb_course 表和 tb_students_info 表中查询出所有学习 Python 课程的学生姓名，SQL 语句和运行结果如下
SELECT name FROM student123 WHERE course_id = (SELECT id FROM course WHERE course_name = 'Python');
+------+
| name |
+------+
| Jane |
+------+1 row in set (0.00 sec)
-- 学习 Python 课程的学生只有 Jane-- 使用<>运算符，在 tb_course 表和 tb_students_info 表中查询出没有学习 Python 课程的学生姓名，SQL 语句和运行结果如下
SELECT name FROM student123 WHERE course_id <> (SELECT id FROM course WHERE course_name = 'Python');
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+10 rows in set (0.00 sec)
-- 运行结果与例 3 刚好相反，没有学习 Python 课程的是除了 Jane 之外的学生-- 查询 tb_course 表中是否存在 id=1 的课程，如果存在，就查询出 tb_students_info 表中的记录，SQL 语句和运行结果如下
SELECT * FROM student123 WHERE EXISTS(SELECT course_name FROM 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)
-- course 表中存在 id=1 的记录，因此 EXISTS 表达式返回 TRUE，外层查询语句接收 TRUE 之后对表 student123 进行查询，返回所有的记录。
-- EXISTS 关键字可以和其它查询条件一起使用，条件表达式与 EXISTS 关键字之间用 AND 和 OR 连接-- 查询 tb_course 表中是否存在 id=1 的课程，如果存在，就查询出 tb_students_info 表中 age 字段大于 24 的记录，SQL 语句和运行结果如下
SELECT * FROM student123 WHERE age>24 AND EXISTS(SELECT course_name FROM course WHERE id=1);
+----+------+------+------+--------+-----------+
| id | name | age  | sex  | height | course_id |
+----+------+------+------+--------+-----------+
|  1 | Dany |   25 | 男   |    160 |         1 |
+----+------+------+------+--------+-----------+1 row in set (0.01 sec)
-- 从 tb_students_info 表中查询出了一条记录，这条记录的 age 字段取值为 25。内层查询语句从 tb_course 表中查询到记录，返回 TRUE。外层查询语句开始进行查询。根据查询条件，从 tb_students_info 表中查询 age 大于 24 的记录。

MySQL 数据库备份与恢复

常用备份方案

备份类型	特点
全量备份	备份整个数据库，恢复快，备份时间长
增量备份	备份自上次备份以来的变更，备份时间短，恢复需按顺序进行
差异备份	备份自上次全量备份以来的变更，恢复时需全量备份+最后一次差异备份

使用 mysqldump 备份

语法

mysqldump [OPTIONS] database [tables ...]
mysqldump [OPTIONS] --all-databases [OPTIONS]
mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]-uUSERNAME      -- 指定数据库用户名
-hHOST          -- 指定服务器主机，请使用ip地址
-pPASSWORD      -- 指定数据库用户的密码
-P#             -- 指定数据库监听的端口，这里的#需用实际的端口号代替，如-P3307

备份整个数据库

mysqldump -u用户名 -p密码 --all-databases > all-当前的时间.sql

备份指定数据库

mysqldump -u用户名 -p密码 --databases 数据库名 > 数据库名-当前时间.sql

备份指定表

mysqldump -u用户名 -p密码 数据库名 表名1 表名2 > tables-当前时间.sql

数据恢复

恢复整个数据库

mysql -u用户名 -p密码 < all-当前时间.sql

恢复指定数据库

mysql -u用户名 -p密码 数据库名 < 数据库名-当前时间.sql

在 MySQL 内恢复表

USE 数据库名;
SOURCE table-当前时间.sql;

差异备份与恢复

开启二进制日志
在 my.cnf 中配置：

[mysqld]
basedir = /usr/local/mysql
datadir = /opt/data
socket = /tmp/mysql.sock
port = 3306
user = mysql
pid-file = /tmp/mysql.pid
skip-name-resolve
server-id=1		#设置服务器标识符
log-bin=mysql_bin		#开启二进制日志功能service mysqld restart   #重启服务

全量备份

mysqldump -u用户名 -p密码 --single-transaction --flush-logs --master-data=2 --all-databases --delete-master-logs > all-202407301642.sql

恢复全量备份

ll /opt/data/
总用量 188548
-rw-r-----. 1 mysql mysql       56 2月  20 10:11 auto.cnf
-rw-r-----. 1 mysql mysql      996 2月  21 14:54 ib_buffer_pool
-rw-r-----. 1 mysql mysql 79691776 2月  21 16:09 ibdata1
-rw-r-----. 1 mysql mysql 50331648 2月  21 16:09 ib_logfile0
-rw-r-----. 1 mysql mysql 50331648 2月  20 10:11 ib_logfile1
-rw-r-----. 1 mysql mysql 12582912 2月  21 14:54 ibtmp1
-rw-r-----. 1 mysql mysql     8304 2月  21 08:45 linux-node1.com.err
-rw-r-----. 1 mysql mysql    74620 2月  21 14:54 localhost.err
drwxr-x---. 2 mysql mysql     4096 2月  21 16:03 mysql
-rw-r-----. 1 mysql mysql      154 2月  21 16:09 mysql_bin.000001
-rw-r-----. 1 mysql mysql       19 2月  21 16:09 mysql_bin.index
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 performance_schema
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 sys#刷新创建新的二进制日志
mysqladmin -uroot -predhat flush-logs
ll /opt/data/
总用量 188552
-rw-r-----. 1 mysql mysql       56 2月  20 10:11 auto.cnf
-rw-r-----. 1 mysql mysql      996 2月  21 14:54 ib_buffer_pool
-rw-r-----. 1 mysql mysql 79691776 2月  21 16:17 ibdata1
-rw-r-----. 1 mysql mysql 50331648 2月  21 16:18 ib_logfile0
-rw-r-----. 1 mysql mysql 50331648 2月  20 10:11 ib_logfile1
-rw-r-----. 1 mysql mysql 12582912 2月  21 14:54 ibtmp1
-rw-r-----. 1 mysql mysql     8304 2月  21 08:45 linux-node1.com.err
-rw-r-----. 1 mysql mysql    74620 2月  21 14:54 localhost.err
drwxr-x---. 2 mysql mysql     4096 2月  21 16:16 mysql
-rw-r-----. 1 mysql mysql      945 2月  21 16:18 mysql_bin.000001
-rw-r-----. 1 mysql mysql      154 2月  21 16:18 mysql_bin.000002
-rw-r-----. 1 mysql mysql       38 2月  21 16:18 mysql_bin.index
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 performance_schema
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 sys#恢复完全备份
mysql -u用户名 -p密码 < all-202407301642.sql

使用二进制日志恢复增量数据

#恢复差异备份
ll /opt/data/
总用量 189572
-rw-r-----. 1 mysql mysql       56 2月  20 10:11 auto.cnf
-rw-r-----. 1 mysql mysql      996 2月  21 14:54 ib_buffer_pool
-rw-r-----. 1 mysql mysql 79691776 2月  21 16:20 ibdata1
-rw-r-----. 1 mysql mysql 50331648 2月  21 16:20 ib_logfile0
-rw-r-----. 1 mysql mysql 50331648 2月  20 10:11 ib_logfile1
-rw-r-----. 1 mysql mysql 12582912 2月  21 14:54 ibtmp1
-rw-r-----. 1 mysql mysql     8304 2月  21 08:45 linux-node1.com.err
-rw-r-----. 1 mysql mysql    74620 2月  21 14:54 localhost.err
drwxr-x---. 2 mysql mysql     4096 2月  21 16:20 mysql
-rw-r-----. 1 mysql mysql      945 2月  21 16:18 mysql_bin.000001
-rw-r-----. 1 mysql mysql   786443 2月  21 16:20 mysql_bin.000002
-rw-r-----. 1 mysql mysql       38 2月  21 16:18 mysql_bin.index
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 performance_schema
drwxr-x---. 2 mysql mysql     8192 2月  20 10:11 sys
drwxr-x---. 2 mysql mysql       96 2月  21 16:20 cy#检查误删数据库的位置在什么地方
show binlog events in 'mysql_bin.000001';
+------------------+-----+----------------+-----------+-------------+---------------------------------------+
| Log_name         | Pos | Event_type     | Server_id | End_log_pos | Info                                  |
+------------------+-----+----------------+-----------+-------------+---------------------------------------+
| mysql_bin.000001 |   4 | Format_desc    |         1 |         123 | Server ver: 5.7.22-log, Binlog ver: 4 |
| mysql_bin.000001 | 123 | Previous_gtids |         1 |         154 |                                       |
| mysql_bin.000001 | 154 | Anonymous_Gtid |         1 |         219 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'  |
| mysql_bin.000001 | 219 | Query          |         1 |         295 | BEGIN                                 |
| mysql_bin.000001 | 295 | Table_map      |         1 |         353 | table_id: 330 (cy.chenyu)      |
| mysql_bin.000001 | 353 | Write_rows     |         1 |         410 | table_id: 330 flags: STMT_END_F       |
| mysql_bin.000001 | 410 | Xid            |         1 |         441 | COMMIT /* xid=2628 */                 |
| mysql_bin.000001 | 441 | Anonymous_Gtid |         1 |         506 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'  |
| mysql_bin.000001 | 506 | Query          |         1 |         582 | BEGIN                                 |
| mysql_bin.000001 | 582 | Table_map      |         1 |         640 | table_id: 330 (cy.chenyu)      |
| mysql_bin.000001 | 640 | Update_rows    |         1 |         698 | table_id: 330 flags: STMT_END_F       |
| mysql_bin.000001 | 698 | Xid            |         1 |         729 | COMMIT /* xid=2630 */                 |
| mysql_bin.000001 | 729 | Anonymous_Gtid |         1 |         794 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'  |
| mysql_bin.000001 | 794 | Query          |         1 |         898 | drop database cy                |     //此处就是删除数据库的位置，对应的pos位置是794
| mysql_bin.000001 | 898 | Rotate         |         1 |         945 | mysql_bin.000002;pos=4                |
+------------------+-----+----------------+-----------+-------------+---------------------------------------+15 rows in set (0.00 sec)#使用mysqlbinlog恢复差异备份
mysqlbinlog --stop-position=位置号 mysql_bin.000001 | mysql -u用户名 -p密码