连接表是根据特定连接类型的规则从其他两个（真实或派生的）表派生的表。提供内部连接、外部连接和交叉连接。连接表的通用语法是

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;    -- 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 语法组合，结果以并行列的形式返回；在这种情况下，结果行的数量是最大的函数结果的数量，较小的结果用 null 值填充以匹配。

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;

在某些情况下，定义可以根据调用方式返回不同列集的表函数是有用的。为了支持这一点，表函数可以被声明为返回伪类型 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 子句，则可以在 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;