7.2. 表表达式

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对标准的扩展）是在 FROM 子句里面隐含地增加了一个表引用，因此这个查询将会象下面这样处理

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

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

圆括弧用于解决歧义．下面的语句将把别名 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. 子查询

声明一个派生表的子查询必须包围在圆括弧里并且必须赋予一个别名。 （参阅 Section 7.2.1.2．）比如：

FROM (SELECT * FROM table1) AS alias_name

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

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，因为它可能会被用于任何类型的查询。 实际的字段集必须在调用它的查询中声明，这样分析器才知道类似 * 这样的东西应该扩展成什么样子。