A joined table is a table derived from two other (real or derived) tables according to the rules of the particular join type. Inner, outer, and cross-joins are available. The general syntax of a joined table is 結合テーブルは、2つの（実または派生）テーブルから、指定した結合種類の規則に従って派生したテーブルです。 内部結合、外部結合、およびクロス結合が使用可能です。 テーブル結合の一般的な構文は次のとおりです

T1 join_type T2 [ join_condition ]

Joins of all types can be chained together, or nested: either or both <replaceable>T1</replaceable> and <replaceable>T2</replaceable> can be joined tables. Parentheses can be used around <literal>JOIN</literal> clauses to control the join order. In the absence of parentheses, <literal>JOIN</literal> clauses nest left-to-right. すべての結合は、互いに結び付けたり、あるいは入れ子にしたりすることができます。 T1とT2のどちらか、あるいは両方が、結合テーブルになることがあります。 括弧でJOIN句を括ることで結合の順序を制御することができます。 括弧がない場合、JOIN句は左から右に入れ子にします。

To put this together, assume we have tables <literal>t1</literal>: まとめとして、 以下のテーブルt1

 num | name
-----+------
   1 | a
   2 | b
   3 | c

and <literal>t2</literal>: および、テーブルt2

 num | value
-----+-------
   1 | xxx
   3 | yyy
   5 | zzz

then we get the following results for the various joins: を想定すると、以下のように様々な結合に関する結果が得られます。

=> 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)

The join condition specified with <literal>ON</literal> can also contain conditions that do not relate directly to the join. This can prove useful for some queries but needs to be thought out carefully. For example: 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)

Notice that placing the restriction in the <literal>WHERE</literal> clause produces a different result: 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)

This is because a restriction placed in the <literal>ON</literal> clause is processed <emphasis>before</emphasis> the join, while a restriction placed in the <literal>WHERE</literal> clause is processed <emphasis>after</emphasis> the join. That does not matter with inner joins, but it matters a lot with outer joins. この理由はON句の中の制約は結合の前に処理され、一方WHERE句の中の制約は結合の後に処理されることによります。 これは内部結合には影響がありませんが、外部結合には大きな影響があります。

A temporary name can be given to tables and complex table references to be used for references to the derived table in the rest of the query. This is called a <firstterm>table alias</firstterm>. テーブルや複雑なテーブル参照に一時的な名前を付与し、問い合わせの以降の部分では、その名前を使ってテーブルや複雑なテーブル参照を利用することができます。 これをテーブルの別名と呼びます。

To create a table alias, write テーブルの別名を作成するには以下のようにします。

FROM table_reference AS alias

or もしくは

FROM table_reference alias

The <literal>AS</literal> key word is optional noise. <replaceable>alias</replaceable> can be any identifier. ASキーワードはなくても構わないノイズです。 aliasは任意の識別子になります。

A typical application of table aliases is to assign short identifiers to long table names to keep the join clauses readable. For example: テーブルの別名の一般的な適用法は、長いテーブル名に短縮した識別子を割り当てて結合句を読みやすくすることです。 例を示します。

SELECT * FROM some_very_long_table_name s JOIN another_fairly_long_name a ON s.id = a.num;

The alias becomes the new name of the table reference so far as the current query is concerned &mdash; it is not allowed to refer to the table by the original name elsewhere in the query. Thus, this is not valid: 現在の問い合わせに関しては、別名がテーブル参照をする時の新しい名前になります。 問い合わせの他の場所で元々の名前でテーブルを参照することはできなくなります。 よって、次の例は有効ではありません。

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

SELECT * FROM my_table AS m WHERE my_table.a > 5;    -- 間違い

Table aliases are mainly for notational convenience, but it is necessary to use them when joining a table to itself, e.g.: テーブルの別名は主に表記を簡単にするためにあります。 しかし次のように、1つのテーブルが自分自身と結合する場合は、必須となります。

SELECT * FROM people AS mother JOIN people AS child ON mother.id = child.mother_id;

Parentheses are used to resolve ambiguities. In the following example, the first statement assigns the alias <literal>b</literal> to the second instance of <literal>my_table</literal>, but the second statement assigns the alias to the result of the join: 括弧は曖昧さをなくすために使われます。 次の例では、最初の文で2つ目のmy_tableのインスタンスにbという別名を付与し、一方、2つ目の文では結合結果に対して別名を付与しています。

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

Another form of table aliasing gives temporary names to the columns of the table, as well as the table itself: 次のような形式でテーブル別名を付けて、テーブル自身と同様にテーブルの列に一時的な名前を付けることができます。

FROM table_reference [AS] alias ( column1 [, column2 [, ...]] )

If fewer column aliases are specified than the actual table has columns, the remaining columns are not renamed. This syntax is especially useful for self-joins or subqueries. もし、実際のテーブルが持つ列よりも少ない数の列の別名が与えられる場合、残りの列は改名されません。 この構文は、自己結合あるいは副問い合わせで特に役立ちます。

When an alias is applied to the output of a <literal>JOIN</literal> clause, the alias hides the original name(s) within the <literal>JOIN</literal>. For example: 別名がJOIN句の結果に適用される場合、別名はJOIN内で参照される元々の名を隠します。 以下に例を示します。

SELECT a.* FROM my_table AS a JOIN your_table AS b ON ...

is valid SQL, but: は有効なSQLですが、

SELECT a.* FROM (my_table AS a JOIN your_table AS b ON ...) AS c

is not valid; the table alias <literal>a</literal> is not visible outside the alias <literal>c</literal>. は有効ではありません。 テーブルの別名aは、別名cの外側では参照することができません。

Subqueries specifying a derived table must be enclosed in parentheses. They may be assigned a table alias name, and optionally column alias names (as in <xref linkend="queries-table-aliases"/>). For example: 派生テーブルを指定する副問い合わせは括弧で囲む必要があります。 テーブルの別名、およびオプションで列の別名を（7.2.1.2にあるように）割り当てることができます。 例を示します。

FROM (SELECT * FROM table1) AS alias_name

This example is equivalent to <literal>FROM table1 AS alias_name</literal>. More interesting cases, which cannot be reduced to a plain join, arise when the subquery involves grouping or aggregation. この例はFROM table1 AS alias_nameと同じです。 副問い合わせがグループ化や集約を含んでいる場合は、単純結合にまとめることはできない、より重要な例が発生します。

A subquery can also be a <command>VALUES</command> list: また、副問い合わせをVALUESリストとすることもできます。

FROM (VALUES ('anne', 'smith'), ('bob', 'jones'), ('joe', 'blow'))
     AS names(first, last)

Again, a table alias is optional. Assigning alias names to the columns of the <command>VALUES</command> list is optional, but is good practice. For more information see <xref linkend="queries-values"/>. ここでも、テーブルの別名は省略できます。 VALUESリストの列に別名を付与することは省略することもできますが、付与することを勧めます。 詳細は7.7を参照してください。

According to the SQL standard, a table alias name must be supplied for a subquery. <productname>PostgreSQL</productname> allows <literal>AS</literal> and the alias to be omitted, but writing one is good practice in SQL code that might be ported to another system. SQL標準によれば、副問い合わせにはテーブル別名を指定する必要があります。 PostgreSQLでは、ASと別名を省略できますが、別のシステムに移植する可能性があるSQLコードでは、別名を書くことをお勧めします。

Table functions are functions that produce a set of rows, made up of either base data types (scalar types) or composite data types (table rows). They are used like a table, view, or subquery in the <literal>FROM</literal> clause of a query. Columns returned by table functions can be included in <literal>SELECT</literal>, <literal>JOIN</literal>, or <literal>WHERE</literal> clauses in the same manner as columns of a table, view, or subquery. テーブル関数は、基本データ型（スカラ型）、もしくは複合データ型（テーブル行）からなる行の集合を生成する関数です。 これらは、問い合わせのFROM句内でテーブル、ビュー、副問い合わせのように使用されます。 テーブル関数から返される列は、テーブル、ビュー、副問い合わせの列と同様の手順で、SELECT、JOIN、WHEREの中に含めることができます。

Table functions may also be combined using the <literal>ROWS FROM</literal> syntax, with the results returned in parallel columns; the number of result rows in this case is that of the largest function result, with smaller results padded with null values to match. テーブル関数はROWS FROM構文を使用することで、それらの返却列を一緒に組み合わせることもできます。 このときの結果の行数は、行数が最大となる関数の結果と同じになり、少ない結果側は多い結果に合わせてnull値で埋められます。

function_call [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]
ROWS FROM( function_call [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

If the <literal>WITH ORDINALITY</literal> clause is specified, an additional column of type <type>bigint</type> will be added to the function result columns. This column numbers the rows of the function result set, starting from 1. (This is a generalization of the SQL-standard syntax for <literal>UNNEST ... WITH ORDINALITY</literal>.) By default, the ordinal column is called <literal>ordinality</literal>, but a different column name can be assigned to it using an <literal>AS</literal> clause. WITH ORDINALITY句が指定されている場合、関数の結果の列にbigint型の列が追加されます。 この列は関数の結果の行を1から数えます。 （これは標準SQLの構文UNNEST ... WITH ORDINALITYの一般化です。） デフォルトでは、この序数(ordinal)の列はordinalityになります。しかし別の名前をAS句を使用して別名を付与できます。

The special table function <literal>UNNEST</literal> may be called with any number of array parameters, and it returns a corresponding number of columns, as if <literal>UNNEST</literal> (<xref linkend="functions-array"/>) had been called on each parameter separately and combined using the <literal>ROWS FROM</literal> construct. 特別なテーブル関数UNNESTは、任意の数の配列パラメータで呼ぶことができます。 そしてそれは、対応する数の列を返し、あたかもUNNEST(9.19)が各パラメータ毎にROWS FROM構文を使用して結合されているかのようになります。

UNNEST( array_expression [, ... ] ) [WITH ORDINALITY] [[AS] table_alias [(column_alias [, ... ])]]

If no <replaceable>table_alias</replaceable> is specified, the function name is used as the table name; in the case of a <literal>ROWS FROM()</literal> construct, the first function's name is used. table_aliasが指定されない場合、テーブル名として関数名が使用されます。 ROWS FROM()の場合は最初の関数名が使用されます。

If column aliases are not supplied, then for a function returning a base data type, the column name is also the same as the function name. For a function returning a composite type, the result columns get the names of the individual attributes of the type. 列に別名が提供されない場合、基本データ型を返す関数に対しては、列名も関数名と同じになります。 複合型を返す関数の場合は、結果の列は型の個々の属性の名前を取得します。

Some examples: 以下に数例示します。

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;

In some cases it is useful to define table functions that can return different column sets depending on how they are invoked. To support this, the table function can be declared as returning the pseudo-type <type>record</type> with no <literal>OUT</literal> parameters. When such a function is used in a query, the expected row structure must be specified in the query itself, so that the system can know how to parse and plan the query. This syntax looks like: 呼び出し方法に応じて異なる列集合を返すテーブル関数を定義することが役に立つ場合があります。 これをサポートするために、テーブル関数はOUTパラメータを持たないrecord擬似型を返すものと宣言することができます。 こうした関数を問い合わせで使用する場合、システムがその問い合わせをどのように解析し計画を作成すればよいのかが判断できるように、想定した行構造を問い合わせ自身内に指定しなければなりません。 この構文は次のようになります。

function_call [AS] alias (column_definition [, ... ])
function_call AS [alias] (column_definition [, ... ])
ROWS FROM( ... function_call AS (column_definition [, ... ]) [, ... ] )

When not using the <literal>ROWS FROM()</literal> syntax, the <replaceable>column_definition</replaceable> list replaces the column alias list that could otherwise be attached to the <literal>FROM</literal> item; the names in the column definitions serve as column aliases. When using the <literal>ROWS FROM()</literal> syntax, a <replaceable>column_definition</replaceable> list can be attached to each member function separately; or if there is only one member function and no <literal>WITH ORDINALITY</literal> clause, a <replaceable>column_definition</replaceable> list can be written in place of a column alias list following <literal>ROWS FROM()</literal>. ROWS FROM()構文を使用しない場合は、column_definitionのリストがFROM項目に取り付けることができる列の別名の代わりとなります。 列の定義内の名前は、列の別名として機能します。 ROWS FROM()構文を使用する場合は、column_definitionリストを個別に各メンバ関数に添付することができます。 またはメンバ関数が1つだけしかなく、かつWITH ORDINALITY句がない場合は、column_definitionリストを、ROWS FROM()の後ろの列別名のリストの場所に書くことができます。

Consider this example: 以下の例を考えます。

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

The <xref linkend="contrib-dblink-function"/> function (part of the <xref linkend="dblink"/> module) executes a remote query. It is declared to return <type>record</type> since it might be used for any kind of query. The actual column set must be specified in the calling query so that the parser knows, for example, what <literal>*</literal> should expand to. dblink関数（dblinkモジュールの一部）は遠隔問い合わせを実行します。 これは任意の問い合わせで使用できるように、recordを返すものと宣言されています。 実際の列集合は、パーサが例えば*がどのように展開されるかを理解できるように、呼び出した問い合わせ内で指定されなければなりません。

This example uses <literal>ROWS FROM</literal>: 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

It joins two functions into a single <literal>FROM</literal> target. <function>json_to_recordset()</function> is instructed to return two columns, the first <type>integer</type> and the second <type>text</type>. The result of <function>generate_series()</function> is used directly. The <literal>ORDER BY</literal> clause sorts the column values as integers. 2つの関数を結合して1つのFROMターゲットにします。 json_to_recordset()は、2つの列(最初のintegerと2番目のtext)を返すように指示されます。 generate_series()の結果は直接使用されます。 ORDER BY句では、列値が整数として並べ替えられます。

Subqueries appearing in <literal>FROM</literal> can be preceded by the key word <literal>LATERAL</literal>. This allows them to reference columns provided by preceding <literal>FROM</literal> items. (Without <literal>LATERAL</literal>, each subquery is evaluated independently and so cannot cross-reference any other <literal>FROM</literal> item.) FROMに現れる副問い合わせの前にキーワードLATERALを置くことができます。 こうすると、副問い合わせは先行するFROM項目によって提供される列を参照できます。 （LATERALがない場合、それぞれの副問い合わせは個別に評価され、従ってその他のFROM項目を相互参照できません。）

Table functions appearing in <literal>FROM</literal> can also be preceded by the key word <literal>LATERAL</literal>, but for functions the key word is optional; the function's arguments can contain references to columns provided by preceding <literal>FROM</literal> items in any case. FROMに現れるテーブル関数の前にもキーワードLATERALを置くことが可能ですが、関数に対してこのキーワードは省略可能です。 どんな場合であっても、関数の引数は先行する FROM項目により提供される列の参照を含むことができます。

A <literal>LATERAL</literal> item can appear at the top level in the <literal>FROM</literal> list, or within a <literal>JOIN</literal> tree. In the latter case it can also refer to any items that are on the left-hand side of a <literal>JOIN</literal> that it is on the right-hand side of. LATERAL項目はFROMリストの最上層、またはJOINツリーの中で表示することができます。 後者の場合、右側にあるJOINの左側のすべての項目を参照することが可能です。

When a <literal>FROM</literal> item contains <literal>LATERAL</literal> cross-references, evaluation proceeds as follows: for each row of the <literal>FROM</literal> item providing the cross-referenced column(s), or set of rows of multiple <literal>FROM</literal> items providing the columns, the <literal>LATERAL</literal> item is evaluated using that row or row set's values of the columns. The resulting row(s) are joined as usual with the rows they were computed from. This is repeated for each row or set of rows from the column source table(s). FROM項目がLATERAL相互参照を含む場合の評価は以下のようになります。 相互参照される列（複数可）を提供するFROM項目のそれぞれの行、もしくは列を提供する複数のFROM項目の行一式に対し、LATERAL項目は列の行または複数行の一式の値により評価されます。 結果行（複数可）は通常のように演算された行と結合されます。 元となるテーブル（複数可）の列からそれぞれの行、または行の一式に対し反復されます。

A trivial example of <literal>LATERAL</literal> is LATERALの些細な例としては以下があげられます。

SELECT * FROM foo, LATERAL (SELECT * FROM bar WHERE bar.id = foo.bar_id) ss;

This is not especially useful since it has exactly the same result as the more conventional 上記は以下のより伝統的なやり方と全く同じ結果をもたらしますので特別に有用ではありません。

SELECT * FROM foo, bar WHERE bar.id = foo.bar_id;

<literal>LATERAL</literal> is primarily useful when the cross-referenced column is necessary for computing the row(s) to be joined. A common application is providing an argument value for a set-returning function. For example, supposing that <function>vertices(polygon)</function> returns the set of vertices of a polygon, we could identify close-together vertices of polygons stored in a table with: 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;

This query could also be written この問い合わせは以下のようにも書くことができます。

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;

or in several other equivalent formulations. (As already mentioned, the <literal>LATERAL</literal> key word is unnecessary in this example, but we use it for clarity.) そのほか幾つかの同等の定式化が考えられます。 （既に言及したとおり、LATERALキーワードはこの例に於いて必要ではありませんが、明確に示すために使用しました。）

It is often particularly handy to <literal>LEFT JOIN</literal> to a <literal>LATERAL</literal> subquery, so that source rows will appear in the result even if the <literal>LATERAL</literal> subquery produces no rows for them. For example, if <function>get_product_names()</function> returns the names of products made by a manufacturer, but some manufacturers in our table currently produce no products, we could find out which ones those are like this: LATERAL副問い合わせはLEFT JOINの対象として、しばしば特に重宝します。 たとえ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;