MySQL-2（14000字详解）

一： 数据库约束

在 MySQL 中，约束是用于限制数据库表中数据的规则或条件。它们是为了保证数据的完整性和一致性。MySQL 提供了多种约束类型，包括 NOT NULL、UNIQUE、DEFAULT、PRIMARY KEY、FOREIGN KEY 和 CHECK等等

1. NOT NULL 约束： NOT NULL 约束用于确保列中的值不为空。 示例语句：

CREATETABLE Users (
       id INTNOTNULL,
       name VARCHAR(50)NOTNULL);

这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且id 和 name不能存储NULL值

1. UNIQUE 约束： UNIQUE 约束用于确保列中的值唯一。 示例语句：

CREATETABLE Users (
       id INTUNIQUE,
       email VARCHAR(50)UNIQUE);

这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且id 和 name的值是唯一的，不重复的

1. DEFAULT 约束： DEFAULT 约束用于为列设置默认值。 示例语句：

CREATETABLE Users (
       id INT,
       name VARCHAR(50)DEFAULT'John');

这是用于创建名为 “Users” 的表的 SQL 命令。该表包含两个列：id 和 name，并且在插入数据的时候，name列如果为空，默认值为 ‘John’

1. PRIMARY KEY 约束： PRIMARY KEY 约束用于定义表中的主键。主键是唯一标识表中每一行的列。 示例语句：

CREATETABLE Users (
       id INTPRIMARYKEY,
       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 属性创建自增长列的示例：

CREATETABLE employees (
    id INTAUTO_INCREMENTPRIMARYKEY,
    name VARCHAR(50),
    age INT);

在上面的示例中，我们创建了一个名为 employees 的表，其中包含三个列：id、name 和 age。id 列使用 AUTO_INCREMENT 属性，因此它将自动递增。PRIMARY KEY 关键字指定 id 列为主键。

要插入新行并为自增长列生成值，只需忽略 id 列即可，数据库将自动为其生成值。

INSERTINTO employees (name, age)VALUES('John',25);INSERTINTO employees (name, age)VALUES('Jane',30);

在上面的示例中，我们插入了两行数据，没有提供 id 值，数据库为其生成了唯一的自增长值。

可以使用如下查询语句获取自增长列的最新值：

SELECT LAST_INSERT_ID();

要更新自增长列的值，可以使用 ALTER TABLE 语句。例如，将自增长列的起始值更改为 100：

ALTERTABLE employees AUTO_INCREMENT=100;

每当我新增一个数据的时候，那么主键的值就会自动+1，例如，如果你将一个表的主键列定义为 AUTO_INCREMENT，而且当前的最大主键值是 100，当你插入一条新的数据时，主键列的值会自动设为 101。当你插入下一条记录时，主键列的值将会是 102，依此类推，每次插入都会自动递增。

当我们给自增主键插入数据的时候，可以手动指定一个值，也可以让mysql自己分配，如果要让mysql自己分配，那么只需要在insert语句中，对于主键的值设置为null，即可，eg：

insertinto student values（null，'张三'）;

注意，此时的null是让mysql自己分配主键的初始值，而不是将id设置为空。

1. FOREIGN KEY 约束： FOREIGN KEY 约束用于定义表之间的引用关系。它建立了从一个表到另一个表的链接，用于关联其他表的主键或唯一键。 示例语句：

-- 创建班级表，有使用MySQL关键字作为字段时，需要使用``来标识DROPTABLEIFEXISTS classes;CREATETABLE classes (
id INTPRIMARYKEYauto_increment,
name VARCHAR(20),`desc`VARCHAR(100));-- 重新设置学生表结构DROPTABLEIFEXISTS student;CREATETABLE student (
 id INTPRIMARYKEYauto_increment,
 sn INTUNIQUE,
 name VARCHAR(20)DEFAULT'unkown',
 qq_mail VARCHAR(20),
classes_id int,FOREIGNKEY(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 表中的行时，将会自动处理学生表中依赖于该行的数据，以避免数据不一致的情况发生。

1. CHECK 约束： CHECK 约束用于限制列中的值必须满足指定的条件。 示例语句：

CREATETABLE 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

-- 创建用户表DROPTABLEIFEXISTS test_user;CREATETABLE test_user (
 id INTprimarykeyauto_increment,
 name VARCHAR(20)comment'姓名',
 age INTcomment'年龄',
 email VARCHAR(20)comment'邮箱',
sex varchar(1)comment'性别',
mobile varchar(20)comment'手机号');-- 将学生表中的所有数据复制到用户表insertinto 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

-- 统计班级共有多少同学SELECTCOUNT(*)FROM student;SELECTCOUNT(0)FROM student;-- 统计班级收集的 qq_mail 有多少个，qq_mail 为 NULL 的数据不会计入结果SELECTCOUNT(qq_mail)FROM student;

SUM

-- 统计数学成绩总分SELECTSUM(math)FROM exam_result;-- 不及格 < 60 的总分，没有结果，返回 NULLSELECTSUM(math)FROM exam_result WHERE math <60;

AVG

-- 统计平均总分SELECTAVG(chinese + math + english)as avg_total FROM exam_result;

MAX

-- 返回英语最高分SELECTMAX(english)FROM exam_result;

MIN

-- 返回 > 70 分以上的数学最低分SELECTMIN(math)FROM exam_result WHERE math >70;

2.2.1.2GROUP BY子句

SELECT 中使用 GROUP BY 子句可以对指定列进行分组查询。但是需要满足：使用 GROUP BY 进行分组查询时，SELECT 指定的字段必须是“分组依据字段”，其他字段若想出现在SELECT 中则必须包含在聚合函数中。

案例：

createtable emp(
id intprimarykeyauto_increment,
name varchar(20)notnull,
role varchar(20)notnull,
salary numeric(11,2));insertinto 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 groupby role;

这条SQL语句的含义是从"emp"表中查询每个不同"role"（角色）的最高薪水（“max(salary)”）、最低薪水（“min(salary)”）和平均薪水（“avg(salary)”）。

• “select role,max(salary),min(salary),avg(salary) from emp group by role;”

会执行以下操作：

1. 从"emp"表中选择"role"和相关的聚合函数（“max(salary)”, “min(salary)”, “avg(salary)”）。
2. 使用"GROUP BY"子句按"role"分组结果。
3. 对于每个不同的"role"分组，计算该分组中的最高薪水、最低薪水和平均薪水的值。
4. 返回包含"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 groupby role havingavg(salary)<1500;

2.2.2联合查询（多表查询）

实际开发中往往数据来自不同的表，所以需要多表联合查询。多表查询是对多张表的数据取笛卡尔积：

2.2.2.1内连接

内连接（Inner Join）是MySQL中常用的一种连接方式，它将两个表中符合连接条件的行进行匹配，并返回匹配成功的结果。

内连接的语法如下：

select 字段(列名)from 表1 别名1[inner]join 表2 别名2on 连接条件 and 其他条件;select 字段 from 表1 别名1,表2 别名2where 连接条件 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 INNERJOIN 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    |
+--------+-------+

-- 写法1select sco.score from student stu innerjoin score sco on stu.id=sco.student_id and stu.name='许仙';-- 写法2select 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 这三个子句来进行过滤和条件筛选。虽然它们的作用有些相似，但它们的使用场景和操作对象是不同的。

1. WHERE 子句： WHERE 子句用于在检索数据时对行进行条件过滤（分组前）。它通常与 SELECT 语句一起使用，用于筛选满足特定条件的行。 示例：SELECT*FROM customers WHERE age >25;上面的示例查询将返回 age 大于 25 的所有 customers 行。
2. ON 子句： ON 子句通常用于 JOIN 操作，用于指定连接条件。它在连接两个或多个表时使用，指定连接表之间的关系。 示例：SELECT*FROM customers JOIN orders ON customers.id = orders.customer_id;上面的示例查询通过连接 customers 表和 orders 表，使用 customers 表的 id 列和 orders 表的 customer_id 列进行匹配。
3. HAVING 子句： HAVING 子句用于在检索数据后对结果进行条件过滤（分组后）。它通常与 GROUP BY 子句一起使用，用于筛选满足特定条件的分组结果。 示例：SELECT customer_id,COUNT(*)as order_count FROM orders GROUPBY customer_id HAVING order_count >5;上面的示例查询将返回订单数量大于 5 的每个 customer_id。

2.2.2.3 外连接

外连接分为左外连接和右外连接。如果联合查询，左侧的表完全显示我们就说是左外连接；右侧的表完全显示我们就说是右外连接。

在MySQL中，外连接是一种用来联接两个或多个表的方法，它允许我们检索那些无法在内连接中匹配的数据。外连接包括左外连接和右外连接，它们分别基于左表和右表的数据，以不同的方式返回结果。

1. 左外连接（Left Outer Join）：左外连接返回左表中的所有数据，以及与右表中匹配的数据。如果右表中没有匹配的数据，则以 NULL 值表示。左外连接使用关键字 LEFT JOIN 或 LEFT OUTER JOIN。

示例语句：

SELECT Customers.CustomerName, Orders.OrderID FROM Customers LEFTJOIN 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 值。

1. 右外连接（Right Outer Join）：右外连接返回右表中的所有数据，以及与左表中匹配的数据。如果左表中没有匹配的数据，则以 NULL 值表示。右外连接使用关键字 RIGHT JOIN 或 RIGHT OUTER JOIN。

示例语句：

SELECT Customers.CustomerName, Orders.OrderID FROM Customers RIGHTJOIN 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
  INNERJOIN 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_idemp_namemanager_id1John22Mike33EmmaNULL4Lisa2
此示例包含了一个

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_namemanager_nameJohnMikeMikeEmmaLisaMike
以上结果显示了每个雇员以及他们对应的经理名字，下面解释一下原因：
emp_idemp_namemanager_id1John22Mike33EmmaNULL4Lisa2
这张表在与自身求笛卡尔积之后形成的结果表的结构如下：
emp_idemp_namemanager_idemp_idemp_namemanager_id1John21John21John22Mike31John23EmmaNULL1John24Lisa22Mike31John22Mike32Mike32Mike33EmmaNULL2Mike34Lisa23EmmaNULL1John23EmmaNULL2Mike33EmmaNULL3EmmaNULL3EmmaNULL4Lisa24Lisa21John24Lisa22Mike34Lisa23EmmaNULL4Lisa24Lisa2

SELECT 
  e.emp_name AS employee_name,
  m.emp_name AS manager_name
FROM
  employees e
  INNERJOIN employees m ON e.manager_id = m.emp_id;

接着显示e.emp_name和 m.emp_name，接着我们通过e.manager_id = m.emp_id;筛选，筛选后结果就是：
employee_namemanager_nameJohnMikeMikeEmmaLisaMike

2.2.3子查询

子查询是指嵌入在其他sql语句中的select语句，也叫嵌套查询

单行子查询：返回一行记录的子查询
eg：查询与“不想毕业” 同学的同班同学：

select*from student where classes_id=(select classes_id from student where name='不想毕业');

多行子查询：返回多行记录的子查询
eg：查询“语文”或“英文”课程的成绩信息

-- 使用INselect*from score where course_id in(select id from course where name='语文'or name='英文');-- 使用 NOT INselect*from score where course_id notin(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班”的平均分，将其看作临时表SELECTavg( 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班"的平均分，并将其视为临时表。

1. 首先，我们指定要从哪个表中获取数据。在这个查询中，我们使用了三个表，分别是score、student和classes。我们通过使用JOIN子句来连接这些表。
2. 我们使用JOIN子句将score表与student表连接起来。连接条件是score表中的student_id列与student表中的id列匹配。
3. 接下来，我们使用另一个JOIN子句将student表与classes表连接起来。连接条件是student表中的classes_id列与classes表中的id列匹配。
4. 然后，我们使用WHERE子句来筛选满足条件的数据。在这里，我们指定了classes表的NAME列等于’中文系2019级3班’，以限制结果只包括该班级的学生。
5. 最后，我们使用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示例，它将两个表的结果合并成一个不包含重复记录的结果集。

如果你想要一个包含重复记录的结果集，那么你可以使用:

unionall

该操作符用于取得两个结果集的并集。当使用该操作符时，不会去掉结果集中的重复行。