FROM 子句从逗号分隔的表引用列表中给出的一个或多个其他表派生一张表。

FROM table_reference [, table_reference [, ...]]

表引用可以是表名称（可能具有模式限定）或派生表，例如子查询、JOIN 构造或这些的复杂组合。如果在 FROM 子句中列出了多于一个表引用，则对这些表进行交叉连接（即生成它们行的笛卡尔积；请参阅下文）。FROM 列表的结果是中间虚拟表，然后可由 WHERE、GROUP BY 和 HAVING 子句执行转换，并最终是整体表表达式的结果。

当表引用指定一个作为表继承层次结构的父级的表时，表引用不仅生成该表中的行，还生成其所有后代表中的所有行，除非关键字 ONLY 出现在表名前面。但是，引用仅生成在已命名表中出现的列 — 将忽略在子表中添加的任何列。

除了在表名之前填写 ONLY 外，也可以在表名之后填写 * 来明确指出后代表也是包含项。由于现在默认情况下是搜索后代表，因此没有理由再使用此语法。但是，为了与旧版本兼容，该语法仍然得到支持。

T1 join_type T2 [ join_condition ]

 num | name
-----+------
   1 | a
   2 | b
   3 | c

 num | value
-----+-------
   1 | xxx
   3 | yyy
   5 | zzz

=> SELECT * FROM t1 CROSS JOIN t2;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   1 | a    |   3 | yyy
   1 | a    |   5 | zzz
   2 | b    |   1 | xxx
   2 | b    |   3 | yyy
   2 | b    |   5 | zzz
   3 | c    |   1 | xxx
   3 | c    |   3 | yyy
   3 | c    |   5 | zzz
(9 rows)

=> SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   3 | c    |   3 | yyy
(2 rows)

=> SELECT * FROM t1 INNER JOIN t2 USING (num);
 num | name | value
-----+------+-------
   1 | a    | xxx
   3 | c    | yyy
(2 rows)

=> SELECT * FROM t1 NATURAL INNER JOIN t2;
 num | name | value
-----+------+-------
   1 | a    | xxx
   3 | c    | yyy
(2 rows)

=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |   3 | yyy
(3 rows)

=> SELECT * FROM t1 LEFT JOIN t2 USING (num);
 num | name | value
-----+------+-------
   1 | a    | xxx
   2 | b    |
   3 | c    | yyy
(3 rows)

=> SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   3 | c    |   3 | yyy
     |      |   5 | zzz
(3 rows)

=> SELECT * FROM t1 FULL JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |   3 | yyy
     |      |   5 | zzz
(4 rows)

=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num AND t2.value = 'xxx';
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |     |
(3 rows)

=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num WHERE t2.value = 'xxx';
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
(1 row)

FROM table_reference AS alias

FROM table_reference alias

SELECT * FROM some_very_long_table_name s JOIN another_fairly_long_name a ON s.id = a.num;

SELECT * FROM my_table AS m WHERE my_table.a > 5;    -- wrong

SELECT * FROM people AS mother JOIN people AS child ON mother.id = child.mother_id;

SELECT * FROM my_table AS a CROSS JOIN my_table AS b ...
SELECT * FROM (my_table AS a CROSS JOIN my_table) AS b ...

FROM table_reference [AS] alias ( column1 [, column2 [, ...]] )

SELECT a.* FROM my_table AS a JOIN your_table AS b ON ...

SELECT a.* FROM (my_table AS a JOIN your_table AS b ON ...) AS c

FROM (SELECT * FROM table1) AS alias_name

FROM (VALUES ('anne', 'smith'), ('bob', 'jones'), ('joe', 'blow'))
     AS names(first, last)

function_call [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
ROWS FROM( function_call [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

UNNEST( array_expression [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

CREATE TABLE foo (fooid int, foosubid int, fooname text);

CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
    SELECT * FROM foo WHERE fooid = $1;
$$ LANGUAGE SQL;

SELECT * FROM getfoo(1) AS t1;

SELECT * FROM foo
    WHERE foosubid IN (
                        SELECT foosubid
                        FROM getfoo(foo.fooid) z
                        WHERE z.fooid = foo.fooid
                      );

CREATE VIEW vw_getfoo AS SELECT * FROM getfoo(1);

SELECT * FROM vw_getfoo;

function_call [AS] alias (column_definition [, ... ])
function_call AS [alias] (column_definition [, ... ])
ROWS FROM( ... function_call AS (column_definition [, ... ]) [, ... ] )

SELECT *
    FROM dblink('dbname=mydb', 'SELECT proname, prosrc FROM pg_proc')
      AS t1(proname name, prosrc text)
    WHERE proname LIKE 'bytea%';

SELECT *
FROM ROWS FROM
    (
        json_to_recordset('[{"a":40,"b":"foo"},{"a":"100","b":"bar"}]')
            AS (a INTEGER, b TEXT),
        generate_series(1, 3)
    ) AS x (p, q, s)
ORDER BY p;

  p  |  q  | s
-----+-----+---
  40 | foo | 1
 100 | bar | 2
     |     | 3

SELECT * FROM foo, LATERAL (SELECT * FROM bar WHERE bar.id = foo.bar_id) ss;

SELECT * FROM foo, bar WHERE bar.id = foo.bar_id;

SELECT p1.id, p2.id, v1, v2
FROM polygons p1, polygons p2,
     LATERAL vertices(p1.poly) v1,
     LATERAL vertices(p2.poly) v2
WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;

SELECT p1.id, p2.id, v1, v2
FROM polygons p1 CROSS JOIN LATERAL vertices(p1.poly) v1,
     polygons p2 CROSS JOIN LATERAL vertices(p2.poly) v2
WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;

SELECT m.name
FROM manufacturers m LEFT JOIN LATERAL get_product_names(m.id) pname ON true
WHERE pname IS NULL;

WHERE 子句的语法为

WHERE search_condition

其中 search_condition 是任何值表达式（见 4.2 节），它返回 boolean 类型的值。

在 FROM 子句的处理完成后，导出的虚拟表的每行将针对搜索条件进行检查。如果条件的结果为真，则将该行保存在输出表中，否则（即，如果结果为假或空），则将其丢弃。该搜索条件通常引用在 FROM 子句中生成的表的至少一列；此非必需，否则 WHERE 子句将相当无用。

FROM a, b WHERE a.id = b.id AND b.val > 5

FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val > 5

FROM a NATURAL JOIN b WHERE b.val > 5

以下列出部分 WHERE 子句的示例

SELECT ... FROM fdt WHERE c1 > 5

SELECT ... FROM fdt WHERE c1 IN (1, 2, 3)

SELECT ... FROM fdt WHERE c1 IN (SELECT c1 FROM t2)

SELECT ... FROM fdt WHERE c1 IN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10)

SELECT ... FROM fdt WHERE c1 BETWEEN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10) AND 100

SELECT ... FROM fdt WHERE EXISTS (SELECT c1 FROM t2 WHERE c2 > fdt.c1)

fdt 是 FROM 子句中导出的表。不符合 WHERE 子句的搜索条件的行将从 fdt 中移除。注意将标量子查询用作值表达式。恰如其他任何查询，子查询可以使用复杂表表达式。还要注意 fdt 在子查询中引用的方式。仅当 c1 也是子查询衍生输入表中某列的名称时，将 c1 限定为 fdt.c1 才必要。但即使不需要，限定列名称也会增强清晰度。此示例说明了外部查询的列命名范围是如何扩展到其内部查询中的。

通过 WHERE 筛选后，衍生输入表可能会使用 GROUP BY 子句进行分组，并使用 HAVING 子句消除组行。

SELECT select_list
    FROM ...
    [WHERE ...]
    GROUP BY grouping_column_reference [, grouping_column_reference]...

使用 GROUP BY 子句可以将表中所有在所列所有列中具有相同值的行分组在一起。列出的列顺序无关紧要。其效果是将每组具有公共值的众多行组合到一组行中，代表该组中的所有行。这样做是为了消除输出中的冗余和/或计算适用于这些组的聚合。例如

=> SELECT * FROM test1;
 x | y
---+---
 a | 3
 c | 2
 b | 5
 a | 1
(4 rows)

=> SELECT x FROM test1 GROUP BY x;
 x
---
 a
 b
 c
(3 rows)

在第二个查询中，我们无法编写 SELECT * FROM test1 GROUP BY x，因为没有可以与每个组关联的 y 列的单个值。可以引用组列的选择列表，因为它们在每个组中具有单个值。

一般来说，如果一张表被分组，除 GROUP BY 中列出的列之外的列不能被引用，除非在聚合表达式中。使用聚合表达式的示例如下

=> SELECT x, sum(y) FROM test1 GROUP BY x;
 x | sum
---+-----
 a |   4
 b |   5
 c |   2
(3 rows)

这里 sum 是一个聚合函数，用于计算整个组中的单个值。有关可用聚合函数的更多信息，请参见 第 9.21 节。

以下为另一个示例：它计算每个产品的总销售额（而不是所有产品的总销售额）

SELECT product_id, p.name, (sum(s.units) * p.price) AS sales
    FROM products p LEFT JOIN sales s USING (product_id)
    GROUP BY product_id, p.name, p.price;

在此示例中，列 product_id、p.name 和 p.price 必须在 GROUP BY 子句中，因为它们在查询选择列表中被引用（但请参见下面）。列 s.units 不必在 GROUP BY 列表中，因为它只用于聚合表达式（sum(...)）中，表示某个产品的销售额。对于每个产品，查询会返回该产品所有销售额的汇总行。

如果 products 表已设置完毕，例如，product_id 是主键，那么在上例中它足以按 product_id 分组，因为 name 和 price 在形式上依赖于 product ID，因此对于要为每个 product ID 组返回的 name 和 price 值，不会产生歧义。

在严格的 SQL 中，GROUP BY 可以按源表的列进行分组，但 PostgreSQL 将其扩展，允许 GROUP BY 也按选择列表中的列进行分组。同时，也可以按值表达式而不是简单的列名进行分组。

如果某个表已使用 GROUP BY 进行了分组，但只对某些组感兴趣，可以使用 HAVING 子句（很多像 WHERE 子句）从结果中消除这些组。其语法为

SELECT select_list FROM ... [WHERE ...] GROUP BY ... HAVING boolean_expression

HAVING 子句中的表达式既可以指组表达式，也可以指非组表达式（必然涉及汇总函数）。

例如

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING sum(y) > 3;
 x | sum
---+-----
 a |   4
 b |   5
(2 rows)

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING x < 'c';
 x | sum
---+-----
 a |   4
 b |   5
(2 rows)

当然，还有一个更贴近实际的例子

SELECT product_id, p.name, (sum(s.units) * (p.price - p.cost)) AS profit
    FROM products p LEFT JOIN sales s USING (product_id)
    WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
    GROUP BY product_id, p.name, p.price, p.cost
    HAVING sum(p.price * s.units) > 5000;

在上述示例中，WHERE 子句按未分组的列选择行（该表达式仅对过去四星期的销售额为真），而 HAVING 子句将输出限制为总毛销售额超过 5000 的组。注意，汇总表达式不一定在查询的所有部分中都是相同的。

如果某个查询包含汇总函数调用但没有 GROUP BY 子句，仍然会出现分组：结果是一个单独的组行（或者可能完全没有行，如果该单独行随后被 HAVING 所消除）。如果查询包含 HAVING 子句，即使没有任何汇总函数调用或 GROUP BY 子句，情况也是一样。

可以使用分组集的概念执行比上面所述更复杂的分组操作。由 FROM 和 WHERE 子句选择的数据按指定的每个分组集单独分组，为每个组计算汇总值（就像是对简单的 GROUP BY 子句一样），然后返回结果。例如

=> SELECT * FROM items_sold;
 brand | size | sales
-------+------+-------
 Foo   | L    |  10
 Foo   | M    |  20
 Bar   | M    |  15
 Bar   | L    |  5
(4 rows)

=> SELECT brand, size, sum(sales) FROM items_sold GROUP BY GROUPING SETS ((brand), (size), ());
 brand | size | sum
-------+------+-----
 Foo   |      |  30
 Bar   |      |  20
       | L    |  15
       | M    |  35
       |      |  50
(5 rows)

每个 GROUPING SETS 的子列表可以指定零个或更多列或表达式，并且解释它们的含义与直接放在 GROUP BY 子句中的相同。空的组集表示所有行都已经汇总到一个组中（即使没有输入行，也输出该组），正如上面在没有 GROUP BY 子句的情况下使用汇总函数的情况中所述。

对分组列或表达式的引用会在这些列未显示的分组集中替换为结果行中的 Null 值。要区分特定输出行从哪个分组中产生的，请参阅表 9.64。

提供了一个简写符号，用于指定两种常见的分组集类型。形式为

ROLLUP ( e1, e2, e3, ... )

表示给定的表达式列表和所有列表前缀，包括空列表；因此相当于

GROUPING SETS (
    ( e1, e2, e3, ... ),
    ...
    ( e1, e2 ),
    ( e1 ),
    ( )
)

此函数通常用于针对分层数据进行分析；例如，按部门、部门和全公司计算总薪资。

形式的条款

CUBE ( e1, e2, ... )

表示给定的列表和所有可能的子集（即幂集）。因此

CUBE ( a, b, c )

相当于

GROUPING SETS (
    ( a, b, c ),
    ( a, b    ),
    ( a,    c ),
    ( a       ),
    (    b, c ),
    (    b    ),
    (       c ),
    (         )
)

CUBE 或 ROLLUP 条款中的各个元素可以是单独的表达式，或者括号中元素的子列表。在后一种情况下，在生成各个分组集合时，子列表将被视为单一单位。例如

CUBE ( (a, b), (c, d) )

相当于

GROUPING SETS (
    ( a, b, c, d ),
    ( a, b       ),
    (       c, d ),
    (            )
)

和

ROLLUP ( a, (b, c), d )

相当于

GROUPING SETS (
    ( a, b, c, d ),
    ( a, b, c    ),
    ( a          ),
    (            )
)

CUBE 和 ROLLUP 构造可以单独在 GROUP BY 条款中使用，或者嵌套在 GROUPING SETS 条款中。如果一个 GROUPING SETS 条款嵌套在另一个条款中，效果与将内部条款的所有元素直接写入外部条款相同。

如果在单个 GROUP BY 条款中指定了多个分组项，则分组集合的最终列表是各个项的笛卡尔积。例如

GROUP BY a, CUBE (b, c), GROUPING SETS ((d), (e))

相当于

GROUP BY GROUPING SETS (
    (a, b, c, d), (a, b, c, e),
    (a, b, d),    (a, b, e),
    (a, c, d),    (a, c, e),
    (a, d),       (a, e)
)

在共同指定多个分组项时，分组集合的最终集合可能包含重复项。例如

GROUP BY ROLLUP (a, b), ROLLUP (a, c)

相当于

GROUP BY GROUPING SETS (
    (a, b, c),
    (a, b),
    (a, b),
    (a, c),
    (a),
    (a),
    (a, c),
    (a),
    ()
)

如果这些重复项是不可取的，可以使用 DISTINCT 条款直接在 GROUP BY 上将其移除。因此

GROUP BY DISTINCT ROLLUP (a, b), ROLLUP (a, c)

相当于

GROUP BY GROUPING SETS (
    (a, b, c),
    (a, b),
    (a, c),
    (a),
    ()
)

这与使用 SELECT DISTINCT 不同，因为输出行可能仍包含重复项。如果任何未分组列包含 NULL，则它将与在对同一列进行分组时使用的 NULL 无法区分。

如果查询包含任何窗口函数（见章节 3.5、章节 9.22和章节 4.2.8），在执行任何分组、聚集及HAVING过滤后，再评估这些函数。也就是说，如果查询使用任何聚集、GROUP BY或HAVING，则窗口函数看到的行是组行，而不是FROM/WHERE的原始表行。

如果使用多个窗口函数，则在窗口定义中具有语法等效PARTITION BY和ORDER BY子句的所有窗口函数保证一次性评估数据。因此，它们将看到相同的排序顺序，即使ORDER BY未唯一确定顺序。但是，对于具有不同的PARTITION BY或ORDER BY规范的函数的评估，不作任何保证。（在这种情况下，窗口函数评估通过之间通常需要一个排序步骤，并且该排序不能保证按其ORDER BY视为相等的行的顺序排列。）

目前，窗口函数总是需要经过预先排序的数据，因此查询输出将按照窗口函数的PARTITION BY/ORDER BY子句之一进行排序。但是，不建议依赖于此。如果要确保结果以特定方式排序，请使用显式的顶级ORDER BY子句。