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)

请注意，放置在WHERE条款的限制 产生不同的结果：

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

这是因为在ON子句连接之前处理，而WHERE子句在连接之后处理。

7.2.1.2. 表和列别名

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

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

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;    -- wrong

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

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

另外，要引用子查询的结果也必须使用别名(参见节Section 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. 子查询

子查询的结果(派生表)必须包围在圆括弧里并 且必须赋予一个别名(参阅Section 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列表中的字段取别名， 并且被认为是一个好习惯。更多信息参见Section 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，因为它可能会被用于任何类型的查询。实际的字段集必 须在调用它的查询中声明，这样分析器才知道类似*这样的东西应该扩展成什么样子。