一： 数据库约束
在 MySQL 中，约束是用于限制数据库表中数据的规则或条件。它们是为了保证数据的完整性和一致性。MySQL 提供了多种约束类型，包括 NOT NULL、UNIQUE、DEFAULT、PRIMARY KEY、FOREIGN KEY 和 CHECK等等
- NOT NULL 约束：
NOT NULL 约束用于确保列中的值不为空。
示例语句：
CREATE TABLE Users ( id INT NOT NULL, name VARCHAR(50) NOT NULL );
这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且id 和 name不能存储NULL值
- UNIQUE 约束：
UNIQUE 约束用于确保列中的值唯一。
示例语句：
CREATE TABLE Users ( id INT UNIQUE, email VARCHAR(50) UNIQUE );
这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且id 和 name的值是唯一的，不重复的
- DEFAULT 约束：
DEFAULT 约束用于为列设置默认值。
示例语句：
CREATE TABLE Users ( id INT, name VARCHAR(50) DEFAULT 'John' );
这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且在插入数据的时候，name列如果为空，默认值为 ‘John’
- PRIMARY KEY 约束：
PRIMARY KEY 约束用于定义表中的主键。主键是唯一标识表中每一行的列。
示例语句：
CREATE TABLE Users ( id INT PRIMARY KEY, name VARCHAR(50) );
这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且id作为这个表的主键，主键就相当于现实生活中的身份证，一个表里只有一个主键，在这个表中，我们可以通过id来唯一标识学生，如果要查询学生的信息，只需要通过id查询即可，因为主键都是唯一且不为空的。
简单来说，主键就是NOT NULL 和UNIQUE 的结合，对于整数类型的主键，常配搭自增长auto_increment来使用。插入数据对应字段不给值时，使用最大值+1，下面详细讲解一下auto_increment
当在 MySQL 数据库中创建表时，可以使用 AUTO_INCREMENT 属性为某个列指定自增长。
自增长列（也称为自增列或自动增长列）是一种特殊的列，其值会在每次插入新行时自动增加。通常用于为表生成唯一的标识符。自增长列只能与数字数据类型（如 INT、BIGINT 等）一起使用。
以下是使用 AUTO_INCREMENT 属性创建自增长列的示例：
CREATE TABLE employees ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(50), age INT );
在上面的示例中，我们创建了一个名为 employees 的表，其中包含三个列：id、name 和 age。id 列使用 AUTO_INCREMENT 属性，因此它将自动递增。PRIMARY KEY 关键字指定 id 列为主键。
要插入新行并为自增长列生成值，只需忽略 id 列即可，数据库将自动为其生成值。
INSERT INTO employees (name, age) VALUES ('John', 25); INSERT INTO employees (name, age) VALUES ('Jane', 30);
在上面的示例中，我们插入了两行数据，没有提供 id 值，数据库为其生成了唯一的自增长值。
可以使用如下查询语句获取自增长列的最新值：
SELECT LAST_INSERT_ID();
要更新自增长列的值，可以使用 ALTER TABLE 语句。例如，将自增长列的起始值更改为 100：
ALTER TABLE employees AUTO_INCREMENT = 100;
每当我新增一个数据的时候，那么主键的值就会自动+1，例如，如果你将一个表的主键列定义为 AUTO_INCREMENT，而且当前的最大主键值是 100，当你插入一条新的数据时，主键列的值会自动设为 101。当你插入下一条记录时，主键列的值将会是 102，依此类推，每次插入都会自动递增。
当我们给自增主键插入数据的时候，可以手动指定一个值，也可以让mysql自己分配，如果要让mysql自己分配，那么只需要在insert语句中，对于主键的值设置为null，即可，eg：
insert into student values（null，'张三'）;
注意，此时的null是让mysql自己分配主键的初始值，而不是将id设置为空。
- FOREIGN KEY 约束：
FOREIGN KEY 约束用于定义表之间的引用关系。它建立了从一个表到另一个表的链接，用于关联其他表的主键或唯一键。
示例语句：
-- 创建班级表，有使用MySQL关键字作为字段时，需要使用``来标识 DROP TABLE IF EXISTS classes; CREATE TABLE classes ( id INT PRIMARY KEY auto_increment, name VARCHAR(20), `desc` VARCHAR(100) ); -- 重新设置学生表结构 DROP TABLE IF EXISTS student; CREATE TABLE student ( id INT PRIMARY KEY auto_increment, sn INT UNIQUE, name VARCHAR(20) DEFAULT 'unkown', qq_mail VARCHAR(20), classes_id int, FOREIGN KEY (classes_id) REFERENCES classes(id) );
- FOREIGN KEY (classes_id) REFERENCES classes(id)
这个语句将学生表的 classes_id 列作为外键，参考了 classes 表的 id 列。这意味着学生表中的 classes_id 列的值必须在 classes 表的 id 列中存在。
这样定义外键后，学生表中的 classes_id 列的值只能是 classes 表中存在的 id 值。如果尝试插入或更新学生表的数据时，classes_id 列的值不存在于 classes 表中，将会触发外键约束错误。
通过定义外键，数据库能够维护表之间的关联关系，确保相关数据的一致性和完整性。当删除或更新 classes 表中的行时，将会自动处理学生表中依赖于该行的数据，以避免数据不一致的情况发生。
- CHECK 约束：
CHECK 约束用于限制列中的值必须满足指定的条件。
示例语句：
CREATE TABLE Products ( product_id INT, quantity INT, CHECK (quantity > 0) );
在 MySQL 中，CHECK 是用来添加约束条件（constraint）的关键字。它可以用来限制插入（INSERT）或更新（UPDATE）操作对表中某一列的值的合法性。CHECK (quantity > 0) 用来限制 “quantity” 列的值必须大于零。
换句话说，当你尝试插入或更新 “Products” 表中的记录时，MySQL 将会检查 “quantity” 列的值是否大于零。如果满足条件，则操作被允许进行；如果不满足条件，则操作将会被拒绝，并返回错误消息。
二：表的增删查改（进阶）
2.1 新增
案例：创建一张用户表，设计有name姓名、email邮箱、sex性别、mobile手机号字段。需要把已有的学生数据复制进来，可以复制的字段为name、qq_mail
-- 创建用户表 DROP TABLE IF EXISTS test_user; CREATE TABLE test_user ( id INT primary key auto_increment, name VARCHAR(20) comment '姓名', age INT comment '年龄', email VARCHAR(20) comment '邮箱', sex varchar(1) comment '性别', mobile varchar(20) comment '手机号' ); -- 将学生表中的所有数据复制到用户表 insert into test_user(name, email) select name, qq_mail from student;
最后一条条 SQL 语句的作用是将另一张名为 student 的表中的 name 和 qq_mail 列的值插入到名为 test_user 的表中的 name 和 email 列中
2.2查询
2.2.1聚合查询
2.2.1.1 聚合函数
| 函数 | 说明 |
| COUNT([DISTINCT] expr) | 返回查询到的数据的 数量 |
| SUM([DISTINCT] expr) | 返回查询到的数据的 总和，不是数字没有意义 |
| AVG([DISTINCT] expr) | 返回查询到的数据的 平均值，不是数字没有意义 |
| MAX([DISTINCT] expr) | 返回查询到的数据的 最大值，不是数字没有意义 |
| MIN([DISTINCT] expr) | 返回查询到的数据的 最小值，不是数字没有意义 |
案例：
COUNT
-- 统计班级共有多少同学 SELECT COUNT(*) FROM student; SELECT COUNT(0) FROM student; -- 统计班级收集的 qq_mail 有多少个，qq_mail 为 NULL 的数据不会计入结果 SELECT COUNT(qq_mail) FROM student;
SUM
-- 统计数学成绩总分 SELECT SUM(math) FROM exam_result; -- 不及格 < 60 的总分，没有结果，返回 NULL SELECT SUM(math) FROM exam_result WHERE math < 60;
AVG
-- 统计平均总分 SELECT AVG(chinese + math + english) as avg_total FROM exam_result;
MAX
-- 返回英语最高分 SELECT MAX(english) FROM exam_result;
MIN
-- 返回 > 70 分以上的数学最低分 SELECT MIN(math) FROM exam_result WHERE math > 70;
2.2.1.2GROUP BY子句
SELECT 中使用 GROUP BY 子句可以对指定列进行分组查询。但是需要满足：使用 GROUP BY 进行分组查询时，SELECT 指定的字段必须是“分组依据字段”，其他字段若想出现在SELECT 中则必须包含在聚合函数中。
案例：
create table emp( id int primary key auto_increment, name varchar(20) not null, role varchar(20) not null, salary numeric(11,2) ); insert into emp(name, role, salary) values ('马云','服务员', 1000.20), ('马化腾','游戏陪玩', 2000.99), ('孙悟空','游戏角色', 999.11), ('猪无能','游戏角色', 333.5), ('沙和尚','游戏角色', 700.33), ('隔壁老王','董事长', 12000.66); select role,max(salary),min(salary),avg(salary) from emp group by role;
这条SQL语句的含义是从"emp"表中查询每个不同"role"（角色）的最高薪水（“max(salary)”）、最低薪水（“min(salary)”）和平均薪水（“avg(salary)”）。
- “select role,max(salary),min(salary),avg(salary) from emp group by role;”
会执行以下操作：
- 从"emp"表中选择"role"和相关的聚合函数（“max(salary)”, “min(salary)”, “avg(salary)”）。
- 使用"GROUP BY"子句按"role"分组结果。
- 对于每个不同的"role"分组，计算该分组中的最高薪水、最低薪水和平均薪水的值。
- 返回包含"role"、最高薪水、最低薪水和平均薪水的结果集。
简而言之，该查询语句将返回每个职位（role）的最高、最低和平均薪水的值。
在给定的数据例子中，结果可能是这样的：
±-------------±------------±------------±------------+
| role | max(salary) | min(salary) | avg(salary) |
±-------------±------------±------------±------------+
| 董事长 | 12000.66 | 12000.66 | 12000.66 |
| 服务员 | 1000.20 | 1000.20 | 1000.20 |
| 游戏角色 | 999.11 | 333.5 | 677.31 |
| 游戏陪玩 | 2000.99 | 2000.99 | 2000.99 |
±-------------±------------±------------±------------+
2.2.1.3HAVING
GROUP BY 子句进行分组以后，需要对分组结果再进行条件过滤时，不能使用 WHERE 语句，而需要用HAVING
- 分组前筛选用where
- 分组后筛选用having
案例：
显示平均工资低于1500的角色和它的平均工资
select role,max(salary),min(salary),avg(salary) from emp group by role having avg(salary)<1500;
2.2.2联合查询（多表查询）
实际开发中往往数据来自不同的表，所以需要多表联合查询。多表查询是对多张表的数据取笛卡尔积：
2.2.2.1内连接
内连接（Inner Join）是MySQL中常用的一种连接方式，它将两个表中符合连接条件的行进行匹配，并返回匹配成功的结果。
内连接的语法如下：
select 字段(列名) from 表1 别名1 [inner] join 表2 别名2 on 连接条件 and 其他条件; select 字段 from 表1 别名1,表2 别名2 where 连接条件 and 其他条件;
其中，表1 和 表2 是要连接的两个表，列名 是连接条件。连接条件可以是两个表中具有相同值的列或表达式。
下面是一个示例，假设有两个表 students 和 scores，students 表存储学生的基本信息，scores 表存储学生的考试成绩。
students 表：
+------+--------+ | id | name | +------+--------+ | 1 | Alice | | 2 | Bob | | 3 | Charlie| | 4 | David | +------+--------+
scores 表：
+------+-------+-------+ | id | score | grade | +------+-------+-------+ | 1 | 90 | A | | 2 | 80 | B | | 3 | 95 | A | | 4 | 75 | C | +------+-------+-------+
我们可以使用内连接将这两个表连接起来，获取学生的成绩及姓名：
SELECT students.name, scores.score FROM students INNER JOIN scores ON students.id = scores.id;
以上语句将返回以下结果：
+--------+-------+ | name | score | +--------+-------+ | Alice | 90 | | Bob | 80 | | Charlie| 95 | | David | 75 | +--------+-------+
这里的连接条件是 students.id = scores.id，即两个表中的 id 列相等。通过内连接，我们将学生姓名和成绩进行了关联，并只返回匹配成功的结果。
students 表和scores 表取笛卡尔积后形成的新表如图所示：
+----+----------+------+------+-------+-------+ | id | name | id | score | grade | grade | +----+----------+------+------+-------+-------+ | 1 | Alice | 1 | 90 | A | A | | 1 | Alice | 2 | 80 | B | B | | 1 | Alice | 3 | 95 | A | A | | 1 | Alice | 4 | 75 | C | C | | 2 | Bob | 1 | 90 | A | A | | 2 | Bob | 2 | 80 | B | B | | 2 | Bob | 3 | 95 | A | A | | 2 | Bob | 4 | 75 | C | C | | 3 | Charlie | 1 | 90 | A | A | | 3 | Charlie | 2 | 80 | B | B | | 3 | Charlie | 3 | 95 | A | A | | 3 | Charlie | 4 | 75 | C | C | | 4 | David | 1 | 90 | A | A | | 4 | David | 2 | 80 | B | B | | 4 | David | 3 | 95 | A | A | | 4 | David | 4 | 75 | C | C | +----+----------+------+------+-------+-------+
因为连接条件是 students.id = scores.id，即两个表中的 id 列相等，所以我们在这张表中提取出了这张表：
+--------+-------+ | name | score | +--------+-------+ | Alice | 90 | | Bob | 80 | | Charlie| 95 | | David | 75 | +--------+-------+
-- 写法1 select sco.score from student stu inner join score sco on stu.id=sco.student_id and stu.name='许仙'; -- 写法2 select sco.score from student stu, score sco where stu.id=sco.student_id and stu.name='许仙';
对于这两种写法，效果是完全一样的
2.2.2.2 where on having 的区别
当在 MySQL 中使用 SQL 查询时，我们可以使用 WHERE、ON 和 HAVING 这三个子句来进行过滤和条件筛选。虽然它们的作用有些相似，但它们的使用场景和操作对象是不同的。
- WHERE 子句：
WHERE 子句用于在检索数据时对行进行条件过滤（分组前）。它通常与 SELECT 语句一起使用，用于筛选满足特定条件的行。
示例：
SELECT * FROM customers WHERE age > 25;
- 上面的示例查询将返回 age 大于 25 的所有 customers 行。
- ON 子句：
ON 子句通常用于 JOIN 操作，用于指定连接条件。它在连接两个或多个表时使用，指定连接表之间的关系。
示例：
SELECT * FROM customers JOIN orders ON customers.id = orders.customer_id;
- 上面的示例查询通过连接 customers 表和 orders 表，使用 customers 表的 id 列和 orders 表的 customer_id 列进行匹配。
- HAVING 子句：
HAVING 子句用于在检索数据后对结果进行条件过滤（分组后）。它通常与 GROUP BY 子句一起使用，用于筛选满足特定条件的分组结果。
示例：
SELECT customer_id, COUNT(*) as order_count FROM orders GROUP BY customer_id HAVING order_count > 5;
- 上面的示例查询将返回订单数量大于 5 的每个 customer_id。
2.2.2.3 外连接
外连接分为左外连接和右外连接。如果联合查询，左侧的表完全显示我们就说是左外连接；右侧的表完全显示我们就说是右外连接。
在MySQL中，外连接是一种用来联接两个或多个表的方法，它允许我们检索那些无法在内连接中匹配的数据。外连接包括左外连接和右外连接，它们分别基于左表和右表的数据，以不同的方式返回结果。
- 左外连接（Left Outer Join）：左外连接返回左表中的所有数据，以及与右表中匹配的数据。如果右表中没有匹配的数据，则以 NULL 值表示。左外连接使用关键字
LEFT JOIN或LEFT OUTER JOIN。
示例语句：
SELECT Customers.CustomerName, Orders.OrderID FROM Customers LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID;
这条SQL查询语句使用了左外连接来获取所有客户的姓名和订单ID。下面是对查询语句的详细解释：
- SELECT: 这是一个关键字，用于指定查询要返回的列。在这个例子中，我们希望返回Customers表中的CustomerName和Orders表中的OrderID。
- Customers.CustomerName: 这是一个表列的引用，它指定了我们希望从Customers表中获取CustomerName列的值。
- Orders.OrderID: 这同样是一个表列的引用，它指定了我们希望从Orders表中获取OrderID列的值。
- FROM: 这是一个关键字，用于指定查询的源表。在这个例子中，我们从Customers表中获取数据。
- LEFT JOIN: 这是一个连接类型的关键字，指定了我们希望使用左外连接。左外连接返回左表（Customers）中的所有行，以及与右表（Orders）中匹配的行。如果没有匹配的行，那么右表中的列将显示为NULL。
- ON: 这是一个关键字，用于指定连接条件。在这个例子中，我们使用Customers表和Orders表之间的CustomerID列进行连接。
- Customers.CustomerID = Orders.CustomerID: 这是连接条件，它指定了左表（Customers）的CustomerID列与右表（Orders）的CustomerID列之间的匹配。
所以，这条查询语句的含义是：从Customers表中获取每个客户的姓名，以及他们对应的订单ID。如果客户没有任何订单，那么订单ID列将显示为NULL。
在上面的示例中，我们使用 LEFT JOIN 将 Customers 表和 Orders 表联接起来。它会将 Customers 表中的所有数据返回，如果在 Orders 表中有匹配的数据，则返回相应的 OrderID。如果没有匹配的数据，则 OrderID 列将显示为 NULL 值。
- 右外连接（Right Outer Join）：右外连接返回右表中的所有数据，以及与左表中匹配的数据。如果左表中没有匹配的数据，则以 NULL 值表示。右外连接使用关键字
RIGHT JOIN或RIGHT OUTER JOIN。
示例语句：
SELECT Customers.CustomerName, Orders.OrderID FROM Customers RIGHT JOIN Orders ON Customers.CustomerID = Orders.CustomerID;
同理，与左外连接类似，这里不过多解释。
在上面的示例中，我们使用 RIGHT JOIN 将 Customers 表和 Orders 表联接起来。它会将 Orders 表中的所有数据返回，如果在 Customers 表中有匹配的数据，则返回相应的 CustomerName。如果没有匹配的数据，则 CustomerName 列将显示为 NULL 值。
2.2.2.4自连接
自连接是指在同一张表连接自身进行查询，（本质上是把行转成列），用于比较行之间的关系。
MySQL中的自连接是指在同一张表中进行连接操作。它允许将一个表作为两个逻辑表来连接和操作。自连接通常用于解决需要在同一表中比较不同行之间的数据的情况。
示例场景：假设我们有一个名为employees的表，其中包含员工的信息，包括emp_id（员工ID），emp_name（员工姓名），manager_id（经理ID）等字段。我们想要找到每个员工的经理姓名。
下面是一个使用自连接的示例查询语句：
SELECT e.emp_name AS employee_name, m.emp_name AS manager_name FROM employees e INNER JOIN employees m ON e.manager_id = m.emp_id;
在上述示例中，我们将employees表自连接两次。首先，我们将表employees命名为e，表示员工的数据。然后，我们再次将表employees命名为m，表示经理的数据。通过将表名起别名，我们可以区分它们。
然后，我们使用INNER JOIN来连接两个别名的表，通过e.manager_id = m.emp_id条件将员工表中的manager_id（经理ID）与经理表中的emp_id（员工ID）进行匹配。
最后，我们选择要显示的列，即员工姓名和经理姓名，分别使用e.emp_name AS employee_name和m.emp_name AS manager_name进行别名设置。
通过这个自连接查询语句，我们可以获得每个员工的经理姓名。
当我们执行上述 SQL 查询时，我们可以假设我们有以下数据示例：
表格 employees：
| emp_id | emp_name | manager_id |
| 1 | John | 2 |
| 2 | Mike | 3 |
| 3 | Emma | NULL |
| 4 | Lisa | 2 |
此示例包含了一个 employees 表格，其中每一行代表一个雇员。每个雇员有一个 emp_id（雇员 ID）、emp_name（雇员名字）和 manager_id（直属经理的雇员 ID）。manager_id 列用于表示每个雇员的直属经理。
现在，让我们根据上述查询和示例数据来进行解释和说明。
这个查询的目标是获取每个雇员以及他们的经理名字。为了达到这个目标，我们使用了 INNER JOIN 子句。INNER JOIN 通过将两个表格中满足指定连接条件的行进行连接，来返回联合后的结果。
在本查询中，我们将 employees 表格与自身进行连接，使用了两个表格别名：e 用于表示当前雇员，m 用于表示直属经理。我们指定连接条件为 e.manager_id = m.emp_id，即当前雇员的 manager_id 值等于经理的 emp_id 值，这样可以将每个雇员与其经理进行匹配。
结果集包含两列：employee_name 和 manager_name。employee_name 列将存储雇员的名字，manager_name 列将存储经理的名字。
根据上述示例数据和连接条件，查询的结果应该如下：
| employee_name | manager_name |
| John | Mike |
| Mike | Emma |
| Lisa | Mike |
以上结果显示了每个雇员以及他们对应的经理名字，下面解释一下原因：
| emp_id | emp_name | manager_id |
| 1 | John | 2 |
| 2 | Mike | 3 |
| 3 | Emma | NULL |
| 4 | Lisa | 2 |
这张表在与自身求笛卡尔积之后形成的结果表的结构如下：
| emp_id | emp_name | manager_id | emp_id | emp_name | manager_id |
| 1 | John | 2 | 1 | John | 2 |
| 1 | John | 2 | 2 | Mike | 3 |
| 1 | John | 2 | 3 | Emma | NULL |
| 1 | John | 2 | 4 | Lisa | 2 |
| 2 | Mike | 3 | 1 | John | 2 |
| 2 | Mike | 3 | 2 | Mike | 3 |
| 2 | Mike | 3 | 3 | Emma | NULL |
| 2 | Mike | 3 | 4 | Lisa | 2 |
| 3 | Emma | NULL | 1 | John | 2 |
| 3 | Emma | NULL | 2 | Mike | 3 |
| 3 | Emma | NULL | 3 | Emma | NULL |
| 3 | Emma | NULL | 4 | Lisa | 2 |
| 4 | Lisa | 2 | 1 | John | 2 |
| 4 | Lisa | 2 | 2 | Mike | 3 |
| 4 | Lisa | 2 | 3 | Emma | NULL |
| 4 | Lisa | 2 | 4 | Lisa | 2 |
SELECT e.emp_name AS employee_name, m.emp_name AS manager_name FROM employees e INNER JOIN employees m ON e.manager_id = m.emp_id;
接着显示e.emp_name和 m.emp_name，接着我们通过e.manager_id = m.emp_id;筛选，筛选后结果就是：
| employee_name | manager_name |
| John | Mike |
| Mike | Emma |
| Lisa | Mike |
2.2.3子查询
子查询是指嵌入在其他sql语句中的select语句，也叫嵌套查询
单行子查询：返回一行记录的子查询
eg：查询与“不想毕业” 同学的同班同学：
select * from student where classes_id=(select classes_id from student where name='不想毕业');
多行子查询：返回多行记录的子查询
eg：查询“语文”或“英文”课程的成绩信息
-- 使用IN select * from score where course_id in (select id from course where name='语文' or name='英文'); -- 使用 NOT IN select * from score where course_id not in (select id from course where ame!='语文' and name!='英文');
这个查询语句是用来筛选出满足以下条件的数据：在score表中存在一个id，这个id在course表中对应的course_id上有满足条件 (name=‘语文’ or name=‘英文’) 的记录。
具体解释每个部分的含义：
select *：表示查询返回所有列的数据。from score sco：指定要查询的表为score，并设置别名为sco。where exists (...)：使用exists关键字来判断是否存在满足条件的记录。- 在主查询中，使用exists关键字来判断score表中是否存在满足子查询条件的记录。
select sco.id：在子查询中，选择score表的id列。from course cou：指定子查询中要查询的表为course，并设置别名为cou。where (name='语文' or name='英文')：在子查询中，设置两个条件，要求course表的name列为’语文’或者为’英文’。and cou.id = sco.course_id：在子查询中，将course表的id列与score表的course_id列进行连接，保证两个表的course_id相等。
综上所述，这个查询语句的目的是找到在score表中，课程名称为’语文’或者’英文’的记录，并返回对应的所有列数据。
2.2.3.4.from子句中使用子查询
在from子句中使用子查询：子查询语句出现在from子句中。这里要用到数据查询的技巧，把一个子查询当做一个临时表使用。
查询所有比“中文系2019级3班”平均分高的成绩信息：
-- 获取“中文系2019级3班”的平均分，将其看作临时表 SELECT avg( sco.score ) score FROM score sco JOIN student stu ON sco.student_id = stu.id JOIN classes cls ON stu.classes_id = cls.id WHERE cls.NAME = '中文系2019级3班';
下面来详细解释一下这条语句：
这个查询语句用于获取"中文系2019级3班"的平均分，并将其视为临时表。
- 首先，我们指定要从哪个表中获取数据。在这个查询中，我们使用了三个表，分别是score、student和classes。我们通过使用JOIN子句来连接这些表。
- 我们使用JOIN子句将score表与student表连接起来。连接条件是score表中的student_id列与student表中的id列匹配。
- 接下来，我们使用另一个JOIN子句将student表与classes表连接起来。连接条件是student表中的classes_id列与classes表中的id列匹配。
- 然后，我们使用WHERE子句来筛选满足条件的数据。在这里，我们指定了classes表的NAME列等于’中文系2019级3班’，以限制结果只包括该班级的学生。
- 最后，我们使用avg函数来计算score表中分数列的平均值，并将其别名为score。
整体而言，这个查询语句的目的是获取"中文系2019级3班"的平均分，并将结果作为临时表在查询中使用。
2.2.4合并查询
在实际应用中，为了合并多个select的执行结果，可以使用集合操作符 union，union all。使用UNION和UNION ALL时，前后查询的结果集中，字段需要一致。
当在MySQL中需要将多个查询结果合并为单个结果集时，可以使用UNION运算符。UNION运算符用于合并两个或多个SELECT语句的结果集，并将其作为单个结果返回。下面是UNION的一些详细说明和示例语句：
基本语法：
SELECT column1, column2, ... FROM table1 UNION SELECT column1, column2, ... FROM table2
说明：
- UNION运算符用于合并两个或多个SELECT语句的结果集。
- UNION合并的结果集中不会包含重复的行，它自动去除重复的记录。
- UNION运算符必须由两个或多个SELECT语句组成，并且每个SELECT语句的列数和数据类型必须一致。
示例：
假设我们有两个表：students（学生表）和teachers（教师表），它们的结构如下：
students表：
+------+-------+ | id | name | +------+-------+ | 1 | Alice | | 2 | Bob | | 3 | Cindy | +------+-------+
teachers表：
+------+-------+ | id | name | +------+-------+ | 1 | Tom | | 2 | John | | 3 | Mary | +------+-------+
我们可以使用UNION运算符将这两个表的姓名字段合并为单个结果集，并去除重复的记录，如下所示：
SELECT name FROM students UNION SELECT name FROM teachers;
执行上述查询语句后，将得到以下结果：
+-------+ | name | +-------+ | Alice | | Bob | | Cindy | | Tom | | John | | Mary | +-------+
以上是一个简单的UNION示例，它将两个表的结果合并成一个不包含重复记录的结果集。
如果你想要一个包含重复记录的结果集，那么你可以使用:
union all
该操作符用于取得两个结果集的并集。当使用该操作符时，不会去掉结果集中的重复行。
