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)