聯結表是根據特定聯結類型的規則從另外兩個（真實或衍生的）表衍生而來的表。可以使用內部聯結、外部聯結和交叉聯結。聯結表的一般語法為

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 子句，則可以將 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 左側的任何項目，它位於該 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;