SQL LIMIT 语法与示例详解 – wiki基地

---

SQL LIMIT 语法与示例详解：从入门到精通

在处理大量数据时，我们常常不需要获取查询结果集中的所有记录。无论是为了提高查询效率、减少网络传输、实现数据分页，还是仅仅为了快速查看几条示例数据，限制返回的行数都是一个非常常见的需求。SQL 语言提供了多种机制来实现这一目标，其中最常用且在许多数据库系统中广泛支持的一种语法便是 LIMIT。

本文将深入探讨 SQL 中的 LIMIT 语法，包括其基本用法、高级应用（如偏移量）、在不同数据库系统中的变体、与其它 SQL 子句的交互、常见的应用场景（尤其是数据分页和查找 Top N/Bottom N 记录）、性能考量以及一些使用时的注意事项。无论您是 SQL 初学者还是有一定经验的开发者，希望本文都能帮助您全面掌握 LIMIT 的精髓。

1. 什么是 SQL LIMIT？

LIMIT 是一个用于限制 SELECT 语句返回行数的子句。它的主要作用是从查询结果集的顶部（或排序后的顶部）截取指定数量的记录。这使得我们能够有效地控制从数据库中检索的数据量，从而带来多方面的好处。

为什么要使用 LIMIT？

1. 性能优化： 当表包含数百万甚至数十亿行数据时，检索所有数据可能非常耗时且占用大量系统资源（CPU、内存、磁盘 I/O）。使用 LIMIT 可以显著减少数据库需要处理和传输的数据量，加快查询速度。
2. 节省资源： 减少返回的数据量意味着更少的内存占用、更少的网络带宽消耗以及更快的应用程序响应速度。
3. 数据分页： 在 Web 应用或桌面软件中显示大量数据时，通常采用分页的方式。LIMIT 子句是实现数据分页最核心的工具之一，它允许我们每次只加载一页的数据。
4. 获取示例数据： 在开发或测试阶段，我们可能只需要快速查看表中的几条记录来了解数据结构或验证查询逻辑，此时 LIMIT 非常方便。
5. 查找 Top N 或 Bottom N： 结合 ORDER BY 子句，LIMIT 可以轻松找出排序后的前 N 条或后 N 条记录，例如查找销售额最高的 10 个产品或分数最低的 5 名学生。

需要注意的是，LIMIT 并非 ANSI SQL 标准的一部分，它是一个在 MySQL、PostgreSQL、SQLite、H2、HSQLDB 等众多数据库系统中得到广泛支持的非标准扩展。而标准 SQL (SQL:2008 及其后续版本) 引入了 OFFSET ... FETCH FIRST/NEXT ... ROWS ONLY 语法来实现类似的功能，SQL Server 和 Oracle 在较新版本中也支持了这一标准语法，同时保留了各自原有的实现方式（如 SQL Server 的 TOP 和早期 Oracle 的 ROWNUM）。不过，由于 LIMIT 的普及度极高，了解并掌握它是非常有必要的。

2. LIMIT 的基本语法

LIMIT 子句通常跟在 SELECT 语句的末尾，但必须在 ORDER BY 子句（如果存在）之后。

最简单的 LIMIT 语法形式是：

sql
SELECT column1, column2, ...
FROM table_name
WHERE condition
ORDER BY column_name [ASC|DESC]
LIMIT count;

在这个语法中：

• count：一个非负整数，指定了要从结果集中返回的最大行数。数据库会从查询结果集（如果使用了 ORDER BY，则是排序后的结果集）的开头开始返回 count 行。

示例 1：获取表中的前 5 条记录

假设我们有一个 customers 表，我们想快速查看其中的前 5 条记录。

sql
SELECT customer_id, customer_name, city
FROM customers
LIMIT 5;

重要提示： 如果不使用 ORDER BY 子句，数据库返回的行顺序是不确定的。不同的数据库系统、甚至同一数据库系统在不同的执行计划下，都可能返回不同的前 count 行。LIMIT 仅仅是截取了数据库 碰巧 先处理或先找到的那些行。因此，为了获取 特定顺序 的前 N 条记录，必须 结合 ORDER BY 子句。

示例 2：获取按创建日期排序后的前 3 条最新订单

假设有一个 orders 表，包含 order_id, customer_id, order_date, total_amount 等字段。我们要查找最新的 3 条订单。

sql
SELECT order_id, customer_id, order_date, total_amount
FROM orders
ORDER BY order_date DESC
LIMIT 3;

这里，ORDER BY order_date DESC 确保结果集按照订单日期降序排列（最新日期在前），然后 LIMIT 3 从这个排序后的结果集中取出最上面的 3 条记录，即最新的 3 条订单。

3. LIMIT 结合偏移量 (OFFSET)

除了简单地限制数量，LIMIT 语法通常还支持指定一个偏移量，这样可以跳过结果集开头的若干行，然后再开始返回指定的行数。这对于数据分页尤为重要。

带有偏移量的 LIMIT 语法通常有两种形式，这取决于不同的数据库系统，但含义是相似的：

形式 1 (MySQL, SQLite, H2, HSQLDB): LIMIT offset, count

sql
SELECT column1, column2, ...
FROM table_name
WHERE condition
ORDER BY column_name [ASC|DESC]
LIMIT offset, count;

在这个语法中：

• offset: 一个非负整数，表示要跳过的行数。数据库会跳过结果集（排序后）开头的 offset 行。注意： 大多数支持这种语法的数据库（如 MySQL）中的 offset 是从 0 开始计数的。LIMIT 0, count 等同于 LIMIT count。
• count: 一个非负整数，表示从跳过的行之后开始，要返回的最大行数。

形式 2 (PostgreSQL): LIMIT count OFFSET offset

sql
SELECT column1, column2, ...
FROM table_name
WHERE condition
ORDER BY column_name [ASC|DESC]
LIMIT count OFFSET offset;

在这个语法中：

• count: 要返回的最大行数。
• offset: 要跳过的行数。PostgreSQL 的 OFFSET 也是从 0 开始计数的。LIMIT count OFFSET 0 等同于 LIMIT count。

尽管语法顺序不同，但 LIMIT offset, count 和 LIMIT count OFFSET offset 表达的含义是相同的：跳过前 offset 行，然后返回接下来的 count 行。

示例 3：实现数据分页 – 获取第 2 页的数据

假设每页显示 10 条记录，我们要获取 customers 表中按照 customer_id 升序排列的第 2 页数据。

使用 LIMIT offset, count 语法 (MySQL/SQLite)：

sql
-- 每页10条，获取第2页（即跳过前10条，取接下来的10条）
SELECT customer_id, customer_name, city
FROM customers
ORDER BY customer_id ASC
LIMIT 10, 10; -- 跳过 10 行，取 10 行

使用 LIMIT count OFFSET offset 语法 (PostgreSQL)：

sql
-- 每页10条，获取第2页（即取10条，偏移10行）
SELECT customer_id, customer_name, city
FROM customers
ORDER BY customer_id ASC
LIMIT 10 OFFSET 10; -- 取 10 行，偏移 10 行

分页公式：

对于一个每页显示 page_size 条记录的分页功能，要获取第 page_number 页的数据，可以使用以下公式计算 offset 和 count：

• count = page_size
• offset = (page_number - 1) * page_size

例如，如果 page_size = 15，要获取第 3 页的数据：
count = 15
offset = (3 - 1) * 15 = 2 * 15 = 30
对应的查询就是 LIMIT 30, 15 (MySQL) 或 LIMIT 15 OFFSET 30 (PostgreSQL)。

使用偏移量进行分页是非常常见的模式，但需要注意，随着页码的增加（即 offset 变大），数据库可能需要扫描并丢弃大量的行，这在大数据量下可能导致性能下降。后续我们会讨论一些优化策略。

4. ORDER BY 子句的重要性与 LIMIT

前文已经强调过，LIMIT 子句在没有 ORDER BY 的情况下返回的结果是不可预测的。这是因为关系数据库理论上不保证行的存储顺序或查询返回的顺序，除非明确指定 ORDER BY。

示例 4：没有 ORDER BY 的 LIMIT (不可靠)

sql
SELECT product_id, product_name, price
FROM products
LIMIT 10;

这条查询会返回 products 表中的任意 10 条记录。下次执行时，可能会返回完全不同的 10 条记录。在某些简单的场景下（如快速查看表结构的数据示例），这可能不是问题，但在大多数需要确定性结果的场景下（如分页、Top N），省略 ORDER BY 是一个错误。

示例 5：带有 ORDER BY 的 LIMIT (可靠)

sql
SELECT product_id, product_name, price
FROM products
ORDER BY price DESC -- 按价格降序排序
LIMIT 10;

这条查询会先将 products 表按照 price 从高到低排序，然后从排序后的结果集中取出前 10 条记录。这确保了您总是能得到价格最高的 10 个产品。

执行顺序理解：

在 SQL 查询的逻辑处理顺序中，LIMIT（或 OFFSET/FETCH）通常是最后执行的子句之一，它在 SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY 之后。这意味着：

1. 数据库根据 FROM 子句确定数据源。
2. 根据 WHERE 子句过滤行。
3. 如果使用了 GROUP BY，对结果进行分组。
4. 如果使用了 HAVING，过滤分组。
5. 根据 SELECT 子句选择列。
6. 根据 ORDER BY 子句对结果集进行排序（这是一个潜在的高开销操作，尤其是在大数据集上）。
7. 最后，根据 LIMIT (和 OFFSET) 子句从排序后的结果集中选取指定范围的行。

因此，ORDER BY 的结果是 LIMIT 操作的基础，没有它，LIMIT 截取的子集就没有明确的意义。

5. LIMIT 在不同数据库系统中的变体

虽然 LIMIT 是很多数据库的首选，但其它数据库系统有自己的实现方式。了解这些变体对于编写跨平台或特定平台的 SQL 代码至关重要。

5.1 MySQL, PostgreSQL, SQLite, H2, HSQLDB:

这些数据库系统直接支持 LIMIT count 和 LIMIT offset, count (MySQL, SQLite) 或 LIMIT count OFFSET offset (PostgreSQL)。这是本文主要讨论的语法。

5.2 SQL Server:

• 旧版本 (SQL Server 2008 及更早): 主要使用 TOP 子句。TOP N 返回前 N 行。没有直接的 OFFSET 语法，需要结合子查询和 ROW_NUMBER() 窗口函数实现分页。
  “`sql
  — 获取前 10 行
  SELECT TOP 10 product_id, product_name, price
  FROM products
  ORDER BY price DESC;

  — 分页：获取按 product_id 排序的第 2 页，每页 10 条 (SQL Server 2005+)
  WITH RankedResults AS (
  SELECT product_id, product_name, city,
  ROW_NUMBER() OVER (ORDER BY product_id ASC) as rn
  FROM customers
  )
  SELECT product_id, product_name, city
  FROM RankedResults
  WHERE rn BETWEEN 11 AND 20; — BETWEEN (offset + 1) AND (offset + count)
  “`

• SQL Server 2012 及更新版本: 引入了更标准的 OFFSET offset ROWS FETCH NEXT count ROWS ONLY 语法，这与标准 SQL 和 PostgreSQL 的 OFFSET/LIMIT 概念非常相似，并且必须与 ORDER BY 子句一起使用。
  “`sql
  — 获取按 price 降序排列的前 10 行
  SELECT product_id, product_name, price
  FROM products
  ORDER BY price DESC
  OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY; — 偏移 0 行，取 10 行

  — 分页：获取按 customer_id 排序的第 2 页，每页 10 条
  SELECT customer_id, customer_name, city
  FROM customers
  ORDER BY customer_id ASC
  OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY; — 偏移 10 行，取 10 行
  “`
  这个语法在 SQL Server 2012+ 中是实现分页的首选方式。

5.3 Oracle:

• 旧版本 (Oracle 11g 及更早): 主要使用伪列 ROWNUM 来限制行数。ROWNUM 是在获取结果时为每一行分配的序号，从 1 开始。注意： ROWNUM 在 ORDER BY 之前生成，因此直接在 WHERE 子句中使用 ROWNUM 和 ORDER BY 结合可能会得到意外结果。实现分页通常需要通过子查询先排序，然后在外部查询中使用 ROWNUM。
  “`sql
  — 获取按 price 降序排列的前 10 行 (需要子查询先排序)
  SELECT product_id, product_name, price
  FROM (
  SELECT product_id, product_name, price
  FROM products
  ORDER BY price DESC
  )
  WHERE ROWNUM <= 10; — ROWNUM <= count

  — 分页：获取按 customer_id 排序的第 2 页，每页 10 条 (Oracle 11g 及更早，复杂写法)
  SELECT *
  FROM (
  SELECT sub.*, ROWNUM as rn
  FROM (
  SELECT customer_id, customer_name, city
  FROM customers
  ORDER BY customer_id ASC
  ) sub
  WHERE ROWNUM <= 20 — ROWNUM <= offset + count
  )
  WHERE rn > 10; — rn > offset
  “`

• Oracle 12c 及更新版本: 也引入了标准 SQL 的 OFFSET offset ROWS FETCH FIRST/NEXT count ROWS ONLY 语法。这是 Oracle 12c+ 中实现分页和限制行数的最推荐方式。
  “`sql
  — 获取按 price 降序排列的前 10 行
  SELECT product_id, product_name, price
  FROM products
  ORDER BY price DESC
  OFFSET 0 ROWS FETCH FIRST 10 ROWS ONLY; — 或 FETCH NEXT

  — 分页：获取按 customer_id 排序的第 2 页，每页 10 条
  SELECT customer_id, customer_name, city
  FROM customers
  ORDER BY customer_id ASC
  OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY;
  “`

5.4 Db2:

Db2 也支持标准 SQL 的 OFFSET ... FETCH FIRST/NEXT ... ROWS ONLY 语法，并且也支持自己的 FETCH FIRST count ROWS ONLY 语法。

“`sql
— 获取前 10 行
SELECT product_id, product_name, price
FROM products
ORDER BY price DESC
FETCH FIRST 10 ROWS ONLY;

— 分页：获取按 customer_id 排序的第 2 页，每页 10 条
SELECT customer_id, customer_name, city
FROM customers
ORDER BY customer_id ASC
OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY;
“`

总结不同数据库的限制行数语法：

数据库系统	限制前 N 行	带偏移量的分页 (跳过 offset，取 count)
MySQL	LIMIT N	LIMIT offset, count 或 LIMIT count OFFSET offset
PostgreSQL	LIMIT N	LIMIT count OFFSET offset
SQLite	LIMIT N	LIMIT offset, count
SQL Server (<2012)	TOP N + ORDER BY	使用 ROW_NUMBER() 窗口函数 + 子查询
SQL Server (>=2012)	OFFSET 0 ROWS FETCH NEXT N ROWS ONLY + ORDER BY	OFFSET offset ROWS FETCH NEXT count ROWS ONLY + ORDER BY
Oracle (<12c)	WHERE ROWNUM <= N + 子查询先 ORDER BY	使用 ROWNUM 和子查询，写法复杂
Oracle (>=12c)	OFFSET 0 ROWS FETCH FIRST N ROWS ONLY + ORDER BY	OFFSET offset ROWS FETCH FIRST count ROWS ONLY + ORDER BY
Db2	FETCH FIRST N ROWS ONLY + ORDER BY	OFFSET offset ROWS FETCH NEXT count ROWS ONLY + ORDER BY

可以看出，虽然语法各异，但核心思想都是先确定完整的（或排序后的）结果集，然后从中截取或跳过指定数量的行。在需要跨数据库兼容性的场景下，需要根据目标数据库使用不同的语法，或者利用 ORM 框架的抽象能力。

6. LIMIT 的常见应用场景详解

让我们更详细地探讨 LIMIT 的几个主要应用场景。

6.1 获取 Top N 和 Bottom N 记录

这是 LIMIT (或其他数据库的等效语法) 最常见和最有用的应用之一。通过结合 ORDER BY，我们可以轻松找出某个指标最高或最低的 N 条记录。

• Top N: 使用 ORDER BY column_name DESC 和 LIMIT N。
  示例： 查找销售额最高的 5 个客户。
  sql
SELECT customer_id, customer_name, total_sales
FROM customers
ORDER BY total_sales DESC
LIMIT 5;

• Bottom N: 使用 ORDER BY column_name ASC 和 LIMIT N。
  示例： 查找库存量最少的 10 个产品。
  sql
SELECT product_id, product_name, stock_quantity
FROM products
ORDER BY stock_quantity ASC
LIMIT 10;

6.2 实现数据分页

分页是处理大量数据在用户界面展示时的标准做法。LIMIT (或 OFFSET/FETCH) 是实现分页的关键。

如前所述，要获取第 page_number 页、每页 page_size 条数据，使用公式：
offset = (page_number - 1) * page_size
count = page_size

示例： 实现一个每页显示 20 条新闻文章的网站，获取按发布日期降序排列的第 5 页文章。

“`sql
— 假设 page_size = 20, page_number = 5
— offset = (5 – 1) * 20 = 80
— count = 20

SELECT article_id, title, publish_date
FROM articles
ORDER BY publish_date DESC
LIMIT 80, 20; — MySQL/SQLite
“`

或

sql
SELECT article_id, title, publish_date
FROM articles
ORDER BY publish_date DESC
LIMIT 20 OFFSET 80; -- PostgreSQL

或

sql
-- SQL Server 2012+ / Oracle 12c+ / Db2
SELECT article_id, title, publish_date
FROM articles
ORDER BY publish_date DESC
OFFSET 80 ROWS FETCH NEXT 20 ROWS ONLY;

实现分页时，通常还需要一个查询来获取总记录数，以便计算总页数并在界面上显示分页导航。获取总记录数通常使用 COUNT(*)：

sql
SELECT COUNT(*) FROM articles;

分页的注意事项：

• 排序键的唯一性： 在进行分页时，用于 ORDER BY 的列最好是唯一的（如主键）。如果排序字段包含重复值，那么在页与页之间的边界上可能会出现同一行的位置不确定，导致某些行重复出现在相邻页，或者某些行丢失。如果排序字段不唯一，通常建议在 ORDER BY 子句中包含一个或多个可以唯一标识行的列作为次要排序键，例如：ORDER BY publish_date DESC, article_id ASC。
• 大偏移量性能： 使用大偏移量 (OFFSET 值很高) 进行分页时，数据库可能仍然需要处理（但不返回）从开始到偏移量之间的所有行。这在非常大的表中可能会成为性能瓶颈。下一节将讨论如何优化。

6.3 数据采样或随机记录

有时我们需要从表中随机抽取少量数据进行分析或测试。虽然 LIMIT 本身不是用于随机抽样的，但可以结合随机函数来实现。

示例： 从 products 表中随机获取 5 条记录 (MySQL)。

sql
SELECT product_id, product_name, price
FROM products
ORDER BY RAND()
LIMIT 5;

注意： ORDER BY RAND() 在大多数数据库中效率很低，因为它需要为表中的每一行生成一个随机值，然后对整个表进行排序。这对于大表来说开销巨大。在生产环境中，如果需要更高效的随机采样，可能需要考虑数据库特有的采样方法（如 PostgreSQL 的 TABLESAMPLE）或基于算法的更复杂实现。

6.4 快速查询验证

在编写复杂的 SQL 查询时，我们可能只想查看查询结果的开头几行，以验证逻辑是否正确。LIMIT 在这时就非常有用。

sql
-- 编写了一个复杂的查询，想看看结果是什么样的
SELECT c.customer_name, o.order_id, o.order_date, i.product_name, i.quantity
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products i ON oi.product_id = i.product_id
WHERE c.city = 'New York' AND o.order_date >= '2023-01-01'
ORDER BY o.order_date DESC
LIMIT 10; -- 只看前 10 条结果验证
这比不加 LIMIT 执行整个查询并等待大量结果返回要快得多。

7. LIMIT 的性能考量与优化

尽管 LIMIT 可以通过减少返回数据量来提高性能，但其内部执行机制和与其它子句的结合方式会显著影响实际的查询速度。

7.1 ORDER BY 的开销

如前所述，LIMIT 通常在 ORDER BY 之后执行。如果 ORDER BY 的列没有合适的索引，数据库可能需要将整个（或大部分）结果集加载到内存或临时磁盘空间中进行排序。这对于大表来说是一个非常昂贵的步骤。为 ORDER BY 子句中使用的列创建索引是优化 LIMIT + ORDER BY 查询的关键。

示例： 优化按 total_sales 查找 Top 客户的查询。
原始查询 (如果 total_sales 没有索引)：
sql
SELECT customer_id, customer_name, total_sales
FROM customers
ORDER BY total_sales DESC
LIMIT 5; -- 可能会对整个表进行排序
优化：为 total_sales 列创建索引。
sql
CREATE INDEX idx_customers_total_sales ON customers (total_sales DESC); -- 考虑降序索引
创建索引后，数据库可以直接利用索引的有序性来快速定位排序后的前 N 条记录，而无需扫描和排序整个表。

7.2 大偏移量 (Large OFFSET) 的性能问题

使用 LIMIT offset, count 或 OFFSET offset ROWS FETCH NEXT count ROWS ONLY 进行分页时，当 offset 值非常大时，性能可能会显著下降。这是因为数据库通常必须检索并处理从结果集开始到 offset + count 位置的所有行，然后丢弃前 offset 行。它仍然需要做很多工作来确定并跳过这些行。

优化大偏移量分页的策略：

• 基于游标或上一次查询结果： 避免直接使用大偏移量。改为记录上一页最后一条记录的唯一标识符（如主键或排序字段的值），下一页的查询条件是获取排序字段值大于（或小于，取决于排序方向）上一页最后一条记录的那些行，然后再使用 LIMIT count。
  示例： 按 publish_date DESC, article_id ASC 排序的新闻分页。获取第 5 页（假设前 4 页共有 80 条记录），假设第 80 条记录的 publish_date 是 ‘2023-03-15 10:00:00’，article_id 是 150。
  下一页（第 5 页）的查询可以这样写：
  sql
SELECT article_id, title, publish_date
FROM articles
WHERE (publish_date < '2023-03-15 10:00:00') OR (publish_date = '2023-03-15 10:00:00' AND article_id > 150)
ORDER BY publish_date DESC, article_id ASC
LIMIT 20;
  这个方法利用了索引（假设 publish_date 和 article_id 有索引），数据库可以直接跳到满足条件的第一个位置开始扫描，而不需要从头处理前 80 条记录。这种方法通常比大偏移量更高效，尤其适用于深度分页。缺点是它要求客户端在请求下一页时携带上一页最后一条记录的信息。

• 覆盖索引 (Covering Index): 如果 SELECT 列表中的所有列都包含在用于 ORDER BY 的索引中（或者是一个复合索引覆盖了 ORDER BY 列和 SELECT 列），数据库可以直接通过扫描索引来获取所需的数据，而无需访问实际的数据行。这能显著提高性能。

7.3 LIMIT 与 GROUP BY/HAVING

当查询包含 GROUP BY 和 HAVING 子句时，LIMIT 在这些子句之后、ORDER BY 之前（逻辑上）或之后（物理上，取决于优化器）应用。通常的执行顺序是：FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT/OFFSET.
这意味着 GROUP BY 和 HAVING 会处理所有符合 WHERE 条件的行，无论最终 LIMIT 多少。LIMIT 只是从最终聚合和过滤后的分组结果集中截取行。

示例： 查找销售总额最高的 3 个城市的销售数据。

sql
SELECT city, SUM(total_amount) AS total_sales
FROM orders
GROUP BY city
ORDER BY total_sales DESC
LIMIT 3;
这里，GROUP BY city 会对所有订单按城市分组，SUM(total_amount) 计算每个城市的总销售额，ORDER BY total_sales DESC 对这些城市按总销售额排序，最后 LIMIT 3 返回总销售额最高的 3 个城市。

8. 使用 LIMIT 的注意事项和潜在陷阱

1. 永远不要在生产环境中的 LIMIT 查询中省略 ORDER BY，除非你真的不关心结果的顺序。 这是最常见的错误。
2. 理解不同数据库的语法差异。 LIMIT, OFFSET, TOP, ROWNUM, FETCH FIRST/NEXT 都是用来限制行数的，但用法、语法、以及内部处理逻辑有差异。确保使用您特定数据库支持的正确语法。
3. 注意偏移量的基数。 大多数 LIMIT offset, count 或 LIMIT count OFFSET offset 中的 offset 是从 0 开始的，表示跳过 0 行、1 行、2 行…。但某些系统的 ROWNUM 从 1 开始。务必查阅您使用的数据库的文档。
4. 警惕大偏移量的性能问题。 对于深度分页，考虑使用基于游标或索引范围的优化策略，而不是简单的 OFFSET。
5. LIMIT 可能会影响聚合函数的结果。 如果在 SELECT 列表中使用了聚合函数（如 COUNT(), SUM(), AVG() 等），LIMIT 是在聚合计算 之后 应用的。LIMIT 限制的是聚合后的行数，而不是聚合计算所基于的原始行数。如果你想计算受 LIMIT 影响的行数，通常需要一个子查询或窗口函数。
   示例： 查找价格最高的 10 个产品，并计算这 10 个产品的平均价格。
   sql
SELECT AVG(price)
FROM (
SELECT product_id, product_name, price
FROM products
ORDER BY price DESC
LIMIT 10
) AS Top10Products;
   不能直接在外部查询中使用 AVG(price) 并应用 LIMIT，因为 LIMIT 限制的是最终返回的行数（这里只有一行，即平均价格），而不是用于计算平均值的原始产品行。

9. 结论

SQL 的 LIMIT 子句 (以及其它数据库系统中的等效语法如 TOP, OFFSET/FETCH, ROWNUM) 是一个强大而实用的工具，用于控制 SELECT 语句返回的行数。它在提高查询性能、实现数据分页、获取 Top N 记录以及进行查询测试等方面发挥着核心作用。

掌握 LIMIT 的基本语法 (LIMIT count) 和带偏移量的语法 (LIMIT offset, count 或 LIMIT count OFFSET offset) 是基础。更重要的是，要深入理解 LIMIT 与 ORDER BY 子句之间的紧密关系——没有 ORDER BY 的 LIMIT 结果通常是不可靠的。此外，了解不同数据库系统在实现这一功能上的差异性，并关注大偏移量可能带来的性能问题及其优化策略，将帮助您编写出更高效、更健壮的 SQL 代码。

在实际应用中，请根据您所使用的具体数据库系统查阅其官方文档，以确认最准确的语法和行为细节。通过熟练运用 LIMIT (或其变体)，您将能更有效地管理和处理大规模数据集。

---