non_recursive_term UNION [ ALL | DISTINCT ] recursive_term

其中，递归自引用必须出现在 UNION 的右侧。每个查询只允许有一个递归自引用。不支持递归数据修改语句，但是可以在数据修改语句中使用递归 SELECT 查询的结果。有关示例，请参阅第 7.8 节。

RECURSIVE 的另一个效果是 WITH 查询无需按顺序排列：一个查询可以引用列表中后面的另一个查询。（但是，循环引用或相互递归未实现。）如果没有 RECURSIVE，WITH 查询只能引用 WITH 列表中较早的兄弟 WITH 查询。

如果 WITH 子句中有多个查询，则应在紧跟 WITH 之后只写一次 RECURSIVE。它适用于 WITH 子句中的所有查询，尽管它对不使用递归或前向引用的查询没有影响。

可选 SEARCH 子句计算一个 搜索序列列，它可用于以广度优先或深度优先顺序对递归查询的结果进行排序。提供列名称列表，指定用来跟踪已访问行数的行关键字。名为 search_seq_col_name 的列将添加到 WITH 查询的结果列列表中。此列可由外部查询进行排序，以实现各自的排序。有关示例，请参阅 第 7.8.2.1 节。

可选的 CYCLE 子句用于检测递归查询中的循环。提供列名称列表，指定用来跟踪已访问行数的行关键字。名为 cycle_mark_col_name 的列将添加到 WITH 查询的结果列列表中。当检测到循环时，此列将设置为 cycle_mark_value，否则设置为 cycle_mark_default。此外，当检测到循环时，递归联合的处理将停止。 cycle_mark_value 和 cycle_mark_default 必须为常量，并且必须可强制转换为通用数据类型，且数据类型必须具有不等式运算符。（SQL 标准要求它们是布尔常量或字符串，但 PostgreSQL 并不做此要求。）默认情况下，使用 TRUE 和 FALSE（类型为 boolean）。此外，名为 cycle_path_col_name 的列将添加到 WITH 查询的结果列列表中。此列在内部用于跟踪已访问的行。有关示例，请参阅 第 7.8.2.2 节。

SEARCH 和 CYCLE 子句仅对递归 WITH 查询有效。 with_query 必须是两个 SELECT（或等效）命令（没有嵌套 UNION）的 UNION（或 UNION ALL）。如果同时使用两个子句，则 SEARCH 子句添加的列会显示在 CYCLE 子句添加的列之前。

主查询和 WITH 查询都在（概念上）同时执行。这意味着在 WITH 中的数据修改语句的效果无法从查询的其他部分看到，只能通过读取其 RETURNING 输出看到。如果两个此类数据修改语句尝试修改同一行，则结果是未指定的。

WITH 查询的一个关键属性是它们通常每个主查询执行一次，即便主查询引用它们多次。特别是，无论主查询是否读取所有或部分输出，数据修改语句都保证仅执行一次。

但是，可以将 WITH 查询标记为 NOT MATERIALIZED 来取消此保证。在这种情况下，WITH 查询可以折叠到主查询中，就像它们是主查询 FROM 子句中的一个简单的子 SELECT 一样。如果主查询引用该 WITH 查询多次，则会导致重复计算；但是，如果每次使用仅需要 WITH 查询总输出的几行，那么 NOT MATERIALIZED 可以通过允许联合优化查询来提供净节约。如果 NOT MATERIALIZED 附加到递归或非副作用（即不是不包含不稳定函数的纯 SELECT）的 WITH 查询上，则将忽略它。

默认情况下，如果在主查询的 FROM 子句中仅使用一次，则将副作用为 WITH 的查询折叠到主查询中。这允许在语义上不可见的情况下对两个查询级别进行联合优化。然而，可以通过将 WITH 查询标记为 MATERIALIZED 来防止这种折叠。例如，如果 WITH 查询被用作优化围栏以防止计划程序选择错误的计划，这可能很有用。PostgreSQL v12 之前的版本从未进行过此类折叠，因此为较旧版本编写的查询可能依赖于 WITH 作为优化围栏。

有关更多信息，请参阅第 7.8 节。

FROM 子句

FROM 子句为 SELECT 指定一个或多个源表。如果指定了多个源，结果便是所有源的笛卡尔积（交叉联接）。但通常会添加限定条件（通过 WHERE）将返回的行限制为笛卡尔积的一小部分。

FROM 子句可以包含以下元素

WHERE 子句

可选 WHERE 子句的常规格式为

WHERE condition

其中 condition 是任何计算为 boolean 类型结果的表达式。任何不满足此条件的行都将从输出中消除。如果用实际行值替换任何变量引用时返回 true，则该行满足此条件。

GROUP BY 子句

可选 GROUP BY 子句的常规格式为

GROUP BY [ ALL | DISTINCT ] grouping_element [, ...]

GROUP BY 将所有对分组表达式具有相同值的选中行浓缩为一行。在 grouping_element 中使用的 expression 可以是输入列名称，或者输出列（SELECT 列表项）的名称或序号，或者由输入列值形成的任意表达式。当模棱两可时，GROUP BY 名称会被解释为输入列名称而非输出列名称。

如果 GROUPING SETS、ROLLUP 或 CUBE 作为分组元素出现，则整个 GROUP BY 子句定义一些独立的 grouping sets。其效果等同于在子查询之间构造一个 UNION ALL，子查询的 GROUP BY 子句作为其单个分组集使用。可选的 DISTINCT 子句删除重复的集，然后才进行处理；它不会将 UNION ALL 转换为 UNION DISTINCT。有关分组集处理的详细信息，请参阅7.2.4 节。

如果有聚合函数参与运算的话，这些函数作用于组成每个分组的所有行，针对每个分组产生一个独立的值。（如果存在聚合函数但没有 GROUP BY 从句，则查询被视为只有一个，包含所有所选行的分组。）可以通过在聚合函数调用上附加一个 FILTER 从句来进一步筛选提供给每个聚合函数的行集；有关更多信息，请参见 第 4.2.7 节。如果存在 FILTER 从句，只有与之匹配的行才包含在提供给该聚合函数的输入中。

如果存在 GROUP BY 或者任何聚合函数，那么 SELECT 列表表达式引用未分组的列是不允许的（聚合函数内或未分组的列在分组列上函数相关的情况下除外），因为这会导致必须返回多个针对未分组列可能的列值。如果表中包含未分组列的分组列（或其子集）为主键，那么就会存在函数相关性。

请注意，在计算 HAVING 从句或 SELECT 列表中的任何 “标量” 表达式之前，都会计算所有聚合函数。这意味着例如无法使用 CASE 表达式来跳过聚合函数的计算；请参见 第 4.2.14 节。

目前，FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 和 GROUP BY 无法一起指定。

HAVING 从句

可选 HAVING 从句的一般形式为

HAVING condition

其中 condition 与为 WHERE 从句指定的相同。

HAVING 删掉不满足条件的分组行。HAVING 不同于 WHERE：WHERE 在应用 GROUP BY 之前筛选各行，而 HAVING 则筛选由 GROUP BY 创建的分组行。引用在 condition 中的每列都必须明确地引用分组列，除非该引用出现在聚合函数内，或者未分组的列在分组列上是函数相关的。

存在 HAVING 会让查询变成分组查询，即使没有 GROUP BY 子句。这与当查询含有聚合函数但没有 GROUP BY 子句时一样。所有选定的行都被当作形成一个单一组，并且 SELECT 列表和 HAVING 子句只能在聚合函数中引用表列。如果 HAVING 条件为真，这样的查询会发出单行；如果它不为真，则发出 0 行。

目前，FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 无法和 HAVING 一起指定。

WINDOW 子句

可选的 WINDOW 子句有以下通式

WINDOW window_name AS ( window_definition ) [, ...]

其中 window_name 是可以从 OVER 子句或后续窗口定义中引用的名称，window_definition 是

[ existing_window_name ]
[ PARTITION BY expression [, ...] ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ frame_clause ]

如果指定 existing_window_name，它必须指向 WINDOW 列表中之前的一个条目；新窗口从该条目中复制其分区子句，如果存在，也复制其排序子句。在这种情况下，新窗口无法指定其自己的 PARTITION BY 子句，且仅当所复制窗口没有时才指定 ORDER BY。新窗口始终使用其自己的框架子句；所复制的窗口不得指定框架子句。

PARTITION BY 列表的元素的解释方式与 GROUP BY 子句的元素类似，区别在于它们始终是简单表达式，从不为输出列的名称或编号。另一个区别是，这些表达式可包含聚合函数调用，而这在规则 GROUP BY 子句中不被允许。这里允许它们，这是因为分窗发生在分组和聚合之后。

类似地，ORDER BY 列表的元素的解释方式与语句级 ORDER BY 子句的元素类似，区别在于表达式始终被视为简单表达式，从不为输出列的名称或编号。

可选的 frame_clause 为依赖框架的窗口函数（并非所有函数都依赖）定义 窗口框架。窗口框架是对查询中每行的相关行集合（称为 当前行）。frame_clause 可以是以下之一

{ RANGE | ROWS | GROUPS } frame_start [ frame_exclusion ]
{ RANGE | ROWS | GROUPS } BETWEEN frame_start AND frame_end [ frame_exclusion ]

其中 frame_start 和 frame_end 可以是以下之一

UNBOUNDED PRECEDING
offset PRECEDING
CURRENT ROW
offset FOLLOWING
UNBOUNDED FOLLOWING

并且 frame_exclusion 可以是以下之一

EXCLUDE CURRENT ROW
EXCLUDE GROUP
EXCLUDE TIES
EXCLUDE NO OTHERS

如果省略frame_end，它将默认为CURRENT ROW。限制条件是frame_start不能为UNBOUNDED FOLLOWING，frame_end不能为UNBOUNDED PRECEDING，且frame_end选项不能出现在上面列出的frame_start和frame_end选项列表中比frame_start选项更早的位置—例如，RANGE BETWEEN CURRENT ROW AND offset PRECEDING不允许。

默认的框架选项是 RANGE UNBOUNDED PRECEDING，它与 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 相同；它将框架设置为从分区开始到当前行的最后一个 对等行（窗口的 ORDER BY 子句将其视为与当前行等效的行；如果不存在 ORDER BY，则所有行均为对等行）。通常，UNBOUNDED PRECEDING 表示框架从分区的首行开始，类似地，UNBOUNDED FOLLOWING 表示框架以分区的最后一行结束，无论为 RANGE、ROWS 还是 GROUPS 模式。在 ROWS 模式中，CURRENT ROW 表示框架从当前行开始或以其结束；但在 RANGE 或 GROUPS 模式中，它表示框架从 ORDER BY 排序中的当前行的第一个或最后一个对等行开始或以其结束。offset PRECEDING 和 offset FOLLOWING 选项的含义会根据框架模式而有所不同。在 ROWS 模式中，offset 是一个整数，表示框架在当前行之前或之后开始或结束的行数。在 GROUPS 模式中，offset 是一个整数，表示框架在当前行对等行之前的或之后的对等行组数，其中 对等行组 根据窗口的 ORDER BY 子句是一组等效行。在 RANGE 模式中，如果使用 offset 选项，则要求窗口定义中只有一列 ORDER BY。然后，框架将包含那些排序列值最多比当前行的排序列值小 offset（对于 PRECEDING）或大 offset（对于 FOLLOWING）的行。在这些情况下，offset 表达式的类型取决于排序列的类型。对于数字排序列，它通常与排序列的类型相同，但对于日期时间排序列，它是一个 interval。在所有这些情况下，offset 的值必须为非空和非负。另外，虽然 offset 不必是一个简单的常量，但它不能包含变量、聚合函数或窗口函数。

frame_exclusion 选项允许将当前行周围的行从框架中排除，即使它们会根据框架起始和框架结束选项而被包含。EXCLUDE CURRENT ROW 将当前行从框架中排除。EXCLUDE GROUP 将当前行及其排序对等行从框架中排除。EXCLUDE TIES 将当前行所有对等行从框架中排除，但不排除当前行本身。EXCLUDE NO OTHERS 只是明确指定了默认行为，即不排除当前行或其对等行。

请注意，如果 ORDER BY 排序并未对行进行唯一排序，ROWS 模式可能产生不可预测的结果。RANGE 和 GROUPS 模式旨在确保在 ORDER BY 排序中为对等的行提供一致对待：给定对等组的所有行都将在框架中或从框架中排除。

WINDOW 子句的目的是指定查询的 SELECT 列表 或 ORDER BY 子句中出现的 窗口函数 的行为。这些函数可以在 OVER 子句中按名称引用 WINDOW 子句条目。但是，不必在任何地方引用 WINDOW 子句条目；如果它未在查询中使用，则将简单地忽略它。可以使用窗口函数，而完全不使用任何 WINDOW 子句，因为窗口函数调用可以在其 OVER 子句中直接指定窗口定义。然而，当同一窗口定义对多个窗口函数都是必需时，WINDOW 子句可以节省输入。

目前，无法使用带有 WINDOW 的 FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE。

第 3.5 节、第 4.2.8 节 和 第 7.2.5 节 中详细描述了窗口函数。

SELECT 列表

SELECT 列表（关键字 SELECT 和 FROM 之间）指定形成 SELECT 语句输出行的表达式。这些表达式可以引用（而且通常也引用） FROM 子句中计算的列。

正如在表中一样， SELECT 的每个输出列都有一个名称。在简单的 SELECT 中，此名称仅用于给列贴标签以显示，但当 SELECT 是更大查询的子查询时，该名称由更大的查询视为子查询生成的虚拟表的列名称。要指定用于输出列的名称，请在列的表达式后面写 AS output_name。（您可以省略 AS，但仅当所需的输出名称与任何 PostgreSQL 关键字不匹配时（请参阅 附录 C）。为了防止未来可能添加的关键字，建议您始终编写 AS 或给输出名称加引号。）如果您未指定列名称，PostgreSQL 会自动选择一个名称。如果该列的表达式是一个简单的列引用，则选取的名称与该列的名称相同。在更复杂的情况下，可以使用函数或类型名称，或者系统可能会使用生成名称，如 ?column?。

输出列的名称可用于在 ORDER BY 和 GROUP BY 子句中引用该列的值，但不能在 WHERE 或 HAVING 子句中引用；在那里您必须改为写出表达式。

在输出列表中可以写 * 替代一个表达式，它表示所有所选行的列的速写。此外，您可以使用 table_name.* 表示只来自该表的列的速写。在这些情况下，无法使用 AS 指定新的名称；输出列名称将与表列的名称相同。

根据 SQL 标准，在应用 DISTINCT、ORDER BY 或 LIMIT 之前，应计算出输出列表中的表达式。在使用 DISTINCT 时，此操作显然很有必要，因为否则不明确区分了哪些值。但是，在许多情况下，如果在 ORDER BY 和 LIMIT 之后计算输出表达式会很方便；特别是如果输出列表包含任何不稳定或开销大的函数时。如果采用这种行为，函数评估的顺序会更直观，而且不会对从未出现在输出中的行进行评估。PostgreSQL 将有效地在排序和限定之后评估输出表达式，前提是这些表达式未在 DISTINCT、ORDER BY 或 GROUP BY 中引用。（反例：SELECT f(x) FROM tab ORDER BY 1 在排序之前显然必须评估 f(x)。）包含集返回函数的输出表达式会在排序之后和限定之前有效地计算，这样 LIMIT 将起作用，从集返回函数中截断输出。

DISTINCT 子句

如果指定 SELECT DISTINCT，则会从结果集中删除所有重复行（保留每一组重复行中的一个行）。SELECT ALL 指定相反的操作：保留所有行；这是默认设置。

SELECT DISTINCT ON ( expression [, ...] ) 仅保留给定表达式计算结果相等的每一组行中的第一行。DISTINCT ON 表达式按照与 ORDER BY 相同的规则进行解释（请参见上文）。请注意，除非使用 ORDER BY 确保所需的行首先出现，否则每一组的“第一行”不可预测。例如

SELECT DISTINCT ON (location) location, time, report
    FROM weather_reports
    ORDER BY location, time DESC;

将检索到每个位置的天气最新报告。但如果我们未使用 ORDER BY 对每个位置的时间值强制按降序排列，我们得到的将是每个位置时间不可预测的某份报告。

DISTINCT ON 表达式必须匹配最左侧的 ORDER BY 表达式。ORDER BY 子句通常会包含其他表达式，这些表达式确定每个 DISTINCT ON 组内行的所需优先级。

目前，FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 无法与 DISTINCT 一起指定。

UNION 子句

UNION 子句具有这种一般形式

select_statement UNION [ ALL | DISTINCT ] select_statement

select_statement 是任何不带 ORDER BY、LIMIT、FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 或 FOR KEY SHARE 子句的 SELECT 语句。（ORDER BY 和 LIMIT 可以附加到一个子表达式，如果它包含在括号中。如果没有括号，则会将这些子句应用到 UNION 的结果，而不是它的右侧输入表达式。）

UNION 运算符计算相关 SELECT 语句返回的行集并集。如果一行出现在两个结果集中至少一个，则该行位于两个结果集的并集中。表示 UNION 直接操作数的两个 SELECT 语句必须生成相同数量的列，并且相应列必须具有兼容的数据类型。

UNION 的结果不包含任何重复行，除非指定 ALL 选项。 ALL 可防止消除重复项。（因此，UNION ALL 通常比 UNION 快得多；在可以的情况下使用 ALL。）可以编写 DISTINCT 以明确指定消除重复行的默认行为。

在同一 SELECT 语句中，多个 UNION 运算符从左到右进行计算，除非括号另有指示。

目前， FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 不能为 UNION 结果或 UNION 的任何输入指定。

INTERSECT 子句

INTERSECT 子句具有这种一般形式

select_statement INTERSECT [ ALL | DISTINCT ] select_statement

select_statement 是任何不带 ORDER BY、LIMIT、FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 或 FOR KEY SHARE 子句的 SELECT 语句。

INTERSECT 运算符计算相关 SELECT 语句返回行的交集。如果一行出现在两个结果集中，则该行位于两个结果集的交集中。

INTERSECT 的结果不包含任何重复行，除非指定 ALL 选项。使用 ALL，如果一行在左表中有 m 个重复项，在右表中有 n 个重复项，则该行将出现在结果集中 min(m,n) 次。可以编写 DISTINCT 以明确指定消除重复行的默认行为。

同一 SELECT 语句中多个 INTERSECT 运算符从左向右求值，除非括号另有指示。 INTERSECT 的绑定优先级高于 UNION。即，A UNION B INTERSECT C 将读取为 A UNION (B INTERSECT C)。

目前，FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 既不能针对 INTERSECT 结果指定，也不能针对 INTERSECT 的任何输入指定。

EXCEPT 子句

EXCEPT 子句具有以下常规格式

select_statement EXCEPT [ ALL | DISTINCT ] select_statement

select_statement 是任何不带 ORDER BY、LIMIT、FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 或 FOR KEY SHARE 子句的 SELECT 语句。

EXCEPT 运算符计算存在于左侧 SELECT 语句结果中但不存在右侧结果中的行集。

EXCEPT 的结果不包含任何重复行，除非指定了 ALL 选项。使用 ALL 时，左表中有 m 个重复行，右表中有 n 个重复行的行将在结果集中显示 max(m-n,0) 次。可以编写 DISTINCT 来明确指定消除重复行的默认行为。

同一 SELECT 语句中多个 EXCEPT 运算符从左向右求值，除非括号另有指示。 EXCEPT 的绑定级别与 UNION 相同。

目前，FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE 既不能针对 EXCEPT 结果指定，也不能针对 EXCEPT 的任何输入指定。

ORDER BY 子句

可选的 ORDER BY 子句具有以下常规格式

ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...]

ORDER BY 子句使结果行根据指定的表达式排序。如果两行根据最左边的表达式是相等的，则根据下一个表达式比较它们，依此类推。如果它们根据所有指定表达式都是相等的，则按与实现无关的顺序返回它们。

每个 expression 可能是输出列的名称或序号（SELECT 列表项），或者它可以是根据输入列值形成的任意表达式。

序号是指输出列按从左到右顺序所处的位置。此功能可用于根据没有唯一名称的列定义排序。由于总是可以使用 AS 子句为输出列指定名称，因此此功能并非绝对必要。

还可以使用 ORDER BY 子句中的任意表达式，包括那些未在 SELECT 输出列表中出现的列。因此以下语句有效：

SELECT name FROM distributors ORDER BY code;

此功能的一项限制是，应用于 UNION、INTERSECT 或 EXCEPT 子句结果的 ORDER BY 子句只能指定输出列名称或编号，而不能指定表达式。

如果 ORDER BY 表达式是一个简单名称，它既匹配输出列名称又匹配输入列名称，那么 ORDER BY 将将其解释为输出列名称。这与 GROUP BY 在相同情况下做出的选择相反。这种不一致是为了与 SQL 标准兼容。

可以选择在 ORDER BY 子句中的任何表达式后添加关键词 ASC（升序）或 DESC（降序）。如果未指定，则默认情况下假定为 ASC。此外，可以在 USING 子句中指定特定的排序运算符名称。排序运算符必须是某个 B 树运算符系列中的小于或大于运算符。ASC 通常等效于 USING <，DESC 通常等效于 USING >。（但用户定义数据类型的创建者可以精确定义默认排序顺序，它可能对应于其他名称的运算符。）

如果指定了 NULLS LAST，则在所有非空值之后对空值进行排序；如果指定了 NULLS FIRST，则在所有非空值之前对空值进行排序。如果两个都没有指定，当 ASC 被指定或暗示时，则默认行为是 NULLS LAST，当 DESC 被指定时，则是 NULLS FIRST（因此，默认行为是将空值视为大于非空值）。当 USING 被指定时，默认的空值排序取决于该运算符是小于运算符还是大于运算符。

请注意，排序选项仅适用于其后跟随的表达式；例如，ORDER BY x, y DESC 与 ORDER BY x DESC, y DESC 的含义不同。

字符字符串数据根据应用于正在排序的列的排序顺序进行排序。对于需求，可以通过在 expression 中包含 COLLATE 子句来覆盖该顺序，例如 ORDER BY mycolumn COLLATE "en_US"。有关详细信息，请参阅 第 4.2.10 节 和 第 23.2 节。

LIMIT 子句

LIMIT 子句由两个独立的子句组成

LIMIT { count | ALL }
OFFSET start

参数 count 指定要返回的最大行数，而 start 指定在开始返回行之前要跳过的行数。当两个参数都指定时，在开始计算要返回的 count 行之前跳过了 start 行。

如果 count 表达式求值为 NULL，则其被视为 LIMIT ALL，即没有限制。如果 start 求值为 NULL，则其被视为与 OFFSET 0 相同。

SQL:2008 引入了不同的语法来获得相同的结果，PostgreSQL 也支持该语法。它为

OFFSET start { ROW | ROWS }
FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES }

在此语法中，start 或 count 值在标准中要求是常量、参数或变量名称；作为 PostgreSQL 扩展，允许其他表达式，但通常需要将其括在括号中以避免歧义。如果在 FETCH 子句中省略 count，则其默认值为 1。 WITH TIES 选项用于返回根据 ORDER BY 子句与结果集中最后一行持平的任何其他行；在此情况下，ORDER BY 为强制性的，且不允许 SKIP LOCKED。 ROW 和 ROWS 以及 FIRST 和 NEXT 是不会影响这些子句效果的噪声词。根据标准，如果 OFFSET 子句和 FETCH 子句同时出现，则 OFFSET 子句必须出现在 FETCH 子句之前；但 PostgreSQL 较宽松，允许任何顺序。

使用 LIMIT 时，建议使用 ORDER BY 子句，对结果行按唯一顺序进行约束。否则，您将获得查询行的一个不可预测的子集——您可能请求查询第 10 至第 20 行，但按什么顺序排列的第 10 至第 20 行？除非您指定 ORDER BY，否则您不知道采用什么顺序。

查询计划器在生成查询计划时会将 LIMIT 考虑在内，因此，您很有可能根据用于 LIMIT 和 OFFSET 的内容得到不同的计划（产生不同的行顺序）。因此，如果不用 ORDER BY 强制执行可预测的结果排序，则使用不同的 LIMIT/OFFSET 值来选择查询结果的不同子集将产生不一致的结果。这不是缺陷，这是 SQL 不会承诺按任何特定顺序交付查询结果的事实所导致的固有结果，除非使用 ORDER BY 来约束顺序。

如果没有 ORDER BY 来强制选择确定性子集，甚至有可能重复执行同一 LIMIT 查询会返回表中行的一组不同子集。同样，这也不是缺陷，在这种情况中，结果的确定性只是没有得到保证。

锁定子句

FOR UPDATE、FOR NO KEY UPDATE、FOR SHARE 和 FOR KEY SHARE 是锁定子句；它们影响 SELECT 锁定从表中获取的行的方式。

锁定子句具有以下常规形式：

FOR lock_strength [ OF from_reference [, ...] ] [ NOWAIT | SKIP LOCKED ]

其中 lock_strength 可以为以下一项：

UPDATE
NO KEY UPDATE
SHARE
KEY SHARE

from_reference 必须是 FROM 子句中引用的表别名或非隐藏的表_名称。若要了解更多有关每个行级锁定模式的信息，请参阅第 13.3.2 节。

若要防止操作等待其他事务提交，请使用 NOWAIT 或 SKIP LOCKED 选项。对于 NOWAIT，如果所选行无法立即锁定，则语句会报告错误，而不是等待。对于 SKIP LOCKED，将跳过任何无法立即锁定的所选行。跳过锁定的行会提供数据的不一致视图，因此不适合进行一般用途的工作，但可以用来避免多个使用者访问类似队列的表时的锁竞争。请注意，NOWAIT 和 SKIP LOCKED 仅适用于行级锁，仍按照普通方式获取必需的 ROW SHARE 表级锁（请参阅 章节 13）。如果您需要获取表级锁而不等待，可以先将 LOCK 与 NOWAIT 选项结合使用。

如果在锁定子句中指定了特定表，那么只锁定来自这些表的行；在 SELECT 中使用的任何其他表只作普通读取。无表列表的锁定子句会影响语句中使用的所有表。如果将锁定子句应用于视图或子查询，则会影响视图或子查询中使用的所有表。但这些子句不适用于主查询引用的 WITH 查询。如果您希望在 WITH 查询中发生行锁定，请在 WITH 查询中指定锁定子句。

如果需要为不同表指定不同的锁定行为，则可以编写多个锁定子句。如果一张表被多个锁定子句提及（或隐式受影响），那么将对其进行处理，就好像它只由最强的子句指定一样。类似地，如果在影响一张表的任何子句中指定了 NOWAIT，则该表将按 NOWAIT 处理。否则，如果在影响它的任何子句中指定了 SKIP LOCKED，则将按 SKIP LOCKED 处理。

无法在返回行无法与各个表行清晰关联的上下文中使用锁定子句；例如，它们不能与聚合一起使用。

当一个锁定从句出现在 SELECT 查询的顶级时，被锁定的行正是查询返回的行；对于一个联接查询，被锁定的行是那些有助于返回联接行的行。此外，满足查询条件的行从查询快照开始将被锁定，尽管如果它们在快照之后被更新并且不再满足查询条件，它们将不会被返回。如果使用了 LIMIT，锁定一旦停止就足以返回行以满足限制（但请注意 OFFSET 跳过的行将被锁定）。类似地，如果锁定从句在游标的查询中使用，则只有游标实际获取或跨步过去的行将被锁定。

当锁定从句出现在子-SELECT 中，被锁定的行由子查询返回给外部查询的行。这可能涉及比单独检查子查询更少的行，因为外部查询中的条件可能用于优化子查询的执行。例如，

SELECT * FROM (SELECT * FROM mytable FOR UPDATE) ss WHERE col1 = 5;

只会锁定具有 col1 = 5 的行，即使该条件不在子查询中。

早期版本未能保留由稍后的保存点升级的锁定。例如，此代码

BEGIN;
SELECT * FROM mytable WHERE key = 1 FOR UPDATE;
SAVEPOINT s;
UPDATE mytable SET ... WHERE key = 1;
ROLLBACK TO s;

将无法保留 FOR UPDATE 锁，在 ROLLBACK TO 之后。此问题在第 9.3 版中已得到修复。

SELECT * FROM (SELECT * FROM mytable FOR UPDATE) ss ORDER BY column1;

TABLE 命令

该命令

TABLE name

相当于

SELECT * FROM name

可将它用作顶级命令，也可将其用作复杂查询部分中的空间节省语法变体。通过 TABLE 只能使用 WITH、UNION、INTERSECT、EXCEPT、ORDER BY、LIMIT、OFFSET、FETCH 和 FOR 锁定子句；不能使用 WHERE 子句和任何聚合形式。

省略的 FROM 子句

PostgreSQL 允许省略 FROM 子句。它可以用直接的方式计算简单表达式的结果

SELECT 2+2;

 ?column?
----------
        4

其他一些SQL数据库无法做到这一点，除非引入伪单行表，再从中执行 SELECT。

空的 SELECT 列表

SELECT 之后的输出表达式列表可以为空，产生零列结果表。根据 SQL 标准，这不是有效的语法。 PostgreSQL 允许该语法，以保持与允许零列表的兼容性。但是，当使用 DISTINCT 时，不允许空列表。

省略 AS 关键字

在 SQL 标准中，当新列名称是有效列名称（即，与任何保留关键字不同）时，可以在输出列名称之前省略可选关键字 AS。 PostgreSQL 略微严格一些：如果新列名称与任何关键字（保留关键字或非保留关键字）匹配，则需要 AS。建议使用 AS 或双引号输出列名称，以避免与未来添加的关键字发生任何可能的冲突。

在 FROM 项中，标准和 PostgreSQL 都允许在别名（非保留关键字）之前省略 AS。但是，由于语法歧义，对于输出列名称来说，这是不切实际的。

在 FROM 中省略子-SELECT 别名

根据 SQL 标准，FROM 列表中的子-SELECT 必须具有别名。在 PostgreSQL 中，可以省略此别名。

ONLY 和继承

编写 ONLY 时，SQL 标准要求用括号括起表名称，例如 SELECT * FROM ONLY (tab1), ONLY (tab2) WHERE ...。 PostgreSQL 认为这些括号是可选的。

PostgreSQL 允许编写尾随 * 来明确指定非-ONLY 行为（包括子表）。标准不允许这样做。

（这些要点同样适用于支持 ONLY 选项的所有 SQL 命令。）

TABLESAMPLE 子句限制

目前 TABLESAMPLE 子句仅适用于常规表和物化视图。根据 SQL standard，它应该能够应用于任何 FROM 项。

在 FROM 中调用函数

PostgreSQL 允许直接在 FROM 列表中将函数调用写做成员。在 SQL standard 中需要将这样的函数调用包装在一个子 SELECT 中；例如，语法 FROM func(...) alias 大致等效于 FROM LATERAL (SELECT func(...)) alias。注意 LATERAL 被视为隐式的；这是因为标准要求在 FROM 中将 UNNEST() 项的语义设为 LATERAL 语义。PostgreSQL 将 UNNEST() 与其他返回集合的函数视为相同。

向 GROUP BY 和 ORDER BY 可用的命名空间

在 SQL-92 标准中，ORDER BY 子句只能使用输出列名或编号，而 GROUP BY 子句只能使用基于输入列名的表达式。PostgreSQL 对这两个子句进行了扩展，也允许以另一种选择作为选取标准（但是如果出现歧义，PostgreSQL 会使用标准的诠释）。PostgreSQL 还允许这两个子句指定任意的表达式。注意出现在表达式中的名称始终作为输入列名处理，而不是作为输出列名处理。

SQL:1999 及更高版本使用略有不同的定义，与 SQL-92 并非完全向后兼容。但在大多数情况下，PostgreSQL 对 ORDER BY 或 GROUP BY 表达式的诠释与 SQL:1999 相同。

函数相关性

PostgreSQL 仅在表的主键包含在 GROUP BY 列表中时才识别出函数相关性（允许从 GROUP BY 中省略列）。SQL standard 规定了应当识别出的其他条件。

LIMIT 和 OFFSET

子句 LIMIT 和 OFFSET 是 PostgreSQL 的特定语法，MySQL 也使用。SQL:2008 标准引入了子句 OFFSET ... FETCH {FIRST|NEXT} ... 用于与上述 LIMIT 子句 相同的功能。该语法也由 IBM DB2 使用。（针对 Oracle 编写的应用程序经常使用涉及自动生成的 rownum 列的解决方法，PostgreSQL 中没有该列，以实现这些子句的效果。）

FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE、FOR KEY SHARE

虽然 FOR UPDATE 在 SQL 标准中出现，但该标准仅将其允许为 DECLARE CURSOR 的一个选项。PostgreSQL 在任何 SELECT 查询以及子 SELECT 中也允许使用，但这是个扩展。该 FOR NO KEY UPDATE、FOR SHARE 和 FOR KEY SHARE 变体以及 NOWAIT 和 SKIP LOCKED 选项不会出现在该标准中。

在 WITH 中的数据修改语句

PostgreSQL 允许 INSERT、UPDATE、DELETE 和 MERGE 被用作 WITH 查询。这在 SQL 标准中找不到。

非标准子句

DISTINCT ON ( ... ) 是 SQL 标准的一个扩展。

ROWS FROM( ... ) 是 SQL 标准的一个扩展。

该 MATERIALIZED 和 NOT MATERIALIZED 选项的 WITH 是 SQL 标准的一个扩展。