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

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 开始。（这是 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;