7.2. 表表達式

7.2.1.1. 連接表

一個連接表是根據特定的連接類型的規則從兩個其它表（真實表或生成表）中派生的表。 我們支持內連接，外連接和交叉連接類型。

如果 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)

7.2.1.2. 表和列別名

你可以給一個表或復雜表引用一個臨時的名字，用于在後面的處理過程中引用那些派生的表。 這樣做叫做表別名。

要創建一個表別名，我們可以寫：

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;

這樣會生成一個交叉連接，通常可不是你想要的。

圓括弧用于解決歧義．下面的語句將把別名 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.3. 子查詢

聲明一個派生表的子查詢必須包圍在圓括弧裡並且必須賦予一個別名。 （參閱 Section 7.2.1.2．）比如：

FROM (SELECT * FROM table1) AS alias_name

這個例子等效于 FROM table1 AS alias_name。 更有趣的例子是在子查詢裡面有分組或聚集的時候， 這個時候子查詢不能歸納成一個簡單的連接。

7.2.1.4. 表函數

表函數是那些生成一個行集合的函數，這個集合可以是由基本數據類型（標量類型）組成， 也可以是由符合數據類型（表的行）組成。他們的用法類似一個表，視圖，或者在查詢的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，因為它可能會被用于任何類型的查詢。 實際的字段集必須在調用它的查詢中聲明，這樣分析器才知道類似 * 這樣的東西應該擴展成什麼樣子。