7.2. 表表达式

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

7.2.1.1. 连接表

一个连接表是根据特定的连接规则从两个其它表(真实表或生成表)中派生的表。我们支持内连接、外连接、交叉连接。

如果 T1 和 T2 之一或全部是可以连接的表，那么所有类型的连接都可以串连或嵌套在一起。你可以在 JOIN 子句周围使用圆括弧来控制连接顺序，如果没有圆括弧，那么 JOIN 子句从左向右嵌套。

为了解释这些问题，假设我们有一个表 t1

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

和 t2

 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)

用 ON 声明的连接条件也可以包含与连接不直接相关的条件。这种功能可能对某些查询很有用，但是需要我们仔细想清楚。比如：

=> 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)

7.2.1.2. 表和列别名

你可以给表或复杂的表引用起一个临时的表别名，以便被其余的查询引用。

要创建一个表别名，可以这样：

FROM table_reference AS alias

或

FROM table_reference alias

AS 关键字没啥特别的含义。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;

是不符合 SQL 语法的。在 PostgreSQL 中，当 add_missing_from 配置参数为 off (默认)时将会抛出一个错误，但如果为 on 将隐含地在 FROM 子句里增加一个表引用，因此这个查询将会像下面这样处理：

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

这样会生成一个交叉连接，这通常不是你想要的。

表别名主要是为了方便标记，但对于自连接却是必须的。比如：

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

另外，要引用子查询的结果也必须使用别名(参见节7.2.1.3)。

圆括弧用于解决歧义。下面的第一个语句把别名 b 赋予第二个 my_table 表；而第二个语句则把别名 b 赋予了连接的结果。

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 [, ...]] )

如果声明的字段别名比表里实际的字段少，那么后面的字段就没有别名。这个语法对于自连接或子查询特别有用。

如果用这些形式中的任何一种给一个 JOIN 子句的输出结果附加了一个别名，那么该别名就在 JOIN 里隐藏了其原始的名字。比如

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

是合法 SQL ，但是

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

是不合法的：别名 a 在别名 c 的外面是看不到的。

7.2.1.3. 子查询

子查询的结果(派生表)必须包围在圆括弧里并且必须赋予一个别名(参阅节7.2.1.2)。比如：

FROM (SELECT * FROM table1) AS alias_name

这个例子等效于 FROM table1 AS alias_name 。更有趣的例子是在子查询里面有分组或聚集的时候，这个时候子查询不能归纳成一个简单的连接。

子查询也可以是一个 VALUES 列表：

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

这种情况同样也必须要取一个别名。还可以为 VALUES 列表中的字段取别名，并且被认为是一个好习惯。更多信息参见节7.7。

7.2.1.4. 表函数

表函数是那些生成一个行集合的函数，这个集合可以是由基本数据类型(标量类型)组成，也可以是由复合数据类型(表的行)组成。他们的用法类似一个表、视图、或 FROM 子句里的子查询。表函数返回的字段可以像一个表、视图、或者子查询字段那样包含在 SELECT, JOIN, WHERE 子句里。

如果表函数返回基本数据类型，那么单一结果字段的名字与函数名相同。如果表函数返回复合数据类型，那么多个结果字段的名字和该类型的每个属性的名字相同。

可以在 FROM 子句中为表函数取一个别名，也可以不取别名。如果一个函数在 FROM 子句中没有别名，那么将使用函数名作为结果表的名字。

一些例子：

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;

有时侯，把一个函数定义成根据不同的调用方法可以返回不同的字段是很有用的。为了支持这个，表函数可以声明为返回伪类型 record 。如果在查询里使用这样的函数，那么我们必须在查询中声明预期的行结构，这样系统才知道如何分析和规划该查询。让我们看看下面的例子：

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

dblink 函数执行一个远程的查询(参阅 contrib/dblink)。它声明为返回 record ，因为它可能会被用于任何类型的查询。实际的字段集必须在调用它的查询中声明，这样分析器才知道类似 * 这样的东西应该扩展成什么样子。