1、mysql查询的五种子句mysql
where子句（条件查询）：按照“条件表达式”指定的条件进行查询。sql
group by子句（分组）：按照“属性名”指定的字段进行分组。group by子句一般和count()、sum()等聚合函数一块儿使用。数据库
having子句（筛选）：有group by才能having子句，只有知足“条件表达式”中指定的条件的才可以输出。express
order by子句（排序）：按照“属性名”指定的字段进行排序。排序方式由“asc”和“desc”两个参数指出，默认是按照“asc”来排序，即升序。函数
limit（限制结果集）。post
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 |
要检索的行数 |
否 |
2、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后的内层查询能查出数据，则表示存在；为空则不存在。
3、链接查询
学习链接查询，先了解下"笛卡尔积"，看下百度给出的解释：
在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。表之间做联合查询便是做笛卡尔乘积，好比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;
链接查询总结：
一、在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。链接查询便是做笛卡尔积，好比A表有1W条数据，B表有1W条数据，那么两表查询就有1W X 1W = 100W 条数据
二、若是在两张表里有相同字段，作联合查询的时候，要区别表名，不然会报错误(ambiguous 模糊不清)
三、全相乘效率低，全相乘会在内存中生成一个很是大的数据(临时表)，由于有不少没必要要的数据。
若是一张表有10000条数据，另外一张表有10000条数据，两表全相乘就是100W条数据，是很是消耗内存的。
并且，全相乘不能好好的利用索引，由于全相乘生成一张临时表，临时表里是没有索引的，大大下降了查询效率。
四、左链接查询时，以左表为主表，会将左表全部数据查询出来；左表不动，右表根据条件去一条条匹配，若是没有知足条件的记录，则右边返回NULL。
右链接查询值，以右表为主表，会将右表全部数据查询出来，右表不动，左表则根据条件去匹配，若是左表没有知足条件的行，则左边返回NULL。
左右链接是能够互换的：A left join B == B right join A (都是以A为主表) 。
左右链接既然能够互换，出于移植兼容性方面的考虑，尽可能使用左链接。
五、链接查询时，虽然说也是读取一行行记录，而后判断是否知足条件，可是，链接查询使用了索引，条件列创建了索引的话，查询速度很是快，因此总体效率相比于全相乘要快得多，全相乘是没有使用索引的。
使用链接查询，查询速度快，消耗内存小，并且使用了索引。链接查询效率相比于全相乘的查询效率快了10+倍以上。
六、内链接查询，就是取左链接和右链接的交集，若是两边不能匹配条件，则都不取出。
七、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。
八、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)