WITH 子句

WITH 子句允许您指定一个或多个子查询，这些子查询可以在主查询中通过名称进行引用。子查询在主查询持续期间实际上充当临时表或视图。每个子查询可以是 SELECT、TABLE、VALUES、INSERT、UPDATE 或 DELETE 语句。在 WITH 中编写数据修改语句（INSERT、UPDATE 或 DELETE）时，通常会包含一个 RETURNING 子句。主查询读取的临时表形成的是 RETURNING 的输出，而不是 语句修改的基础表。如果省略了 RETURNING，该语句仍会被执行，但它不会产生输出，因此主查询无法将其作为表进行引用。

必须为每个 WITH 查询指定一个名称（不带模式限定）。还可以选择指定列名称列表；如果省略此列表，则列名称将从子查询中推断出来。

如果指定了 RECURSIVE，它允许 SELECT 子查询通过名称引用自身。此类子查询必须具有以下形式

non_recursive_term UNION [ ALL | DISTINCT ] recursive_term

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

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

当 WITH 子句中有多个查询时，RECURSIVE 应仅在 WITH 之后立即编写一次。它适用于 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。这相当于在具有各个分组集作为其 GROUP BY 子句的子查询之间构造 UNION ALL。可选的 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 中引用的每一列都必须明确引用分组列，除非引用出现在聚合函数中或未分组的列在功能上依赖于分组列。

即使没有 GROUP BY 子句，HAVING 的存在也会将查询变成分组查询。这与查询包含聚合函数但没有 GROUP BY 子句时发生的情况相同。所有选定的行都被视为形成一个组，并且 SELECT 列表和 HAVING 子句只能引用聚合函数中的表列。如果 HAVING 条件为真，则此类查询将发出单行；如果为假，则发出零行。

当前，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 时指定 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。

The default framing option is RANGE UNBOUNDED PRECEDING, which is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW; it sets the frame to be all rows from the partition start up through the current row's last peer (a row that the window's ORDER BY clause considers equivalent to the current row; all rows are peers if there is no ORDER BY). In general, UNBOUNDED PRECEDING means that the frame starts with the first row of the partition, and similarly UNBOUNDED FOLLOWING means that the frame ends with the last row of the partition, regardless of RANGE, ROWS or GROUPS mode. In ROWS mode, CURRENT ROW means that the frame starts or ends with the current row; but in RANGE or GROUPS mode it means that the frame starts or ends with the current row's first or last peer in the ORDER BY ordering. The offset PRECEDING and offset FOLLOWING options vary in meaning depending on the frame mode. In ROWS mode, the offset is an integer indicating that the frame starts or ends that many rows before or after the current row. In GROUPS mode, the offset is an integer indicating that the frame starts or ends that many peer groups before or after the current row's peer group, where a peer group is a group of rows that are equivalent according to the window's ORDER BY clause. In RANGE mode, use of an offset option requires that there be exactly one ORDER BY column in the window definition. Then the frame contains those rows whose ordering column value is no more than offset less than (for PRECEDING) or more than (for FOLLOWING) the current row's ordering column value. In these cases the data type of the offset expression depends on the data type of the ordering column. For numeric ordering columns it is typically of the same type as the ordering column, but for datetime ordering columns it is an interval. In all these cases, the value of the offset must be non-null and non-negative. Also, while the offset does not have to be a simple constant, it cannot contain variables, aggregate functions, or window functions.

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 子句可以节省输入。

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

窗口函数在 第 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 语句必须生成相同数量的列，并且相应列必须具有兼容的数据类型。

除非指定了 ALL 选项，否则 UNION 的结果不包含任何重复行。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)。

目前，对于 INTERSECT 结果或 INTERSECT 的任何输入，都无法指定 FOR NO KEY UPDATE、FOR UPDATE、FOR SHARE 和 FOR KEY SHARE。

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 语句结果中但不在右 SELECT 语句结果中的行集。

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

同一 EXCEPT 演算符が同じ SELECT ステートメント内にある場合、括弧で指定しない限り、左から右に評価されます。 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 句により、結果行は指定された式に従ってソートされます。2 つの行が最左の式に従って等しい場合、それらは次の式に従って比較されます。指定されたすべての式に従って等しい場合、それらは実装依存の順序で返されます。

各 式 は出力列の名前または序数 (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 节 和 第 24.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 子句，将结果行约束为一个唯一顺序。否则，你将获得查询行的一个不可预测的子集——你可能要求第十到第二十行，但第十到第二十行的排序是什么？除非你指定 ORDER BY，否则你不知道排序是什么。

查询计划器在生成查询计划时会考虑 LIMIT，因此你很可能会根据对 LIMIT 和 OFFSET 的使用获得不同的计划（产生不同的行顺序）。因此，使用不同的 LIMIT/OFFSET 值来选择查询结果的不同子集 将给出不一致的结果，除非你使用 ORDER BY 强制执行可预测的结果排序。这不是一个错误；这是 SQL 不承诺以任何特定顺序提供查询结果这一事实的固有结果，除非使用 ORDER BY 来约束顺序。

如果未指定 ORDER BY 以强制选择确定性子集，则即使重复执行相同的 LIMIT 查询，也可能返回表中行的不同子集。同样，这不是一个错误；在这种情况下，结果的确定性根本无法得到保证。

锁定子句

FOR UPDATE、FOR NO KEY UPDATE、FOR SHARE 和 FOR KEY SHARE 是 锁定子句；它们影响 SELECT 在从表中获取行时如何锁定这些行。

锁定子句的一般形式为

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

其中 lock_strength 可以为以下之一

UPDATE
NO KEY UPDATE
SHARE
KEY SHARE

有关每种行级锁定模式的更多信息，请参阅 第 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;

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

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

TABLE 命令

命令

TABLE name

等效于

SELECT * FROM name

它可以用作顶级命令或用作复杂查询部分中的节省空间的语法变体。只有 WITH、UNION、INTERSECT、EXCEPT、ORDER BY、LIMIT、OFFSET、FETCH 和 FOR 锁定子句可与 TABLE 一起使用；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 和继承

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

PostgreSQL 允许编写尾随 * 以明确指定包括子表的非 ONLY 行为。该标准不允许这样做。

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

TABLESAMPLE 子句限制

目前仅接受常规表和物化视图中的 TABLESAMPLE 子句。根据 SQL 标准，应该可以将其应用于任何 FROM 项。

FROM 中的函数调用

PostgreSQL 允许将函数调用直接写为 FROM 列表的成员。在 SQL 标准中，有必要将此类函数调用包装在子 SELECT 中；也就是说，语法 FROM func(...) alias 大致相当于 FROM LATERAL (SELECT func(...)) alias。请注意，LATERAL 被认为是隐式的；这是因为该标准要求 LATERAL 语义用于 FROM 中的 UNNEST() 项。 PostgreSQL 将 UNNEST() 与其他返回集的函数视为相同。

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

在 SQL-92 标准中，ORDER BY 子句只能使用输出列名或数字，而 GROUP BY 子句只能使用基于输入列名的表达式。 PostgreSQL 扩展了这两个子句，以允许另一个选择（但在存在歧义时使用该标准的解释）。 PostgreSQL 还允许这两个子句指定任意表达式。请注意，表达式中出现的名称将始终被视为输入列名，而不是输出列名。

SQL:1999 及更高版本使用略有不同的定义，该定义与 SQL-92 并不完全向上兼容。然而，在大多数情况下，PostgreSQL 将以 SQL:1999 的方式解释 ORDER BY 或 GROUP BY 表达式。

函数依赖关系

PostgreSQL 仅在表的主键包含在 GROUP BY 列表中时才识别函数依赖关系（允许从 GROUP BY 中省略列）。SQL 标准指定应识别的其他条件。

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 用作 WITH 查询。这在 SQL 标准中找不到。

非标准子句

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

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

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