MySQL-2（14000字详解）-阿里云开发者社区

一：数据库约束

在 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）的最高、最低和平均薪水的值。

在给定的数据例子中，结果可能是这样的：

±-------------±------------±------------±------------+

±-------------±------------±------------±------------+

| 董事长 | 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

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

MySQL-2（14000字详解）

一：数据库约束

二：表的增删查改（进阶）

2.1 新增

2.2查询

2.2.1聚合查询

2.2.1.1 聚合函数

2.2.1.2GROUP BY子句

2.2.1.3HAVING

2.2.2联合查询（多表查询）

2.2.2.1内连接

2.2.2.2 where on having 的区别

2.2.2.3 外连接

2.2.2.4自连接

2.2.3子查询

2.2.3.4.from子句中使用子查询

2.2.4合并查询

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

MySQL-2（14000字详解）

一： 数据库约束

二：表的增删查改（进阶）

2.1 新增

2.2查询

2.2.1聚合查询

2.2.1.1 聚合函数

2.2.1.2GROUP BY子句

2.2.1.3HAVING

2.2.2联合查询（多表查询）

2.2.2.1内连接

2.2.2.2 where on having 的区别

2.2.2.3 外连接

2.2.2.4自连接

2.2.3子查询

2.2.3.4.from子句中使用子查询

2.2.4合并查询

热门文章

最新文章

相关课程

相关电子书

相关实验场景

一：数据库约束