一个连接表是根据特定的连接类型的规则从两个其它表（真实表或推导表）中派生的表。目前可以使用内连接、外连接和交叉连接。

所有类型的连接都可以被链在一起或者嵌套：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)

你可以给表以及复杂的表引用指定一个临时名字，以便在后续处理中引用该派生表。这被称为表别名。

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

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;

不是合法的 SQL 语法。实际会发生的是（这是PostgreSQL对标准的一个扩展）：一个隐式的表引用会被加入FROM子句，因此该查询会被当作像下面这样写的一样来处理

SELECT * FROM my_table AS m, my_table AS my_table WHERE my_table.a > 5;

这将产生一个交叉连接，而这通常不是你想要的。

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

SELECT * FROM my_table AS a CROSS JOIN my_table AS b ...

此外，当表引用是子查询时也必须使用别名（参见第 7.2.1.3 节）。

圆括弧用于解决歧义。下面的语句会把别名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。更有趣的情况是在子查询里面有分组或聚合的时候，这时子查询不能被简化为一个简单的连接。

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

如果一个表函数返回基础数据类型，唯一的结果列名与该函数名相同。如果该函数返回一个复合类型，结果列会得到与该类型的各个属性相同的名称。

表函数可以在FROM子句中被赋予别名，但也可以不使用别名。如果一个函数在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。当此类函数在查询中使用时，必须在查询本身中指定预期的行结构，这样系统才能知道如何分析和规划该查询。考虑下面的示例：

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

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