mysql基础查询语法

一、mysql查询的五种子句

where子句(条件查询):按照“条件表达式”指定的条件进行查询。

group by子句(分组):按照“属性名”指定的字段进行分组。group by子句通常和count()、sum()等聚合函数一起使用。

having子句(筛选):有group by才能having子句,只有满足“条件表达式”中指定的条件的才能够输出。

order by子句(排序):按照“属性名”指定的字段进行排序。排序方式由“asc”和“desc”两个参数指出,默认是按照“asc”来排序,即升序。

limit(限制结果集)。

1where——基础查询

where常用运算符:


运算符


说明


比较运算符


<


小于


<=


小于或等于


=


等于


!= 或<>


不等于


>=


大于等于


>


大于


in


在某集合内


between


在某范围内


逻辑运算符


not 或!


逻辑非


or 或||


逻辑或


and 或&&


逻辑与

2group
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(列名):统计记录的条数。

3having

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

wherehaving的区别:

作用的对象不同。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)来计算不及格的科目数!

4order
by
排序

(1)order
by price  //默认升序排列
(2)order
by price desc //降序排列
(3)order
by price asc //升序排列,与默认一样
(4)order
by rand() //随机排列,效率不高

5limit

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子查询

1where型子查询(把内层查询结果当作外层查询的比较条件)

(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);

2from型子查询(把内层的查询结果当成临时表,供外层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最大。

3exists型子查询(把外层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.2union查询,列名不一致时,以第一条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.5union查询,如果列数不相等,会报列数不相等错误

6.6union 后的结果集还可以再做筛选

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/descasc表示升序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 一起使用,表示对分组后的数据进行过滤

原文地址:https://www.cnblogs.com/duanlinxiao/p/10383013.html

时间: 2024-08-09 10:53:58

mysql基础查询语法的相关文章

mysql基础查询

#进阶1:基础查询/*语法:select:查询列表 from 表名; 类似于:System.out.println(打印的东西); 特点:1.查询列表可以是:表中的字段.常量值.表达式.函数2.查询的结果是一个虚拟的表格*/USE myemployees #1.查询表中的单个字段SELECT last_name FROM employees; #2.查询表中的多个字段SELECT last_name,salary,email FROM employees; #3.查询表中的所有字段SELECT

MySQL 基础查询

6月业绩榜 名次   伙伴 业绩 签单 面谈 每日目标 1 杜艳花 12367 2 0 查看目标 2 郑东杰 2345 1 0 查看目标 3 黄传龙 345 1 1 查看目标 4 测试 0 0 0 查看目标 5 李夏 0 0 0 查看目标 6 王恪 0 0 1 查看目标 7 陈爽 0 0 0 查看目标 当我拿到以上业务需求时,我就立即在想SQL语句该怎样写. 试了简单的表左右链接查询left join right join,显然问题没有这么简单,数据查询有误,后来得到大鸟指点,记录下. sele

MySQL联合查询语法内联、左联、右联、全联

MySQL联合查询效率较高,以下例子来说明联合查询(内联.左联.右联.全联)的好处: T1表结构(用户id,用户名,密码)   userid   username  password 1   jack jackpwd    2   owen   owenpwd T2表结构(用户id,用户积分,用户等级)   userid(int)   jifen   dengji     1    20   3       3    50    6 第一:内联( inner join )如果想把用户信息.积分.

mysql分页查询语法

一.limit语法 SELECT * FROM table LIMIT [offset,] rows | rows OFFSET offset LIMIT 子句可以被用于强制 SELECT 语句返回指定的记录数.LIMIT 接受一个或两个数字参数.参数必须是一个整数常量.如果给定两个参数,第一个参数指定第一个返回记录行的偏移量,第二个参数指定返回记录行的最大数目. 初始记录行的偏移量是 0(而不是 1); mysql> SELECT * FROM table LIMIT 5,10; // 检索记

MySQL基础实用语法

查看mysql版本version(): 创建数据库 create database dpname: 删除数据库 drop database dbname; 查看当前用户 select user(); 查看当前所在库 select database(); 查看当前所有数据库show databases;打开指定库use 库名:查看当前库的所有表show tables:查看其他库的所有表show tables from 库名:创建表creat table 表明(    列名 列类型,    ....

mysql中的基础查询 练习

#进阶1:基础查询 /* 语法: select 查询列表 from 表名; 类似于:System.out.println(打印东西); 特点: 1.查询列表可以是:表中的字段.常量值.表达式.函数 2.查询的结果是一个虚拟的表格 */ USE myemployees; #1.查询表中的单个字段 SELECT last_name FROM employees; #2.查询表中的多个字段 SELECT last_name,salary,email FROM employees; #3.查询表中的所有

01_MySQL DQL_基础查询

DQL,Data Query Language,数据查询 # 基础查询/*语法:select 查询列表 from 表名: 特点:1.查询列表可以是:表中的字段,常量值.表达式.函数,也可以是多个组合2.查询结果是1个虚拟表格,供查看*/USE myemployees; #1.查询表中的单个字段SELECT last_name FROM employees; #2.查询表中的多个字段SELECT last_name,salary,email FROM employees; #3.查询表中的所有字段

【转】mysql基础汇总

mysql基础知识语法汇总整理(二)  原文:https://www.cnblogs.com/cxx8181602/p/9525950.html 连接数据库操作 /*连接mysql*/ mysql -h 地址 -P 端口 -u 用户名 -p 密码 例如: mysql -h 127.0.0.1 -P 3306 -u root -p **** /*退出mysql*/ exit;   数据库操作 #数据库操作 /*关键字:create 创建数据库(增)*/ create database 数据库名 [

MySQL基础知识清单

学习大纲(★为重点,√其次) 一.为什么要学习数据库 二.数据库的相关概念 DBMS.DB.SQL 三.数据库存储数据的特点 四.初始MySQL MySQL产品的介绍 MySQL产品的安装 ★ MySQL服务的启动和停止 ★ MySQL服务的登录和退出 ★ MySQL的常见命令和语法规范 五.DQL语言的学习 ★ 基础查询 ★ 条件查询 ★ 排序查询 ★ 常见函数 ★ 分组函数 ★ 分组查询 ★ 连接查询 ★ 子查询 √ 分页查询 ★ union联合查询 √ 六.DML语言的学习 ★ 插入语句