一文掌握mysql中的查询语句_mysql如何查询语句

1. 聚合查询

1.1 聚合函数

常见的统计总数、计算平局值等操作，可以使用聚合函数来实现，常见的聚合函数有：

案例

• 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) 平均总分 FROM exam_result;

• max

– 返回英语最高分
SELECT MAX(english) FROM exam_result;

• min

– 返回 > 70 分以上的数学最低分
SELECT MIN(math) FROM exam_result WHERE math > 70;

1.2 GROUP BY子句

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

假设我们有一个名为"orders"的表，包含以下字段：
order_id（订单ID）
customer_id（顾客ID）
order_date（订单日期）
total_amount（订单总金额）

我们想要按照顾客ID对订单进行分组，并计算每个顾客的订单总金额。在这种情况下，"customer_id"是分组依据字段，而"total_amount"是一个非分组依据字段。

SELECT customer_id, SUM(total_amount) AS total_order_amount
FROM orders
GROUP BY customer_id;

1
2
3
4

在上面的查询中，"customer_id"是分组依据字段，因此可以直接出现在SELECT语句中，而"total_amount"是一个非分组依据字段，它被包含在了SUM聚合函数中，以计算每个顾客的订单总金额。

案例
准备测试表及数据：职员表，有id（主键）、name（姓名）、role（角色）、salary（薪水）“

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);
1
2
3
4
5
6
7
8
9
10
11
12
13

查询每个角色的最高工资、最低工资和平均工资。在这里面就需要根据角色来分组，然后在买一组里面，查询出最高的工资，平均工资、最低工资。

select role,max(salary),min(salary),avg(salary) from emp group by role;
1

同样，**salary不是分组依据字段，所以使用了聚合函数处理，刚好符合我们的要求。
**

1.3 HAVING

GROUP BY 子句进行分组以后，需要对分组结果再进行条件过滤时，不能使用 WHERE 语句，而需要用HAVING:

显示平均工资低于1500的角色和它的平均工资:

select role,max(salary),min(salary),avg(salary) from emp group by role 
having avg(salary)<1500;
1
2

2. 联合查询

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

创建几个表：

-- 创建 classes 表
CREATE TABLE classes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    `desc` VARCHAR(255)
);

-- 创建 student 表
CREATE TABLE student (
    id INT AUTO_INCREMENT PRIMARY KEY,
    sn VARCHAR(20) NOT NULL,
    name VARCHAR(50) NOT NULL,
    qq_mail VARCHAR(50),
    classes_id INT,
    FOREIGN KEY (classes_id) REFERENCES classes(id)
);

-- 创建 course 表
CREATE TABLE course (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL
);

-- 创建 score 表
CREATE TABLE score (
    id INT AUTO_INCREMENT PRIMARY KEY,
    score FLOAT NOT NULL,
    student_id INT,
    course_id INT,
    FOREIGN KEY (student_id) REFERENCES student(id),
    FOREIGN KEY (course_id) REFERENCES course(id)
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

初始化测试数据：

insert into classes(name, `desc`) values 
('计算机系2019级1班', '学习了计算机原理、C和Java语言、数据结构和算法'),
('中文系2019级3班','学习了中国传统文学'),
('自动化2019级5班','学习了机械自动化');
 
 insert into student(sn, name, qq_mail, classes_id) values
 ('09982','黑旋风李逵','xuanfeng@qq.com',1),
 ('00835','菩提老祖',null,1),
 ('00391','白素贞',null,1),
 ('00031','许仙','xuxian@qq.com',1),
 ('00054','不想毕业',null,1),
 ('51234','好好说话','say@qq.com',2),
 ('83223','tellme',null,2),
 ('09527','老外学中文','foreigner@qq.com',2);
 
 insert into course(name) values
 ('Java'),('中国传统文化'),('计算机原理'),('语文'),('高阶数学'),('英文');
 
 insert into score(score, student_id, course_id) values 
(70.5, 1, 1),(98.5, 1, 3),(33, 1, 5),(98, 1, 6),-- 黑旋风李逵
(60, 2, 1),(59.5, 2, 5),-- 菩提老祖
(33, 3, 1),(68, 3, 3),(99, 3, 5),-- 白素贞
(67, 4, 1),(23, 4, 3),(56, 4, 5),(72, 4, 6),-- 许仙
(81, 5, 1),(37, 5, 5),-- 不想毕业
(56, 6, 2),(43, 6, 4),(79, 6, 6),-- 好好说话
(80, 7, 2),(92, 7, 6);-- tellme
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

现在classes表：
学生表：
课程表：

成绩表：

先来看一下直接使用多表查询，没有任何连接。我们查询学生表和班级表：

SELECT * FROM student, classes;
1

当然这是一种错误的写法，大家也不要使用*。这里方便大家观看，我i就直接使用了*，并且没有使用join关键字，这样可以看到直接多表查询出来的笛卡尔积。

这时候通过where子句指定条件，是否能够筛选出来有效的数据呢：

SELECT *
FROM student, classes
WHERE student.classes_id = classes.id;
1
2
3

答案是肯定的：
但是，在实际的数据库查询中，使用 JOIN 操作（如 INNER JOIN、LEFT JOIN、RIGHT JOIN 等）可以更有效地控制返回的数据集，并确保只返回符合特定条件的数据。虽然直接列出多个表并使用 WHERE 子句来进行连接可能会得到笛卡尔积，但这种方法通常不推荐使用，因为它缺乏表之间的明确关系，并且可能导致不必要的数据重复和性能问题。

2.1 内连接

内连接（INNER JOIN）是一种在多个表之间执行的连接操作，它返回满足连接条件的行，即两个表中都存在匹配的值的行。内连接通过使用 ON 子句指定连接条件来实现。如果没有指定连接条件，内连接将返回两个表的笛卡尔积。

语法：

SELECT 字段
FROM 表1 别名
INNER JOIN 表2 别名 ON 连接条件 AND 其他条件;
1
2
3

案例：
（1）查询“许仙”同学的 成绩。

select sco.score from student stu inner join score sco on stu.id=sco.student_id and stu.name='许仙';
1

（2）查询所有同学的总成绩，及同学的个人信息：

SELECT
 stu.sn,
 stu.NAME,
 stu.qq_mail,
 sum( sco.score ) 
FROM
 student stu
 JOIN score sco ON stu.id = sco.student_id 
GROUP BY
 sco.student_id;
1
2
3
4
5
6
7
8
9
10

（3）查询所有同学的成绩，及同学的个人信息：

-- 学生表、成绩表、课程表3张表关联查询
SELECT
 stu.id,
 stu.sn,
 stu.NAME,
 stu.qq_mail,
 sco.score,
 sco.course_id,
 cou.NAME 
FROM
 student stu
 JOIN score sco ON stu.id = sco.student_id
 JOIN course cou ON sco.course_id = cou.id 
ORDER BY
 stu.id;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2 外连接

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

使用语法：

-- 左外连接，表1完全显示
select 字段 from 表名1 left join 表名2 on 连接条件;
-- 右外连接，表2完全显示
select 字段 from 表名1 right join 表名2 on  连接条件;
1
2
3
4

案例：查询所有同学的成绩，及同学的个人信息，如果该同学没有成绩，也需要显示

SELECT
 stu.id,
 stu.sn,
 stu.NAME,
 stu.qq_mail,
 sco.score,
 sco.course_id,
 cou.NAME 
FROM
 student stu
 LEFT JOIN score sco ON stu.id = sco.student_id
 LEFT JOIN course cou ON sco.course_id = cou.id 
ORDER BY
 stu.id;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3 自连接

自连接是指在同一张表连接自身进行查询。自连接通常使用别名来区分两个表实例。在查询中，将同一张表用不同的别名表示，并在连接条件中使用这些别名来建立关系。

案例：
显示所有“计算机原理”成绩比“Java”成绩高的成绩信息

-- 先查询“计算机原理”和“Java”课程的id
 select id,name from course where name='Java' or name='计算机原理';



-- 再查询成绩表中，“计算机原理”成绩比“Java”成绩 好的信息
SELECT
 s1.* 
FROM
 score s1,
 score s2 
WHERE
 s1.student_id = s2.student_id 
AND s1.score < s2.score 
AND s1.course_id = 1 
AND s2.course_id = 3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

以上查询只显示了成绩信息，并且是分布执行的。要显示学生及成绩信息，并在一条语句显示：

SELECT
 stu.*,
 s1.score Java,
 s2.score 计算机原理 
FROM
 score s1
 JOIN score s2 ON s1.student_id = s2.student_id
 JOIN student stu ON s1.student_id = stu.id
 JOIN course c1 ON s1.course_id = c1.id
 JOIN course c2 ON s2.course_id = c2.id 
AND s1.score < s2.score 
AND c1.NAME = 'Java' 
AND c2.NAME = '计算机原理';
1
2
3
4
5
6
7
8
9
10
11
12
13

2.4 子查询

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

• 单行子查询
  查询与“不想毕业” 同学的同班同学：

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

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

 select * from score where course_id in (select id from course
 where name='语文' or name='英文');
1
2

• 在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班';
1
2
3
4
5
6
7
8
9

查询成绩表中，比以上临时表平均分高的成绩：

SELECT
 * 
FROM
 score sco,
 (
 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班' 
 ) tmp 
WHERE
 sco.score > tmp.score;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.5 合并查询

合并查询是指将多个查询结果合并成一个结果集的操作，注意保持前后查询的结果集中字段需要一致。在SQL中，可以使用UNION、UNION ALL、INTERSECT和EXCEPT等操作符来实现查询的合并。

• UNION操作符：合并两个或多个查询结果，并去除重复的行。

SELECT column1, column2 FROM table1
UNION
SELECT column1, column2 FROM table2;
1
2
3

• UNION ALL操作符：合并两个或多个查询结果，不去重。

SELECT column1, column2 FROM table1
UNION ALL
SELECT column1, column2 FROM table2;
1
2
3

• INTERSECT操作符：返回同时出现在两个查询结果中的行。交集

SELECT column1, column2 FROM table1
INTERSECT
SELECT column1, column2 FROM table2;
1
2
3

• EXCEPT操作符：返回只出现在第一个查询结果中而不在第二个查询结果中的行。

SELECT column1, column2 FROM table1
EXCEPT
SELECT column1, column2 FROM table2;
1
2
3

这些合并查询操作可以帮助我们从多个数据源中获取需要的数据，并进行必要的去重或筛选。