联接表是根据特定联接类型的规则从另外两个（真实或派生）表派生的表。内部联接、外部联接和交叉联接均可用。联接表的通用语法为

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 关键字是可选的噪音。别名 可以是任何标识符。

表别名的典型应用是为长表名分配短标识符，以保持联接子句的可读性。例如

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;

括号用于解决歧义。在以下示例中，第一个语句将别名 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 开始。（这是 UNNEST ... WITH ORDINALITY 的 SQL 标准语法的概括。）默认情况下，序数列称为 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;

在某些情况下，定义表函数很有用，该表函数可以根据调用方式返回不同的列集。为了支持这一点，可以将表函数声明为返回伪类型 record，且没有 OUT 参数。在查询中使用此类函数时，必须在查询本身中指定预期的行结构，以便系统能够知道如何解析和规划查询。此语法如下所示

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 子句，则可以编写 column_definition 列表来代替 ROWS FROM() 后面的列别名列表。

考虑此示例

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;