一、mysql查询的五种子句
where子句（条件查询）：按照“条件表达式”指定的条件进行查询。
group by子句（分组）：按照“属性名”指定的字段进行分组。group by子句通常和count()、sum()等聚合函数一起使用。
having子句（筛选）：有group by才能having子句，只有满足“条件表达式”中指定的条件的才能够输出。
order by子句（排序）：按照“属性名”指定的字段进行排序。排序方式由“asc”和“desc”两个参数指出，默认是按照“asc”来排序，即升序。
limit（限制结果集）。
1、where——基础查询
where常用运算符：
| 运算符 |
说明 |
| 比较运算符 |
|
| < |
小于 |
| <= |
小于或等于 |
| = |
等于 |
| != 或<> |
不等于 |
| >= |
大于等于 |
| > |
大于 |
| in |
在某集合内 |
| between |
在某范围内 |
| 逻辑运算符 |
|
| not 或! |
逻辑非 |
| or 或|| |
逻辑或 |
| and 或&& |
逻辑与 |
2、group by 分组
“Group By”从字面意义上理解就是根据“By”指定的规则对数据进行分组，所谓的分组就是将一个“数据集”划分成若干个“小区域”，然后针对若干个“小区域”进行数据处理。
select类别, sum(数量) as数量之和 from A groupby类别
注：group by语句中select指定的字段必须是“分组依据字段”，其他字段若想出现在select中则必须包含在聚合函数中。
mysql中五种常用的聚合函数：
（1）max(列名)：求最大值。
（2）min(列名)：求最小值。
（2）sum(列名)：求和。
（4）avg(列名)：求平均值。
（5）count(列名)：统计记录的条数。
3、having
having子句可以让我们筛选成组后的各种数据，where子句在聚合前先筛选记录，也就是说作用在group by和having子句前。而having子句在聚合后对组记录进行筛选。
示例：
select类别, sum(数量) as数量之和from A groupby类别 havingsum(数量) >18
示例：Having和Where的联合使用方法
select类别, SUM(数量)from A where数量>8 groupby类别 havingSUM(数量) >10
where和having的区别：
作用的对象不同。WHERE 子句作用于表和视图，HAVING 子句作用于组。
WHERE 在分组和聚集计算之前选取输入行（因此，它控制哪些行进入聚集计算），而HAVING 在分组和聚集之后选取分组的行。因此，WHERE 子句不能包含聚集函数； 因为试图用聚集函数判断那些行输入给聚集运算是没有意义的。相反，HAVING 子句总是包含聚集函数。（严格说来，你可以写不使用聚集的HAVING 子句，但这样做只是白费劲。同样的条件可以更有效地用于WHERE 阶段。）
在上面的例子中，我们可以在WHERE 里应用数量字段来限制，因为它不需要聚集。这样比在HAVING 里增加限制更加高效，因为我们避免了为那些未通过WHERE 检查的行进行分组和聚集计算。
综上所述：
having一般跟在group by之后，执行记录组选择的一部分来工作的。where则是执行所有数据来工作的。
再者having可以用聚合函数，如having sum(qty)>1000
例子：where + group by + having + 函数综合查询
练习表：
查询出两门及两门以上不及格者的平均成绩(注意是所有科目的平均成绩)
错误情况1：题意理解错误，理解成查出不及格科目的平均成绩。
错误情况2：count()不正确，SQL错误。
count(a),无论a是什么，都只是数一行；count时，每遇到一行，就数一个a，跟条件无关！
正解：count(score<60)达不到想要的结果，并不是条件的问题，而是无论count()里的表达式是什么都会数一行。score<60 返回1 或0；所以可以用sum(score<60)来计算不及格的科目数！
4、order by 排序
（1）order by price //默认升序排列
（2）order by price desc //降序排列
（3）order by price asc //升序排列，与默认一样
（4）order by rand() //随机排列，效率不高
5、limit
limit [offset,] N
offset 偏移量，可选，不写则相当于limit 0,N
N 取出条目
示例：取价格第4-6高的商品
select good_id,goods_name,goods_price from goods orderby good_price desc limit 3,3;
总结：
select子句顺序
| 子句 |
说明 |
是否必须使用 |
| select |
要返回的列或表示式 |
是 |
| form |
从中检索数据的表 |
仅在从表选择数据时使用 |
| where |
行级过滤 |
否 |
| group by |
分组说明 |
仅在按组计算聚集时使用 |
| having |
组级过滤 |
否 |
| order by |
输出排序顺序 |
否 |
| limit |
要检索的行数 |
否 |
二、mysql子查询
1、where型子查询（把内层查询结果当作外层查询的比较条件）
（1）查询id最大的一件商品(使用排序+分页实现)
SELECT goods_id,goods_name,shop_price FROM goods ORDERBY goods_id DESC LIMIT 1;
（2）查询id最大的一件商品(使用where子查询实现)
SELECT goods_id,goods_name,shop_price FROM goods WHERE goods_id = (SELECTMAX(goods_id) FROM goods);
（3）查询每个类别下id最大的商品(使用where子查询实现)
SELECT goods_id,goods_name,cat_id,shop_price FROM goods WHERE goods_id IN (SELECTMAX(goods_id) FROM goods GROUPBY cat_id);
2、from型子查询(把内层的查询结果当成临时表，供外层sql再次查询。查询结果集可以当成表看待。临时表要使用一个别名。)
（1）查询每个类别下id最大的商品(使用from型子查询)
SELECT goods_id,goods_name,cat_id,shop_price FROM (SELECT goods_id,goods_name,cat_id,shop_price FROM goods ORDERBY cat_id ASC,goods_id DESC) AS tmp GROUPBY cat_id;
子查询查出的结果集看第二张图，可以看到每个类别的第一条的商品id都为该类别下的最大值。然后将这个结果集作为一张临时表，巧妙的使用group by 查询出每个类别下的第一条记录，即为每个类别下商品id最大。
3、exists型子查询（把外层sql的结果，拿到内层sql去测试，如果内层的sql成立，则该行取出。内层查询是exists后的查询。）
（1）从类别表中取出其类别下有商品的类别(如果该类别下没有商品，则不取出)[使用where子查询]
SELECT c.cat_id,c.cat_name FROM category c WHERE c.cat_id IN (SELECT g.cat_id FROM goods g GROUPBY g.cat_id);
（2）从类别表中取出其类别下有商品的类别(如果该类别下没有商品，则不取出)[使用exists子查询]
SELECT c.cat_id,c.cat_name FROM category c WHEREEXISTS (SELECT1FROM goods g WHERE g.cat_id = c.cat_id);
exists子查询，如果exists后的内层查询能查出数据，则表示存在；为空则不存在。
三、连接查询
学习连接查询，先了解下"笛卡尔积"，看下百度给出的解释：
在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。表之间作联合查询即是作笛卡尔乘积，比如A表有5条数据，B表有8条数据，如果不作条件筛选，那么两表查询就有5 X 8 = 40 条数据。
先看下用到的测试表基本信息：我们要实现的功能就是查询商品的时候，从类别表将商品类别名称关联查询出来。
行数：类别表14条，商品表4条。
结构：商品表和类别表都有一个cat_id
1、全相乘(不是全连接、连接查询)，全相乘是作笛卡尔积
两表全相乘，就是直接从两张表里查询；从查询的截图看出，总共查出了4 X 14 = 56 条记录，这些记录是笛卡尔乘积的结果，即两两组合；
但我们要的是每个商品信息显示类别名称而已，这里却查出了56条记录，其中有52条记录都是无效的数据，全相乘的查询效率低。
SELECT goods_id,goods_name,cat_name FROM mingoods,category;
如果在两张表里有相同字段，做联合查询的时候，要区别表名，否则会报错误(模糊不清)。
SELECT goods_name,cat_id,cat_name FROM mingoods,category;
添加条件，使两表关联查询，这样查出来就是商品和类别一一对应了。虽然这里查出来4条记录，但是全相乘效率低，全相乘会在内存中生成一个非常大的数据(临时表)，因为有很多不必要的数据。
如果一张表有10000条数据，另一张表有10000条数据，两表全相乘就是100W条数据，是非常消耗内存的。而且，全相乘不能好好的利用索引，因为全相乘生成一张临时表，临时表里是没有索引的，大大降低了查询效率。
SELECT g.goods_name,g.cat_id AS g_cat_id, c.cat_id AS c_cat_id, c.cat_name FROM mingoods g, category c WHERE g.cat_id = c.cat_id;
2、左连接查询left join ... on ...
语法：
select A.filed, [A.filed2, .... ,] B.filed, [B.filed4...,]from<lefttable>as A leftjoin<righttable>as B on<expression>
假设有A、B两张表，左连接查询即A表在左不动，B表在右滑动，A表与B表通过一个关系来关联行，B表去匹配A表。
2.1、先来看看on后的条件恒为真的情况
SELECT g.goods_name,g.cat_id, c.cat_id ,c.cat_name FROM mingoods g LEFTJOIN category c ON1;
跟全相乘相比，从截图可以看出，总记录数仍然不变，还是4 X 14 = 56 条记录。但这次是商品表不动，类别表去匹配，因为每次都为真，所以将所有的记录都查出来了。左连接，其实就可以看成左表是主表，右表是从表。
2.2 、根据cat_id使两表关联行
SELECT g.goods_name,g.cat_id,c.cat_id,c.cat_name FROM mingoods g LEFTJOIN category c ON g.cat_id = c.cat_id;
使用左连接查询达到了同样的效果，但是不会有其它冗余数据，查询速度快，消耗内存小，而且使用了索引。左连接查询效率相比于全相乘的查询效率快了10+倍以上。
左连接时，mingoods表(左表)不动，category表(右表)根据条件去一条条匹配，虽说category表也是读取一行行记录，然后判断cat_id是否跟mingoods表的相同，但是，左连接使用了索引，cat_id建立了索引的话，查询速度非常快，所以整体效率相比于全相乘要快得多，全相乘没有使用索引。
2.3、查询出第四个类别下的商品，要求显示商品名称
SELECT g.goods_name,g.cat_id,c.cat_name,g.shop_price FROM goods g LEFTJOIN category c ON g.cat_id = c.cat_id WHERE g.cat_id =4;
2.4 、对于左连接查询，如果右表中没有满足条件的行，则默认填充NULL。
SELECT g.goods_name,g.cat_id AS g_cat_id, c.cat_id AS c_cat_id,c.cat_id FROM mingoods g LEFTJOIN mincategory c ON g.cat_id = c.cat_id;
3、右连接查询right join ... on ...
语法：
select A.field1,A.field2,..., B.field3,B.field4 from<lefttable> A rightjoin<righttable> B on<expression>
右连接查询跟左连接查询类似，只是右连接是以右表为主表，会将右表所有数据查询出来，而左表则根据条件去匹配，如果左表没有满足条件的行，则左边默认显示NULL。左右连接是可以互换的。
SELECT g.goods_name,g.cat_id AS g_cat_id, c.cat_id AS c_cat_id,c.cat_name FROM mingoods g RIGHTJOIN mincategory c ON g.cat_id = c.cat_id;
4、内连接查询inner join ... on ...
语法：
select A.field1,A.field2,.., B.field3, B.field4 from<lefttable> A innerjoin<righttable> B on<expression>
内连接查询，就是取左连接和右连接的交集，如果两边不能匹配条件，则都不取出。
SELECT g.goods_name,g.cat_id, c.*from mingoods g INNERJOIN mincategory c ON g.cat_id = c.cat_id;
5、全连接查询full join ... on ...
语法：
select ... from<lefttable>fulljoin<righttable>on<expression>
全连接会将两个表的所有数据查询出来，不满足条件的为NULL。
全连接查询跟全相乘查询的区别在于，如果某个项不匹配，全相乘不会查出来，全连接会查出来，而连接的另一边则为NULL。
6、联合查询union
语法：
select A.field1 as f1, A.field2 as f2 from<table1> A union (select B.field3 as f1, field4 as f2 from<table2> B)
union是求两个查询的并集。union合并的是结果集，不区分来自于哪一张表，所以可以合并多张表查询出来的数据。
6.1、将两张表的数据合并查询出来
SELECT id, content, userFROM comment UNION (SELECT id, msg AS content, userFROM feedback);
6.2、union查询，列名不一致时，以第一条sql语句的列名对齐
SELECT id, content, userFROM comment UNION (SELECT id, msg, userFROM feedback);
6.3、使用union查询会将重复的行过滤掉
SELECT content,userFROM comment UNION (SELECT msg, userFROM feedback);
6.4、使用union all查询所有，重复的行不会被过滤
SELECT content,userFROM comment UNIONALL (SELECT msg, userFROM feedback);
6.5、union查询，如果列数不相等，会报列数不相等错误
6.6、union 后的结果集还可以再做筛选
SELECT id,content,userFROM comment UNIONALL (SELECT id, msg, userFROM feedback) ORDERBY id DESC;
union查询时，order by放在内层sql中是不起作用的；因为union查出来的结果集再排序，内层的排序就没有意义了；因此，内层的order by排序，在执行期间，被mysql的代码分析器给优化掉了。
(SELECT id,content,userFROM comment ORDERBY id DESC) UNIONALL (SELECT id, msg, userFROM feedback ORDERBY id DESC);
order by 如果和limit一起使用，就显得有意义了，就不会被优化掉。
( SELECT goods_name,cat_id,shop_price FROM goods WHERE cat_id =3ORDERBY shop_price DESC LIMIT 3 )
UNION
( SELECT goods_name,cat_id,shop_price FROM goods WHERE cat_id =4ORDERBY shop_price DESC LIMIT 2 );
6.7、练习
SELECT name, SUM(money) FROM ( ( SELECT*FROM A ) UNIONALL ( SELECT*FROM B ) ) tmp GROUPBY name;
连接查询总结：
1、在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。连接查询即是作笛卡尔积，比如A表有1W条数据，B表有1W条数据，那么两表查询就有1W X 1W = 100W 条数据
2、如果在两张表里有相同字段，做联合查询的时候，要区别表名，否则会报错误(ambiguous 模糊不清)
3、全相乘效率低，全相乘会在内存中生成一个非常大的数据(临时表)，因为有很多不必要的数据。
如果一张表有10000条数据，另一张表有10000条数据，两表全相乘就是100W条数据，是非常消耗内存的。
而且，全相乘不能好好的利用索引，因为全相乘生成一张临时表，临时表里是没有索引的，大大降低了查询效率。
4、左连接查询时，以左表为主表，会将左表所有数据查询出来；左表不动，右表根据条件去一条条匹配，如果没有满足条件的记录，则右边返回NULL。
右连接查询值，以右表为主表，会将右表所有数据查询出来，右表不动，左表则根据条件去匹配，如果左表没有满足条件的行，则左边返回NULL。
左右连接是可以互换的：A left join B == B right join A (都是以A为主表) 。
左右连接既然可以互换，出于移植兼容性方面的考虑，尽量使用左连接。
5、连接查询时，虽说也是读取一行行记录，然后判断是否满足条件，但是，连接查询使用了索引，条件列建立了索引的话，查询速度非常快，所以整体效率相比于全相乘要快得多，全相乘是没有使用索引的。
使用连接查询，查询速度快，消耗内存小，而且使用了索引。连接查询效率相比于全相乘的查询效率快了10+倍以上。
6、内连接查询，就是取左连接和右连接的交集，如果两边不能匹配条件，则都不取出。
7、MySql可以用union(联合查询)来查出左连接和右连接的并集。
union查询会过滤重复的行，union all 不会过滤重复的行。
union查询时，union之间的sql列数必须相等，列名以第一条sql的列为准；列类型可以不一样，但没太大意义。
union查询时，order by放在内层sql中是不起作用的；因为union查出来的结果集再排序，内层的排序就没有意义了；因此，内层的order by排序，在执行期间，被mysql的代码分析器给优化掉了。
但是，order by 如果和limit一起使用，就显得有意义了，会影响最终结果集，就不会被优化掉。order by会根据最终是否会影响结果集而选择性的优化。
注：union和union all的区别，union会去掉重复的记录，在结果集合并后悔对新产生的结果集进行排序运算，效率稍低，union all直接合并结果集，如果确定没有重复记录，建议使用union all。
8、LEFT JOIN 是LEFT OUTER JOIN 的缩写，同理，RIGHT JOIN 是RIGHT OUTER JOIN 的缩写；JOIN 是INNER JOIN 的缩写。
关联查询
1、使用join关键字关联查询
（1）、内连接（inner join）
连接两张表，连接条件使用on关键字，内连接只会显示匹配的数据记录。
eg:查询学生姓名、科目、分数
select a.name 姓名,b.subject 科目,b.score 分数from student a innerjoin score b on a.id = b.sid;
（2）、左连接（left join）
返回左表中所有记录以及右表中符合连接条件的所有记录。
eg: 使用左连接查询学生姓名、科目、分数
select a.name 姓名,b.subject 科目,b.score 分数from student a leftjoin score b on a.id = b.sid;
（3）、右连接（right join）
返回右表中所有记录以及左表中符合连接条件的所有记录。
eg:使用右连接查询学生姓名、科目、分数
select a.name 姓名,b.subject 科目,b.score 分数from student a rightjoin score b on a.id = b.sid;
注：内外连接区别：内连接只会显示匹配的数据记录，外连接例如左连接会把左边表中所有记录显示出来，即使在右边表中没有匹配记录也会显示左表的数据，右连接反之。
2、使用表和表之间相同id关联查询
这种关联方式和内连接一样，只会显示出匹配的数据
select a.name 姓名,b.subject 科目,b.score 分数from student a,score b where a.id = b.sid;
MySQL —— 简单查询与按条件查询
在MySQL中从数据表中查询数据的基本语句时select语句。
select语句基本语法格式：
select 查询内容
from 表名
where 表达式
group by 字段名
having 表达式
order by 字段名
limit 记录数
每一个select语句由多个子句组成。
1. from 表名 指定是从那张表中查询
2. select 查询内容
查询所有字段 select * from 表名；
*通配符：表示所有字段
mysql>select*from test;
+------+------+------+
| id | name | age |
+------+------+------+
|1| A |4|
|2| B |7|
|3| C |5|
|4| D |12|
+------+------+------+
4 rows inset (0.06 sec)
查询部分字段 select 字段名from 表名；
mysql>select name from test;
+------+
| name |
+------+
| A |
| B |
| C |
| D |
+------+
4 rows inset (0.00 sec)
在MySQL表中，每个字段的数据可以当做变量处理。
查询所需的某个字段数据处理后的结果：select 字段处理方式from 表名；
mysql>select age-3from test;
+-------+
| age-3|
+-------+
|1|
|4|
|2|
|9|
+-------+
4 rows inset (0.11 sec)
3. where 表达式 (按条件查询)
在MySQL的表查询时，往往并不是需要将所有内容全部查出，而是根据实际需求，查询所需数据
select 查询内容from 表名where 表达式；
在MySQL语句中，条件表达式是指select语句的查询条件，在where子句中可以使用关系运算符连
接操作数作为查询条件对数据进行选择。
关系运算符：
= 等于
<> 不等于
!= 不等于
< 小于
> 大于
<= 小于等于
>= 大于等于
例如查询年龄大于5的信息
mysql>select*from test where age >5;
+------+------+------+
| id | name | age |
+------+------+------+
|2| B |7|
|4| D |12|
+------+------+------+
2 rows inset (0.04 sec)
带in的关键字查询
查询某个指定集合内的记录select 查询内容from 表名where 条件in(指定内容);
mysql>select*from test where age in (5, 12);
+------+------+------+
| id | name | age |
+------+------+------+
|3| C |5|
|4| D |12|
+------+------+------+
2 rows inset (0.00 sec)
带有between and 关健字查询
查询某个在给定范围内的记录 select 查询内容from 表名where 条件between 值1 and 值2；
mysql>select*from test where age between5and12;
+------+------+------+
| id | name | age |
+------+------+------+
|2| B |7|
|3| C |5|
|4| D |12|
+------+------+------+
3 rows inset (0.07 sec)
查询某些为空NULL 或非空的记录 select 查询内容from 表名where 条件is(not) NULL；
mysql>select*from test where age isNULL;
+------+------+------+
| id | name | age |
+------+------+------+
|6| F |NULL|
+------+------+------+
1 row inset (0.00 sec)
在查询时过滤掉重复的值：select distinct 字段名from 表名；字段名表示要过滤重复记录的字段
mysql>select num from a;
+------+
| num |
+------+
|5|
|10|
|15|
|10|
|15|
|5|
|10|
+------+
7 rows inset (0.00 sec)
mysql>selectdistinct num from a;
+------+
| num |
+------+
|5|
|10|
|15|
+------+
3 rows inset (0.00 sec)
在使用distinct指定多个字段时，只有被指定的这些字段的值都相同，才会被认为是重复的
在查询具有一类相同特征的数据时，需要用到模糊查询，这是就需要使用like关键字
select 查询内容from 表名where 内容(not) like ‘匹配的字符串’
百分号通配符%：表示匹配任意长度的任意字符串
mysql>select name from name;
+------+
| name |
+------+
|1112|
|1122|
|1222|
|2111|
+------+
4 rows inset (0.00 sec)
mysql>select name from name where name like'11%';
+------+
| name |
+------+
|1112|
|1122|
+------+
2 rows inset (0.00 sec)
下划线通配符_ :表示匹配任意单个字符，如果需要匹配多个字符，则需要使用多个_
mysql>select name from name where name like'11__';
+------+
| name |
+------+
|1112|
|1122|
+------+
2 rows inset (0.00 sec)
如果需要查询带有 % 或_ 的数据，由于% 和_ 是通配符，则需要使用 \ 进行转义
\% 表示%，\_ 表示_
有时在查询时为了查询结果更加精确，需要多个限条件，这时就需要 and(&&) 来连接条件
mysql>select cat_id, cat_name, parent_id from category;
+--------+---------------------------+-----------+
| cat_id | cat_name | parent_id |
+--------+---------------------------+-----------+
|1|手机类型|0|
|2| CDMA手机|1|
|3| GSM手机|1|
|4| 3G手机|1|
|5|双模手机|1|
|6|手机配件|0|
|7|充电器|6|
|8|耳机|6|
|9|电池|6|
|11|读卡器和内存卡|6|
|12|充值卡|0|
|13|小灵通/固话充值卡|12|
|14|移动手机充值卡|12|
|15|联通手机充值卡|12|
+--------+---------------------------+-----------+
14 rows inset (0.00 sec)
mysql>select cat_id, cat_name, parent_id from category
->where cat_id >7and parent_id =6;
+--------+-----------------------+-----------+
| cat_id | cat_name | parent_id |
+--------+-----------------------+-----------+
|8|耳机|6|
|9|电池|6|
|11|读卡器和内存卡|6|
+--------+-----------------------+-----------+
3 rows inset (0.05 sec)
有时在查询时，只需要数据满足某些条件中的某一个，这时就需要使用 or(||) 来连接条件
mysql>select cat_id, cat_name, parent_id from category where cat_id =3or cat_id =9;
+--------+-----------+-----------+
| cat_id | cat_name | parent_id |
+--------+-----------+-----------+
|3| GSM手机|1|
|9|电池|6|
+--------+-----------+-----------+
2 rows inset (0.02 sec)
注意：在查询时，and 的优先级高于or
聚合函数：
count()函数：统计记录条数select count(记录) from 表名
mysql>select*from test;
+------+------+------+
| id | name | age |
+------+------+------+
|1| A |4|
|2| B |7|
|3| C |5|
|4| D |12|
|5| E |0|
|6| F |NULL|
+------+------+------+
6 rows inset (0.01 sec)
mysql>selectcount(name) from test;
+-------------+
|count(name) |
+-------------+
|6|
+-------------+
1 row inset (0.09 sec)
sum()函数：计算表中某个字段值的总和，select sum(字段名) from 表名
mysql>selectsum(age) from test;
+----------+
|sum(age) |
+----------+
|28|
+----------+
1 row inset (0.00 sec)
avg()函数：计算表中某个字段的平均值select avg(字段名) from 表名
mysql>selectavg(age) from test;
+----------+
|avg(age) |
+----------+
|5.6000|
+----------+
1 row inset (0.00 sec)
max()函数：返回表中某个字段中的最大值
mysql>selectmax(age) from test;
+----------+
|max(age) |
+----------+
|12|
+----------+
1 row inset (0.04 sec)
min()函数：返回表中某个字段中的最小值
mysql>selectmin(age) from test;
+----------+
|min(age) |
+----------+
|0|
+----------+
1 row inset (0.00 sec)
在对数据表中的数据进行统计时，需要将数据按照一定的特征分组统计，此时就需
要使用分组查询 select 查询内容from 表名group by 分组依据[having表达式条件]
mysql>select*from test;
+------+------+------+-------+
| id | name | age | class |
+------+------+------+-------+
|1| A |4|1|
|2| B |7|1|
|3| C |5|1|
|4| D |12|2|
|5| E |0|2|
|6| F |8|3|
+------+------+------+-------+
6 rows inset (0.00 sec)
mysql>selectmax(age) from test groupby class;
+----------+
|max(age) |
+----------+
|7|
|12|
|8|
+----------+
3 rows inset (0.03 sec)
对查询结果进行排序
select 查询内容from 表名order by 排序条件asc/desc，asc表示升序desc表示降序
mysql>select name, age from test orderby age asc;
+------+------+
| name | age |
+------+------+
| E |0|
| A |4|
| C |5|
| B |7|
| F |8|
| D |12|
+------+------+
6 rows inset (0.00 sec)
mysql>select name, age from test orderby age desc;
+------+------+
| name | age |
+------+------+
| D |12|
| F |8|
| B |7|
| C |5|
| A |4|
| E |0|
+------+------+
限制查询：
在查询时，可能需要只显示部分数据，这是需要限制查出来的数据数量
select 查询内容from 表名limit 偏移量m 记录数n，表示从第m+1个记录开始查询出n条记录
mysql>select name, age from test orderby age asc limit 2, 2;
+------+------+
| name | age |
+------+------+
| C |5|
| B |7|
+------+------+
2 rows inset (0.00 sec)
where 与having：
where 与having关键字都用于设置条件表达式对查询结果进行过滤，区别是having后面可以跟聚合
函数，而where不能，通常having关键字都与group by 一起使用，表示对分组后的数据进行过滤