一个连接表是根据特定的连接类型的规则从两个其他表（真实表或派生表）中派生的表。目前支持内连接、外连接和交叉连接。一个连接表的一般语法是：

T1 join_type T2 [ join_condition ]

所有类型的连接都可以串接在一起或者嵌套：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 子句中的约束则会在连接之后处理。这对内连接无关紧要，但对外连接影响很大。

你可以给表以及复杂的表引用指定一个临时名字，以便在查询的其余部分引用该派生表。这被称为表别名。

要创建一个表别名，我们可以写：

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;    -- 错误

表别名主要用于简化符号，但是当把一个表连接到它自身时必须使用别名，例如：

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

圆括弧用于解决歧义。在下面的示例中，第一个语句将把别名 b 赋给 my_table 的第二个实例，但是第二个语句把别名赋给连接的结果：

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

根据 SQL 标准，子查询必须提供表别名。PostgreSQL 允许省略 AS 和别名，但在可能移植到其他系统的 SQL 代码中，显式写出别名是更好的做法。

表函数是那些生成行集合的函数，这些行可以由基础类型（标量类型）组成，也可以由复合数据类型（表行）组成。它们在查询的 FROM 子句中用法类似于表、视图或子查询。表函数返回的列可以像表、视图或子查询的列一样，出现在 SELECT、JOIN 或 WHERE 子句中。

也可以使用 ROWS FROM 语法把多个表函数组合起来，并列返回各函数的结果列；这种情况下，结果行数等于返回行数最多的那个函数的结果行数，较小的结果会用空值填充到相同长度。

function_call [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
ROWS FROM( function_call [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

如果指定了 WITH ORDINALITY 子句，一个额外的 bigint 类型的列将会被增加到函数的结果列中。这个列对函数结果集的行进行编号，编号从 1 开始（这是对 SQL 标准语法 UNNEST ... WITH ORDINALITY 的一般化）。默认情况下，序数列被称为 ordinality，但也可以通过使用一个 AS 子句给它分配一个不同的列名。

调用特殊的表函数 UNNEST 可以使用任意数量的数组参数，它会返回对应的列数，就好像在每一个参数上单独调用 UNNEST（第 9.19 节）并且使用 ROWS FROM 结构把它们组合起来。

UNNEST( array_expression [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

如果没有指定 table_alias，该函数名将被用作表名。在 ROWS 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;

有时候，定义一个能够根据调用方式返回不同列集合的表函数很有用。为支持这一点，可以将不带 OUT 参数的表函数声明为返回伪类型 record。当此类函数在查询中使用时，必须在查询本身中指定预期的行结构，这样系统才能知道如何解析和规划该查询。这种语法如下：

function_call [AS] alias (column_definition [, ... ])
function_call AS [alias] (column_definition [, ... ])
ROWS FROM( ... function_call AS (column_definition [, ... ]) [, ... ] )

在不使用 ROWS FROM() 语法时，column_definition 列表会取代原本可附加到 FROM 项上的列别名列表，列定义中的名称就起到列别名的作用。在使用 ROWS FROM() 语法时，可以为每一个成员函数单独附着一个 column_definition 列表；或者在只有一个成员函数并且没有 WITH ORDINALITY 子句的情况下，可以在 ROWS FROM() 后面写一个 column_definition 列表来取代一个列别名列表。

考虑下面的示例：

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

dblink 函数（dblink 模块的一部分）执行远程查询。它被声明为返回 record，因为它可能用于任意类型的查询。实际的列集必须在调用它的查询中指定，这样解析器才知道像* 这样的写法应当扩展成什么。

此示例使用 ROWS FROM：

SELECT *
FROM ROWS FROM
    (
        json_to_recordset('[{"a":40,"b":"foo"},{"a":"100","b":"bar"}]')
            AS (a INTEGER, b TEXT),
        generate_series(1, 3)
    ) AS x (p, q, s)
ORDER BY p;

  p  |  q  | s
-----+-----+---
  40 | foo | 1
 100 | bar | 2
     |     | 3

它把两个函数组合成一个 FROM 目标。json_to_recordset() 被指定返回两列，第一列为 integer，第二列为 text。generate_series() 的结果则直接使用。ORDER BY 子句会把列值按整数排序。

可以在出现于 FROM 中的子查询前放置关键词 LATERAL。这允许它们引用前面的 FROM 项提供的列（如果没有 LATERAL，每一个子查询将被独立计算，并且因此不能交叉引用其他 FROM 项）。

出现在 FROM 中的表函数的前面也可以被放上关键词 LATERAL，但对于函数该关键词是可选的，在任何情况下函数的参数都可以包含对前面的 FROM 项提供的列的引用。

LATERAL 项可以出现在 FROM 列表的顶层，也可以出现在 JOIN 树中。在后一种情况下，如果它位于某个 JOIN 的右侧，也可以引用该连接左侧的任何项。

当 FROM 项包含 LATERAL 交叉引用时，求值过程如下：对于提供被引用列的 FROM 项中的每一行，或者对于多个 FROM 项共同提供这些列时对应的每一组行，都会用该行或该组行中的列值来计算 LATERAL 项。得到的结果行再像通常那样与生成它们的行做连接。对于源表中的每一行或每一组行，这一过程都会重复。

LATERAL 的一个简单示例：

SELECT * FROM foo, LATERAL (SELECT * FROM bar WHERE bar.id = foo.bar_id) ss;

这不是非常有用，因为它和一种更简单的形式得到的结果完全一样：

SELECT * FROM foo, bar WHERE bar.id = foo.bar_id;

在必须要使用交叉引用列来计算那些即将要被连接的行时，LATERAL 是最有用的。一种常用的应用是为一个返回集合的函数提供一个参数值。例如，假设 vertices(polygon) 返回一个多边形的顶点集合，我们可以这样标识存储在一个表中的多边形中靠近的顶点：

SELECT p1.id, p2.id, v1, v2
FROM polygons p1, polygons p2,
     LATERAL vertices(p1.poly) v1,
     LATERAL vertices(p2.poly) v2
WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;

这个查询也可以被写成：

SELECT p1.id, p2.id, v1, v2
FROM polygons p1 CROSS JOIN LATERAL vertices(p1.poly) v1,
     polygons p2 CROSS JOIN LATERAL vertices(p2.poly) v2
WHERE (v1 <-> v2) < 10 AND p1.id != p2.id;

或者写成其他几种等价的形式。（正如前面提到的，这个示例中的 LATERAL 关键字并非必需，但这里写出来是为了更清楚。）

把 LEFT JOIN 用于 LATERAL 子查询往往特别方便，这样即使 LATERAL 子查询没有为源行产生任何结果行，源行也仍会出现在结果中。例如，如果 get_product_names() 返回某个制造商生产的产品名称，而我们表中的某些制造商当前没有生产任何产品，就可以像下面这样找出它们：

SELECT m.name
FROM manufacturers m LEFT JOIN LATERAL get_product_names(m.id) pname ON true
WHERE pname IS NULL;