連線表是根據特定連線型別的規則從其他兩個（真實或派生的）表派生的表。提供內部連線、外部連線和交叉連線。連線表的通用語法是

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;