Mysql高级语句（进阶查询语句、数据库函数、连接查询）_mysql 查询语句进阶

一、mysql查询语句

先建立lilade数据库，在建立nba表和cba表，用于测试

create  database lilade;

create table  lilade.nba (id int,name char(4), age int, sex char(2), hobby varchar(20));

create table  lilade.cba (id int,name char(4), age int, sex char(2), hobby varchar(20));

1
2
3
4
5
6

1.1、 select ----显示表格中一个或数个字段的所有数据记录

语法
select "字段" from "表名";
例子
select * from nba;
1
2
3
4

select name from nba;

1
2

1.2、 distinct ----不显示重复的数据记录

语法
select distinct "字段" from "表名"
#例子
select distinct name from nba;

1
2
3
4
5

1.3、where ----有条件查询

where是对源语句进行条件查询。

语法
select "字段" from "表名" where "条件";
#例子
select store_name from laozi where sales > 1000;

1
2
3
4
5

1.4、 and or ----且 或

语法
select "字段" from "表名" where "条件1" {[and|or] "条件2"}+ ;
#例子
select store_name from laozi where sales > 1000 or (sales < 500 and sales > 200);

1
2
3
4
5

1.5 、in----显示已知的值的数据记录

语法
select "字段" from "表名" where "字段" in ('值1', '值2', ...);
#例子
select * from laozi where store_name in ('los angeles', 'houston');

1
2
3
4
5

1.6、between----显示两个值范围内的数据记录

语法：select "字段" from "表名" where "字段" between '值1' and '值2';
#例子
select * from laozi where date between '2020-12-06' and '2020-12-10';

1
2
3
4

1.7、 通配符

#语法：
select 字段名  from 表名 where 字段 like 模式
1
2

1.8 、like ----模糊匹配

• 一般和通配符配合使用。
• 模糊匹配默认会扫描全表，索引不生效。

语法
select "字段" from "表名" where "字段" like {模式};
#例子
select * from laozi where store_name like '%os%';

1
2
3
4
5

1.9 、order by

按关键字排序

语法
select "字段" from "表名" [where "条件"] order by "字段" [asc, desc];
#asc 是按照升序进行排序的，是默认的排序方式。
#desc 是按降序方式进行排序。
#例子
select store_name,sales,date from laozi order by sales desc;

1
2
3
4
5
6
7

1.10、 group by ----汇总分组

• 对group by后面的字段的查询结果进行汇总分组，通常是结合聚合函数一起使用的。

• group by 有一个原则，凡是在 group by 后面出现的字段，必须在 select 后面出现；

• 凡是在 select 后面出现的、且未在聚合函数中出现的字段，必须出现在 group by 后面。

语法
select "字段1", sum("字段2") from "表名" group by "字段1";
#例子
select store_name, sum(sales) from laozi group by store_name order by sales desc;

1
2
3
4
5

select store_name,count(store_name) from laozi group by store_name;

1
2

1.11、 having

• 对group by语句的结果，进行条件筛选。

• 用来过滤由 group by 语句返回的记录集，通常与 group by 语句联合使用.

• having 语句的存在弥补了 where 关键字不能与聚合函数联合使用的不足。

语法
select "字段1", sum("字段2") from "表格名" group by "字段1" having (函数条件);
#举个例子
select store_name, sum(sales) from laozi group by store_name having sum(sales) > 1500;

1
2
3
4
5

1.12 、别名 ----字段別名 表格別名

as可省略，仅在当前SQL语句生效。

语法
select "表格別名"."字段1" [as] "字段別名" from "表格名" [as] "表格別名";
#例子
select a.store_name store, sum(a.sales) as "total sales" from laozi as a group by a.store_name;

1
2
3
4
5

1.13 、子查询语句

连接表格，在where 子句或 having 子句中插入另一个 sql 语句。

语法
select "字段1" from "表格1" where "字段2" [比较运算符] (select "字段1" from "表格2" where "条件");
#外查询	(#内查询)
#内查询的结果，作为外查询的参数

[比较运算符]
#可以是符号的运算符，例如 =、>、<、>=、<= 
#也可以是文字的运算符，例如 like、in、between
#例子
select sum(sales) from laozi where store_name in (select store_name from location where region = 'West');

1
2
3
4
5
6
7
8
9
10
11

#举个例子2
select sum(A.sales) from laozi as A where A.store_name in (select store_name from location as B where B.store_name = A.store_name);
#store_info表 别名为A表，在当前语句中，可以直接用a代替store_info使用
#location表 别名为B表

1
2
3
4
5

1.14、exists

• 用来测试内查询有没有产生任何结果。

• 如果有，系统就会执行外查询中的sql语句;

• 如果没有，那整个 SQL语句就不会产生任何结果

语法
select "字段1" from "表格1" where exists (select * from "表格2" where "条件";
#例子
select sum(sales) from laozi where exists (select * from location where region = 'West');

select sum(sales) from laozi where exists (select store_name from location where region ='Westt');

1
2
3
4
5
6
7

二、MySQL数据库函数

2.1、数学函数

select abs(-1), rand(), mod(5,3), power(2,3), round(1.89);

1
2

select round(1.8937,3), truncate(1.235,2), ceil(5.2), floor(2.1), least(1.89,3,6.1,2.1);

1
2

2.2、 聚合函数

select avg(sales) from laozi;

1
2

select count(store_name) from laozi;

1
2

select count(distinct store_name) from laozi;

1
2

select max(sales) from laozi;

1
2

select min(sales) from laozi;

1
2

select sum(sales) from laozi;

1
2

2.3、 字符串函数

1）trim

#示例1：从名字开头的开始，移除Sun Dasheng中的Sun显示
select trim(leading ‘Sun’ from ‘Sun Dasheng’);
select trim([ [位置] [要移除的字符串] from ] 字符串);
#[位置]：的值可以为 leading (起头), trailing (结尾), both (起头及结尾)。 
#[要移除的字符串]：从字串的起头、结尾，或起头及结尾移除的字符串。缺省时为空格。

1
2
3
4
5
6

#子查询语句，select 嵌套select

select trim(leading 'Los' from (select store_name from location where store_name='Los Angeles'));

select trim( trailing 'York' from (select store_name from location where store_name='New York'));

1
2
3
4
5
6

2）concat

字段名 不要加 ' '
字符串 要加' '
1
2

select concat (region ,' ',store_name) from location;

1
2

select region|| ' ' || store_name from location;

1
2

3）substr

select substr(store_name,5) from location where store_name ='Los Angeles';


select substr(store_name,5,6) from location where store_name ='Los Angeles';

1
2
3
4
5

4）length

 select replace(region,'stern','st'),store_name,length(store_name) from location;

1
2

5）replace

select replace (region,'st','stern') from location;

1
2

三、连接查询

3.1、 表连接

3.2、 union语句

• 联集，将两个sql语句的结果合并起来，两个sql语句所产生的字段需要是同样的数据记录种类。

• union ：生成结果的数据记录值将没有重复，且按照字段的顺序进行排序。

语法
[select 语句 1] union [select 语句 2];
select store_name from location union select store_name from laozi;

1
2
3
4

union all ：将生成结果的数据记录值都列出来，无论有无重复
1

语法
[select 语句 1] union all [select 语句 2];
select store_name from location union all select store_name from laozi;

1
2
3
4

3.3、 多表查询之求交集值

取两个SQL语句结果的交集。

基本语法
select A.字段 from 左表 A inner join 右表 B on A.字段 = B.字段;
select A.字段 from 左表 A inner join 右表 B using(同名字段);

select A.字段 from 左表 A, 右表 B where A.字段 = B.字段;

select A.字段 from 左表 A where A.字段 in (select B.字段 from 右表 B);

select A.字段 from 左表 A left join 右表 B on A.字段 = B.字段 where B.字段 is not null;
select B.字段 from 左表 A right join 右表 B on A.字段 = B.字段 where A.字段 is not null;

1
2
3
4
5
6
7
8
9
10
11

#求交集
#方式一
select A.store_name from location A inner join laozi B on A.store_name = B.store_name;

1
2
3
4

#方式二
select A.store_name from location A inner join laozi B using (store_name);

1
2
3

#取两个SQL语句结果的交集，且没有重复
select distinct A.store_name from location A inner join laozi B on A.store_name = B.store_name;

select distinct A.store_name from location A inner join laozi B using (store_name);
1
2
3
4

select distinct A.store_name from location A inner join laozi B using (store_name) where B.store_name is not NULL;

1
2

select A.store_name from (select distinct store_name from location union all select distinct store_name from laozi) A group by A.store_name having count( *) > 1;

#首先，子查询`select distinct store_name from location`从“location”表中选择所有不重复的店铺名称。
#然后，子查询`select distinct store_name from store_info`从“store_info”表中选择所有不重复的店铺名称。
#使用`union all`将两个子查询的结果合并，并作为临时表A。
#最后，对临时表A按照店铺名称进行分组，使用`having count(*) > 1`筛选出出现次数大于1的店铺名称。

1
2
3
4
5
6
7

3.4、 多表查询之求无交集值

显示第一个SQL语句的结果，且与第二个SQL语句没有交集的结果，且没有重复。
1

求左表无交集
select A.字段 from 左表 A left join 右表 B on A.字段 = B.字段 where B.字段 is null;

select 字段 from 左表 where 字段 not in (select 字段 from 右表);

求右表无交集
select B.字段 from 左表 A right join 右表 B on A.字段 = B.字段 where A.字段 is null;

select 字段 from 右表 where 字段 not in (select 字段 from 左表);

求多表的无交集
select A.字段 from (select distinct 字段 from 左表 union all select distinct 字段 from 右表) A group by A.字段 having count(A.字段)=1;

1
2
3
4
5
6
7
8
9
10
11
12
13

select distinct store_name from location where (store_name) not in ( select store_name from laozi);

#子查询`select store_name from store_info`从"store_info"表中选择所有的店铺名称。
#主查询`select distinct store_name from location`从"location"表中选择所有不重复的店铺名称。
#使用`where (store_name) not in`条件将主查询中的店铺名称过滤掉那些在子查询结果中出现的店铺名称。

1
2
3
4
5
6

select distinct A.store_name from location A left join laozi B using (store_name) where B.store_name is NULL;

#使用`left join`将"location"表（作为左表，记为A）和"store_info"表（作为右表，记为B）按照店铺名称进行连接。
#使用`using (store_name)`条件指定以店铺名称为连接的字段。
#使用`where B.store_name is NULL`条件过滤掉在连接结果中，店铺名称在"location"表中出现但在"store_info"表中没有匹配的记录。
#最后，使用`distinct`关键字来返回不重复的店铺名称。


1
2
3
4
5
6
7
8

select A.store_name from (select distinct store_name from location union all select distinct store_name from laozi) as A group by A.store_name having count(*)=1;

#子查询`select distinct store_name from location`从"location"表中选择所有不重复的店铺名称。
#子查询`select distinct store_name from store_info`从"store_info"表中选择所有不重复的店铺名称。
#使用`union all`将两个子查询的结果合并。
#将合并结果作为临时表A，并使用`as A`来给临时表起一个别名。
#在临时表A的基础上，使用`group by A.store_name`对店铺名称进行分组。
#使用`having count(*) = 1`筛选出出现次数为1的店铺名称。

1
2
3
4
5
6
7
8
9

四、SQL语句执行顺序

FROM
<left table>

ON
<join_condition>
<join_type>

JOIN
<right_table>

WHERE
<where condition>

GROUP BY
<group_by_list>

HAVING
<having_condition>

SELECT

DISTINCT
<select list>

ORDER BY
<order_by_condition>

LIMIT
<limit number>

########################################################################################################
在SQL中，一般而言，SQL查询语句的执行顺序如下：

1. FROM：指定要查询的数据表或视图。
2. JOIN：根据指定的条件连接多个表。
3. WHERE：基于指定的条件筛选出符合要求的行。
4. GROUP BY：按照指定的列进行分组。
5. HAVING：对分组后的结果进行条件筛选。
6. SELECT：选择要返回的列。
7. DISTINCT：去除重复的行。
8. ORDER BY：按照指定的列进行排序。
9. LIMIT/OFFSET：限制返回的结果数量和起始位置。

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
34
35
36
37
38
39
40
41
42
43

小结

```go
order by 字段 ASC|DESC                 #排序
group by 字段                          #分组
group by 字段 having 条件表达式        #根据group by分组后的结果再进行条件过滤

表连接
inner join    内连接，只返回两个表的字段相等的行记录
left join     左连接，返回左表所有的行记录和右表字段相等的行记录，不相等的行返回NULL
right join    右连接，返回右表所有的行记录和左表字段相等的行记录，不相等的行返回NULL
union         联集，将两个select查询语句的结果合并，并去重
union all     联集，将两个select查询语句的结果合并，不去重


求交集
select A.字段 from 左表 A inner join 右表 B on A.字段 = B.字段;
select A.字段 from 左表 A inner join 右表 B using(同名字段);

select A.字段 from 左表 A, 右表 B where A.字段 = B.字段;

select A.字段 from 左表 A where A.字段 in (select B.字段 from 右表 B);

select A.字段 from 左表 A left join 右表 B on A.字段 = B.字段 where B.字段 is not null;
select B.字段 from 左表 A right join 右表 B on A.字段 = B.字段 where A.字段 is not null;


求左表无交集
select A.字段 from 左表 A left join 右表 B on A.字段 = B.字段 where B.字段 is null;

select 字段 from 左表 where 字段 not in (select 字段 from 右表);

求右表无交集
select B.字段 from 左表 A right join 右表 B on A.字段 = B.字段 where A.字段 is null;

select 字段 from 右表 where 字段 not in (select 字段 from 左表);

求多表的无交集
select A.字段 from (select distinct 字段 from 左表 union all select distinct 字段 from 右表) A group by A.字段 having count(A.字段)=1;

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
34
35
36
37
38
39

1