MySQL——单表查询

select  select_list                                                                 //要查询的内容，选择哪些列

from   数据表名                                                                   //指定数据表

where  primary_constraint                                                   //查询时需要满足的条件，行必须满足的条件

group  by   grouping_columns                                             //如何对结果进行分组

order  by    sorting_columns                                                //如何对结果进行排序

having  secondary_constraint                                              //查询时满足的第二条件

limit  count                                                                            //限定输出的查询结果

1.  查询所有字段

    a.  在 SELECT  语句中使用星号（*）通配符查询所有字段    

    使用 SELECT 查询记录最简单的形式是从一个表中检索所有记录，实现的方法是用星号（*）通配符指定查找所有的列，语法格式如下:

    SELECT  *  FROM  表名；

【例】从 fruits 表中检索所有字段的数据

mysql> SELECT * FROM fruits;
+------+------+------------+---------+
| f_id | s_id | f_name     | f_price |
+------+------+------------+---------+
| a1   |  101 | apple      |    5.20 |
| a2   |  103 | apricot    |    2.20 |
| b1   |  101 | blackberry |   10.20 |
| b2   |  104 | berry      |    7.60 |
| b5   |  107 | xxxx       |    3.60 |
| bs1  |  102 | orange     |   11.20 |
| bs2  |  105 | melon      |    8.20 |
| c0   |  101 | cherry     |    3.20 |
| l2   |  104 | lemon      |    6.40 |
| m1   |  106 | mango      |   15.60 |
| m2   |  105 | xbabay     |    2.60 |
| m3   |  105 | xxtt       |   11.60 |
| o2   |  103 | coconut    |    9.20 |
| t1   |  102 | blanana    |   10.30 |
| t2   |  102 | grape      |    5.30 |
| t4   |  107 | xbababa    |    3.60 |
+------+------+------------+---------+

    b.  在 SELECT 语句中指定所有字段

    根据前面 SELECT  语句的格式，SELECT 关键字后面的字段名为将要查找的数据，因此可以将表中所有学段的名称写在 SELECT 子句后面，如果忘记了字段名称，可以用  DESC  命令查看表的结构。

    【例】从 fruits 表中检索所有字段的数据，SQL 语句如下：

mysql> SELECT f_id,s_id, f_name ,f_price  FROM  fruits;
+------+------+------------+---------+
| f_id | s_id | f_name     | f_price |
+------+------+------------+---------+
| a1   |  101 | apple      |    5.20 |
| a2   |  103 | apricot    |    2.20 |
| b1   |  101 | blackberry |   10.20 |
| b2   |  104 | berry      |    7.60 |
| b5   |  107 | xxxx       |    3.60 |
| bs1  |  102 | orange     |   11.20 |
| bs2  |  105 | melon      |    8.20 |
| c0   |  101 | cherry     |    3.20 |
| l2   |  104 | lemon      |    6.40 |
| m1   |  106 | mango      |   15.60 |
| m2   |  105 | xbabay     |    2.60 |
| m3   |  105 | xxtt       |   11.60 |
| o2   |  103 | coconut    |    9.20 |
| t1   |  102 | blanana    |   10.30 |
| t2   |  102 | grape      |    5.30 |
| t4   |  107 | xbababa    |    3.60 |
+------+------+------------+---------+

    【注】 一般情况下，除非需要使用表中所有的字段数据，否则最好不要使用通配符，使用通配符虽然可以节省输入查询语句的时间，但是获取不需要的列數据通常会降低查询和所使用的应用程序的效率。使用通配符的优势是，当不知道所需要的列的名称时，可以用送配符来代替。

2.  查询指定字段

    a.  查询单个字段

     查询表中的某一个字段的语法格式如下:

     SELECT  列名  FROM 表名;

    【例】查询 fruits 表中 f_name 列的所有水果名称。

mysql> SELECT  f_name FROM  fruits;
+------------+
| f_name     |
+------------+
| apple      |
| apricot    |
| blackberry |
| berry      |
| xxxx       |
| orange     |
| melon      |
| cherry     |
| lemon      |
| mango      |
| xbabay     |
| xxtt       |
| coconut    |
| blanana    |
| grape      |
| xbababa    |
+------------+

    b.  查询多个字段

     使用 SELECT 声明，可以获取多个宁段中的数据，方法是在关键字 SELECT 后面指定要查找的字段的名称，不同的字段名称之间用逗号 (，) 分隔，最后一个字段后面不需要加逗号，语法格式如下:

    SELECT   字段名1，字段名2，…，字段名n   FROM 表名；

【例】从 fruits 表中获取 f_name 和 f_price  两列中的数据。SQL 语句如下：

mysql> SELECT  f_name,f_price  FROM  fruits;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| apple      |    5.20 |
| apricot    |    2.20 |
| blackberry |   10.20 |
| berry      |    7.60 |
| xxxx       |    3.60 |
| orange     |   11.20 |
| melon      |    8.20 |
| cherry     |    3.20 |
| lemon      |    6.40 |
| mango      |   15.60 |
| xbabay     |    2.60 |
| xxtt       |   11.60 |
| coconut    |    9.20 |
| blanana    |   10.30 |
| grape      |    5.30 |
| xbababa    |    3.60 |
+------------+---------+

3.  查询指定记录

    数据库中包含大量的数据，根据特殊要求，可能只需要查询表中的指定数据，即对数据进行过滤。在  SELECT  语句中，通过  WHERE  子句可以对数据进行过滤，语法格式如下：

    SELECT   字段名1，字段名2，…，字段名n

    FROM  表名

    WHERE  查询条件

                                                              WHERE 条件判断符

运算符	名称	示例	运算符	名称	示例
=	等于	id=5	Is not null		Id is not null
>	大于	id>5	Between		Id between 1 and 15
<	小于	id>5	in		Id in (3,4,5)
>=	大于等于	id>=5	Not in		Name not in (shi,li)
<=	小于等于	id<=5	Like	模式匹配	Name like (" shi%")
!=或<>	不等于	id!=5	not like	模式匹配	Name like (" shi%")
Is null		id is null	Regexp	常规表达式	Name 正则表达式

    【例】查询价格为 10.2 元的水果的名称，SQL 语句如下：

mysql> SELECT  f_name,f_price
    -> FROM  fruits
    -> WHERE  f_price = 10.2;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| blackberry |   10.20 |
+------------+---------+

    【例】查找名为 apple 的水果的价格，SQL  语句如下：

mysql> SELECT  f_name,f_price
    -> FROM  fruits
    -> WHERE  f_name= 'apple';
+--------+---------+
| f_name | f_price |
+--------+---------+
| apple  |    5.20 |
+--------+---------+

    【例】查询价格小于 10 元的水果名称。SQL  语句如下：

mysql> SELECT  f_name,f_price
    -> FROM  fruits
    -> WHERE  f_price<10.00;
+---------+---------+
| f_name  | f_price |
+---------+---------+
| apple   |    5.20 |
| apricot |    2.20 |
| berry   |    7.60 |
| xxxx    |    3.60 |
| melon   |    8.20 |
| cherry  |    3.20 |
| lemon   |    6.40 |
| xbabay  |    2.60 |
| coconut |    9.20 |
| grape   |    5.30 |
| xbababa |    3.60 |
+---------+---------+

4.  带  IN  关键字的查询

    IN  操作符用来查询满足指定范围的记录，使用  IN  操作符时，将所有检索条件用括号括起来，检索条件之间用逗号分隔，只要满足条件范围内的一个值即为匹配项。

    【例】查询 s_id  为  101 和 102 的记录。SQL 语句如下：

mysql> SELECT s_id, f_name,f_price
    -> FROM  fruits
    -> WHERE  s_id  IN (101,102)
    -> ORDER BY f_name;
+------+------------+---------+
| s_id | f_name     | f_price |
+------+------------+---------+
|  101 | apple      |    5.20 |
|  101 | blackberry |   10.20 |
|  102 | blanana    |   10.30 |
|  101 | cherry     |    3.20 |
|  102 | grape      |    5.30 |
|  102 | orange     |   11.20 |
+------+------------+---------+

    【例】查询 所有 s_id  不等于  101 也不等于102 的记录。SQL 语句如下：

mysql> SELECT s_id, f_name,f_price
    -> FROM  fruits
    -> WHERE  s_id  NOT IN (101,102)
    -> ORDER BY f_name;
+------+---------+---------+
| s_id | f_name  | f_price |
+------+---------+---------+
|  103 | apricot |    2.20 |
|  104 | berry   |    7.60 |
|  103 | coconut |    9.20 |
|  104 | lemon   |    6.40 |
|  106 | mango   |   15.60 |
|  105 | melon   |    8.20 |
|  107 | xbababa |    3.60 |
|  105 | xbabay  |    2.60 |
|  105 | xxtt    |   11.60 |
|  107 | xxxx    |    3.60 |
+------+---------+---------+

5.  带 BETWEEN   AND  的范围查询

    BETWEEN AND  用来查询某个范围内的值，该操作符需要两个参数，即范围的开始值和结束值。如果字段值满足指定的范围查询条件，则这些记录被返回。

    【例】查询价格在 2.00 元到  10.2 元之间的水果名称和价格。SQL 语句如下：

mysql> SELECT  f_name,f_price
    -> FROM  fruits
    -> WHERE  f_price  BETWEEN 2.00 AND 10.20;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| apple      |    5.20 |
| apricot    |    2.20 |
| blackberry |   10.20 |
| berry      |    7.60 |
| xxxx       |    3.60 |
| melon      |    8.20 |
| cherry     |    3.20 |
| lemon      |    6.40 |
| xbabay     |    2.60 |
| coconut    |    9.20 |
| grape      |    5.30 |
| xbababa    |    3.60 |
+------------+---------+

       BETWEEN AND  操作符前可以加关键字 NOT，表示指定范围之外的值，如果字段不满足指定的范围，则这些记录被返回。

    【例】查询价格在 2.00 元到  10.2 元之外的水果名称和价格。SQL 语句如下：

mysql> SELECT  f_name,f_price
    -> FROM  fruits
    -> WHERE  f_price NOT BETWEEN 2.00 AND 10.20;
+---------+---------+
| f_name  | f_price |
+---------+---------+
| orange  |   11.20 |
| mango   |   15.60 |
| xxtt    |   11.60 |
| blanana |   10.30 |
+---------+---------+

6.  带 LIKE 的字符匹配查询

    通配符是一种在SQL 的 WHERE 条件子句中拥有特殊意义的字符，SQL 语句中支持多种通配符，可以和 LIKE 一起使用的通配符有“%”和“_”。

    a.  百分号通配符（%）

     百分号通配符（%），可以匹配任意长度的字符，甚至包括空字符。

    【例】查找所有已“b”字母开头的水果。SQL 语句如下;

mysql> SELECT f_id ,f_name
    -> FROM  fruits
    -> WHERE  f_name LIKE 'b%';
+------+------------+
| f_id | f_name     |
+------+------------+
| b1   | blackberry |
| b2   | berry      |
| t1   | blanana    |
+------+------------+

【例】在  fruits 表中，查询 f_name 中包含字母“g”的记录，SQL 语句如下：

mysql> SELECT f_id, f_name
    -> FROM  fruits
    -> WHERE  f_name LIKE '%g%';
+------+--------+
| f_id | f_name |
+------+--------+
| bs1  | orange |
| m1   | mango  |
| t2   | grape  |
+------+--------+

    【例】查询以“b”开头，并以“y”结尾的水果的名称。SQL语句如下：

mysql> SELECT f_id, f_name
    -> FROM  fruits
    -> WHERE  f_name LIKE 'b%y';
+------+------------+
| f_id | f_name     |
+------+------------+
| b1   | blackberry |
| b2   | berry      |
+------+------------+

    b.  下划线通配符（_）

    下划线通配符( _ )，一次只能匹配任意一个字符。

    该通配符的用法和“%”相同，区别是“%”可以匹配多个字符，而“_”只能匹配任意单个字符，如果要匹配多个字符,则需要使用相同个数的“_”。

    【例】在 fruits 表中，查询以字母“y”结尾，且“y" 的前面只有4 个字母的记录。SQL 语句如下:

mysql> SELECT f_id,f_name
    -> from fruits
    -> WHERE f_name  LIKE  '____y';
+------+--------+
| f_id | f_name |
+------+--------+
| b2   | berry  |
+------+--------+

7.  空值查询

     创建数据表的时候，设计者可以指定某列中是否可以包含空值( NULL)。空值不同于 0, 也不同于空字符串。空值一般表示数据未知、不适用或将在以后添加数据。在SELECT 语句中使用  IS NULL 子句，可以查询某字段内容为空的记录。

【例】在  fruits 表中查询价格为空的 f_id 和 f_name 

mysql> SELECT f_id,f_name
    -> from fruits
    -> WHERE f_price  IS NULL;
Empty set (0.00 sec)

【例】在  fruits 表中查询价格不为空的 f_id 和 f_name 

mysql> SELECT f_id,f_name
    -> from fruits
    -> WHERE f_price  IS NOT NULL;
+------+------------+
| f_id | f_name     |
+------+------------+
| a1   | apple      |
| a2   | apricot    |
| b1   | blackberry |
| b2   | berry      |
| b5   | xxxx       |
| bs1  | orange     |
| bs2  | melon      |
| c0   | cherry     |
| l2   | lemon      |
| m1   | mango      |
| m2   | xbabay     |
| m3   | xxtt       |
| o2   | coconut    |
| t1   | blanana    |
| t2   | grape      |
| t4   | xbababa    |
+------+------------+

8.  带  AND 的多条件查询

    使用  SELECT 查询时，可以增加查询的限制条件，这样可以使查询的结果更加精确，在  WHERE 子句中使用 AND 操作符可以限定只有满足所有查询条件的记录才会被返回，可以使用 AND 连接两个甚至多个查询条件，多个条件表达式之间用 AND 分开。

    【例】在 fruits  表中查询 s_id=101，并且 f_price 大于等于 5 的水果价格和名称。SQL语句如下:

mysql> SELECT  f_id, f_price, f_name
    -> FROM fruits
    -> WHERE s_id=101  AND  f_price>5;
+------+---------+------------+
| f_id | f_price | f_name     |
+------+---------+------------+
| a1   |    5.20 | apple      |
| b1   |   10.20 | blackberry |
+------+---------+------------+

【例】在 fruits 表中查询 s_id= 101 或者102,且 f_price 大于等于 5, 并且 f_name='apple'  的水果价格和名称。SQL语句如下:

mysql> SELECT  f_id, f_price, f_name
    -> FROM fruits
    -> WHERE  s_id in ('101' ,'102')  AND  f_price >=5  AND f_name = 'apple';
+------+---------+--------+
| f_id | f_price | f_name |
+------+---------+--------+
| a1   |    5.20 | apple  |
+------+---------+--------+

9.  带  OR  的多条件查询

    与 AND 相反，在 WHERE 声明中使用 OR 操作符，表示只需要满足其中一个条件的记录即可返回。OR 也可以连接两个甚至多个查询条件，多个条件表达式之间用 OR 分开。
    【例】查询 s_id=101 或者 s_id=102 的水果供应商的  f_price 和 f_name。SQL 语句如下:

mysql> SELECT  f_id, f_name, f_price
    -> FROM  fruits
    -> WHERE  s_id='101' OR  s_id= '102';
+------+------------+---------+
| f_id | f_name     | f_price |
+------+------------+---------+
| a1   | apple      |    5.20 |
| b1   | blackberry |   10.20 |
| bs1  | orange     |   11.20 |
| c0   | cherry     |    3.20 |
| t1   | blanana    |   10.30 |
| t2   | grape      |    5.30 |
+------+------------+---------+

    OR 操作符告诉 MySQL, 检索的时候只需要满足其中的一个条件，不需要全部都满足，如果这里使用 AND ,将检索不到符合条件的数据。在这里，也 可以使用 IN 操作符实现与 OR 相同的功能。

mysql> SELECT  f_id, f_name, f_price
    -> FROM  fruits
    -> WHERE  s_id IN ('101' ,'102');
+------+------------+---------+
| f_id | f_name     | f_price |
+------+------------+---------+
| a1   | apple      |    5.20 |
| b1   | blackberry |   10.20 |
| bs1  | orange     |   11.20 |
| c0   | cherry     |    3.20 |
| t1   | blanana    |   10.30 |
| t2   | grape      |    5.30 |
+------+------------+---------+

    可以看到，使用  OR 操作符和 IN 操作符结果是一样的，它们可以实现相同的功能，但是使用 IN 操作符可以使检索语句更加简洁明了，并且 IN 执行的速度要快于 OR 。更重要的是，使 IN 操作符，可以执行更加复杂的嵌套查询。
    OR 可以和 AND 一起使用，但是在使用时要注意两者的优先级。由于 AND 的优先级高于 OR，因此会先对  AND 两边的操作数进行操作，再与 OR 中的操作教结合。

10.   查询结果不重复

    SELECT 查询可以返回所有匹配的行。例如，查询 fruits 表中所有的 s_id 值，其结果如下:

mysql> SELECT  s_id
    -> FROM  fruits;
+------+
| s_id |
+------+
|  101 |
|  103 |
|  101 |
|  104 |
|  107 |
|  102 |
|  105 |
|  101 |
|  104 |
|  106 |
|  105 |
|  105 |
|  103 |
|  102 |
|  102 |
|  107 |
+------+

    其中有一些重复的  s_id  值，有时，出于对数据分析的要求，需要消除重复的记录值。

    在  SELECT  语句中，可以使用  DISTINCT  关键字消除重复的记录值，语法格式如下：

    SELECT   DISTINCT   字段名  FROM 表名；

    【例】查询  fruits  表中  s_id  字段的值，返回  s_id  字段值且不得重复。SQL 语句如下：

mysql> SELECT DISTINCT  s_id   FROM  fruits;
+------+
| s_id |
+------+
|  101 |
|  103 |
|  104 |
|  107 |
|  102 |
|  105 |
|  106 |
+------+

11.  对查询结果排序

    MySQL  可以通过在   SELECT  语句中使用  ORDER BY  子句，对查询的结果进行排序。

    a.  单列排序

    【例】  查询  fruits  表中的  f_name  字段值，并对其进行排序。SQL  语句如下：

mysql> SELECT   f_name   FROM  fruits ORDER  BY  f_name;
+------------+
| f_name     |
+------------+
| apple      |
| apricot    |
| berry      |
| blackberry |
| blanana    |
| cherry     |
| coconut    |
| grape      |
| lemon      |
| mango      |
| melon      |
| orange     |
| xbababa    |
| xbabay     |
| xxtt       |
| xxxx       |
+------------+

    b.  多列排序

    对多列数据进行排序时，需要排列的列之间要用逗号隔开。

    【例】  查询  fruits  表中的  f_name  和  f_price  字段，先按  f_name  排序，再按  f_price  排序。SQL语句如下：

mysql> SELECT  f_name  , f_price
    -> FROM  fruits
    -> ORDER by  f_name, f_price;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| apple      |    5.20 |
| apricot    |    2.20 |
| berry      |    7.60 |
| blackberry |   10.20 |
| blanana    |   10.30 |
| cherry     |    3.20 |
| coconut    |    9.20 |
| grape      |    5.30 |
| lemon      |    6.40 |
| mango      |   15.60 |
| melon      |    8.20 |
| orange     |   11.20 |
| xbababa    |    3.60 |
| xbabay     |    2.60 |
| xxtt       |   11.60 |
| xxxx       |    3.60 |
+------------+---------+

    在对多列进行排序的时候，首先排序的第一列必须有相同的列值，才会对第二列进行排序，如果第一列教据中的所有值都是唯一的，并不再对第二列进行排序。

    c.  指定排序方向

    默认情况下，查询数据按字母升序进行排序 (从 A 到 Z），但数据的排序并仅限于此，还可以使用 ORDER BY 对查询结果进行降序排序(从Z 到 A),这可以通过关键字  DESC  实现。
    【例】查询  fruits  表中的f_name 和  f_price 字段，对结果按  f_price 降序方式排序。SQL 语句如下:

mysql> SELECT  f_name  , f_price
    -> FROM  fruits
    -> ORDER by   f_price  DESC;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| mango      |   15.60 |
| xxtt       |   11.60 |
| orange     |   11.20 |
| blanana    |   10.30 |
| blackberry |   10.20 |
| coconut    |    9.20 |
| melon      |    8.20 |
| berry      |    7.60 |
| lemon      |    6.40 |
| grape      |    5.30 |
| apple      |    5.20 |
| xxxx       |    3.60 |
| xbababa    |    3.60 |
| cherry     |    3.20 |
| xbabay     |    2.60 |
| apricot    |    2.20 |
+------------+---------+

    【注】与  DESC 相反的是  ASC(升序排序)，意思是将列中的数据，按宇母表顺序升序排序。实际上，在排序的时候  ASC 是默认的排序方式，所以加不加都可以。

    也可对多列进行不同法人顺序排列

    【例】查询  fruits  表，先按  f_price  降序排序，再按  f_name 字段升序排序。SQL.语句如下:

mysql> SELECT  f_name  , f_price
    -> FROM  fruits
    -> ORDER by   f_price  DESC , f_name;
+------------+---------+
| f_name     | f_price |
+------------+---------+
| mango      |   15.60 |
| xxtt       |   11.60 |
| orange     |   11.20 |
| blanana    |   10.30 |
| blackberry |   10.20 |
| coconut    |    9.20 |
| melon      |    8.20 |
| berry      |    7.60 |
| lemon      |    6.40 |
| grape      |    5.30 |
| apple      |    5.20 |
| xbababa    |    3.60 |
| xxxx       |    3.60 |
| cherry     |    3.20 |
| xbabay     |    2.60 |
| apricot    |    2.20 |
+------------+---------+

12.  分组查询

    分组查询是对数据按照某个或多个字段进行分组，MySQL 中使用  GROUP BY 关键字对数据进行分组，基本语法形式如下：
    [GROUP BY  学段]    [HAVING   <条件表达式>]
    “字段”为进行分组时所依据的列名称;“HAVING  <条件表达式> "   指定满足表达式限定条件的结果将被显示。

    a.  创建分组

     GROUP  BY  关键字通常和集合函数一起使用，如   MAX()、MIN()、COUNT()、SUM()、AVG()。例如，要返回每个水果供应商提供的水果种类，就要在分组过程中用到  COUNT()  函数，把数据分为多个逻辑组，并对每个组进行集合计算。
    【例】根据  s_id   对  fruits 表中的数据进行分组。SQL 语句如下:

mysql> SELECT   s_id,  COUNT(*)  AS  Total   FROM  fruits  GROUP BY s_id;
+------+-------+
| s_id | Total |
+------+-------+
|  101 |     3 |
|  102 |     3 |
|  103 |     2 |
|  104 |     2 |
|  105 |     3 |
|  106 |     1 |
|  107 |     2 |
+------+-------+

    【例】 根据  s_id  对  fruits 表中的数据进行分组，将每个供立商提供的水果品显示出来，SQL语句如下:

mysql> SELECT  s_id , GROUP_CONCAT(f_name) AS Names   FROM  fruits  GROUP BY s_id;
+------+-------------------------+
| s_id | Names                   |
+------+-------------------------+
|  101 | apple,blackberry,cherry |
|  102 | orange,blanana,grape    |
|  103 | apricot,coconut         |
|  104 | berry,lemon             |
|  105 | melon,xbabay,xxtt       |
|  106 | mango                   |
|  107 | xxxx,xbababa            |
+------+-------------------------+

    group_concat()
    
    1、功能：将group by产生的同一个分组中的值连接起来，返回一个字符串结果。
    2、语法：group_concat( [distinct] 要连接的字段 [order by 排序字段 asc/desc  ] [separator '分隔符'] )
说明：通过使用distinct可以排除重复值；如果希望对结果中的值进行排序，可以使用 order by子句；separator是一个字符串值，缺省为一个逗号。

    b.  使用  HAVING  过滤分组

    GROUP  BY  可以和  HAVING  一起限定显示记录所需满足的条件，只有满足条件的分组才会被显示。

    【例】根据  s_id  对  fruits  表中的数据进行分组，并显示水果种类大于1的分组信息。SQL  语句如下：

mysql> SELECT  s_id , GROUP_CONCAT(f_name) AS Names
    -> FROM  fruits
    -> GROUP  BY  s_id  HAVING  COUNT(f_name)>1;
+------+-------------------------+
| s_id | Names                   |
+------+-------------------------+
|  101 | apple,blackberry,cherry |
|  102 | orange,blanana,grape    |
|  103 | apricot,coconut         |
|  104 | berry,lemon             |
|  105 | melon,xbabay,xxtt       |
|  107 | xxxx,xbababa            |
+------+-------------------------+

【注】 HAVING 关键宇与  WHERE  关键宇都是用来过滤数据的，两者有什么区别呢？其中重要的一点是，HAVING 在数据分组之后进行过滤来选择分组，而  WHERE 在分组之前用来选择记录。另外 WHERE  排除的记录不再包括在分组中。

c.  在  GROUP BY 子句中使用  WITH ROLLUP

    使用  WITH ROLLUP 关键字之后，在所有查询出的分组记录之后增加一条记录，计算查询出的所有记录的总和，即统计记录数量。

    【例】根据  s_id  对  fruits 表中的数据进行分组，并显示记录数量。SQL语句如下:

mysql> SELECT  s_id  ,  count(*)  AS  Total
    -> from  fruits
    -> group  by  s_id  with  rollup;
+------+-------+
| s_id | Total |
+------+-------+
|  101 |     3 |
|  102 |     3 |
|  103 |     2 |
|  104 |     2 |
|  105 |     3 |
|  106 |     1 |
|  107 |     2 |
| NULL |    16 |
+------+-------+

    d.  多字段分组

    使用  GROUP BY 可以对多个字段进行分组，GROUP BY 关键字后面跟需要分组的字段。分组层次从左到右，即先按第1个字段分组，然后对第1个字段值相同的记录，再根据第2个字段进行分组，依次类推。

    【例】根据s_id 和 f_name 字段对 fruits 表中的数据进行分组，SQL 语句如下:

mysql> use test_db;
Database changed
mysql> SELECT  *  FROM  fruits
    -> group  by  s_id,f_name;
+------+------+------------+---------+
| f_id | s_id | f_name     | f_price |
+------+------+------------+---------+
| a1   |  101 | apple      |    5.20 |
| b1   |  101 | blackberry |   10.20 |
| c0   |  101 | cherry     |    3.20 |
| t1   |  102 | blanana    |   10.30 |
| t2   |  102 | grape      |    5.30 |
| bs1  |  102 | orange     |   11.20 |
| a2   |  103 | apricot    |    2.20 |
| o2   |  103 | coconut    |    9.20 |
| b2   |  104 | berry      |    7.60 |
| l2   |  104 | lemon      |    6.40 |
| bs2  |  105 | melon      |    8.20 |
| m2   |  105 | xbabay     |    2.60 |
| m3   |  105 | xxtt       |   11.60 |
| m1   |  106 | mango      |   15.60 |
| t4   |  107 | xbababa    |    3.60 |
| b5   |  107 | xxxx       |    3.60 |
+------+------+------------+---------+

    e.  GROUP BY   和  ORDER BY  一起使用

    一起使用可以完成对分组的排序

13.  使用  LIMIT  限制查询结果的数量

    使用  SELECT 返回匹配的行时，如果只需要返回第一行或者前几行，可以使用  LIMIT  关键字，基本语法格式如下:

    LIMIT  [位置偏移量，]  行数

  “位置偏移量”参数指示  MySQL 从哪一行开始显示，是一个可选参数。如果不指定“位置偏移量”，将会从表中的第一条记录开始显示(第一条记录的位置偏移量是 0，第二条记录的位置偏移量是1，依次类推); 参数“行数”指示返回的记录条数。

   

     【例】 显示fruits 表查询结果的前4 行，SQL语句如下:

mysql> SELECT  *  FROM  fruits  LIMIT  4;
+------+------+------------+---------+
| f_id | s_id | f_name     | f_price |
+------+------+------------+---------+
| a1   |  101 | apple      |    5.20 |
| a2   |  103 | apricot    |    2.20 |
| b1   |  101 | blackberry |   10.20 |
| b2   |  104 | berry      |    7.60 |
+------+------+------------+---------+

    可以看到，该语句没有指定返回记录的“位置偏移量”参数，显示结果从第一行开始，“行数”参数为 4.因此返回的结果为表中的前4行记录。

    【例】在  fruits  表中，使用  LIMIT 子句返回从第  5 个记录开始的 3 行记录，SQL语句如下:

mysql> SELECT  *  FROM  fruits  LIMIT  4,3;
+------+------+--------+---------+
| f_id | s_id | f_name | f_price |
+------+------+--------+---------+
| b5   |  107 | xxxx   |    3.60 |
| bs1  |  102 | orange |   11.20 |
| bs2  |  105 | melon  |    8.20 |
+------+------+--------+---------+

    可以看到，上述语句指示  MySQL 返回从第 5 条记录开始的 3 条记录。第一个数字 4 表示从第5行开始( 置偏移量从0 开始，第5 行的位置偏移量为4)，第二个数字3表示返回的行数。
    综上所述，带一个参数的  LIMIT 指定从查询结果的首行开始，唯一的参数表示返回的行数，即  LIMIT n 与 LIMIT 0,n 等价。带两个参数的  LIMIT 可以返回从任何一个位置开始的指定的行数。
    返回第一行时，位置偏移量是0。因此，“LIMIT 1,1”将返回第二行，而不是第一行。