4.2. 表表达式

4.2.1. FROM 子句

FROM子句从一个用逗号分隔的表引用列表中的一个或更多个其它表 中生成一个表．

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

表引用可以是一个表名字(可能有模式修饰)或者是一个生成的表， 比如子查询，一个 表连接，或者这些东西的复杂组合．如果在FROM子句中列出了多于一个表， 那么它们被 cross join （见下文）形成一个派生表，该表可以进行 WHERE，GROUP BY 和 HAVING 子句的转换处理，并最后生成所有表表达式的结果．

如果一个表引用是一个简单的表名字并且它是表继承级别中的 超级表，那么该表的行包括所有它的后代子表的行，除非你在 该表名字前面加ONLY关键字．这样的话，这个引用就只生成 出现在命名表中的列 --- 任何在子表中追加的列都会被忽略．

 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)

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;

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 ...

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

4.2.2. WHERE 子句

WHERE子句的语法是

WHERE search_condition

这里的 search condition 是定义在 Section 1.2 里的任意表达式，它返回一个 类型为boolean的值．

在完成对FROM子句的处理之后，生成的每一行都会对搜索条件进行检查． 如果该条件的结果是真，那么该行输出到输出表中，否则（也就是说， 如果结果是假或空）就把它抛弃．搜索条件通常至少要引用一些在 FROM子句里生成的列；这不是必须的，但如果不是这样的话，那么 WHERE子句就没什么用了．

这里是一些 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 修饰成fdt.c1只有 在c1是该子查询生成的列的名字时才是必须的． 修饰列名字可以增加语句的准确性，即使有时候不是必须的． 这样就演示了字段名字范围如何从外层查询扩展到它的内层查询．

4.2.3. GROUP BY 和 HAVING 子句

在通过了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 里没有哪个值可以和每个组相关联起来。 被分组的字段可以在选择列表中引用是因为它们每个组都有已知的常量值。

通常，如果一个表被分了组，那么没有在分组中引用的 字段都不能引用，除了在聚集表达式中以外。一个带聚集 表达式的例子是：

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

这里的 sum() 是一个聚集函数，它在整个 组上计算一个数值。有关可用的聚集函数的更多信息可以在 Section 6.14 中找到。

这里是另外一个例子：在一个用产品代码分组了的表上计算 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子句里， 因为它们都在查询选择列表里被引用到． （根据产品表具体的设置的不同，名字和价格可能和产品 ID 完全无关，因此理论上额外的分组可能是不必的，但是这些 尚未实现。） 列s.units不必在GROUP BY 列表里，因为它只是在一个聚集表达式（sum()） 里使用，它代表一组产品的销售额．对于每种产品，都返回一个该产品 的所有销售额的总和．

在严格的 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 的组的行． 请注意聚集函数不需要在所有地方都一样。