文章目录
 
前言
之前的总结
Select
Select+聚合函数
总数
最大值
最小值
求和
平均值
     
Select+case...when...then语句
select+top
   
   
from(表)+连接查询
from+inner join
from+left join
from+right join
   
   
Where（条件语句查询）
比较运算符
模糊查询
范围查询
空判断
优先级
   
   
group by(分组)
group by+聚合函数
group by+having
   
   
Order by（排序）
 

 
前言
 
在一级项目组时，监控服务器的同时，总结了一下SQL关于查询的语句，希望能给大家带来一些帮助
 推荐两个博客，下面借鉴了这两个
 菜鸟教程
 网上大佬的
 
之前的总结
 

 这次在之前的基础上扩展一些内容，分别在字句的后面扩展更多的表达式或者函数。
 
 下面会用到一级中具体某个表，会有说明
 
Select
 
Select+聚合函数
 
总数
 
count(*)表示计算总行数，括号中写星与列名，结果相同
 例1.查询登录系统学总数
 
select count(*) from StudentBindPaperTypeEntity
 
最大值
 
max(列)求此列的最大值
 例2.求下表的最大编号
 
select max(StudentID) from StudentBindPaperTypeEntity
 
最小值
 
min(列)求此列的最小值
 例3.求下表编号最小编号
 
select min(StudentID) from StudentBindPaperTypeEntity
 
求和
 
sum(列)求此列之和（注:sum运算符与数字类型连用）
 例4.查询当前在线的学生(IsUse=0表示未在线，1表示在线)
 
select SUM(IsUse) from StudentBindPaperTypeEntity
 
平均值
 
avg(列) 表示求此列的平均值（注：avg运算符与数字类型连用）
 例5：查询学生编号的平均数
 
select avg(StudentID) from StudentBindPaperTypeEntity
 
Select+case…when…then语句
 
case…when…then语句，相当于编程语言中if判断
 例1根据IsUser字段查询学生是否在线
 
select a.StudentID,
	(case a.IsUse 
	when '0' then '未在线' 
	when '1' then '在线' else '未上传' end) as 在线情况
from StudentBindPaperTypeEntity as a
 
显示情况：
 
 
select+top
 
top：取表中前多少的数据
 例1.取出表中第几行数据（如第一行）
 
select top 1 * from StudentBindPaperTypeEntity
 
例2.取出表中百分之多少数据
 
select top 50 percent * from StudentBindPaperTypeEntity 
 
from(表)+连接查询
 
连接查询
 
内连接：Inner join
左连接：Left join
右连接：Right join
 
例子中涉及的表
 
StudentInfoEntity：全校学生的信息
ScoreEntity：学生考试的成绩(并不全包含全校学生)
 
from+inner join
 

 例1.查出这两个表中共有的信息(as为表的别名，方便)
 
select score.studentID,score.score,s.CollegeID,s.major,s.majorClass
from ScoreEntity as score inner join StudentInfoEntity as s on score.studentID=s.studentID 
where score.CollegeID=02
 
显示结果
 
 
from+left join
 

 左外连接：左表的值会全部显示出来，右表的值显示on条件搜索的的结果，搜索不到为NULL
 例1两个表作左外连接
 
select score.studentID,score.score,s.CollegeID,s.major,s.majorClass
from  StudentInfoEntity as s left join ScoreEntity as score on s.studentID=score.studentID 
 
显示结果：（个别）
 
 
from+right join
 

 右外连接与左外连接相反（右表的值全部显示出来）
 例1两个表做右外连接
 
select score.studentID,score.score,s.CollegeID,s.major,s.majorClass
from  ScoreEntity as score  right join StudentInfoEntity as s on s.studentID=score.studentID 
 
现在两个表换了位置，结果是一样的
 
 
Where（条件语句查询）
 
 
比较运算符
 
例1.查询学号>18832650890的学生
 
select * from StudentBindPaperTypeEntity where StudentID>18832650890
 
例2.查询学号!=18832650890的学生(<>同效)
 
select * from StudentBindPaperTypeEntity where StudentID!=18832650890
 
模糊查询
 
like
 %表示任意多个字符
 例1.查询1月8号考试的学生
 
select * from StudentBindPaperTypeEntity where TimeTamp like '2020-01-08%'
 
例2.查询不是1月8号考试的学生
 
select * from StudentBindPaperTypeEntity where TimeTamp not like '2020-01-08%'
 
范围查询
 
in关键字为非连续查询
 例1.查询两个不相邻的学号的学生
 
select * from StudentBindPaperTypeEntity where StudentID in('19100142001','19100142006')
 
Between…and…为连续查询(注：sql软件情况不一样，可能不包含and后的值)
 例2.查询两个学号之间的学生
 
select * from StudentBindPaperTypeEntity where StudentID Between 19100142001 and 19100142006
 
空判断
 
is null判断为空
 例1.查询没有试卷的学生
 
select * from StudentBindPaperTypeEntity where PaperType is null
 
is not null 判断非空
 例2.查询有试卷的学生
 
select * from StudentBindPaperTypeEntity where PaperType is not null
 
优先级
 
优先级由高到低的顺序为：小括号，not，比较运算符，逻辑运算符
 and比or先运算，如果同时出现并希望先算or，需要结合()使用
 
group by(分组)
 
作用：将字段间一对多的关系，向一的方向靠拢分组
 例1.查出参加考试有几个学院
 
select CollegeID  from StudentBindPaperTypeEntity group by CollegeID
 
显示结果：
 
 
group by+聚合函数
 
例2.查出各个学院参加考试的人数
 
select CollegeID, count(StudentID) from StudentBindPaperTypeEntity group by CollegeID 
 
显示结果：
 
 其实group by + 聚合函数是从group by + group_concat()演变过来的，SqlServer不支持这个函数
 
group by+having
 
having的作用跟where子句功能一样，只不过having只用在group by
 例3.查出学院ID大于10的学院
 
select CollegeID  from StudentBindPaperTypeEntity group by CollegeID having CollegeID>10
 
显示结果：
 
 
Order by（排序）
 
排序查询语法：
 
select * from 表名 order by 列1 asc|desc [,列2 asc|desc,...]
 
如果列1的值相同，则按照列2排序，以此类推
asc从小到大
desc从大到小
 
例1.根据学院分组ID降序(desc)
 
select CollegeID  from StudentBindPaperTypeEntity group by CollegeID order by CollegeID desc
 

 例2.将上表升序(asc)
 
select CollegeID  from StudentBindPaperTypeEntity group by CollegeID order by CollegeID asc
 

SQL查询语句中的 limit 与 offset 的区别：
 
 
limit y 分句表示: 读取 y 条数据
 
 
limit x, y 分句表示: 跳过 x 条数据，读取 y 条数据
 
 
limit y offset x 分句表示: 跳过 x 条数据，读取 y 条数据
 
 
比如分页获取数据：
 
第1页： 跳过0条数据，获取20条数据 (即1~20条)
 
select * from testtable limit 0, 20; 
select * from testtable limit 20 offset 0;  
 
第2页： 跳过20条数据，获取20条数据 (即21~40条)
 
select * from testtable limit 20, 20; 
select * from testtable limit 20 offset 20;  
 
第3页： 跳过40条数据，获取20条数据 (即41~60条)
 
select * from testtable limit 40, 20;  
select * from testtable limit 20 offset 40;   
 
[END]

小伙伴想精准查找自己想看的MySQL文章？喏 → MySQL专栏目录 | 点击这里
 
 
 
SQL 查询的执行顺序是怎样的？
 
 
好像这个问题应该很好回答，毕竟自己已经写了无数个 SQL 查询了，有一些还很复杂的。还装不了这个逼了？！
 
 
但事实是，我仍然很难确切地说出它的顺序是怎样的。
 
 
言归正传，SELECT语句的完整语法如下：
 
1. SELECT 
2. DISTINCT <select_list>
3. FROM <left_table>
4. <join_type> JOIN <right_table>
5. ON <join_condition>
6. WHERE <where_condition>
7. GROUP BY <group_by_list>
8. HAVING <having_condition>
9. ORDER BY <order_by_condition>
10.LIMIT <limit_number>
 
 
 
 
 
然而其执行顺序却是：
 
 
 
FROM
 <表名> # 笛卡尔积
ON
 <筛选条件> # 对笛卡尔积的虚表进行筛选
JOIN <join, left join, right join...> 
 <join表> # 指定join，用于添加数据到on之后的虚表中，例如left join会将左表的剩余数据添加到虚表中
WHERE
 <where条件> # 对上述虚表进行筛选
GROUP BY
 <分组条件> # 分组
 <SUM()等聚合函数> # 用于having子句进行判断，在书写上这类聚合函数是写在having判断里面的
HAVING
 <分组筛选> # 对分组后的结果进行聚合筛选
SELECT
 <返回数据列表> # 返回的单列必须在group by子句中，聚合函数除外
DISTINCT
 # 数据除重
ORDER BY
 <排序条件> # 排序
LIMIT
 <行数限制>
 
 
其实，引擎在执行上述每一步时，都会在内存中形成一张虚拟表，然后对虚拟表进行后续操作，并释放没用的虚拟表的内存，以此类推。
具体解释：（注：下面“VT”表示 → 虚拟表 virtual ）
 
 from：select * from table_1, table_2; 与 select * from table_1 join table_2; 的结果一致，都是表示求笛卡尔积；用于直接计算两个表笛卡尔积，得到虚拟表VT1，这是所有select语句最先执行的操作，其他操作时在这个表上进行的，也就是from操作所完成的内容
on: 从VT1表中筛选符合条件的数据，形成VT2表；
join: 将该 join 类型的数据补充到VT2表中，例如 left join 会将左表的剩余数据添加到虚表VT2中，形成VT3表；若表的数量大于2，则会重复1-3步；
where: 执行筛选，（不能使用聚合函数）得到VT4表；
group by: 对VT4表进行分组，得到VT5表；其后处理的语句，如select，having，所用到的列必须包含在group by条件中，没有出现的需要用聚合函数；
having: 筛选分组后的数据，得到VT6表；
select: 返回列得到VT7表；
distinct: 用于去重得到VT8表；
order by: 用于排序得到VT9表；
limit: 返回需要的行数，得到VT10；
 
 
需要注意的是：
 
 
group by条件中，每个列必须是有效列，不能是聚合函数；
null值也会作为一个分组返回；
除了聚合函数，select子句中的列必须在group by条件中；
 

上述内容让我们知道一个查询会返回什么，同时，也回答了以下这些问题：
 
可以在 GRROUP BY 之后使用 WHERE 吗？（不行，GROUP BY 是在 WHERE 之后！）
可以对窗口函数返回的结果进行过滤吗？（不行，窗口函数是 SELECT 语句里，而 SELECT 是在 WHERE 和 GROUP BY 之后）
可以基于 GROUP BY 里的东西进行 ORDER BY 吗？（可以，ORDER BY 基本上是在最后执行的，所以可以基于任何东西进行 ORDER BY）
LIMIT 是在什么时候执行？（在最后！）
但是，数据库引擎并不一定严格按照这个顺序执行 SQL 查询，因为为了更快地执行查询，它们会做出一些优化，这些问题会在下方进行解释↓↓↓。
 

 SQL中的别名会影响SQL执行顺序么？
 
如下方SQL所示：
 
SELECT CONCAT(first_name, ' ', last_name) AS full_name, count(*)
FROM table
GROUP BY full_name
 
从这个语句来看，好像 GROUP BY 是在 SELECT 之后执行的，因为它引用了 SELECT 中的一个别名。但实际上不一定要这样，数据库引擎会把查询重写成这样↓↓↓：
 
SELECT CONCAT(first_name, ' ', last_name) AS full_name, count(*)
FROM table
GROUP BY CONCAT(first_name, ' ', last_name)
 
所以，这样 GROUP BY 仍然先执行。
 
另外，数据库引擎还会做一系列检查，确保 SELECT 和 GROUP BY 中的东西是有效的，所以会在生成执行计划之前对查询做一次整体检查。
 
 
 
数据库很可能不按正常顺序执行查询（优化）
 

 在实际当中，数据库不一定会按照 JOIN、WHERE、GROUP BY 的顺序来执行查询，因为它们会进行一系列优化，把执行顺序打乱，从而让查询执行得更快，只要不改变查询结果。
 
这个查询说明了为什么需要以不同的顺序执行查询：
 
SELECT * FROM
dept d LEFT JOIN student s ON d.student_id = s.id
WHERE s.name = '陈哈哈'
 

 如果只需要找出名字叫“陈哈哈”的学生信息，那就没必要对两张表的所有数据执行左连接，在连接之前先进行过滤，这样查询会快得多，而且对于这个查询来说，先执行过滤并不会改变查询结果。
  
 
能看到这里的朋友都是有缘人了，为你的学习力点赞！希望大佬也能为小弟点赞支持一下哦！
 

sql查询两张表不同的数据及sql查询语句优化，
 
方法一（推荐）
 
 WITH   C AS ( SELECT   Name
               FROM     ConsumerCouponApply A
               WHERE    NOT EXISTS ( SELECT 1
                                         FROM   ConsumerCouponApply B
                                         WHERE  B.Name = A.Name
                                         GROUP BY B.Name )
               GROUP BY A.Name
             )
    SELECT  COUNT(1)
    FROM    C
 
方法二
 
WITH    C AS ( SELECT   A.Name
               FROM     ConsumerCouponApply A
               GROUP BY A.Name
               EXCEPT
               SELECT   B.Name
               FROM     ConsumerCouponApply B
               GROUP BY B.Name
             )
    SELECT  COUNT(1)
    FROM    C
 
方法三
 
    SELECT  COUNT(A.Name)
    FROM    ConsumerCouponApply A
            LEFT JOIN ConsumerCouponApply B ON A.Name = B.Name
    WHERE   B.ID IS NULL
 
方法四
 
      WITH    C AS ( SELECT   A.Name
                   FROM     ConsumerCouponApply A
                   WHERE    ( SELECT    COUNT(1)
                              FROM      ConsumerCouponApply B
                              WHERE     B.Name = A.Name
                              GROUP BY  B.Name
                            ) IS NULL
                   GROUP BY A.Name
                 )
        SELECT  COUNT(1)
        FROM    C
 
依次查询响应时间：