MYSQL---语法4----SELECT（6）_( ):限定选择行必须满足的一个或多个条件;( ):指定用于分组的列或表达式;( ):指定

SELECT

SELECT
{* | <字段列名>}
[
FROM <表 1>, <表 2>…
[WHERE <表达式>
[GROUP BY <group by definition>
[HAVING <expression> [{<operator> <expression>}…]]
[ORDER BY <order by definition>]
[LIMIT[<offset>,] <row count>]
]
1
2
3
4
5
6
7
8
9
10

其中，各条子句的含义如下：

• {*|<字段列名>}包含星号通配符的字段列表，表示查询的字段，其中字段列至少包含一个字段名称，如果要查询多个字段，多个字段之间要用逗号隔开，最后一个字段后不要加逗号。
• FROM <表 1>，<表 2>…，表 1 和表 2 表示查询数据的来源，可以是单个或多个。
• WHERE 子句是可选项，如果选择该项，将限定查询行必须满足的查询条件。
• GROUP BY< 字段 >，该子句告诉 MySQL 如何显示查询出来的数据，并按照指定的字段分组。
• [ORDER BY< 字段 >]，该子句告诉 MySQL按什么样的顺序显示查询出来的数据，可以进行的排序有升序（ASC）和降序（DESC）。
• [LIMIT[，]]，该子句告诉 MySQL 每次显示查询出来的数据条数。

使用 查询表中的全部内容

SELECT * FROM 表名;
1

mysql> select * from tb_students_info;
+----+--------+---------+------+------+--------+------------+
| id | name   | dept_id | age  | sex  | height | login_date |
+----+--------+---------+------+------+--------+------------+
|  1 | Dany   | 1       | 25   | F    | 160    | 2015-09-10 |
|  2 | Green  | 3       | 23   | F    | 158    | 2016-10-22 |
|  3 | Henry  | 2       | 23   | M    | 185    | 2015-05-31 |
|  4 | Jane   | 1       | 22   | F    | 162    | 2016-12-20 |
|  5 | Jim    | 1       | 24   | M    | 175    | 2016-01-15 |
|  6 | John   | 2       | 21   | M    | 172    | 2015-11-11 |
|  7 | Lily   | 6       | 22   | F    | 165    | 2016-02-26 |
|  8 | Susan  | 4       | 23   | F    | 170    | 2015-10-01 |
|  9 | Thomas | 3       | 22   | M    | 178    | 2016-06-07 |
| 10 | Tom    | 4       | 23   | M    | 165    | 2016-08-05 |
+----+--------+---------+------+------+--------+------------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

查询表中指定的字段

SELECT < 列名 > FROM < 表名 >;
1

mysql> SELECT name FROM tb_students_info;
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
+--------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

SELECT <字段名1>,<字段名2>,…,<字段名n> FROM <表名>;
1

mysql> SELECT id, name, height
    -> FROM tb_students_info;
+----+--------+--------+
| id | name   | height |
+----+--------+--------+
|  1 | Dany   | 160    |
|  2 | Green  | 158    |
|  3 | Henry  | 185    |
|  4 | Jane   | 162    |
|  5 | Jim    | 175    |
|  6 | John   | 172    |
|  7 | Lily   | 165    |
|  8 | Susan  | 170    |
|  9 | Thomas | 178    |
| 10 | Tom    | 165    |
+----+--------+--------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

去重

SELECT DISTINCT <字段名> FROM <表名>;
1

mysql> SELECT age
    -> FROM tb_students_info;
+------+
| age  |
+------+
| 25   |
| 23   |
| 23   |
| 22   |
| 24   |
| 21   |
| 22   |
| 23   |
| 22   |
| 23   |
+------+
10 rows in set (0.00 sec)

mysql> SELECT DISTINCT age
    -> FROM tb_students_info;
+------+
| age  |
+------+
| 25   |
| 23   |
| 22   |
| 24   |
| 21   |
+------+
5 rows in set (0.00 sec)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

为表取别名

<表名> [AS] <别名>
1

其中各子句的含义如下：

• <表名>：数据中存储的数据表的名称。 ·
• <别名>：查询时指定的表的新名称。
• AS：关键字为可选参数。

mysql> SELECT stu.name, stu.height
    -> FROM tb_students_info AS stu;
+--------+--------+
| name   | height |
+--------+--------+
| Dany   | 160    |
| Green  | 158    |
| Henry  | 185    |
| Jane   | 162    |
| Jim    | 175    |
| John   | 172    |
| Lily   | 165    |
| Susan  | 170    |
| Thomas | 178    |
| Tom    | 165    |
+--------+--------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

为列取别名的基本语法格式为：

<列名> [AS] <列别名>
1

其中，各子句的语法含义如下：

• <列名>：为表中字段定义的名称。
• <列别名>：字段新的名称。
• AS：关键字为可选参数

mysql> SELECT name AS student_name,
    -> age AS student_age
    -> FROM tb_students_info;
+--------------+-------------+
| student_name | student_age |
+--------------+-------------+
| Dany         | 25          |
| Green        | 23          |
| Henry        | 23          |
| Jane         | 22          |
| Jim          | 24          |
| John         | 21          |
| Lily         | 22          |
| Susan        | 23          |
| Thomas       | 22          |
| Tom          | 23          |
+--------------+-------------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

限制查询结果的记录条数

<LIMIT> [<位置偏移量>,] <行数>
1

LIMIT 接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。

• 第一个参数“位置偏移量”指示 MySQL 从哪一行开始显示，是一个可选参数，如果不指定“位置偏移量”，将会从表中的第一条记录开始（第一条记录的位置偏移量是 0，第二条记录的位置偏移量是 1，以此类推）；
• 第二个参数“行数”指示返回的记录条数。
  前 4 行

mysql> SELECT * FROM tb_students_info LIMIT 4;
+----+-------+---------+------+------+--------+------------+
| id | name  | dept_id | age  | sex  | height | login_date |
+----+-------+---------+------+------+--------+------------+
|  1 | Dany  | 1       | 25   | F    | 160    | 2015-09-10 |
|  2 | Green | 3       | 23   | F    | 158    | 2016-10-22 |
|  3 | Henry | 2       | 23   | M    | 185    | 2015-05-31 |
|  4 | Jane  | 1       | 22   | F    | 162    | 2016-12-20 |
+----+-------+---------+------+------+--------+------------+
4 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10

第 4 条记录开始的行数为 5 的记录

mysql> SELECT * FROM tb_students_info LIMIT 3,5;
+----+-------+---------+------+------+--------+------------+
| id | name  | dept_id | age  | sex  | height | login_date |
+----+-------+---------+------+------+--------+------------+
|  4 | Jane  | 1       | 22   | F    | 162    | 2016-12-20 |
|  5 | Jim   | 1       | 24   | M    | 175    | 2016-01-15 |
|  6 | John  | 2       | 21   | M    | 172    | 2015-11-11 |
|  7 | Lily  | 6       | 22   | F    | 165    | 2016-02-26 |
|  8 | Susan | 4       | 23   | F    | 170    | 2015-10-01 |
+----+-------+---------+------+------+--------+------------+
5 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11

所以，带一个参数的 LIMIT 指定从查询结果的首行开始，唯一的参数表示返回的行数，即“LIMIT n”与“LIMIT 0，n”等价。带两个参数的 LIMIT 可返回从任何位置开始的指定行数的数据。

返回第一行时，位置偏移量是 0。因此，“LIMIT 1，1”返回第 2 行，而不是第 1 行。

ORDER BY：对查询结果进行排序

ORDER BY {<列名> | <表达式> | <位置>} [ASC|DESC]
1

1. 列名
   指定用于排序的列。可以指定多个列，列名之间用逗号分隔。
2. 表达式
   指定用于排序的表达式。
3. 位置
   指定用于排序的列在 SELECT 语句结果集中的位置，通常是一个正整数。
4. ASC|DESC
   关键字 ASC 表示按升序分组，关键字 DESC 表示按降序分组，其中 ASC 为默认值。这两个关键字必须位于对应的列名、表达式、列的位置之后。

使用 ORDER BY 子句应该注意以下几个方面：

• ORDER BY 子句中可以包含子查询。
• 当排序的值中存在空值时，ORDER BY 子句会将该空值作为最小值来对待。
• 当在 ORDER BY 子句中指定多个列进行排序时，MySQL 会按照列的顺序从左到右依次进行排序。
• 查询的数据并没有以一种特定的顺序显示，如果没有对它们进行排序，则将根据插入到数据表中的顺序显示。使用 ORDER BY子句对指定的列数据进行排序。

mysql> SELECT * FROM tb_students_info ORDER BY height;
+----+--------+---------+------+------+--------+------------+
| id | name   | dept_id | age  | sex  | height | login_date |
+----+--------+---------+------+------+--------+------------+
|  2 | Green  | 3       | 23   | F    | 158    | 2016-10-22 |
|  1 | Dany   | 1       | 25   | F    | 160    | 2015-09-10 |
|  4 | Jane   | 1       | 22   | F    | 162    | 2016-12-20 |
|  7 | Lily   | 6       | 22   | F    | 165    | 2016-02-26 |
| 10 | Tom    | 4       | 23   | M    | 165    | 2016-08-05 |
|  8 | Susan  | 4       | 23   | F    | 170    | 2015-10-01 |
|  6 | John   | 2       | 21   | M    | 172    | 2015-11-11 |
|  5 | Jim    | 1       | 24   | M    | 175    | 2016-01-15 |
|  9 | Thomas | 3       | 22   | M    | 178    | 2016-06-07 |
|  3 | Henry  | 2       | 23   | M    | 185    | 2015-05-31 |
+----+--------+---------+------+------+--------+------------+
10 rows in set (0.01 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

mysql> SELECT name, height
    -> FROM tb_students_info
    -> ORDER BY height, name;
+--------+--------+
| name   | height |
+--------+--------+
| Green  | 158    |
| Dany   | 160    |
| Jane   | 162    |
| Lily   | 165    |
| Tom    | 165    |
| Susan  | 170    |
| John   | 172    |
| Jim    | 175    |
| Thomas | 178    |
| Henry  | 185    |
+--------+--------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意：在对多列进行排序时，首行排序的第一列必须有相同的列值，才会对第二列进行排序。如果第一列数据中所有的值都是唯一的，将不再对第二列进行排序。

默认情况下，查询数据按字母升序进行排序（A～Z），但数据的排序并不仅限于此，还可以使用 ORDER BY
对查询结果进行降序排序（Z～A），这可以通过关键字 DESC 实现。可以对多列进行不同的顺序排序。

mysql> SELECT name, height
    -> FROM tb_students_info
    -> ORDER BY height DESC,
    -> name ;
+--------+--------+
| name   | height |
+--------+--------+
| Henry  | 185    |
| Thomas | 178    |
| Jim    | 175    |
| John   | 172    |
| Susan  | 170    |
| Lily   | 165    |
| Tom    | 165    |
| Jane   | 162    |
| Dany   | 160    |
| Green  | 158    |
+--------+--------+
10 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

WHERE：条件查询

WHERE <查询条件> {<判定运算1>，<判定运算2>，…}
1

• 其中，判定运算其结果取值为 TRUE、FALSE 和 UNKNOWN。
  判定运算的语法分类如下：
• <表达式1>{=|<|<=|>|>=|<=>|<>|！=}<表达式2>
• <表达式1>[NOT]LIKE<表达式2>
• <表达式1>[NOT][REGEXP|RLIKE]<表达式2>
• <表达式1>[NOT]BETWEEN<表达式2>AND<表达式3>
• <表达式1>IS[NOT]NULL

单一条件的查询语句

mysql> SELECT name, height
    -> FROM tb_students_info
    -> WHERE height = 170;
+-------+--------+
| name  | height |
+-------+--------+
| Susan | 170    |
+-------+--------+
1 row in set (0.00 sec)
1
2
3
4
5
6
7
8
9

mysql> SELECT name, age
    -> FROM tb_students_info
    -> WHERE age < 22;
+------+------+
| name | age  |
+------+------+
| John | 21   |
+------+------+
1 row in set (0.00 sec)
1
2
3
4
5
6
7
8
9

多条件的查询语句

mysql> SELECT name , age , height
    -> FROM tb_students_info
    -> WHERE age >21 and height >= 175;
+--------+------+--------+
| name   | age  | height |
+--------+------+--------+
| Henry  | 23   | 185    |
| Jim    | 24   | 175    |
| Thomas | 22   | 178    |
+--------+------+--------+
3 rows in set (0.00 sec)

1
2
3
4
5
6
7
8
9
10
11
12

使用 LIKE 的模糊查询

<表达式1> [NOT] LIKE <表达式2>
1

字符串匹配是一种模式匹配，使用运算符 LIKE 设置过滤条件，过滤条件使用通配符进行匹配运算，而不是判断是否相等进行比较。

相互间进行匹配运算的对象可以是 CHAR、VARCHAR、TEXT、DATETIME 等数据类型。运算返回的结果是 TRUE 或 FALSE。

利用通配符可以在不完全确定比较值的情形下创建一个比较特定数据的搜索模式，并置于关键字 LIKE 之后。可以在搜索模式的任意位置使用通配符，并且可以使用多个通配符。MySQL 支持的通配符有以下两种：

1. 百分号（%）
   百分号是 MySQL 中常用的一种通配符，在过滤条件中，百分号可以表示任何字符串，并且该字符串可以出现任意次。
   使用百分号通配符要注意以下几点：

• MySQL 默认是不区分大小写的，若要区分大小写，则需要更换字符集的校对规则。
• 百分号不匹配空值。
• 百分号可以代表搜索模式中给定位置的 0 个、1 个或多个字符。
• 尾空格可能会干扰通配符的匹配，一般可以在搜索模式的最后附加一个百分号。

2. 下划线（_）
   下划线通配符和百分号通配符的用途一样，下画线只匹配单个字符，而不是多个字符，也不是 0 个字符。

注意：不要过度使用通配符，对通配符检索的处理一般会比其他检索方式花费更长的时间。

mysql> SELECT name
    -> FROM tb_students_info
    -> WHERE name LIKE'T%';
+--------+
| name   |
+--------+
| Thomas |
| Tom    |
+--------+
2 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10

mysql> SELECT name
    -> FROM tb_students_info
    -> WHERE name LIKE'%e%';
+-------+
| name  |
+-------+
| Green |
| Henry |
| Jane  |
+-------+
3 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11

mysql> SELECT name
    ->  FROM tb_students_info
    -> WHERE name LIKE'____y';
+-------+
| name  |
+-------+
| Henry |
+-------+
1 row in set (0.00 sec)
1
2
3
4
5
6
7
8
9

日期字段作为条件的查询语句
以日期字段作为条件，可以使用比较运算符设置查询条件，也可以使用 BETWEEN AND 运算符查询某个范围内的值。

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

mysql> SELECT *
    -> FROM tb_students_info
    -> WHERE login_date < '2016-01-01';
+----+-------+---------+------+------+--------+------------+
| id | name  | dept_id | age  | sex  | height | login_date |
+----+-------+---------+------+------+--------+------------+
|  1 | Dany  | 1       | 25   | F    | 160    | 2015-09-10 |
|  3 | Henry | 2       | 23   | M    | 185    | 2015-05-31 |
|  6 | John  | 2       | 21   | M    | 172    | 2015-11-11 |
|  8 | Susan | 4       | 23   | F    | 170    | 2015-10-01 |
+----+-------+---------+------+------+--------+------------+
4 rows in set (0.00 sec)
1
2
3
4
5
6
7
8
9
10
11
12

mysql>  SELECT *
    ->  FROM tb_students_info
    -> WHERE login_date
    -> BETWEEN '2015-10-01'
    -> AND '2016-05-01';
+----+-------+---------+------+------+--------+------------+
| id | name  | dept_id | age  | sex  | height | login_date |
+----+-------+---------+------+------+--------+------------+
|  5 | Jim   | 1       | 24   | M    | 175    | 2016-01-15 |
|  6 | John  | 2       | 21   | M    | 172    | 2015-11-11 |
|  7 | Lily  | 6       | 22   | F    | 165    | 2016-02-26 |
|  8 | Susan | 4       | 23   | F    | 170    | 2015-10-01 |
+----+-------+---------+------+------+--------+------------+
4 rows in set (0.01 sec)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

常用运算符

MySQL 支持 4 种运算符，分别是：

1. 算术运算符
   执行算术运算，例如：加、减、乘、除等。
2. 比较运算符
   包括大于、小于、等于或者不等于，等等。主要用于数值的比较、字符串的匹配等方面。例如：LIKE、IN、BETWEEN AND 和 IS NULL 等都是比较运算符，还包括正则表达式的 REGEXP 也是比较运算符。
3. 逻辑运算符
   包括与、或、非和异或等逻辑运算符。其返回值为布尔型，真值（1 或 true）和假值（0 或 false）。
4. 位运算符
   包括按位与、按位或、按位取反、按位异或、按位左移和按位右移等位运算符。位运算必须先将数据转换为二进制，然后在二进制格式下进行操作,运算完成后，将二进制的值转换为原来的类型，返回给用户。

算术运算符

比较运算符

1. 等于运算符“=”
   等号“=”用来判断数字、字符串和表达式是否相等。如果相等，返回值为 1，否则返回值为 0。
   数据进行比较时，有如下规则：

• 若有一个或两个参数为 NULL，则比较运算的结果为 NULL。
• 若同一个比较运算中的两个参数都是字符串，则按照字符串进行比较。
• 若两个参数均为正数，则按照整数进行比较。
• 若一个字符串和数字进行相等判断，则 MySQL 可以自动将字符串转换成数字。

2. 安全等于运算符“<=>”
   用于比较两个表达式的值。当两个表达式的值中有一个为空值或者都为空值时，将返回 UNKNOWN。

对于运算符“<=>”，当两个表达式彼此相等或都等于空值时，比较结果为 TRUE；若其中一个是空值或者都是非空值但不相等时，则为 FALSE，不会出现 UNKNOWN 的情况。
3) 不等于运算符“<>”或者“!=”
“<>”或者“!=”用于数字、字符串、表达式不相等的判断。如果不相等，返回值为 1；否则返回值为 0。这两个运算符不能用于判断空值（NULL）。
4) 小于或等于运算符“<=”
“<=”用来判断左边的操作数是否小于或等于右边的操作数。如果小于或等于，返回值为 1；否则返回值为 0。“<=”不能用于判断空值。
5) 小于运算符“<”
“<”用来判断左边的操作数是否小于右边的操作数。如果小于，返回值为 1；否则返回值为 0。“<”不能用于判断空值。
6) 大于或等于运算符“>=”
“>=”用来判断左边的操作数是否大于或等于右边的操作数。如果大于或等于，返回值为 1；否则返回值为 0。“>=”不能用于判断空值。
7) 大于运算符“>”
“>”用来判断左边的操作数是否大于右边的操作数。如果大于，返回值为 1；否则返回值为 0。“>”不能用于判断空值。
8) IS NULL（或者 ISNULL）
IS NULL 和 ISNULL 用于检验一个值是否为 NULL，如果为 NULL，返回值为 1；否则返回值为 0。
9) IS NOT NULL
IS NOT NULL 用于检验一个值是否为非 NULL，如果为非 NULL，返回值为 1；否则返回值为 0。
10) BETWEEN AND

<表达式> BETWEEN <最小值> AND <最大值>
1

若<表达式>大于或等于<最小值>，且小于或等于<最大值>，则 BETWEEN 的返回值为 1；否则返回值为 0。
11) LEAST

LEAST(<值1>,<值2>,…,<值n>)

其中，值 n 表示参数列表中有 n 个值。存在两个或多个参数的情况下，返回最小值。若任意一个自变量为 NULL，则 LEAST() 的返回值为 NULL。
12) GREATEST

GREATEST (<值1>,<值2>,…,<值n>)
1

其中，值 n 表示参数列表中有 n 个值。存在两个或多个参数的情况下，返回最大值。若任意一个自变量为 NULL，则 GREATEST() 的返回值为 NULL。
13) IN
IN 运算符用来判断操作数是否为 IN 列表中的一个值。如果是，返回值为 1；否则返回值为 0。
14) NOT IN
NOT IN 运算符用来判断表达式是否为 IN 列表中的一个值。如果不是，返回值为 1；否则返回值为 0。

逻辑运算符

下面分别介绍不同的逻辑运算符的使用方法。

1. NOT 或者 !
   逻辑非运算符 NOT 或者 !，表示当操作数为 0 时，返回值为 1；当操作数为非零值时，返回值为 0；当操作数为 NULL 时，返回值为 NULL。
2. AND 或者 &&
   逻辑与运算符 AND 或者 &&，表示当所有操作数均为非零值并且不为 NULL 时，返回值为 1；当一个或多个操作数为 0 时，返回值为 0；其余情况返回值为 NULL。
3. OR 或者 ||
   逻辑或运算符 OR 或者 ||，表示当两个操作数均为非 NULL 值且任意一个操作数为非零值时，结果为 1，否则结果为 0；当有一个操作数为 NULL 且另一个操作数为非零值时，结果为 1，否则结果为 NULL；当两个操作数均为 NULL 时，所得结果为 NULL。
4. XOR
   逻辑异或运算符 XOR。当任意一个操作数为 NULL 时，返回值为 NULL；对于非 NULL 的操作数，若两个操作数都不是 0 或者都是 0 值，则返回结果为 0；若一个为 0，另一个不为非 0，则返回结果为 1。

位运算符

1. 位或运算符“|”
   位或运算的实质是将参与运算的两个数据按对应的二进制数逐位进行逻辑或运算。若对应的二进制位有一个或两个为 1，则该位的运算结果为 1，否则为 0。
2. 位与运算符“&”
   位与运算的实质是将参与运算的两个数据按对应的二进制数逐位进行逻辑与运算。若对应的二进制位都为 1，则该位的运算结果为 1，否则为 0。
3. 位异或运算符“^”
   位异或运算的实质是将参与运算的两个数据按对应的二进制数逐位进行逻辑异或运算。对应的二进制位不同时，对应位的结果才为 1。如果两个对应位都为 0 或者都为 1，则对应位的结果为 0。
4. 位左移运算符“<<”
   位左移运算符“<<”使指定的二进制值的所有位都左移指定的位数。左移指定位数之后，左边高位的数值将被移出并丢弃，右边低位空出的位置用 0 补齐。
   语法格式为表达式<<n，这里 n 指定值要移位的位数。
5. 位右移运算符“>>”
   位右移运算符“>>”使指定的二进制值的所有位都右移指定的位数。右移指定位数之后，右边高位的数值将被移出并丢弃，左边低位空出的位置用 0 补齐。
   语法格式为表达式>>n，这里 n 指定值要移位的位数。
6. 位取反运算符“~”
   位取反运算符的实质是将参与运算的数据按对应的二进制数逐位反转，即 1 取反后变 0，0 取反后变为 1。