单表查询

在单表查询中，只涉及到一个表，不涉及多个表之间的关系。通过单表查询可以实现对数据的检索、过滤和排序等操作。

本文将介绍如何使用 SELECT 语句来对 OceanBase 数据库 MySQL 模式中的数据进行单表查询的操作。

单表查询语法

单表查询的语法如下：

SELECT [ALL | DISTINCT] select_list FROM table_name
              [ WHERE query_condition ]
              [ GROUP BY group_by_expression ]
              [ HAVING group_condition ]
              [ ORDER BY column_list ][ASC | DESC]
              [ LIMIT limit_clause ]

column_list：
 column_name[,column_name...] 

关于查询语句的详细用法，请参见 SELECT。

当 WHERE、GROUP BY、HAVING、ORDER BY、LIMIT 这些关键字一起使用时，先后顺序有明确的限制。关键字执行顺序如下：

1. 执行 FROM 找到表。

2. 执行 WHERE 指定约束条件。

3. 执行 GROUP BY 将取出的每条记录进行分组（聚合）。如果没有 GROUP BY，则整体作为一组。

4. 执行 HAVING 将分组的结果进行筛选。

5. 执行 SELECT。

6. 执行 DISTINCT 去重。

7. 执行 ORDER BY 将结果按条件升序或降序排序。

8. 执行 LIMIT 限制结果的条数。

示例

现有一个学生信息表 student，包括以下字段：学生编号（id）、学生姓名（name）、性别（gender）、年龄（age）、成绩（score）、入学日期（enrollment_date），其中性别字段用数字 0 和 1 表示女和男。

数据如下：

+----+-----------+--------+-----+-------+-----------------+
| id | name      | gender | age | score | enrollment_date |
+----+-----------+--------+-----+-------+-----------------+
|  1 | Emma      |      0 |  20 |    85 | 2021-09-01      |
|  2 | William   |      1 |  21 |  90.5 | 2021-09-02      |
|  3 | Olivia    |      0 |  19 |  95.5 | 2021-09-03      |
|  4 | James     |      1 |  20 |  87.5 | 2021-09-03      |
|  5 | Sophia    |      0 |  20 |  91.5 | 2021-09-05      |
|  6 | Benjamin  |      1 |  21 |  96.5 | 2021-09-01      |
|  7 | Ava       |      0 |  22 |  89.5 | 2021-09-06      |
|  8 | Michael   |      1 |  18 |  93.5 | 2021-09-08      |
|  9 | Charlotte |      1 |  19 |    88 | 2021-09-06      |
| 10 | Ethan     |      1 |  20 |    92 | 2021-09-01      |
+----+-----------+--------+-----+-------+-----------------+

SELECT 基础查询

查询全部列

• 可以通过 SELECT * FROM student; 语句将全部学生信息查询出来。

• 也可以手动列出所有字段，通过 SELECT id,name,gender,age,score,enrollment_date FROM student; 语句将全部学生信息查询出来。

示例 1：使用下面的 SQL 语句，查询表 student 中所有行的数据，并返回每行的 id、name、gender、age、score 和 enrollment_date 列的数据。

SELECT id,name,gender,age,score,enrollment_date FROM student;

返回结果如下：

+----+-----------+--------+-----+-------+-----------------+
| id | name      | gender | age | score | enrollment_date |
+----+-----------+--------+-----+-------+-----------------+
|  1 | Emma      |      0 |  20 |    85 | 2021-09-01      |
|  2 | William   |      1 |  21 |  90.5 | 2021-09-02      |
|  3 | Olivia    |      0 |  19 |  95.5 | 2021-09-03      |
|  4 | James     |      1 |  20 |  87.5 | 2021-09-03      |
|  5 | Sophia    |      0 |  20 |  91.5 | 2021-09-05      |
|  6 | Benjamin  |      1 |  21 |  96.5 | 2021-09-01      |
|  7 | Ava       |      0 |  22 |  89.5 | 2021-09-06      |
|  8 | Michael   |      1 |  18 |  93.5 | 2021-09-08      |
|  9 | Charlotte |      1 |  19 |    88 | 2021-09-06      |
| 10 | Ethan     |      1 |  20 |    92 | 2021-09-01      |
+----+-----------+--------+-----+-------+-----------------+
10 rows in set

查询指定列

在表中根据列名查找指定列数据。

示例 2：使用下面的 SQL 语句，查询表 student 中所有行的数据，返回每行的 id 和 name 列的数据。

SELECT id,name FROM student;

返回结果如下：

+----+-----------+
| id | name      |
+----+-----------+
|  1 | Emma      |
|  2 | William   |
|  3 | Olivia    |
|  4 | James     |
|  5 | Sophia    |
|  6 | Benjamin  |
|  7 | Ava       |
|  8 | Michael   |
|  9 | Charlotte |
| 10 | Ethan     |
+----+-----------+
10 rows in set

查询经过计算的值

在查询中可以对指定列进行数据处理。

示例 3：使用下面的 SQL 语句，查询表 student 中所有行的 id、name 和 age 列的数据，并将每行的 age 列的值加 1。返回结果将包含 id、name 和 age+1 三列。

SELECT id,name,age+1 FROM student;

更多对指定列进行数据处理的查询方法请参见，请参见 在查询中使用操作符和函数。

条件查询

当要查询满足特定条件的数据时，可以通过给 SELECT 查询语句增加一个 WHERE 子句来实现。

关键字 WHERE 后面可以带有一个或者多个条件。条件是对前面数据的筛选，只有满足 WHERE 条件的数据才会被返回。

WHERE 子句常用的查询条件如下表所示。

有关查询条件的详细信息，请参见 比较运算符。

比较条件查询

比较条件查询运算符包括 =，>，<，>=，<=，!=，<>。

• 等于（=）：查询出指定列中和目标值相等的数据。如果值是字符串类型，需要用单引号或者双引号括起来。

  示例 4：使用下面的 SQL 语句，查询表 student 中 gender 列等于 1 的所有行，并返回这些行中的 id、name 和 gender 列的数据。

  SELECT id,name,gender FROM student WHERE gender = 1;
  

  返回结果如下：

  +----+-----------+--------+
  | id | name      | gender |
  +----+-----------+--------+
  |  2 | William   |      1 |
  |  4 | James     |      1 |
  |  6 | Benjamin  |      1 |
  |  8 | Michael   |      1 |
  |  9 | Charlotte |      1 |
  | 10 | Ethan     |      1 |
  +----+-----------+--------+
  6 rows in set
  

• 不等于（<> 和 !=）：不等于包括 <> 和 != 两种写法。

  示例 5：使用下面的 SQL 语句，查询表 student 中 gender 列不等于 1 的所有行，并返回这些行中的 id、name 和 gender 列的数据。

  SELECT id,name,gender FROM student WHERE gender <> 1;
  

  返回结果如下：

  +----+--------+--------+
  | id | name   | gender |
  +----+--------+--------+
  |  1 | Emma   |      0 |
  |  3 | Olivia |      0 |
  |  5 | Sophia |      0 |
  |  7 | Ava    |      0 |
  +----+--------+--------+
  4 rows in set
  

• 大于（>）和小于（<）：大于（>）和小于（<）将数值按照大小比较。如果比较的是字符，则按照 ASCII 码对应的值进行比较，比较时按照字符对应的位置逐一进行比较。

  说明

  大于等于（\>=）和小于等于（\<=）与之类似。

  示例 6：使用下面的 SQL 语句，查询表 student 中 score 列小于 90 的所有行，并返回这些行中的 id、name 和 score 列的数据。

  SELECT id,name,score FROM student WHERE score < 90;
  

  返回结果如下：

  +----+-----------+-------+
  | id | name      | score |
  +----+-----------+-------+
  |  1 | Emma      |    85 |
  |  4 | James     |  87.5 |
  |  7 | Ava       |  89.5 |
  |  9 | Charlotte |    88 |
  +----+-----------+-------+
  4 rows in set
  

逻辑条件查询

逻辑查询运算符并且（AND）和或者（OR）支持多个条件的查询。

• 并且（AND）：返回同时满足 AND 两个条件的数据。

  示例 7：使用下面的 SQL 语句，查询表 student 中 gender 等于 1 且 score 小于等于 90 的所有行，并返回这些行中的 id、name、gender 和 score 列的数据。

  SELECT id,name,gender,score FROM student WHERE gender = 1 AND score <= 90;
  

  返回结果如下：

  +----+-----------+--------+-------+
  | id | name      | gender | score |
  +----+-----------+--------+-------+
  |  4 | James     |      1 |  87.5 |
  |  9 | Charlotte |      1 |    88 |
  +----+-----------+--------+-------+
  2 rows in set
  

• 或者（OR）：只要满足其中一个条件的数据都会被返回。

  示例 8：使用下面的 SQL 语句，查询表 student 中 gender 等于 1 或 score 小于 90 的所有行，并返回这些行中的 id、name、gender 和 score 列的数据。

  SELECT id,name,gender,score FROM student WHERE gender = 1 OR score < 90;
  

  返回结果如下：

  +----+-----------+--------+-------+
  | id | name      | gender | score |
  +----+-----------+--------+-------+
  |  1 | Emma      |      0 |    85 |
  |  2 | William   |      1 |  90.5 |
  |  4 | James     |      1 |  87.5 |
  |  6 | Benjamin  |      1 |  96.5 |
  |  7 | Ava       |      0 |  89.5 |
  |  8 | Michael   |      1 |  93.5 |
  |  9 | Charlotte |      1 |    88 |
  | 10 | Ethan     |      1 |    92 |
  +----+-----------+--------+-------+
  8 rows in set
  

模糊查询（LIKE）

谓词 LIKE 可以用来进行字符串的匹配。

语法含义是查找对应列值与 pattern 相匹配的数据。pattern 可以是完整的字符串，也可以包含通配符 % 和 _。其中：

• 下划线 (_) 表示匹配任意一个字符。

• 百分号 (%) 表示可以匹配值中的零个或多个字符。模式"%"不能匹配 NULL。

示例 9：使用下面的 SQL 语句，查询表 student 中 name 包含 am 的所有行，并返回这些行中的 id 和 name 列的数据。

SELECT id,name FROM student WHERE name LIKE '%am%';

返回结果如下：

+----+----------+
| id | name     |
+----+----------+
|  2 | William  |
|  4 | James    |
|  6 | Benjamin |
+----+----------+
3 rows in set

区间查询（BETWEEN AND）

操作符 BETWEEN ... AND 会选取介于两个值之间的数据。这些值可以是数值、文本或者日期。

示例 10：使用下面的 SQL 语句，查询表 student 中 score 值在 85 ~ 90 的所有行，并返回这些行中的 id、name 和 score 列的数据。

SELECT id,name,score FROM student WHERE score BETWEEN 85 AND 90;

返回结果如下：

+----+-----------+-------+
| id | name      | score |
+----+-----------+-------+
|  1 | Emma      |    85 |
|  4 | James     |  87.5 |
|  7 | Ava       |  89.5 |
|  9 | Charlotte |    88 |
+----+-----------+-------+
4 rows in set

指定集合查询（IN）

操作符 IN 在 WHERE 子句指定的多个值，称之为一个集合。IN 表示指定列中的数据只要满足集合中任意一个都会被返回。NOT IN 表示和集合中都不匹配的数据才会被返回。

示例 11：使用下面的 SQL 语句，查询表 student 中 id 值满足在集合 (1, 3, 5, 7) 的所有行，并返回这些行中的 id 和 name 列的数据。

SELECT id,name FROM student WHERE id IN (1,3,5,7);

返回结果如下：

+----+--------+
| id | name   |
+----+--------+
|  1 | Emma   |
|  3 | Olivia |
|  5 | Sophia |
|  7 | Ava    |
+----+--------+
4 rows in set

NULL 值专用查询

由于比较运算符、LIKE、BETWEEN AND、IN、NOT IN 对 NULL 值的查询结果不准确，所以建议使用 NULL 值专用查询语句 IS NULL 和 IS NOT NULL。除此之外，还可以使用安全等于（<=>），其既可以判断普通的数值，也可以判断 NULL 值。

• IS NULL：用于查询指定的列的值为 NULL 的数据。

  示例 12：使用下面的 SQL 语句，查询表 student 中 score 为空的所有行，并返回这些行中的 id、name 和 score 列的数据。

  SELECT id,name,score FROM student WHERE score IS NULL;
  

  返回结果如下：

  Empty set
  

• IS NOT NULL：用于查询指定的列的值为非 NULL 的数据。

  示例 13：使用下面的 SQL 语句，查询表 student 中 score 不为空的所有行，并返回这些行中的 id、name 和 score 列的数据。

  SELECT id,name,score FROM student WHERE score IS NOT NULL;
  

  返回结果如下：

  +----+-----------+-------+
  | id | name      | score |
  +----+-----------+-------+
  |  1 | Emma      |    85 |
  |  2 | William   |  90.5 |
  |  3 | Olivia    |  95.5 |
  |  4 | James     |  87.5 |
  |  5 | Sophia    |  91.5 |
  |  6 | Benjamin  |  96.5 |
  |  7 | Ava       |  89.5 |
  |  8 | Michael   |  93.5 |
  |  9 | Charlotte |    88 |
  | 10 | Ethan     |    92 |
  +----+-----------+-------+
  10 rows in set
  

分组查询

GROUP BY 子句用于对查询结果进行分组。

GROUP BY 支持单字段分组和多字段分组，使用 WHERE 子句可以在分组前对数据进行筛选，使用 HAVING 子句可以在分组后对数据进行筛选，使用 ORDER BY 子句可以在分组后对数据进行排序。

分组中常用的聚合函数如下表所示。

分组查询示例

现有示例表 fruit_order，数据如下：

+----------+---------+-----------+-------------+------------+
| order_id | user_id | user_name | fruit_price | order_year |
+----------+---------+-----------+-------------+------------+
|        1 |    1011 | A1        |       13.11 |       2019 |
|        2 |    1022 | B2        |       23.34 |       2019 |
|        3 |    1022 | B2        |       12.22 |       2019 |
|        4 |    1011 | A1        |       22.21 |       2020 |
|        5 |    1033 | C3        |       51.55 |       2020 |
|        6 |    1011 | A1        |       58.83 |       2020 |
|        7 |    1022 | B2        |       14.66 |       2021 |
|        8 |    1022 | B2        |       34.44 |       2021 |
|        9 |    1033 | C3        |       63.66 |       2021 |
+----------+---------+-----------+-------------+------------+

• 单字段分组查询。

  示例 14：查询每个客户下单数量，并输出 user_id 和 COUNT(order_id)。

  SELECT user_id, COUNT(order_id) FROM fruit_order GROUP BY user_id;
  

  返回结果如下：

  +---------+-----------------+
  | user_id | COUNT(order_id) |
  +---------+-----------------+
  |    1011 |               3 |
  |    1022 |               4 |
  |    1033 |               2 |
  +---------+-----------------+
  3 rows in set
  

• 多字段分组查询。

  示例 15：查询每个客户每年下单数量，并输出 user_id、order_year 和 COUNT(order_id)。

  SELECT user_id,order_year, COUNT(order_id) FROM fruit_order GROUP BY user_id,order_year;
  

  返回结果如下：

  +---------+------------+-----------------+
  | user_id | order_year | COUNT(order_id) |
  +---------+------------+-----------------+
  |    1011 |       2019 |               1 |
  |    1022 |       2019 |               2 |
  |    1011 |       2020 |               2 |
  |    1033 |       2020 |               1 |
  |    1022 |       2021 |               2 |
  |    1033 |       2021 |               1 |
  +---------+------------+-----------------+
  6 rows in set
  

• 分组前筛选。

  示例 16：查询 2020 年每个客户的下单数量，并输出 user_id 和 COUNT(order_id)。

  SELECT user_id, COUNT(order_id) FROM fruit_order t WHERE t.order_year = 2020 GROUP BY user_id;
  

  返回结果如下：

  +---------+-----------------+
  | user_id | COUNT(order_id) |
  +---------+-----------------+
  |    1011 |               2 |
  |    1033 |               1 |
  +---------+-----------------+
  2 rows in set
  

• 分组后筛选。

  示例 17：查询 2019 年订单数量大于 1 的客户，并输出 user_id 和 COUNT(order_id)。

  SELECT user_id, COUNT(order_id) FROM fruit_order t WHERE t.order_year = 2019 GROUP BY user_id HAVING COUNT(order_id)>=2;
  

  说明

  当查询中包含 HAVING 时，先获得不含 HAVING 子句时的 SQL 查询结果，然后在这个结果的基础上使用 HAVING 条件筛选出符合的数据，最后返回这些数据。由此，HAVING 后是可以使用聚合函数，并且这个聚集函数不必与 SELECT 后面的聚集函数相同。

  返回结果如下：

  +---------+-----------------+
  | user_id | COUNT(order_id) |
  +---------+-----------------+
  |    1022 |               2 |
  +---------+-----------------+
  1 row in set
  

• 分组后排序。

  示例 18：查询每个客户订单的最大金额，然后按照最大金额倒序输出 user_id 和 MAX(fruit_price)。

  SELECT user_id, MAX(fruit_price) FROM fruit_order t GROUP BY user_id ORDER BY MAX(fruit_price) DESC;
  

  返回结果如下：

  +---------+------------------+
  | user_id | MAX(fruit_price) |
  +---------+------------------+
  |    1033 |            63.66 |
  |    1011 |            58.83 |
  |    1022 |            34.44 |
  +---------+------------------+
  3 rows in set
  

聚合查询

关于聚合查询的详细信息，请参见 查询中使用聚合函数。

排序查询

ORDER BY 子句用于对查询结果按照一个或多个属性列进行升序（ASC）或降序（DESC）排列，默认为升序。

ORDER BY 支持单字段排序、多字段排序、按别名排序和按函数排序，多字段排序之间用逗号隔开。

进行排序查询时，使用如果不添加 ASC 或 DESC 关键字，则默认查询结果为升序排列。

排序查询示例

在 student 表中查询 score 值在 85 ~ 90 的数据。

• 单字段排序查询。

  示例 19：在 student 表中按照 score 升序显示学生信息。

  SELECT id,name,score FROM student ORDER BY score;
  

  返回结果如下：

  +----+-----------+-------+
  | id | name      | score |
  +----+-----------+-------+
  |  1 | Emma      |    85 |
  |  4 | James     |  87.5 |
  |  9 | Charlotte |    88 |
  |  7 | Ava       |  89.5 |
  |  2 | William   |  90.5 |
  |  5 | Sophia    |  91.5 |
  | 10 | Ethan     |    92 |
  |  8 | Michael   |  93.5 |
  |  3 | Olivia    |  95.5 |
  |  6 | Benjamin  |  96.5 |
  +----+-----------+-------+
  10 rows in set
  

  示例 20：在 student 表中按照 score 降序显示学生信息。

  SELECT id,name,score FROM student ORDER BY score DESC;
  

  返回结果如下：

  +----+-----------+-------+
  | id | name      | score |
  +----+-----------+-------+
  |  6 | Benjamin  |  96.5 |
  |  3 | Olivia    |  95.5 |
  |  8 | Michael   |  93.5 |
  | 10 | Ethan     |    92 |
  |  5 | Sophia    |  91.5 |
  |  2 | William   |  90.5 |
  |  7 | Ava       |  89.5 |
  |  9 | Charlotte |    88 |
  |  4 | James     |  87.5 |
  |  1 | Emma      |    85 |
  +----+-----------+-------+
  10 rows in set
  

• 多字段排序查询。

  示例 21：在 student 表中按照 score 降序、enrollment_date 升序显示学生信息。

  SELECT id,name,score,enrollment_date FROM student ORDER BY score DESC,enrollment_date ASC;
  

  返回结果如下：

  +----+-----------+-------+-----------------+
  | id | name      | score | enrollment_date |
  +----+-----------+-------+-----------------+
  |  6 | Benjamin  |  96.5 | 2021-09-01      |
  |  3 | Olivia    |  95.5 | 2021-09-03      |
  |  8 | Michael   |  93.5 | 2021-09-08      |
  | 10 | Ethan     |    92 | 2021-09-01      |
  |  5 | Sophia    |  91.5 | 2021-09-05      |
  |  2 | William   |  90.5 | 2021-09-02      |
  |  7 | Ava       |  89.5 | 2021-09-06      |
  |  9 | Charlotte |    88 | 2021-09-06      |
  |  4 | James     |  87.5 | 2021-09-03      |
  |  1 | Emma      |    85 | 2021-09-01      |
  +----+-----------+-------+-----------------+
  10 rows in set
  

• 在 ORDER BY 中使用了函数排序。

  示例 22：在 student 表中按照 score 降序、DAY(enrollment_date) 升序显示学生信息。

  SELECT id,name,score,enrollment_date FROM student ORDER BY score DESC,DAY(enrollment_date) ASC;
  

  返回结果如下：

  +----+-----------+-------+-----------------+
  | id | name      | score | enrollment_date |
  +----+-----------+-------+-----------------+
  |  6 | Benjamin  |  96.5 | 2021-09-01      |
  |  3 | Olivia    |  95.5 | 2021-09-03      |
  |  8 | Michael   |  93.5 | 2021-09-08      |
  | 10 | Ethan     |    92 | 2021-09-01      |
  |  5 | Sophia    |  91.5 | 2021-09-05      |
  |  2 | William   |  90.5 | 2021-09-02      |
  |  7 | Ava       |  89.5 | 2021-09-06      |
  |  9 | Charlotte |    88 | 2021-09-06      |
  |  4 | James     |  87.5 | 2021-09-03      |
  |  1 | Emma      |    85 | 2021-09-01      |
  +----+-----------+-------+-----------------+
  10 rows in set
  

• 在 WHERE 子句之后排序。

  使用 WHERE 子句可以在排序前对数据进行筛选。

  示例 22：在 student 表中查询 score 大于 85，按照 DAY(enrollment_date) 升序显示学生信息。

  SELECT id,name,score,DAY(enrollment_date) FROM student WHERE score > 85 ORDER BY DAY(enrollment_date) ASC;
  

  返回结果如下：

  +----+-----------+-------+----------------------+
  | id | name      | score | DAY(enrollment_date) |
  +----+-----------+-------+----------------------+
  |  6 | Benjamin  |  96.5 |                    1 |
  | 10 | Ethan     |    92 |                    1 |
  |  2 | William   |  90.5 |                    2 |
  |  3 | Olivia    |  95.5 |                    3 |
  |  4 | James     |  87.5 |                    3 |
  |  5 | Sophia    |  91.5 |                    5 |
  |  7 | Ava       |  89.5 |                    6 |
  |  9 | Charlotte |    88 |                    6 |
  |  8 | Michael   |  93.5 |                    8 |
  +----+-----------+-------+----------------------+
  9 rows in set
  

限制查询结果数量

LIMIT 语句可以限制 SELECT 查询返回的行数，常用于分页操作。

查询中包含 LIMIT 的 SQL 语句格式如下：

LIMIT [offset,] count_num

说明如下：

• offset 表示偏移量，即跳过多少行。offset 可以省略，默认为 0，表示跳过 0 行；offset 取值范围为 [0,+∞)。

• count_num 表示跳过 offset 行之后开始获取数据，取 count_num 行记录；count_num 取值范围为 [0,+∞)。

• offset 和 count_num 的值不能使用表达式，只能跟随明确的数字。

• LIMIT 后面的数字不能为负数。

使用 LIMIT n, m 查询

• 获取前 m 行记录。

  示例 23：在 student 表中查询列 id、name 数据的前 5 条记录。

  SELECT id,name FROM student LIMIT 5;
  

  返回结果如下：

  +----+---------+
  | id | name    |
  +----+---------+
  |  1 | Emma    |
  |  2 | William |
  |  3 | Olivia  |
  |  4 | James   |
  |  5 | Sophia  |
  +----+---------+
  5 rows in set
  

• 获取跳过 n 行记录后的 m 行记录

  说明

  当跳过 n 行记录后，剩余数据的行数小于 m 时，查询结果取所有剩余数据。

  示例 23：在 student 表中查询列 id、name 第三行之后的三行数据。

  SELECT id,name FROM student LIMIT 3,3;
  

  返回结果如下：

  +----+----------+
  | id | name     |
  +----+----------+
  |  4 | James    |
  |  5 | Sophia   |
  |  6 | Benjamin |
  +----+----------+
  3 rows in set
  

• 获取最大的一条记录。

  示例 24：在 student 表中如果想获取 score 最大的一条记录，可以先按照 score 降序，然后取第一条记录。

  SELECT id,name,score FROM student ORDER BY score DESC LIMIT 1;
  

  返回结果如下：

  +----+----------+-------+
  | id | name     | score |
  +----+----------+-------+
  |  6 | Benjamin |  96.5 |
  +----+----------+-------+
  1 row in set
  

分页查询

LIMIT 也可以按照分页查询的逻辑进行使用。

SQL 语句格式如下：

LIMIT (page_no - 1) * page_size, page_size;

语法的参数说明如下：

• page_no 表示第几页，从 1 开始，范围为 [1,+∞)。

• page_size 表示每页显示多少条记录，范围为 [1,+∞)。例如：page_no = 5，page_size = 10，表示获取第 5 页 10 条数据。

示例 25：在 student 表中，每页显示 2 条数据，依次获取第 1 页、第 2 页和第 3 页的数据。

第 1 页：

SELECT id,name FROM student ORDER BY id LIMIT 0,2;

返回结果如下：

+----+---------+
| id | name    |
+----+---------+
|  1 | Emma    |
|  2 | William |
+----+---------+
2 rows in set

第 2 页：

SELECT id,name FROM student ORDER BY id LIMIT 2,2;

返回结果如下：

+----+--------+
| id | name   |
+----+--------+
|  3 | Olivia |
|  4 | James  |
+----+--------+
2 rows in set

第 3 页：

SELECT id,name FROM student ORDER BY id LIMIT 4,2;

返回结果如下：

+----+----------+
| id | name     |
+----+----------+
|  5 | Sophia   |
|  6 | Benjamin |
+----+----------+
2 rows in set

相关文档

• SELECT

• 比较运算符

• 查询中使用聚合函数