---
title: "单表查询 - OceanBase 数据库 V4.2.5 | OceanBase 文档中心"
description: "单表查询 在单表查询中，只涉及到一个表，不涉及多个表之间的关系。通过单表查询可以实现对数据的检索、过滤和排序等操作。 本文将介绍如何使用 SELECT 语句来对 OceanBase 数据库 MySQL 模式中的数据进行单表查询的操作。 单表查询语法 单表查询的语法如下： SELECT [ALL | DISTINCT]…"
---
切换语言

- 中文站 - 简体中文
- International - English
- 日本站 - 日本語

文档反馈![](https://mdn.alipayobjects.com/huamei_22khvb/afts/img/A*P8CuR4UJ_FkAAAAAAAAAAAAADiGDAQ/original) OceanBase 数据库分布式版 - V 4.2.5 LTS

# 单表查询

更新时间：2026-07-15 20:42:47

[编辑](https://github.com/oceanbase/oceanbase-doc/edit/V4.2.5/zh-CN/300.develop/100.application-development-of-mysql-mode/500.read-data-of-mysql-mode/100.single-table-query-of-mysql-mode.md)  

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

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

## 单表查询语法

单表查询的语法如下：

```sql
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](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001504234)。

当 `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` 限制结果的条数。

#### 注意

`WHERE` 和 `HAVING` 的区别是，`WHERE` 是在分组前对数据进行筛选，而 `HAVING` 是在分组后的结果里进行筛选，最后返回整个 SQL 的查询结果。

## 示例

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

数据如下：

```shell
+----+-----------+--------+-----+-------+-----------------+
| 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` 列的数据。

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

```

返回结果如下：

```shell
+----+-----------+--------+-----+-------+-----------------+
| 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` 列的数据。

```sql
SELECT id,name FROM student;

```

返回结果如下：

```shell
+----+-----------+
| 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` 三列。

```sql
SELECT id,name,age+1 FROM student;

```

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

### 条件查询

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

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

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

| 查询条件类型 | 谓词 |
| --- | --- |
| 比较查询 | `=`，`>`，`<`，`>=`，`<=`，`!=`，`<>` |
| 逻辑查询（多重条件） | `AND`，`OR`，`NOT` |
| 模糊查询（字符匹配） | `LIKE`，`NOT LIKE` |
| 区间查询（确定范围） | `BETWEEN AND`，`NOT BETWEEN AND` |
| 指定集合查询 | `IN`，`NOT IN` |
| NULL 值查询 | `IS NULL`，`IS NOT NULL` |

有关查询条件的详细信息，请参见 [比较运算符](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001503368)。

#### 比较条件查询

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

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

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

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+--------+
  | 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` 列的数据。

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

  ```

  返回结果如下：

  ```shell
  +----+--------+--------+
  | 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` 列的数据。

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+
  | 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` 列的数据。

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+--------+-------+
  | 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` 列的数据。

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+--------+-------+
  | 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`。

#### 注意

当数据库字集为 ASCII 时一个汉字需要两个 `_`；当字符集为 GBK 时只需要一个 `_`。

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

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

```

返回结果如下：

```shell
+----+----------+
| 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` 列的数据。

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

```

返回结果如下：

```

#### 指定集合查询（IN）

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

#### 注意

- `[NOT] IN` 集合中的值类型必须一致或相互兼容。
 - `[NOT] IN` 集合中的值不支持通配符。

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

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

```

返回结果如下：

```shell
+----+--------+
| 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` 列的数据。

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

  ```

  返回结果如下：

  ```shell
  Empty set

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

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

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+
  | 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` 子句可以在分组后对数据进行排序。

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

| 聚合函数 | 作用 |
| --- | --- |
| MAX() | 查询指定列的最大值。 |
| MIN() | 查询指定列的最小值。 |
| COUNT() | 统计查询结果的行数。 |
| SUM() | 返回指定列的总和。 |
| AVG() | 返回指定列数据的平均值。 |

#### 分组查询示例

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

```shell
+----------+---------+-----------+-------------+------------+
| 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)`。

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

  ```

  返回结果如下：

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

  ```
 - 多字段分组查询。

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

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

  ```

  返回结果如下：

  ```shell
  +---------+------------+-----------------+
  | 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)`。

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

  ```

  返回结果如下：

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

  ```
 - 分组后筛选。

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

  ```sql
  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` 后面的聚集函数相同。

  返回结果如下：

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

  ```
 - 分组后排序。

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

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

  ```

  返回结果如下：

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

  ```

### 聚合查询

关于聚合查询的详细信息，请参见 [查询中使用聚合函数](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001500366)。

### 排序查询

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

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

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

#### 排序查询示例

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

- 单字段排序查询。

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

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+
  | 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` 降序显示学生信息。

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+
  | 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` 升序显示学生信息。

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+-----------------+
  | 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)` 升序显示学生信息。

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

  ```

  返回结果如下：

  ```
 - 在 `WHERE` 子句之后排序。

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

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

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

  ```

  返回结果如下：

  ```shell
  +----+-----------+-------+----------------------+
  | 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 语句格式如下：

```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 条记录。

  ```sql
  SELECT id,name FROM student LIMIT 5;

  ```

  返回结果如下：

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

  ```
 - 获取跳过 n 行记录后的 m 行记录

  #### 说明

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

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

  ```sql
  SELECT id,name FROM student LIMIT 3,3;

  ```

  返回结果如下：

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

  ```
 - 获取最大的一条记录。

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

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

  ```

  返回结果如下：

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

  ```

#### 分页查询

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

SQL 语句格式如下：

```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 页：

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

```

返回结果如下：

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

```

第 2 页：

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

```

返回结果如下：

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

```

第 3 页：

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

```

返回结果如下：

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

```

## 相关文档

- [SELECT](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001504234)
 - [比较运算符](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001503368)
 - [查询中使用聚合函数](https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000001500366)

 上一篇 下一篇 ![有帮助](https://gw.alipayobjects.com/mdn/ob_asset/afts/img/A*y6ocSqN8cqsAAAAAAAAAAAAAARQnAQ)![无帮助](https://gw.alipayobjects.com/mdn/ob_asset/afts/img/A*BG9IQJyLHF8AAAAAAAAAAAAAARQnAQ)![反馈](https://gw.alipayobjects.com/mdn/ob_asset/afts/img/A*eTWdQKCRKHwAAAAAAAAAAAAAARQnAQ)[AI](https://www.oceanbase.com/obi) 咨询热线