文章目录

一、数据导入指令
二、基本查询语句
- 2.1 SELECT ...
- 2.2 使用 SELECT 语句查询一个数据表
- 2.3 查询表中的一列或多列
三、单表查询
- 3.1 用 DISTINCT 关键字去除结果中的重复行
- 3.2 使用 AS 设置别名
- 3.3 着重号
- 3.4 运算符
- - 3.4.1 算术运算符
  - 3.4.2 比较运算符
  - 3.4.3 逻辑运算符
  - 3.4.4 位运算符(用得较少)
  - 3.4.5 运算符的优先级
- 3.5 用 ORDER BY 关键字对查询结果排序
- 3.6 用 LIMIT 限制查询结果的数量

数据查询是指从数据库中获取所需要的数据，是数据库操作中最常用也是最重要的操作。通过不同的查询方式可以获得不同的数据，用户可以根据自己对数据的需求使用不同的查询方式。在 MySQL 中使用 SELECT 语句来查询数据。本章将对查询语句的基本语法、在单表上查询数据等内容进行详细讲解，帮助读者了解查询数据的语句。

一、数据导入指令

在进行 SELECT 语句学习之前，数据库中需要存在演示数据，在命令行客户端登录 mysql，使用 source 指令导入，如下所示：

SOURCE xxxx.sql(填写你自己的sql脚本路径)
mysql> SOURCE E:\mysql_study.sql
mysql> USE mysql_study;
Database changed
mysql> SHOW TABLES;
+-----------------------+
| Tables_in_mysql_study |
+-----------------------+
| countries             |
| departments           |
| emp_details_view      |
| employees             |
| job_grades            |
| job_history           |
| jobs                  |
| locations             |
| order                 |
| regions               |
| test1                 |
| test2                 |
| test3                 |
+-----------------------+
13 rows in set (0.00 sec)

二、基本查询语句

SELECT 语句是最常用的查询语句，它的使用方式有些复杂，但功能相当强大。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>…，表 1 和表 2 表示查询数据的来源，可以是单个或多个。
WHERE <表达式> 是可选项，如果选择该项，将限定查询数据必须满足该查询条件。
GROUP BY< 字段 >，该子句告诉 MySQL 如何显示查询出来的数据，并按照指定的字段分组。
[ORDER BY< 字段 >]，该子句告诉 MySQL 按什么样的顺序显示查询出来的数据，可以进行的排序有升序(ASC) 和降序(DESC)，默认情况下是升序。
[LIMIT[<offset>，]<row count>]，该子句告诉 MySQL 每次显示查询出来的数据条数。
HAVING <expression>：查询时满足的第二条件。

SELECT 的可选参数比较多，读者可能无法一下完全理解。不要紧，接下来将从最简单的参数开始，一步一步深入学习之后，读者会对各个参数的作用有清晰的认识，下面先介绍 SELECT 语句的简单应用。补充： 学号、姓名、年龄、性别、专业表示列。如下图所示：
在这里插入图片描述
其中使用的子句将在后面逐个介绍。下面先介绍 SELECT 语句的简单应用。

2.1 SELECT …

SELECT 类似于编程语言中的输出语句，如 Python 中 print，如下：

mysql> USE mysql_study;
Database changed
mysql> SELECT 1;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)

mysql> SELECT 1+1;
+-----+
| 1+1 |
+-----+
|   2 |
+-----+
1 row in set (0.00 sec)

mysql> SELECT 1+1 FROM DUAL;#DUAL 相当于一个伪表
+-----+
| 1+1 |
+-----+
|   2 |
+-----+
1 row in set (0.00 sec)

mysql>

2.2 使用 SELECT 语句查询一个数据表

使用 SELECT 语句时，首先要确定要查询的列。* 代表所有的列。例如，查询 mysql_study 数据库 employees 表中的所有数据，SQL 语句如下：

mysql> SELECT * FROM employees;

查询结果如下图所示：
在这里插入图片描述
这是查询整个表中所有列的操作，还可以针对表中的某一列或多列进行查询。

一般情况下，除非需要使用表中所有的字段数据，最好不要使用通配符 *。使用通配符虽然可以节省输入查询语句的时间，但是获取不需要的列数据通常会降低查询和所使用的应用程序的效率。通配符的优势是，当不知道所需要的列的名称时，可以通过它获取它们。在生产环境下，不推荐直接使用 SELECT * 进行查询。

2.3 查询表中的一列或多列

针对表中的多列进行查询，只要在 SELECT 后面指定要查询的列名即可，多列之间用 , 分隔。例如，查询 employees 表中的 employee_id、first_name、last_name 列数据，SQL 语句如下：

SELECT employee_id, first_name, last_name FROM employees;

查询结果如下图所示：
在这里插入图片描述

三、单表查询

单表查询是指从一个表中查询需要的数据，所有查询操作都比较简单。

3.1 用 DISTINCT 关键字去除结果中的重复行

在 MySQL 中使用 SELECT 语句执行简单的数据查询时，返回的是所有匹配的记录。如果表中的某些字段没有唯一性约束，那么这些字段就可能存在重复值。为了实现查询不重复的数据，MySQL 提供了 DISTINCT 关键字。

DISTINCT 关键字的主要作用就是对数据表中一个或多个字段重复的数据进行过滤，只返回其中的一条数据给用户。

使用 DISTINCT 关键字可以去除查询结果中的重复记录，语法格式如下：

SELECT DISTINCT 字段名1,字段名2,字段名3... FROM 表名;

使用 DISTINCT 关键字去除 employees 表中 department_id 字段中的重复记录。SQL 语句如下：

SELECT DISTINCT department_id FROM employees;

查询结果如下图所示：
在这里插入图片描述
使用 DISTINCT 关键字时需要注意以下几点：

DISTINCT 关键字只能在 SELECT 语句中使用
在对一个或多个字段去重时，DISTINCT 关键字必须在所有字段的最前面
如果 DISTINCT 关键字后有多个字段，则会对多个字段进行组合去重，也就是说，只有多个字段组合起来完全是一样的情况下才会被去重

因为 DISTINCT 只能返回它的目标字段，而无法返回其它字段，所以在实际情况中，我们经常使用 DISTINCT 关键字来返回不重复字段的条数。查询 employees 表中 department_id 字段去重之后记录的条数，SQL 语句和运行结果如下：

mysql> SELECT COUNT(DISTINCT department_id) FROM employees;
+-------------------------------+
| COUNT(DISTINCT department_id) |
+-------------------------------+
|                            11 |
+-------------------------------+
1 row in set (0.00 sec)

结果显示，employees 表中对 department_id 字段去重之后有 11 条记录。COUNT() 函数在后续会进行详细讲解，这里不过多进行赘述。

3.2 使用 AS 设置别名

为了查询方便，MySQL 提供了 AS 关键字来为表和字段指定别名。本小节主要讲解如何为表和字段指定一个别名。为表指定别名： 当表名很长或者执行一些特殊查询的时候，为了方便操作，可以为表指定一个别名，用这个别名代替表原来的名称。为表指定别名的基本语法格式为：

<表名> [AS] <别名>
<表名>：数据库中存储的数据表的名称
<别名>：查询时指定的表的新名称
AS关键字可以省略，省略后需要将表名和别名用空格隔开(最好不省略)

下面为 employees 表指定别名 emp，SQL 语句如下：

SELECT last_name FROM employees AS emp;
SELECT last_name FROM employees emp;

为字段指定别名： 在使用 SELECT 语句查询数据时，MySQL 会显示每个 SELECT 后面指定输出的字段。有时为了显示结果更加直观，我们可以为字段指定一个别名。为字段指定别名的基本语法格式为：

<字段名> [AS] <别名>
<字段名>: 为数据表中字段定义的名称。
<字段别名>: 字段新的名称。别名使用双引号，以便在别名中包含空格或特殊的字符并区分大小写。
AS关键字可以省略，省略后需要将字段名和别名用空格隔开

查询 employees 表，为 first_name 指定别名 fname，为 last_name 指定别名 lname，SQL 语句如下：

SELECT first_name AS "fname", last_name AS "lname" FROM employees AS emp;

查询结果如下图所示：
在这里插入图片描述
注意： 表别名只在执行查询时使用，并不在返回结果中显示。而字段定义别名之后，会返回给客户端显示，显示的字段为字段的别名。

3.3 着重号

我们需要保证表中的字段、表名等没有和保留字、数据库系统或常用方法冲突。如果真的相同，请在 SQL 语句中使用一对 ``(着重号) 引起来。错误示范如下：
在这里插入图片描述
正确示范如下：

在 DOS 窗口中看着不太清晰，在 Navicat 中演示，如下图所示：

SELECT 查询还可以对常数进行查询。对的，就是在 SELECT 查询结果中增加一列固定的常数列。这列的取值是我们指定的，而不是从数据表中动态取出的。你可能会问为什么我们还要对常数进行查询呢？

SQL 中的 SELECT 语法的确提供了这个功能，一般来说我们只从一个表中查询数据，通常不需要增加一个固定的常数列，但如果我们想整合不同的数据源，用常数列作为这个表的标记，就需要查询常数。

举例：我们想对 employees 数据表中的员工姓名进行查询，同时增加一列字段 corporation，这个字段固定值为 CSDN，可以这样写：
在这里插入图片描述

3.4 运算符

同其他语言一样，MySQL 数据库也有自己的运算符和流程控制语句。本小节将对 MySQL 的运算符进行详细介绍。

3.4.1 算术运算符

算术运算符是 MySQL 中最常用的一类运算符。MySQL 支持的算术运算符包括加、减、乘、除、求余。下表所示为算术运算符的符号和作用：
请添加图片描述
【示例1】加法与减法运算符。

mysql> USE mysql_study;
Database changed
mysql> SELECT 100, 100 + 0, 100 - 0, 100 + 50, 100 + 50 -30, 100 + 35.5, 100 - 35.5 FROM DUAL;
+-----+---------+---------+----------+--------------+------------+------------+
| 100 | 100 + 0 | 100 - 0 | 100 + 50 | 100 + 50 -30 | 100 + 35.5 | 100 - 35.5 |
+-----+---------+---------+----------+--------------+------------+------------+
| 100 |     100 |     100 |      150 |          120 |      135.5 |       64.5 |
+-----+---------+---------+----------+--------------+------------+------------+
1 row in set (0.00 sec)

由运算结果可以得出如下结论：

一个整数类型的值对整数进行加法和减法操作，结果还是一个整数；一个整数类型的值对浮点数进行加法和减法操作，结果是一个浮点数；
加法和减法的优先级相同，进行先加后减操作与进行先减后加操作的结果是一样的；

在 Java 中，+的左右两边如果有字符串，那么表示字符串的拼接。但是在 MySQL 中+只表示数值相加。如果遇到非数值类型，先尝试转成数值，如果转失败，就按0计算。(补充：MySQL 中字符串拼接要使用字符串函数 CONCAT() 实现)

mysql> SELECT 100 + 'a';
+-----------+
| 100 + 'a' |
+-----------+
|       100 |
+-----------+
1 row in set, 1 warning (0.00 sec)

mysql> SELECT 100 + '10';
+------------+
| 100 + '10' |
+------------+
|        110 |
+------------+
1 row in set (0.00 sec)

与空值 NULL 参与运算，结果都为 NULL

mysql> SELECT 10 - NULL, 100 + NULL;
+-----------+------------+
| 10 - NULL | 100 + NULL |
+-----------+------------+
|      NULL |       NULL |
+-----------+------------+
1 row in set (0.00 sec)

【示例2】乘法与除法运算符。

mysql> SELECT 100*1, 100*0.1, 100/1.0, 100/2, 100+2*5/2, 100/3, 100/0, 10 DIV 0;
+-------+---------+----------+---------+-----------+---------+-------+----------+
| 100*1 | 100*0.1 | 100/1.0  | 100/2   | 100+2*5/2 | 100/3   | 100/0 | 10 DIV 0 |
+-------+---------+----------+---------+-----------+---------+-------+----------+
|   100 |    10.0 | 100.0000 | 50.0000 |  105.0000 | 33.3333 |  NULL |     NULL |
+-------+---------+----------+---------+-----------+---------+-------+----------+
1 row in set (0.00 sec)

由运算结果可以得出如下结论：

一个数乘以整数1和除以整数1后仍得原数；
一个数乘以浮点数1和除以浮点数1后变成浮点数，数值与原数相等；一个数除以整数后，不管是否能除尽，结果都为一个浮点数；
一个数除以另一个数，除不尽时，结果为一个浮点数，并保留到小数点后4位；
乘法和除法的优先级相同，进行先乘后除操作与先除后乘操作，得出的结果相同。
在数学运算中，0不能用作除数，在 MySQL 中，一个数除以0为 NULL。

【示例3】计算出员工的年基本工资。

#LIMIT 5只输出5条 后续会详细讲解
mysql> SELECT employee_id, salary, salary*12 AS "员工的年基本工资" FROM employees LIMIT 5;
+-------------+----------+------------------+
| employee_id | salary   | 员工的年基本工资 |
+-------------+----------+------------------+
|         100 | 24000.00 |        288000.00 |
|         101 | 17000.00 |        204000.00 |
|         102 | 17000.00 |        204000.00 |
|         103 |  9000.00 |        108000.00 |
|         104 |  6000.00 |         72000.00 |
+-------------+----------+------------------+
5 rows in set (0.00 sec)

【示例4】求模（求余）运算符。

mysql> SELECT 12 % 3, 12 MOD 5 FROM dual;
+--------+----------+
| 12 % 3 | 12 MOD 5 |
+--------+----------+
|      0 |        2 |
+--------+----------+
1 row in set (0.00 sec)

可以看到，12对3求模后的结果为0，对5求模后的结果为2。

3.4.2 比较运算符

比较运算符是查询数据时最常用的一类运算符。SELECT 语句中的条件语句经常使用比较运算符。通过比较运算符，可以判断表中的哪些记录是符合条件的。比较运算符的符号、名称和应用示例如下表所示：
请添加图片描述
1、等号运算符。 等号运算符（=）判断等号两边的值、字符串或表达式是否相等，如果相等则返回1，不相等则返回0。在使用等号运算符时，遵循如下规则：

如果等号两边的值、字符串或表达式都为字符串，则 MySQL 会按照字符串进行比较，其比较的是每个字符串中字符的 ANSI 编码是否相等。
如果等号两边的值都是整数，则 MySQL 会按照整数来比较两个值的大小。
如果等号两边的值一个是整数，另一个是字符串，则 MySQL 会将字符串转化为数字进行比较。如果等号两边的值、字符串或表达式中有一个为NULL，则比较结果为NULL。

【示例5】等号运算符。

mysql> SELECT 1=1,1='1',1=0,'a'='a',(5+3)=(2+6),''=NULL,NULL=NULL;
+-----+-------+-----+---------+-------------+---------+-----------+
| 1=1 | 1='1' | 1=0 | 'a'='a' | (5+3)=(2+6) | ''=NULL | NULL=NULL |
+-----+-------+-----+---------+-------------+---------+-----------+
|   1 |     1 |   0 |       1 |           1 |    NULL |      NULL |
+-----+-------+-----+---------+-------------+---------+-----------+
1 row in set (0.00 sec)

mysql> SELECT 1=2,0='abc',1='abc' FROM dual;
+-----+---------+---------+
| 1=2 | 0='abc' | 1='abc' |
+-----+---------+---------+
|   0 |       1 |       0 |
+-----+---------+---------+
1 row in set, 2 warnings (0.00 sec)

在 MySQL 中，如果需要有条件的从数据表中查询数据，可以使用 WHERE 关键字来指定查询条件。使用 WHERE 关键字的语法格式如下：

WHERE 查询条件 查询条件可以是
#1.带比较运算符和逻辑运算符的查询条件
#2.带 BETWEEN AND 关键字的查询条件
#3.带 IS NULL 关键字的查询条件
#4.带 IN 关键字的查询条件
#5.带 LIKE 关键字的查询条件等 下面结合刚刚学习过的等号运算符来给大家进行演示

【示例6】查询 salary=10000，注意在Java、Python等编程语言中比较是==。

mysql> SELECT employee_id,salary FROM employees WHERE salary=10000;
+-------------+----------+
| employee_id | salary   |
+-------------+----------+
|         150 | 10000.00 |
|         156 | 10000.00 |
|         169 | 10000.00 |
|         204 | 10000.00 |
+-------------+----------+
4 rows in set (0.00 sec)

【示例7】安全等于运算符。

mysql> SELECT 1<=>'1',1<=>0,'a'<=>'a',(5+3)<=>(2+6),''<=>NULL,NULL<=>NULL FROM dual;
+---------+-------+-----------+---------------+-----------+-------------+
| 1<=>'1' | 1<=>0 | 'a'<=>'a' | (5+3)<=>(2+6) | ''<=>NULL | NULL<=>NULL |
+---------+-------+-----------+---------------+-----------+-------------+
|       1 |     0 |         1 |             1 |         0 |           1 |
+---------+-------+-----------+---------------+-----------+-------------+
1 row in set (0.00 sec)

使用安全等于运算符时，两边的操作数的值都为 NULL 时，返回的结果为1而不是 NULL，其他返回结果与等于运算符相同。

切记空值(NULL) 不能使用 = 来判断，可以使用 安全等于运算符

【示例8】查询 employees 表中 commission_pct 值为 NULL 的数据。

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct = NULL LIMIT 5;
Empty set (0.00 sec)

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct <=> NULL LIMIT 5;
+-------------+----------------+
| employee_id | commission_pct |
+-------------+----------------+
|         100 |           NULL |
|         101 |           NULL |
|         102 |           NULL |
|         103 |           NULL |
|         104 |           NULL |
+-------------+----------------+
5 rows in set (0.00 sec)

【示例9】使用运算符 > 来判断数据表 employees 中的 commission_pct 字段值是否大于0.3，是则返回1；否则，返回0，空值返回 NULL。运算结果如下所示：

mysql> SELECT employee_id,salary,commission_pct>0.3 FROM employees WHERE employee_id>=144 LIMIT 5;
+-------------+----------+--------------------+
| employee_id | salary   | commission_pct>0.3 |
+-------------+----------+--------------------+
|         144 |  2500.00 |               NULL |
|         145 | 14000.00 |                  1 |
|         146 | 13500.00 |                  0 |
|         147 | 12000.00 |                  0 |
|         148 | 11000.00 |                  0 |
+-------------+----------+--------------------+
5 rows in set (0.00 sec)

2、运算符 IS NULL。 IS NULL 用来判断操作数是否为空值(NULL)。操作数为 NULL 时，结果返回1；否则，返回0。IS NOT NULL 刚好与 IS NULL 相反。【示例10】测试运算符 IS NULL。

mysql> SELECT NULL IS NULL, ISNULL(NULL), ISNULL('a'), 1 IS NULL;
+--------------+--------------+-------------+-----------+
| NULL IS NULL | ISNULL(NULL) | ISNULL('a') | 1 IS NULL |
+--------------+--------------+-------------+-----------+
|            1 |            1 |           0 |         0 |
+--------------+--------------+-------------+-----------+
1 row in set (0.00 sec)

【示例11】查询 commission_pct 等于 NULL。比较如下的四种写法。

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct IS NULL LIMIT 3;
+-------------+----------------+
| employee_id | commission_pct |
+-------------+----------------+
|         100 |           NULL |
|         101 |           NULL |
|         102 |           NULL |
+-------------+----------------+
3 rows in set (0.00 sec)

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct <=> NULL LIMIT 3;
+-------------+----------------+
| employee_id | commission_pct |
+-------------+----------------+
|         100 |           NULL |
|         101 |           NULL |
|         102 |           NULL |
+-------------+----------------+
3 rows in set (0.00 sec)

mysql> SELECT employee_id,commission_pct FROM employees WHERE ISNULL(commission_pct) LIMIT 3;
+-------------+----------------+
| employee_id | commission_pct |
+-------------+----------------+
|         100 |           NULL |
|         101 |           NULL |
|         102 |           NULL |
+-------------+----------------+
3 rows in set (0.00 sec)

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct = NULL;
Empty set (0.00 sec)

3、非空运算符。 非空运算符（IS NOT NULL）判断一个值是否不为NULL，如果不为NULL则返回1，否则返回0。【示例12】测试运算符 IS NOT NULL。

mysql> SELECT employee_id,commission_pct FROM employees WHERE commission_pct = NULL;
Empty set (0.00 sec)

mysql> SELECT NULL IS NOT NULL, 'a' IS NOT NULL, 1 IS NOT NULL;
+------------------+-----------------+---------------+
| NULL IS NOT NULL | 'a' IS NOT NULL | 1 IS NOT NULL |
+------------------+-----------------+---------------+
|                0 |               1 |             1 |
+------------------+-----------------+---------------+
1 row in set (0.00 sec)

mysql> SELECT employee_id,commission_pct FROM employees WHERE NOT commission_pct <=> NULL;
mysql> SELECT employee_id,commission_pct FROM employees WHERE NOT ISNULL(commission_pct);

4、最小值运算符。 语法格式为：LEAST(值1，值2，…，值n)。其中，值n 表示参数列表中有n个值。在有两个或多个参数的情况下，返回最小值。【示例13】测试最小值运算符。

mysql> SELECT LEAST (1,0,2), LEAST('b','a','c'), LEAST(1,NULL,2);
+---------------+--------------------+-----------------+
| LEAST (1,0,2) | LEAST('b','a','c') | LEAST(1,NULL,2) |
+---------------+--------------------+-----------------+
|             0 | a                  |            NULL |
+---------------+--------------------+-----------------+
1 row in set (0.00 sec)

由结果可以看到，当参数是整数或者浮点数时，LEAST 将返回其中最小的值；当参数为字符串时，返回字母表中顺序最靠前的字符；当比较值列表中有 NULL 时，不能判断大小，返回值为 NULL。

5、最大值运算符。 语法格式为：GREATEST(值1，值2，…，值n)。其中，n表示参数列表中有n个值。当有两个或多个参数时，返回值为最大值。假如任意一个自变量为 NULL，则 GREATEST() 的返回值为 NULL。

mysql> SELECT GREATEST(1,0,2), GREATEST('b','a','c'), GREATEST(1,NULL,2);
+-----------------+-----------------------+--------------------+
| GREATEST(1,0,2) | GREATEST('b','a','c') | GREATEST(1,NULL,2) |
+-----------------+-----------------------+--------------------+
|               2 | c                     |               NULL |
+-----------------+-----------------------+--------------------+
1 row in set (0.00 sec)

由结果可以看到，当参数中是整数或者浮点数时，GREATEST 将返回其中最大的值；当参数为字符串时，返回字母表中顺序最靠后的字符；当比较值列表中有 NULL 时，不能判断大小，返回值为 NULL。

6、运算符 BETWEEN AND。 BETWEEN AND 用于判断数据是否在某个取值范围内，其表达式如下：

#如果x1大于等于m，且小于等于n，结果将返回1；否则，将返回0。
x1 BETWEEN m AND n

【示例14】运算符 BETWEEN AND 示例。

mysql> SELECT 1 BETWEEN 0 AND 1, 10 BETWEEN 11 AND 12, 'b' BETWEEN 'a' AND 'c';
+-------------------+----------------------+-------------------------+
| 1 BETWEEN 0 AND 1 | 10 BETWEEN 11 AND 12 | 'b' BETWEEN 'a' AND 'c' |
+-------------------+----------------------+-------------------------+
|                 1 |                    0 |                       1 |
+-------------------+----------------------+-------------------------+
1 row in set (0.00 sec)

mysql> SELECT last_name, salary FROM employees WHERE salary BETWEEN 2500 AND 3500 LIMIT 5;
+------------+---------+
| last_name  | salary  |
+------------+---------+
| Khoo       | 3100.00 |
| Baida      | 2900.00 |
| Tobias     | 2800.00 |
| Himuro     | 2600.00 |
| Colmenares | 2500.00 |
+------------+---------+
5 rows in set (0.00 sec)

7、运算符IN。 IN用于判断数据是否存在于某个集合中，其表达式如下：

x1 IN(值1,值2,…,值n)

如果x1等于值1到值n中的任何一个值，结果将返回1；否则，结果将返回0。如果给定的值为 NULL 则结果为 NULL。【示例15】运算符 IN 示例。

mysql> SELECT 'a' IN ('a','b','c'), 1 IN (2,3), NULL IN ('a','b');
+----------------------+------------+-------------------+
| 'a' IN ('a','b','c') | 1 IN (2,3) | NULL IN ('a','b') |
+----------------------+------------+-------------------+
|                    1 |          0 |              NULL |
+----------------------+------------+-------------------+
1 row in set (0.00 sec)

8、NOT IN 运算符。 NOT IN 运算符用于判断给定的值是否不是 IN 列表中的一个值，如果不是 IN 列表中的一个值，则返回1，否则返回0。【示例16】运算符 NOT IN 示例。

mysql> SELECT 'a' NOT IN ('a','b','c'), 1 NOT IN (2,3);
+--------------------------+----------------+
| 'a' NOT IN ('a','b','c') | 1 NOT IN (2,3) |
+--------------------------+----------------+
|                        0 |              1 |
+--------------------------+----------------+
1 row in set (0.00 sec)

9、LIKE 运算符。 LIKE 运算符主要用来匹配字符串，通常用于模糊匹配，如果满足条件则返回1，否则返回0。如果给定的值或者匹配条件为 NULL，则返回结果为 NULL。LIKE 运算符通常使用如下通配符：

"%": 匹配0个或多个字符。
"_": 只能匹配一个字符。

【示例17】LIKE 运算符示例。

mysql> SELECT NULL LIKE 'abc', 'abc' LIKE NULL;
+-----------------+-----------------+
| NULL LIKE 'abc' | 'abc' LIKE NULL |
+-----------------+-----------------+
|            NULL |            NULL |
+-----------------+-----------------+
1 row in set (0.00 sec)

mysql> SELECT first_name FROM employees WHERE first_name LIKE 'S%';
+------------+
| first_name |
+------------+
| Steven     |
| Shelli     |
| Sigal      |
| Shanta     |
| Steven     |
| Stephen    |
| Sarath     |
| Sundar     |
| Sundita    |
| Sarah      |
| Samuel     |
| Susan      |
| Shelley    |
+------------+
13 rows in set (0.00 sec)

mysql> SELECT last_name FROM employees WHERE last_name LIKE '_o%';
+------------+
| last_name  |
+------------+
| Kochhar    |
| Lorentz    |
| Popp       |
| Tobias     |
| Colmenares |
| Vollman    |
| Mourgos    |
| Rogers     |
| Doran      |
| Fox        |
| Johnson    |
| Jones      |
+------------+
12 rows in set (0.00 sec)

【示例18】转义字符示例。回避特殊符号的：使用转义符。

#数据准备
mysql> CREATE TABLE test_escape1(id INT(10), column_2 VARCHAR(20), column_3 VARCHAR(20));
Query OK, 0 rows affected, 1 warning (0.02 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(1, '_a\\', 111111);
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(2, '12%', '%12%');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(3, 'a_a', 'a%');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(4, '_a\\', '_12%');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(5, '\\a', '\\\\_a%12%');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO test_escape1(id,column_2,column_3) VALUES(6, '_a\\\\', 111111);
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM test_escape1;
+------+----------+----------+
| id   | column_2 | column_3 |
+------+----------+----------+
|    1 | _a\      | 111111   |
|    2 | 12%      | %12%     |
|    3 | a_a      | a%       |
|    4 | _a\      | _12%     |
|    5 | \a       | \\_a%12% |
|    6 | _a\\     | 111111   |
+------+----------+----------+
6 rows in set (0.00 sec)
#1.查询column_2含 \ 的
SELECT * FROM test_escape1 WHERE column_2 LIKE '%\\\%';
#2.查询column_2以 % 结尾的
SELECT * FROM test_escape1 WHERE column_2 LIKE '%\%';
SELECT * FROM test_escape1 WHERE column_2 LIKE '%\\%';
SELECT * FROM test_escape1 WHERE column_2 LIKE '%$%' ESCAPE '$';
#3.查询column_2含下划线 _ 的
SELECT * FROM test_escape1 WHERE column_2 LIKE '%\_%';
-- 查询column_2含下划线 _ 的,
-- escape 语法表示将其后的字符$当作转义符，与上面直接用转义符\一样的效果
SELECT * FROM test_escape1 WHERE column_2 LIKE '%$_%' ESCAPE '$';
#4.查询column_2含下划线 _，含有\，含有a的
SELECT * FROM test_escape1 WHERE column_2 LIKE '%?_a\\%'  ESCAPE '?';
SELECT * FROM test_escape1 WHERE column_2 LIKE '%?_a?\%'  ESCAPE '?';

3.4.3 逻辑运算符

逻辑运算符用来判断表达式的真假。如果表达式是真，结果返回1；如果表达式是假，结果返回0。逻辑运算符又称为布尔运算符。MySQL 中支持4种逻辑运算符，分别是与、或、非和异或。下表为4种逻辑运算符的符号及作用。
请添加图片描述 1、与运算。 && 或者 AND 是与运算的两种表达方式。如果所有数据不为0且不为空值（NULL），结果返回1；如果存在任何一个数据为0，结果返回0；如果存在一个数据为 NULL 且没有数据为0时，结果返回 NULL 。与运算符支持多个数据同时进行运算。【示例19】与运算示例。

mysql> SELECT 1 AND -1, 0 AND 1, 0 AND NULL, 1 AND NULL;
+----------+---------+------------+------------+
| 1 AND -1 | 0 AND 1 | 0 AND NULL | 1 AND NULL |
+----------+---------+------------+------------+
|        1 |       0 |          0 |       NULL |
+----------+---------+------------+------------+
1 row in set (0.00 sec)
mysql> SELECT employee_id,last_name,job_id salary FROM employees WHERE salary>=10000 AND job_id LIKE '%MAN%';
+-------------+-----------+--------+
| employee_id | last_name | salary |
+-------------+-----------+--------+
|         114 | Raphaely  | PU_MAN |
|         145 | Russell   | SA_MAN |
|         146 | Partners  | SA_MAN |
|         147 | Errazuriz | SA_MAN |
|         148 | Cambrault | SA_MAN |
|         149 | Zlotkey   | SA_MAN |
|         201 | Hartstein | MK_MAN |
+-------------+-----------+--------+
7 rows in set (0.00 sec)

2、或运算。 || 或者 OR 表示或运算。所有数据中存在任何一个数据为非0的数字时，结果返回1；如果数据中不包含非0的数字，但包含 NULL，结果返回 NULL；如果操作数中有0，结果返回0。或运算符也可以同时操作多个数据。【示例20】或运算示例。

mysql> SELECT 1 OR -1, 1 OR 0, 1 OR NULL, 0 || NULL, NULL || NULL;
+---------+--------+-----------+-----------+--------------+
| 1 OR -1 | 1 OR 0 | 1 OR NULL | 0 || NULL | NULL || NULL |
+---------+--------+-----------+-----------+--------------+
|       1 |      1 |         1 |      NULL |         NULL |
+---------+--------+-----------+-----------+--------------+
1 row in set, 2 warnings (0.00 sec)
#查询基本薪资不在9000-12000之间的员工编号和基本薪资
SELECT employee_id,salary FROM employees WHERE NOT (salary >= 9000 AND salary <= 12000);
SELECT employee_id,salary FROM employees WHERE NOT (salary >= 9000 AND salary <= 12000);
mysql> SELECT employee_id, last_name, job_id, salary FROM employees WHERE salary >= 10000 OR job_id LIKE '%MAN%';

3、非运算。 ! 或者 NOT 表示非运算。通过非运算，将返回与操作数据相反的结果。如果操作数据是非0的数字，结果返回0；如果操作数据是0，结果返回1；如果操作数据是 NULL，结果返回 NULL。

注意：OR可以和AND一起使用，但是在使用时要注意两者的优先级，由于AND的优先级高于OR，因此先对AND两边的操作数进行操作，再与OR中的操作数结合。

【示例21】非运算示例。

mysql> SELECT NOT 1, NOT 0, NOT(1+1), NOT !1, NOT NULL;
+-------+-------+----------+--------+----------+
| NOT 1 | NOT 0 | NOT(1+1) | NOT !1 | NOT NULL |
+-------+-------+----------+--------+----------+
|     0 |     1 |        0 |      1 |     NULL |
+-------+-------+----------+--------+----------+
1 row in set, 1 warning (0.00 sec)
mysql> SELECT employee_id,salary FROM employees WHERE NOT salary > 2400;
+-------------+---------+
| employee_id | salary  |
+-------------+---------+
|         127 | 2400.00 |
|         128 | 2200.00 |
|         132 | 2100.00 |
|         135 | 2400.00 |
|         136 | 2200.00 |
+-------------+---------+
5 rows in set (0.00 sec)

4、异或运算。 XOR 表示异或运算。只要其中任何一个操作数据为 NULL，结果返回 NULL；如果两个操作数都是非0值，或者都是0，则结果返回0；如果一个为0，另一个为非0值，结果返回1。【示例22】异或运算示例。

mysql> SELECT 1 XOR -1,1 XOR 0,0 XOR 0,1 XOR NULL,1 XOR 1 XOR 1,0 XOR 0 XOR 0;
+----------+---------+---------+------------+---------------+---------------+
| 1 XOR -1 | 1 XOR 0 | 0 XOR 0 | 1 XOR NULL | 1 XOR 1 XOR 1 | 0 XOR 0 XOR 0 |
+----------+---------+---------+------------+---------------+---------------+
|        0 |       1 |       0 |       NULL |             1 |             0 |
+----------+---------+---------+------------+---------------+---------------+
1 row in set (0.00 sec)

mysql> SELECT last_name,department_id,salary FROM employees WHERE department_id IN (10,20) XOR salary > 8000 LIMIT 5;
+-----------+---------------+----------+
| last_name | department_id | salary   |
+-----------+---------------+----------+
| King      |            90 | 24000.00 |
| Kochhar   |            90 | 17000.00 |
| De Haan   |            90 | 17000.00 |
| Hunold    |            60 |  9000.00 |
| Greenberg |           100 | 12000.00 |
+-----------+---------------+----------+
5 rows in set (0.00 sec)

3.4.4 位运算符(用得较少)

位运算符是在二进制数上进行计算的运算符。位运算会先将操作数变成二进制数再进行运算，然后将计算结果从二进制数变回十进制数。MySQL 中支持6种位运算符，分别是按位与、按位或、按位取反、按位异或、按位左移和按位右移。6种位运算符的符号及作用如下表所示：
请添加图片描述
【示例23】位运算符示例。

mysql> SELECT 1 & 10, 20 & 30;
+--------+---------+
| 1 & 10 | 20 & 30 |
+--------+---------+
|      0 |      20 |
+--------+---------+
1 row in set (0.00 sec)

mysql> SELECT 1 | 10, 20 | 30;
+--------+---------+
| 1 | 10 | 20 | 30 |
+--------+---------+
|     11 |      30 |
+--------+---------+
1 row in set (0.00 sec)

mysql> SELECT 1 ^ 10, 20 ^ 30;
+--------+---------+
| 1 ^ 10 | 20 ^ 30 |
+--------+---------+
|     11 |      10 |
+--------+---------+
1 row in set (0.00 sec)

mysql> SELECT 12 & 5, 12 | 5,12 ^ 5 FROM dual;
+--------+--------+--------+
| 12 & 5 | 12 | 5 | 12 ^ 5 |
+--------+--------+--------+
|      4 |     13 |      9 |
+--------+--------+--------+
1 row in set (0.00 sec)

mysql> SELECT 10 & ~1;
+---------+
| 10 & ~1 |
+---------+
|      10 |
+---------+
1 row in set (0.00 sec)

mysql> SELECT 1 >> 2, 4 >> 2;
+--------+--------+
| 1 >> 2 | 4 >> 2 |
+--------+--------+
|      0 |      1 |
+--------+--------+
1 row in set (0.00 sec)

mysql> SELECT 1 << 2, 4 << 2;
+--------+--------+
| 1 << 2 | 4 << 2 |
+--------+--------+
|      4 |     16 |
+--------+--------+
1 row in set (0.00 sec)

3.4.5 运算符的优先级

由于在实际应用中可能需要同时使用多个运算符，这就必须考虑运算符的运算顺序。本小节将具体阐述 MySQL 运算符使用的优先级，如下表所示：
请添加图片描述
按照从高到低，从左到右的级别进行运算操作。如果优先级相同，则表达式左边的运算符先运算。补充：() 括号的优先级最高。

3.5 用 ORDER BY 关键字对查询结果排序

使用 ORDER BY 关键字可以对查询的结果进行 升序（ASC） 或 降序（DESC） 排列。在默认情况下，ORDER BY 按升序输出结果。如果要按降序排列，可以使用 DESC 来实现。语法格式如下：

#其中，ASC表示按升序排列，DESC表示按降序排列。
ORDER BY 字段名 [ASC|DESC];

【示例24】单列排序。

mysql> SELECT last_name, job_id, department_id, hire_date FROM employees ORDER BY hire_date LIMIT 5;
+-----------+---------+---------------+------------+
| last_name | job_id  | department_id | hire_date  |
+-----------+---------+---------------+------------+
| King      | AD_PRES |            90 | 1987-06-17 |
| Whalen    | AD_ASST |            10 | 1987-09-17 |
| Kochhar   | AD_VP   |            90 | 1989-09-21 |
| Hunold    | IT_PROG |            60 | 1990-01-03 |
| Ernst     | IT_PROG |            60 | 1991-05-21 |
+-----------+---------+---------------+------------+
5 rows in set (0.00 sec)

mysql> SELECT last_name, job_id, department_id, hire_date FROM employees ORDER BY hire_date DESC LIMIT 5;
+-----------+----------+---------------+------------+
| last_name | job_id   | department_id | hire_date  |
+-----------+----------+---------------+------------+
| Banda     | SA_REP   |            80 | 2000-04-21 |
| Kumar     | SA_REP   |            80 | 2000-04-21 |
| Ande      | SA_REP   |            80 | 2000-03-24 |
| Markle    | ST_CLERK |            50 | 2000-03-08 |
| Lee       | SA_REP   |            80 | 2000-02-23 |
+-----------+----------+---------------+------------+
5 rows in set (0.00 sec)

mysql> SELECT employee_id, last_name, salary*12 annsal FROM employees ORDER BY annsal LIMIT 5;
+-------------+------------+----------+
| employee_id | last_name  | annsal   |
+-------------+------------+----------+
|         132 | Olson      | 25200.00 |
|         128 | Markle     | 26400.00 |
|         136 | Philtanker | 26400.00 |
|         135 | Gee        | 28800.00 |
|         127 | Landry     | 28800.00 |
+-------------+------------+----------+
5 rows in set (0.00 sec)

可以使用不在 SELECT 列表中的列排序。在对多列进行排序的时候，首先排序的第一列必须有相同的列值，才会对第二列进行排序。如果第一列数据中所有值都是唯一的，将不再对第二列进行排序。【示例25】多列排序。

mysql> SELECT last_name, department_id, salary FROM employees ORDER BY department_id, salary DESC;

3.6 用 LIMIT 限制查询结果的数量

查询数据时，可能会查询出很多记录，而用户只需要很少的一部分。这样就需要限制查询结果的数量。LIMIT 是 MySQL 中的一个特殊关键字。LIMIT 子句可以对查询结果的记录条数进行限定，控制输出的行数。LIMIT 语句格式如下：

LIMIT 初始位置,记录数

初始位置是开始读取的第一条记录的编号(在查询结果中，第一个结果的记录编号是0，而不是1，第二个结果的记录编号是 1，后面的记录依次类推)；记录数 表示显示记录的条数。

【示例26】在 employees 表中，使用LIMIT子句返回从第4条记录开始的行数为5的记录，SQL 语句和运行结果如下：

mysql> USE mysql_study;
Database changed
mysql> SELECT employee_id,salary FROM employees LIMIT 3,5;
+-------------+---------+
| employee_id | salary  |
+-------------+---------+
|         103 | 9000.00 |
|         104 | 6000.00 |
|         105 | 4800.00 |
|         106 | 4800.00 |
|         107 | 4200.00 |
+-------------+---------+
5 rows in set (0.00 sec)

#补充:LIMIT和OFFSET组合使用
#LIMIT 记录数 OFFSET 初始位置
#参数和 LIMIT 语法中参数含义相同，"初始位置"指定从哪条记录开始显示 "记录数"表示显示记录的条数
mysql> SELECT employee_id,salary FROM employees LIMIT 5 OFFSET 3;
+-------------+---------+
| employee_id | salary  |
+-------------+---------+
|         103 | 9000.00 |
|         104 | 6000.00 |
|         105 | 4800.00 |
|         106 | 4800.00 |
|         107 | 4200.00 |
+-------------+---------+
5 rows in set (0.00 sec)

由结果可以看到，该语句返回的是从第 4 条记录开始的之后的 5 条记录。LIMIT 关键字后的第一个数字 3 表示从第 4 行开始(记录的位置从 0 开始，第 4 行的位置为 3)，第二个数字 5 表示返回的行数。

MySQL 8.0 中可以使用 LIMIT 5 OFFSET 3，意思是获取从第4条记录开始后面的5条记录，和 LIMIT 3,5 返回的结果相同。

LIMIT 关键字不指定初始位置时，记录从第一条记录开始显示。显示记录的条数由 LIMIT 关键字指定。LIMIT 不指定初始位置的基本语法格式如下：

LIMIT 记录数

其中，记录数 表示显示记录的条数。如果 记录数 的值小于查询结果的总数，则会从第一条记录开始，显示指定条数的记录。如果 记录数 的值大于查询结果的总数，则会直接显示查询出来的所有记录。【示例27】显示 employees 表查询结果的前 4 行，SQL 语句和运行结果如下：

mysql> SELECT employee_id,salary FROM employees LIMIT 4;
+-------------+----------+
| employee_id | salary   |
+-------------+----------+
|         100 | 24000.00 |
|         101 | 17000.00 |
|         102 | 17000.00 |
|         103 |  9000.00 |
+-------------+----------+
4 rows in set (0.00 sec)

mysql> SELECT employee_id,salary FROM employees LIMIT 0,4;
+-------------+----------+
| employee_id | salary   |
+-------------+----------+
|         100 | 24000.00 |
|         101 | 17000.00 |
|         102 | 17000.00 |
|         103 |  9000.00 |
+-------------+----------+
4 rows in set (0.00 sec)

上述结果中只显示了 4 条记录，说明 LIMIT 4 限制了显示条数为 4。

【示例28】显示 test_escape1 表查询结果的前10行，SQL 语句和运行结果如下：

mysql> SELECT * FROM test_escape1;
+------+----------+----------+
| id   | column_2 | column_3 |
+------+----------+----------+
|    1 | _a\      | 111111   |
|    2 | 12%      | %12%     |
|    3 | a_a      | a%       |
|    4 | _a\      | _12%     |
|    5 | \a       | \\_a%12% |
|    6 | _a\\     | 111111   |
+------+----------+----------+
6 rows in set (0.00 sec)

mysql> SELECT * FROM test_escape1 LIMIT 10;
+------+----------+----------+
| id   | column_2 | column_3 |
+------+----------+----------+
|    1 | _a\      | 111111   |
|    2 | 12%      | %12%     |
|    3 | a_a      | a%       |
|    4 | _a\      | _12%     |
|    5 | \a       | \\_a%12% |
|    6 | _a\\     | 111111   |
+------+----------+----------+
6 rows in set (0.00 sec)

结果中只显示了 6 条记录。虽然 LIMIT 关键字指定了显示 10 条记录，但是查询结果中只有 6 条记录。因此，数据库系统就将这 6 条记录全部显示出来。

总结：带一个参数的 LIMIT 指定从查询结果的首行开始，唯一的参数表示返回的行数，即 LIMIT n 与 LIMIT 0,n 返回结果相同。带两个参数的 LIMIT 可返回从任何位置开始指定行数的数据。

使用 LIMIT 的好处： 约束返回结果的数量可以减少数据表的网络传输量，也可以提升查询效率。如果我们知道返回结果只有1条，就可以使用 LIMIT 1 ，告诉 SELECT 语句只需要返回一条记录即可。这样的好处就是 SELECT 不需要扫描完整的表，只需要检索到一条符合条件的记录即可返回。

至此今天的学习就到此结束了，笔者在这里声明，笔者写文章只是为了学习交流，以及让更多学习数据库的读者少走一些弯路，节省时间，并不用做其他用途，如有侵权，联系博主删除即可。感谢您阅读本篇博文，希望本文能成为您编程路上的领航者。祝您阅读愉快！

在这里插入图片描述

好书不厌读百回，熟读课思子自知。而我想要成为全场最靓的仔，就必须坚持通过学习来获取更多知识，用知识改变命运，用博客见证成长，用行动证明我在努力。
如果我的博客对你有帮助、如果你喜欢我的博客内容，请 点赞、评论、收藏 一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。
编码不易，大家的支持就是我坚持下去的动力。点赞后不要忘了 关注 我哦！