FROM 子句从逗号分隔的表引用列表所给出的一个或多个其他表推导出一个表。

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

表引用可以是表名，也可以是子查询、表连接等推导表，或它们的复杂组合。如果 FROM 子句中列出了多个表引用，这些表会进行交叉连接（见下文），形成派生表，随后该派生表可以被 WHERE、GROUP BY 和 HAVING 子句变换，并最终成为整个表表达式的结果。

当表引用命名的是表继承层次中的父表时，除非在表名前加上关键字 ONLY，否则该表引用不仅会产生该表中的行，还会产生其所有子表后代的行。不过，这种引用只会产生所命名表中出现的列 ——子表中新增的列会被忽略。

FROM (SELECT * FROM table1) AS alias_name

FROM table_reference AS alias

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

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

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 alias

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 T1 INNER JOIN T2 USING (C)
FROM T1 LEFT OUTER JOIN T2 USING (C)
FROM (T1 RIGHT OUTER JOIN T2 ON (T1.C1=T2.C1)) AS DT1
FROM (T1 FULL OUTER JOIN T2 USING (C)) AS DT1 (DT1C1, DT1C2)

FROM T1 NATURAL INNER JOIN T2
FROM T1 NATURAL LEFT OUTER JOIN T2
FROM T1 NATURAL RIGHT OUTER JOIN T2
FROM T1 NATURAL FULL OUTER JOIN T2

FROM (SELECT * FROM T1) DT1 CROSS JOIN T2, T3
FROM (SELECT * FROM T1) DT1, T2, T3

WHERE 子句的语法是

WHERE search_condition

其中，search_condition是任意的值表达式（如第 1.3 节中所定义），它返回一个boolean类型的值。

在完成 FROM 子句的处理之后，派生表中的每一行都会根据搜索条件进行检查。如果条件结果为真，该行就会保留在输出表中；否则（也就是说，如果结果为假或 NULL）就会被丢弃。搜索条件通常至少会引用 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

FROM FDT WHERE
    C1 > 5

FROM FDT WHERE
    C1 IN (1, 2, 3)
FROM FDT WHERE
    C1 IN (SELECT C1 FROM T2)
FROM FDT WHERE
    C1 IN (SELECT C3 FROM T2 WHERE C2 = FDT.C1 + 10)

FROM FDT WHERE
    C1 BETWEEN (SELECT C3 FROM T2 WHERE C2 = FDT.C1 + 10) AND 100

FROM FDT WHERE
    EXISTS (SELECT C1 FROM T2 WHERE C2 > FDT.C1)

在上面的例子中，FDT是由 FROM 子句推导得到的表。不满足 where 子句搜索条件的行会从FDT中消除。注意，这里将标量子查询用作值表达式。与其他查询一样，子查询也可以使用复杂的表表达式。还要注意子查询中对FDT的引用方式。将C1限定为FDT.C1仅在C1也是子查询推导输入表中的列名时才有必要。限定列名即使在不必要的情况下也能增加清晰度。这说明了外层查询的列命名作用域如何扩展到其内部查询。

通过 WHERE 过滤之后，派生出来的输入表还可以使用 GROUP BY 子句进行分组，并通过 HAVING 子句排除某些分组行。

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

GROUP BY 子句用于把表中所有列出列的值均相同的行分到同一组。列的列出顺序没有影响（这与 ORDER BY 子句不同）。其效果是把具有相同值的每一组行合并为一个分组行，由它代表组内的所有行。这样可以消除输出中的冗余，或者获得应用于各组的聚合。

一旦一个表被分组，没有参与分组的列就不能被引用，除非是在聚合表达式中，因为那些列中的特定值是有歧义的——它应该来自组中的哪一行？参与分组的列可以在选择列表的列表达式中引用，因为它们在每个组都有已知的常量值。对未分组列的聚合函数提供的是跨一个组的各行（而不是整张表）的值。例如，在按产品代码分组的表上，sum(sales)给出每种产品的总销售额，而不是所有产品的总销售额。在未分组列上计算的聚合代表的是组，而未分组列的单个值则不代表组。

例子：

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

在这个示例里，列pid、p.name和p.price必须在 GROUP BY 子句里，因为它们都在查询的选择列表里被引用到。列 s.units 不必在 GROUP BY 列表里，因为它只是在一个聚合表达式（sum()）里使用，它代表一种产品的销售额。对于每种产品，这个查询都返回一个关于该产品所有销售额的汇总行。

在严格的 SQL 里，GROUP BY 只能对源表的列进行分组，但PostgreSQL把这个扩展为也允许 GROUP BY 去根据查询选择列表中的列分组。也允许对值表达式进行分组，而不仅是简单的列名。

如果一个表已经用 GROUP BY 子句分了组，而你只对其中某些组感兴趣，那么就可以使用 HAVING 子句。它很像 WHERE 子句，用于从分组表中删除某些组。PostgreSQL允许 HAVING 子句在没有 GROUP BY 的情况下使用，这时它的作用就像另一个 WHERE 子句，但这样使用 HAVING 的意义并不明确。一个好的经验法则是 HAVING 条件应该引用聚合函数的结果。不涉及聚合的限制条件用 WHERE 子句表达更高效。其语法是

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

一个更实际的例子：

SELECT pid    AS "Products",
       p.name AS "Over 5000",
       (sum(s.units) * (p.price - p.cost)) AS "Past Month Profit"
  FROM products p LEFT JOIN sales s USING ( pid )
  WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
  GROUP BY pid, p.name, p.price, p.cost
    HAVING sum(p.price * s.units) > 5000;

在上面的示例里，WHERE 子句通过一个未分组的列来选择数据行，而 HAVING 子句则把输出限制为总销售收入超过 5000 的组。