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

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

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子句，则可以在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;