Question

名称

SELECT--从表或视图中取出若干行

语法

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
    * | expression [ AS output_name ] [, ...]
    [ FROM from_item [, ...] ]
    [ WHERE condition ]
    [ GROUP BY expression [, ...] ]
    [ HAVING condition [, ...] ]
    [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    [ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]

这里的 from_item 可以是：

    [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
    ( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
    function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
    function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
    from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]

描述

SELECT 将从零个或更多表中返回记录行。SELECT 通常的处理如下：

1. 计算列出在 FROM 中的所有元素(FROM 列表中的每个元素都是一个实际的或虚拟的表)。如果在 FROM 列表里声明了多个元素，那么他们就交叉连接在一起(参见下面的 FROM 子句)。

2. 如果声明了 WHERE 子句，那么在输出中消除所有不满足条件的行。参见下面的 WHERE 子句。

3. 如果声明了 GROUP BY 子句，输出就分成匹配一个或多个数值的不同组里。如果出现了 HAVING 子句，那么它消除那些不满足给出条件的组。参见下面的 GROUP BY 子句 和 HAVING 子句。

4. 实际输出行将使用 SELECT 输出表达式针对每一个选中的行进行计算。参见下面的 SELECT 列表。

5. 使用 UNION, INTERSECT, EXCEPT 可以把多个 SELECT 语句的输出合并成一个结果集。UNION 操作符返回两个结果集的并集。INTERSECT 操作符返回两个结果集的交集。EXCEPT 操作符返回在第一个结果集对第二个结果集的差集。不管哪种情况，重复的行都被删除，除非声明了 ALL 。参阅下面的 UNION 子句、INTERSECT 子句、EXCEPT 子句。

6. 如果声明了 ORDER BY 子句，那么返回的行将按照指定的顺序排序。如果没有给出 ORDER BY ，那么数据行是按照系统认为可以最快生成的顺序给出的。参阅下面的 ORDER BY 子句。

7. DISTINCT 从结果中删除那些重复的行。DISTINCT ON 删除那些匹配所有指定表达式的行。ALL(缺省)将返回所有候选行，包括重复的。参阅下面的 DISTINCT 子句。

8. 如果给出了 LIMIT 或 OFFSET 子句，那么 SELECT 语句只返回结果行的一个子集。参阅下面的 LIMIT 子句。

9. 如果声明了 FOR UPDATE 或 FOR SHARE 子句，那么 SELECT 语句对并发的更新锁住选定的行。参阅下面的 FOR UPDATE/FOR SHARE 子句。

你必须有 SELECT 权限用来从表中读取数值。使用 FOR UPDATE 或 FOR SHARE 还要求 UPDATE 权限。

参数

FROM 子句

FROM 子句为 SELECT 声明一个或者多个源表。如果声明了多个源表，那么结果就是所有源表的笛卡儿积(交叉连接)。但是通常会添加一些条件，把返回行限制成笛卡儿积的一个小的子集。

FROM 子句可以包括下列元素：

table_name

一个现存的表或视图的名字(可以有模式修饰)。如果声明了 ONLY ，则只扫描该表；否则，该表和所有其派生表(如果有的话)都被扫描。可以在表名后面跟一个 * 表示扫所有其后代表，但在目前的版本里，这是缺省特性。缺省的特性可以通过修改配置选项 sql_inheritance 来改变。

alias

为那些包含别名的 FROM 项目取的别名。别名用于缩写或者在自连接中消除歧义(自连接中同一个表将扫描多次)。如果提供了别名，那么它就会完全隐藏表或者函数的实际名字；比如，如果给出 FROM foo AS f ，那么 SELECT 剩下的东西必须把这个 FROM 项按照 f 而不是 foo 引用。如果写了别名，也可以提供一个字段别名列表，这样可以替换表中一个或者多个字段的名字。

select

可以在 FROM 子句里出现一个子 SELECT 。它的输出作用好像是为这条 SELECT 命令在其生存期里创建一个临时表。请注意这个子 SELECT 必须用园括弧包围。并且必须给它一个别名。当然，VALUES 同样也可以在这里使用。

function_name

函数(特别是那些返回结果集的函数)调用可以出现在 FROM 子句里。这么做就好像在这个 SELECT 命令的生命期中，把函数的输出创建为一个临时表一样。当然也可以使用别名。如果写了别名，还可以写一个字段别名列表，为函数返回的复合类型的一个或多个属性提供名字替换。如果函数定义为返回 record 类型，那么必须出现一个 AS 关键字或者别名，后面跟着一个形如 ( column_name data_type [, ...] ) 的字段定义列表。这个字段定义列表必须匹配函数返回的字段的实际数目和类型。

join_type

下列之一

• [ INNER ] JOIN

• LEFT [ OUTER ] JOIN

• RIGHT [ OUTER ] JOIN

• FULL [ OUTER ] JOIN

• CROSS JOIN

必须为 INNER 和 OUTER 连接类型声明一个连接条件，也就是 NATURAL, ON join_condition, USING (join_column [, ...]) 之一。它们的含义见下文，对于 CROSS JOIN 而言，这些子句都不能出现。

一个 JOIN 子句组合两个 FROM 项。必要时使用圆括弧以决定嵌套的顺序。如果没有圆括弧，JOIN 从左向右嵌套。在任何情况下，JOIN 都比逗号分隔的 FROM 项绑定得更紧。

CROSS JOIN 和 INNER JOIN 生成一个简单的笛卡儿积，和你在 FROM 的顶层列出两个项的结果相同。CROSS JOIN 等效于 INNER JOIN ON (TRUE) ，也就是说，没有被条件删除的行。这种连接类型只是符号上的方便，因为它们和你用简单的 FROM 和 WHERE 的效果一样。

LEFT OUTER JOIN 返回笛卡儿积中所有符合连接条件的行，再加上左表中通过连接条件没有匹配右表行的那些行。这样，左边的行将扩展成生成表的全长，方法是在那些右表对应的字段位置填上 NULL 。请注意，只在计算匹配的时候，才使用 JOIN 子句的条件，外层的条件是在计算完毕之后施加的。

相应的，RIGHT OUTER JOIN 返回所有内连接的结果行，加上每个不匹配的右边行(左边用 NULL 扩展)。这只是一个符号上的便利，因为总是可以把它转换成一个 LEFT OUTER JOIN ，只要把左边和右边的输入对掉一下即可。

FULL OUTER JOIN 返回所有内连接的结果行，加上每个不匹配的左边行(右边用 NULL 扩展)，再加上每个不匹配的右边行(左边用 NULL 扩展)。

ON join_condition

一个生成 boolean 类型结果的表达式(类似 WHERE 子句)，限定连接中那些行是匹配的。

USING (join_column [, ...])

一个形如 USING ( a, b, ... ) 的子句，是 ON left_table.a = right_table.a AND left_table.b = right_table.b ... 的缩写。同样，USING 蕴涵着每对等效字段中只有一个包含在连接输出中，而不是两个都输出的意思。

NATURAL

NATURAL 是一个 USING 列表的缩写，这个列表说的是两个表中同名的字段。

WHERE 子句

可选的 WHERE 条件有如下常见的形式：

WHERE condition

这里 condition 可以是任意生成类型为 boolean 的表达式。任何不满足这个条件的行都会从输出中删除。如果一个行的数值代入到条件中计算出来的结果为真，那么该行就算满足条件。

GROUP BY 子句

可选的 GROUP BY 子句的一般形式

GROUP BY expression [, ...]

它将把所有在组合表达式上拥有相同值的行压缩成一行。expression 可以是一个输入字段名字，或者是一个输出字段(SELECT 列表项)的名字或序号，或者也可以是任意输入字段组成的表达式。在有歧义的情况下，一个 GROUP BY 的名字将被解释成输入字段的名字，而不是输出字段的名字。

如果使用了聚集函数，那么就会对每组中的所有行进行计算并生成一个单独的值(而如果没有 GROUP BY ，那么聚集将对选出来的所有行计算出一个单独的值)。如果出现了 GROUP BY ，那么 SELECT 列表表达式中再引用那些没有分组的字段就是非法的，除非放在聚集函数里，因为对于未分组的字段，可能会返回多个数值。

HAVING 子句

可选的 HAVING 子句有如下形式：

HAVING condition

这里 condition 与为 WHERE 子句里声明的相同。

HAVING 去除了一些不满足条件的组行。它与 WHERE 不同：WHERE 在使用 GROUP BY 之前过滤出单独的行，而 HAVING 过滤由 GROUP BY 创建的行。在 condition 里引用的每个字段都必须无歧义地引用一个分组的行，除非引用出现在一个聚集函数里。

HAVING 的出现把查询变成一个分组的查询，即使没有 GROUP BY 子句也这样。这一点和那些包含聚集函数但没有 GROUP BY 子句的查询里发生的事情是一样的。所有选取的行都被认为会形成一个单一的组，而 SELECT 列表和 HAVING 子句只能从聚集函数里面引用表的字段。这样的查询在 HAVING 条件为真的时候将发出一个行，如果为非真，则返回零行。

SELECT 列表

SELECT 列表(在 SELECT 和 FROM 关键字之间的部分)声明组成 SELECT 语句的输出行的表达式。这些表达式可以(并且通常也会)引用在 FROM 子句里面计算出来的字段。通过使用子句 AS output_name 可以为输出字段取个别名。这个别名通常用于输出字段的显示。它也可以用于在 ORDER BY 和 GROUP BY 子句中引用字段值，但是不能在 WHERE 或 HAVING 子句中使用；在那里你必须使用表达式本身。

除了表达式，也可以在输出列表中使用 * 表示所有字段。还可以用 table_name.* 作为来自该表的所有字段的缩写。

UNION 子句

UNION 子句的一般形式是：

select_statement UNION [ ALL ] select_statement

这里的 select_statement 是任意没有 ORDER BY, LIMIT, FOR UPDATE, FOR SHARE 子句的 SELECT 语句。如果用圆括弧包围，ORDER BY 和 LIMIT 可以附着在子表达式里。如果没有圆括弧，这些子句将交给 UNION 的结果使用，而不是给它们右边的输入表达式。

UNION 操作符计算那些涉及到的所有 SELECT 语句返回的行的结果联合。一个行如果至少在两个结果集中的一个里面出现，那么它就会在这两个结果集的集合联合中。两个作为 UNION 直接操作数的 SELECT 必须生成相同数目的字段，并且对应的字段必须有兼容的数据类型。

缺省的 UNION 结果不包含任何重复的行，除非声明了 ALL 子句。ALL 制止了消除重复的动作。因此，UNION ALL 通常比 UNION 明显要快，可能的情况下尽量使用 ALL 。

同一个 SELECT 语句中的多个 UNION 操作符是从左向右计算的，除非用圆括弧进行了标识。

目前，FOR UPDATE 和 FOR SHARE 不能在 UNION 的结果或输入中声明。

INTERSECT 子句

INTERSECT 子句的一般形式是：

select_statement INTERSECT [ ALL ] select_statement

select_statement 是任何不带 ORDER BY, LIMIT, FOR UPDATE, FOR SHARE 子句的 SELECT 语句。

INTERSECT 计算涉及的 SELECT 语句返回的行集合的交集。如果一个行在两个结果集中都出现，那么它就在两个结果集的交集中。

INTERSECT 的结果不包含任何重复行，除非你声明了 ALL 选项。用了 ALL 以后，一个在左边的表里有 m 个重复而在右边表里有 n 个重复的行将出现 min(m, n) 次。

除非用圆括号指明顺序，同一个 SELECT 语句中的多个 INTERSECT 操作符是从左向右计算的。INTERSECT 比 UNION 绑定得更紧，也就是说 A UNION B INTERSECT C 将理解成 A UNION (B INTERSECT C) ，除非你用圆括弧声明。

目前，不能给 INTERSECT 的结果或者任何 INTERSECT 的输入声明 FOR UPDATE 和 FOR SHARE 。

EXCEPT 子句

EXCEPT 子句有如下的通用形式：

select_statement EXCEPT [ ALL ] select_statement

select_statement 是任何没有 ORDER BY, LIMIT, FOR UPDATE, FOR SHARE 子句的 SELECT 表达式。

EXCEPT 操作符计算存在于左边 SELECT 语句的输出而不存在于右边 SELECT 语句输出的行。

EXCEPT 的结果不包含任何重复的行，除非声明了 ALL 选项。使用 ALL 时，一个在左边表中有 m 个重复而在右边表中有 n 个重复的行将在结果中出现 max(m-n,0) 次。

除非用圆括弧指明顺序，否则同一个 SELECT 语句中的多个 EXCEPT 操作符是从左向右计算的。EXCEPT 和 UNION 的绑定级别相同。

目前，不能给 EXCEPT 的结果或者任何 EXCEPT 的输入声明 FOR UPDATE 或 FOR SHARE 子句。

ORDER BY 子句

可选的 ORDER BY 子句有下面的一般形式：

ORDER BY expression [ ASC | DESC | USING operator ] [, ...]

expression 可以是一个输出字段(SELECT 列表项)的名字或者序号，或者也可以是用输入字段的数值组成的任意表达式。

ORDER BY 子句导致结果行根据指定的表达式进行排序。如果根据最左边的表达式，两行的结果相同，那么就根据下一个表达式进行比较，依此类推。如果对于所有声明的表达式他们都相同，那么按随机顺序返回。

序数指的是字段按顺序(从左到右)的位置。这个特性可以对没有唯一名称的字段进行排序。这不是必须的，因为总是可以通过 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(降序)关键字。还可以在 USING 子句里声明一个排序操作符来实现排序。ASC 等效于使用 USING < 而 DESC 等效于使用 USING > 。但是一个用户定义类型的创建者可以明确定义缺省的排序顺序，并且可以使用其他名称的操作符。

NULL 被认为比其他值都大。换句话说，升序排序时，NULL 排在末尾，而降序排序时 NULL 排在开头。

字符类型的数据是按照区域相关的字符集顺序排序的，这个区域是在数据库集群初始化的时候建立的。

DISTINCT 子句

如果声明了 DISTINCT ，那么就从结果集中删除所有重复的行(每个有重复的组都保留一行)。ALL 声明相反的作用：所有行都被保留(这是缺省)。

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 组里面需要的行的优先级。

LIMIT 子句

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

LIMIT { count | ALL }
OFFSET start

count 声明返回的最大行数，而 start 声明开始返回行之前忽略的行数。如果两个都指定了，那么在开始计算 count 个返回行之前将先跳过 start 行。

使用 LIMIT 的一个好习惯是使用一个 ORDER BY 子句把结果行限制成一个唯一的顺序。否则你会得到无法预料的结果子集，你可能想要第十行到第二十行，除非你声明 ORDER BY ，否则你不知道什么顺序。

查询优化器在生成查询规划时会把 LIMIT 考虑进去，所以你很有可能因给出的 LIMIT 和 OFFSET 值不同而得到不同的规划(生成不同的行序)。因此用不同的 LIMIT/OFFSET 值选择不同的查询结果的子集将不会产生一致的结果，除非你用 ORDER BY 强制生成一个可预计的结果顺序。这可不是 bug ；这是 SQL 生来的特点，因为除非用了 ORDER BY 约束顺序，SQL 不保证查询生成的结果有任何特定的顺序。

FOR UPDATE/FOR SHARE 子句

FOR UPDATE 子句的形式如下：

FOR UPDATE [ OF table_name [, ...] ] [ NOWAIT ]

很相近的 FOR SHARE 子句的形式如下：

FOR SHARE [ OF table_name [, ...] ] [ NOWAIT ]

FOR UPDATE 令那些被 SELECT 检索出来的行被锁住，就像要更新一样。这样就避免它们在当前事务结束前被其它事务修改或者删除；也就是说，其它企图 UPDATE, DELETE, SELECT FOR UPDATE 这些行的事务将被阻塞，直到当前事务结束。同样，如果一个来自其它事务的 UPDATE, DELETE, SELECT FOR UPDATE 已经锁住了某个或某些选定的行，SELECT FOR UPDATE 将等到那些事务结束，并且将随后锁住并返回更新的行(或者不返回行，如果行已经被删除)。更多的讨论参阅章12。

为了避免操作等待其它事务提交，使用 NOWAIT 选项。如果被选择的行不能立即被锁住，那么 SELECT FOR UPDATE NOWAIT 将会立即汇报一个错误，而不是等待。请注意，NOWAIT 只适用于行级别的锁，要求的表级锁 ROW SHARE 仍然以通常的方法进行(参阅 章12)。如果需要申请表级别的锁同时又不等待，那么你可以使用 LOCK 的 NOWAIT 选项。

FOR SHARE 的行为类似，只是它在每个检索出来的行上要求一个共享锁，而不是一个排它锁。一个共享锁阻塞其它事务在这些行上执行 UPDATE, DELETE, SELECT FOR UPDATE 却不阻止他们执行 SELECT FOR SHARE 。

如果在 FOR UPDATE 或 FOR SHARE 中明确指定了表名字，那么将只有这些指定的表被锁定，其他在 SELECT 中使用的表将不会被锁定。一个其后不带表列表的 FOR UPDATE 或 FOR SHARE 子句将锁定该命令中所有使用的表。如果 FOR UPDATE 或 FOR SHARE 应用于一个视图或者子查询，它同样将锁定所有该视图或子查询中使用到的表。

多个 FOR UPDATE 和 FOR SHARE 子句可以用于为不同的表指定不同的锁定模式。如果一个表出同时出现(或隐含同时出现)在 FOR UPDATE 和 FOR SHARE 子句中，那么将按照 FOR UPDATE 处理。类似的，如果影响一个表的任意子句中出现了 NOWAIT ，那么该表将按照 NOWAIT 处理。

FOR UPDATE 和 FOR SHARE 不能在那些无法使用独立的表行清晰标识返回行的环境里；比如，它不能和聚集一起使用。

警告

不要先锁定一个行然后在随后的保存点或 PL/pgSQL 异常块中修改它。因为如果后来回滚的话将导致这个快丢失。例如， BEGIN; SELECT * FROM mytable WHERE key = 1 FOR UPDATE; SAVEPOINT s; UPDATE mytable SET ... WHERE key = 1; ROLLBACK TO s; ROLLBACK 之后，该行将被解锁，而不是返回其上一个保存点状态(被锁定但未被修改)。如果一个在当前事务中锁定的行被更新或删除，或者一个共享锁被升级为排它锁，这种情况就可能会出现。在这两种情况下，先前的锁状态将被遗忘。如果事务后来回滚到一个介于最初锁命令和后来变更了锁状态之间的某个点，那么该行将表现得好像根本没有被锁定一样。这个实现上的缺陷可能在将来的 PostgreSQL 版本中得到修补。

警告

一个SELECT 命令可以同时使用 LIMIT 和 FOR UPDATE/SHARE ，这种情况下，它返回的行数可能比 LIMIT 声明的少。这是因为 LIMIT 先生效。命令选取指定数目的数据行，但是可能会在其中一行或多行上获取锁的时候被阻塞。但 SELECT 的阻塞被解除后，该行可能已经被删除或者更新了，因此不再满足查询的 WHERE 条件，在这种情况下，不会返回它。

例子

将表 films 和表 distributors 连接在一起：

SELECT f.title, f.did, d.name, f.date_prod, f.kind
    FROM distributors d, films f
    WHERE f.did = d.did

       title       | did |     name     | date_prod  |   kind
-------------------+-----+--------------+------------+----------
 The Third Man     | 101 | British Lion | 1949-12-23 | Drama
 The African Queen | 101 | British Lion | 1951-08-11 | Romantic
 ...

统计用 kind 分组的每组电影的长度(len)总和：

SELECT kind, sum(len) AS total FROM films GROUP BY kind;

   kind   | total
----------+-------
 Action   | 07:34
 Comedy   | 02:58
 Drama    | 14:28
 Musical  | 06:42
 Romantic | 04:38

统计用 kind 分组的每组电影的长度(len)总和不足五小时的组：

SELECT kind, sum(len) AS total
    FROM films
    GROUP BY kind
    HAVING sum(len) < interval '5 hours';

   kind   | total
----------+-------
 Comedy   | 02:58
 Romantic | 04:38

下面两个例子是根据第二列(name)的内容对单独的结果排序的经典的方法：

SELECT * FROM distributors ORDER BY name;
SELECT * FROM distributors ORDER BY 2;

 did |       name
-----+------------------
 109 | 20th Century Fox
 110 | Bavaria Atelier
 101 | British Lion
 107 | Columbia
 102 | Jean Luc Godard
 113 | Luso films
 104 | Mosfilm
 103 | Paramount
 106 | Toho
 105 | United Artists
 111 | Walt Disney
 112 | Warner Bros.
 108 | Westward

下面这个例子演示如何获得表 distributors 和 actors 的连接，只将每个表中以字母 W 开头的取出来。因为只取了不重复的行，所以关键字 ALL 被省略了：

distributors:               actors:
 did |     name              id |     name
-----+--------------        ----+----------------
 108 | Westward               1 | Woody Allen
 111 | Walt Disney            2 | Warren Beatty
 112 | Warner Bros.           3 | Walter Matthau
 ...                         ...

SELECT distributors.name
    FROM distributors
    WHERE distributors.name LIKE 'W%'
UNION
SELECT actors.name
    FROM actors
    WHERE actors.name LIKE 'W%';

      name
----------------
 Walt Disney
 Walter Matthau
 Warner Bros.
 Warren Beatty
 Westward
 Woody Allen

这个例子显示了如何在 FROM 子句中使用函数，包括带有和不带字段定义列表的。

CREATE FUNCTION distributors(int) RETURNS SETOF distributors AS $$
    SELECT * FROM distributors WHERE did = $1;
$$ LANGUAGE SQL;

SELECT * FROM distributors(111);
 did |    name
-----+-------------
 111 | Walt Disney

CREATE FUNCTION distributors_2(int) RETURNS SETOF record AS $$
    SELECT * FROM distributors WHERE did = $1;
$$ LANGUAGE SQL;

SELECT * FROM distributors_2(111) AS (f1 int, f2 text);
 f1  |     f2
-----+-------------
 111 | Walt Disney

兼容性

SELECT 语句和 SQL 标准兼容。但是还有一些扩展和一些缺少的特性。

省略 FROM 子句

PostgreSQL 允许在一个查询里省略 FROM 子句。它的最直接用途就是计算简单的常量表达式的结果：

SELECT 2+2;

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

其它有些 SQL 数据库不能这么做，除非引入一个单行的伪表做为 SELECT 的数据源。

请注意，如果没有声明 FROM 子句，那么查询不能引用任何数据库表。比如，下面的查询是非法的：

SELECT distributors.* WHERE distributors.name = 'Westward';

PostgreSQL 8.1 之前的版本支持这种形式的查询，为查询里引用的每个表都增加一个隐含的条目到 FROM 子句中。现在这个不再是缺省的行为了，因为它和 SQL 标准不兼容，并且被认为太容易导致错误了。为了兼容那些依赖这个行为的应用，可以打开 add_missing_from 配置参数。

AS 关键字

在 SQL 标准里，可选的 AS 关键字是多余的，可以忽略掉而不对语句产生任何影响。PostgreSQL 分析器在重命名输出字段时需要这个关键字，因为类型扩展的特性会在这种情况下导致歧义。不过，AS 在 FROM 项里是可选的。

GROUP BY 和 ORDER BY 里可用的名字空间

在 SQL-92 标准里，ORDER BY 子句只能使用结果字段名或者编号，而 GROUP BY 子句只能用基于输入字段名的表达式。PostgreSQL 对这两个子句都进行了扩展，允许另外一种选择(但是如果存在歧义，则使用标准的解释)。PostgreSQL 还允许两个子句声明任意的表达式。请注意在表达式中出现的名字总是被当作输入字段名，而不是结果字段名。

SQL:1999 以及之后的一个略微不同的定义并不能和 SQL-92 完全向前兼容。不过，在大多数情况下，PostgreSQL 将把一个 ORDER BY 或 GROUP BY 表达式解析成为 SQL:1999 制定的那样。

非标准子句

DISTINCT ON, LIMIT, OFFSET 子句都没有在 SQL 标准中定义。