<!-- $Header: /usr/prj/pg/cvsroot/doc/doc/src/sgml/queries.sgml,v 1.9 2001/08/30 08:20:00 t-ishii Exp $ 
openjade  -D ref -D ../graphics -d stylesheet.dsl -i output-html -t sgml book-decl.sgml user.sgml 
-->

<chapter id="queries">
<!-- <title>Queries</title> -->
 <title>問い合わせ</title>
<indexterm><primary sortas="といあわせ">問い合わせ</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="といあわせ">問い合わせ</secondary></indexterm>
 <para>
<!--  A <firstterm>query</firstterm> is the process of retrieving or the command
  to retrieve data from a database.  In SQL the <command>SELECT</command>
  command is used to specify queries.  The general syntax of the
  <command>SELECT</command> command is
<synopsis>
SELECT <replaceable>select_list</replaceable> FROM <replaceable>table_expression</replaceable> <optional><replaceable>sort_specification</replaceable></optional>
</synopsis>
  The following sections describe the details of the select list, the
  table expression, and the sort specification.  The simplest kind of
  query has the form
<programlisting>
SELECT * FROM table1;
</programlisting> -->

  <firstterm>問い合わせ</firstterm>とは、抽出の過程のこと、または、データベースからデータを抽出するコマンドのことです。SQLでは、<command>SELECT</command>コマンドを、問い合わせを特定するために使います。<command>SELECT</command>コマンドの一般的な構文は次のとおりです。</para>

<synopsis>
SELECT <replaceable>select_list</replaceable> FROM <replaceable>table_expression</replaceable> <optional><replaceable>sort_specification</replaceable></optional>
</synopsis>

<para>次の節では、選択リスト、テーブル式、ソートの仕様について詳細に説明します。最も単純な問い合わせの形式は、次のようなものです。</para>
<programlisting>
SELECT * FROM table1;
</programlisting>

<!--  Assuming that there is a table called table1, this command would
  retrieve all rows and all columns from table1.  (The method of
  retrieval depends on the client application.  For example, the
  <application>psql</application> program will display an ASCII-art
  table on the screen, client libraries will offer functions to
  retrieve individual rows and columns.)  The select list
  specification <literal>*</literal> means all columns that the table
  expression happens to provide.  A select list can also select a
  subset of the available columns or even make calculations on the
  columns before retrieving them; see <xref
  linkend="queries-select-lists">.  For example, if table1 has columns
  named a, b, and c (and perhaps others) you can make the following
  query: -->

<para>table1というテーブルがあるとして、このコマンドはtable1からすべての行のすべての列を取り出します（抽出する手段はクライアントアプリケーションに依存します。たとえば、<application>psql</application>プログラムでは、アスキー文字によるテキスト図で画面上にテーブルを表示し、クライアントライブラリが個々の行と列を取り出す機能を提供します）。選択リストの指定で「<literal>*</literal>」は、テーブルが持っているすべての列を意味します。選択リストは、列の一部分を選択することや、列を抽出する前に列に対して計算を施すこともできます（<xref linkend="queries-select-lists">を参照）。たとえば、table1にa、b、cという名前の列がある場合（他の列もあってもかまいません）、以下のような問い合わせができます（ここで、bとcは数値データ型であるとみなします）。</para>

<!--
<programlisting>
SELECT a, b + c FROM table1;
</programlisting>
  (assuming that b and c are of a numeric data type).
 </para>
-->

<programlisting>
SELECT a, b + c FROM table1;
</programlisting>

 <para>
<!--
  <literal>FROM table1</literal> is a particularly simple kind of
  table expression.   -->
<literal>FROM table1</literal>は、最も単純な形のテーブル式です。

<!--
In general, table expressions can be complex
  constructs of base tables, joins, and subqueries.  But you can also
  omit the table expression entirely and use the SELECT command as a
  calculator:

<programlisting>
SELECT 3 * 4;
</programlisting>

-->
一般に基本テーブルや結合そして副問い合わせなどで、テーブル式は複雑になることがあります。しかし、テーブル式を省略し、SELECTコマンドを電卓として使用することもできます。</para>

<programlisting>
SELECT 3 * 4;
</programlisting>

<!--  This is more useful if the expressions in the select list return
  varying results.  For example, you could call a function this way. 

<programlisting>
SELECT random();
</programlisting>
 </para>
-->

<para>選択リストの式がさまざまな結果を返す場合、これはさらに有用です。たとえば、関数を次のように呼び出すことができます。</para>

<programlisting>
SELECT random();
</programlisting>

<!-- <sect1 id="queries-table-expressions">
  <title>Table Expressions</title> -->

 <sect1 id="queries-table-expressions">
  <title>テーブル式</title>
<indexterm><primary sortas="てーぶるしき">テーブル式</primary></indexterm>
  <!-- <para>
   A <firstterm>table expression</firstterm> specifies a table.  The
   table expression contains a FROM clause that is optionally followed
   by WHERE, GROUP BY, and HAVING clauses.  Trivial table expressions
   simply refer to a table on disk, a so-called base table, but more
   complex expressions can be used to modify or combine base tables in
   various ways.
  </para> -->

  <para>
   <firstterm>テーブル式</firstterm>は、テーブルを指定するためのものです。テーブル式には、FROM句があり、オプションとしてWHERE句、GROUP BY句、HAVING句を付けることができます。単純なテーブル式は、単にディスク上のいわゆる基本テーブルと呼ばれるテーブルを参照するだけです。しかし、さまざまな方法で基本テーブルを修正したり、組み合わせたりするためにより複雑な式を使用することができます。
  </para>

<!-- <para>
   The optional WHERE, GROUP BY, and HAVING clauses in the table expression
   specify a pipeline of successive transformations performed on the
   table derived in the FROM clause.  The derived table that is produced by
   all these transformations provides the input rows used to compute output
   rows as specified by the select list of column value expressions.
  </para> -->
  <para>

テーブル式のオプションで指定するWHERE句、GROUP BY句、HAVING句は、FROM句で引き出されたテーブル上で、次々に変換されて実行されます。これらすべての変換によって生成される派生テーブルは、列評価式の選択リストで指定されたように出力行を算出するための入力行を提供します。
  </para>
	
  <sect2 id="queries-from">
<!--   <title>FROM clause</title> -->
   <title>FROM句</title>
 <indexterm><primary sortas="FROMく">FROM句</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="FROMく">FROM句</secondary></indexterm>
   <para>
<!--    The FROM clause derives a table from one or more other tables
    given in a comma-separated table reference list. -->

FROM句は、カンマで分けられたテーブル参照リストで与えられる1つ以上のテーブルから、1つのテーブルを構築します。</para>

<synopsis>
FROM <replaceable>table_reference</replaceable> <optional>, <replaceable>table_reference</replaceable> <optional>, ...</optional></optional>
</synopsis>
<!-- A table reference may be a table name or a derived table such as a
    subquery, a table join, or complex combinations of these.  If more
    than one table reference is listed in the FROM clause they are
    CROSS JOINed (see below) to form the derived table that may then
    be subject to transformations by the WHERE, GROUP BY, and HAVING
    clauses and is finally the result of the overall table expression. -->

<para>テーブル参照（table_reference）は、テーブル名、または、副問い合わせ、テーブル結合、それらの複雑な組み合わせなどで作られるテーブルです。FROM句に1つ以上のテーブル参照がある場合、それらは、あとでWHERE句、GROUP BY句、HAVING句によって変換される派生テーブルを作るためのクロス結合（CROSS JOIN、下記を参照）で、最終的にはすべてのテーブル式の結果となります。
    </para>

    <para>
<!--   
    When a table reference names a table that is the
    supertable of a table inheritance hierarchy, the table reference
    produces rows of not only that table but all of its subtable successors,
    unless the keyword ONLY precedes the table name.  However, the reference
    produces only the columns that appear in the named table  any columns
    added in subtables are ignored. -->

   テーブル参照で、テーブルの継承階層のスーパーテーブルに名前を付けると、テーブル名の前にONLYキーワードがない場合は、テーブル参照はそのテーブルだけでなくそのサブテーブルに継承されたすべての列を生成します。しかし、参照は、名前付きのテーブルに現れた列のみを生成し、サブテーブルで追加された列は無視されます。
   </para>
   <sect3 id="queries-join">
<!-- <title>Joined Tables</title> -->
    <title>結合テーブル</title>
<indexterm><primary sortas="けつごうてーぶる">結合テーブル</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="けつごうてーぶる">結合テーブル</secondary></indexterm>
<indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="けつごう">結合</secondary></indexterm>
    <para>
<!-- 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 JOIN are supported. -->

結合テーブルは、2つの実テーブルか派生テーブルから、結合の規則に従って派生されます。内部結合（INNER JOIN）、外部結合（OUTER JOIN）、クロス結合（CROSS JOIN）がサポートされています。
    </para>
    <variablelist>
<!-- <title>Join Types</title> -->
     <title>結合のタイプ</title>

     <varlistentry>
<!--  <term>CROSS JOIN</term> -->
      <term>クロス結合（CROSS JOIN）</term><indexterm><primary sortas="くろすけつごう">クロス結合</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="くろすけつごう">クロス結合</secondary></indexterm><indexterm><primary>CROSS JOIN</primary></indexterm>

      <listitem>
<synopsis>
<replaceable>T1</replaceable> CROSS JOIN <replaceable>T2</replaceable>
</synopsis>

       <para>
<!--    For each combination of rows from
        <replaceable>T1</replaceable> and
        <replaceable>T2</replaceable>, the derived table will contain a
        row consisting of all columns in <replaceable>T1</replaceable>
        followed by all columns in <replaceable>T2</replaceable>. If
        the tables have N and M rows respectively, the joined
        table will have N * M rows.  A cross join is equivalent to an
        <literal>INNER JOIN ON TRUE</literal>. -->

         どの<replaceable>T1</replaceable>と<replaceable>T2</replaceable>の行の組み合わせについても、<replaceable>T1</replaceable>のすべての列に続き、<replaceable>T2</replaceable>のすべての列を含む行が派生テーブルに含まれます。2つのテーブルがN行とM行で構成されているとすると、結合されたテーブルの行数はN×M行となります。クロス結合は<literal>INNER JOIN ON TRUE</literal>と同じです。
       </para>

       <tip>
       <!-- <para>
         <literal>FROM <replaceable>T1</replaceable> CROSS JOIN
         <replaceable>T2</replaceable></literal> is equivalent to
         <literal>FROM <replaceable>T1</replaceable>,
         <replaceable>T2</replaceable></literal>.
        </para> -->
        <para>
         <literal>FROM <replaceable>T1</replaceable> CROSS JOIN <replaceable>T2</replaceable></literal>は<literal>FROM <replaceable>T1</replaceable>, <replaceable>T2</replaceable></literal>と等価です。
        </para>
       </tip>
      </listitem>
     </varlistentry>

     <varlistentry>
<!--  <term>Qualified JOINs</term> -->
      <term>修飾付き結合（Qualified JOIN）</term><indexterm><primary sortas="しゅうしょくつきけつごう">修飾付き結合</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="しゅうしょくつきけつごう">修飾付き結合</secondary></indexterm>
      <listitem>

<synopsis>
<replaceable>T1</replaceable> { <optional>INNER</optional> | { LEFT | RIGHT | FULL } <optional>OUTER</optional> } JOIN <replaceable>T2</replaceable> ON <replaceable>boolean_expression</replaceable>
<replaceable>T1</replaceable> { <optional>INNER</optional> | { LEFT | RIGHT | FULL } <optional>OUTER</optional> } JOIN <replaceable>T2</replaceable> USING ( <replaceable>join column list</replaceable> )
<replaceable>T1</replaceable> NATURAL { <optional>INNER</optional> | { LEFT | RIGHT | FULL } <optional>OUTER</optional> } JOIN <replaceable>T2</replaceable>
</synopsis>
        
       <para>
<!--    The words <token>INNER</token> and <token>OUTER</token> are
        optional for all JOINs.  <token>INNER</token> is the default;
        <token>LEFT</token>, <token>RIGHT</token>, and 
        <token>FULL</token> imply an OUTER JOIN. -->

        <token>INNER</token>や<token>OUTER</token>は、省略可能です。<token>INNER</token>がデフォルトとなります。<token>LEFT</token>、<token>RIGHT</token>、<token>FULL</token>をOUTER JOINに指定できます。
       </para>

       <para>

<!--    The <firstterm>join condition</firstterm> is specified in the
        ON or USING clause, or implicitly by the word NATURAL.   The join
	condition determines which rows from the two source tables are
	considered to <quote>match</quote>, as explained in detail below. -->

        <firstterm>結合条件</firstterm>は、ON句かUSING句で指定するか、または暗黙的にNATURAL記述で指定されます。結合条件は、以下で詳しく説明するように、2つの元となるテーブルのどの行が<quote>一致するか</quote>を決めます。
       </para>

       <para>
<!--    The ON clause is the most general kind of join condition: it takes a
	Boolean value expression of the same kind as is used in a WHERE
	clause.  A pair of rows from T1 and T2 match if the ON expression
	evaluates to TRUE for them. -->

	ON句は最も一般的な結合条件であり、WHERE句で使われるのと同じブール値評価式となります。ONで表現された部分が真となる場合、T1とT2の対応する行が対象となります。
       </para>

       <para>
<!--    USING is a shorthand notation: it takes a
        comma-separated list of column names, which the joined tables
        must have in common, and forms a join condition specifying equality
	of each of these pairs of columns.  Furthermore, the output of
	a JOIN USING has one column for each of the equated pairs of
	input columns, followed by all of the other columns from each table.
        Thus, <literal>USING (a, b, c)</literal> is equivalent to
	<literal>ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c)</literal>
	with the exception that
        if ON is used there will be two columns a, b, and c in the
        result, whereas with USING there will be only one of each. -->

	USINGは略記法です。それは、結合テーブルが共通で持つカンマで区切られた列名のリストから、各々の列の組み合わせをイコールとした結合条件を生成します。さらに、JOIN USINGの出力は、入力列でイコールとなった列の組み合わせに対して、1つの列があり、各テーブルの他のすべての列がそのあと続きます。つまり、<literal>USING (a, b, c)</literal>は<literal>ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c)</literal>と等価です。ただし、ONを使った場合は、結果においてa,b,cは2つの列になりますが、USINGを使うとそれぞれ1つの列になるという例外があります。
       </para>

       <para>
<!--    Finally, NATURAL is a shorthand form of USING: it forms a USING
	list consisting of exactly those column names that appear in both
	input tables.  As with USING, these columns appear only once in
	the output table. -->

	最後にNATURALはUSINGの略記形式です。2つの入力テーブルに必ずある列名の持ったをUSING句リストを形成します。USINGのように、これらの列は出力テーブルに一度だけ現われます。
       </para>

       <para>
<!--     The possible types of qualified JOIN are: -->
         JOINには次のものがあります。
       </para>

       <variablelist>
        <varlistentry>
<!--     <term>INNER JOIN</term> -->
         <term>内部結合（INNER JOIN）</term><indexterm><primary sortas="ないぶけつごう">内部結合</primary></indexterm><indexterm><primary>INNER JOIN</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="ないぶけつごう">ないぶ結合</secondary></indexterm>

         <listitem>
          <para>
<!--       For each row R1 of T1, the joined table has a row for each
           row in T2 that satisfies the join condition with R1. -->

	   T1の各R1行に対して、T2においてR1との結合条件を満たしている行が、結合されたテーブルに含まれます。
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
<!--     <term>LEFT OUTER JOIN</term> -->
         <term>左外部結合（LEFT OUTER JOIN）</term><indexterm><primary sortas="ひだりがいぶけつごう">左外部結合</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="ひだりがいぶけつごう">左外部結合</secondary></indexterm><indexterm><primary>LEFT OUTER JOIN</primary></indexterm>

         <listitem>
          <para>
<!--       First, an INNER JOIN is performed.  Then, for each row in T1
           that does not satisfy the join condition with any row in
           T2, a joined row is returned with NULL values in columns of
           T2.  Thus, the joined table unconditionally has at least one
	   row for each row in T1. -->

           まず、内部結合が行われます。その後、T2の任意の行で結合条件を満たさないT1の各行については、T2の列はNULL値として、結合されたテーブルを作ります。したがって、連結されたテーブルは、無条件に少なくとも1行はT1の行があります。
          </para>
         </listitem>
        </varlistentry>
         
        <varlistentry>
<!--    <term>RIGHT OUTER JOIN</term> -->
        <term>右外部結合（RIGHT OUTER JOIN）</term><indexterm><primary sortas="みぎがいぶけつごう">右外部結合</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="みぎがいぶけつごう">右外部結合</secondary></indexterm><indexterm><primary>RIGHT OUTER JOIN</primary></indexterm>

         <listitem>
          <para>
<!--       First, an INNER JOIN is performed.  Then, for each row in T2
           that does not satisfy the join condition with any row in
           T1, a joined row is returned with NULL values in columns of
           T1.  This is the converse of a left join: the result table will
           unconditionally have a row for each row in T2. -->

	   まず、内部結合が行われます。その後、T1の任意の行で結合条件を満たさないT2の各行については、T1の列はNULL値として、結合されたテーブルを作ります。これは左結合の反対です。結果のテーブルは、T2の行が無条件に入ります。
          </para>
         </listitem>
        </varlistentry>
         
        <varlistentry>
<!--         <term>FULL OUTER JOIN</term> -->
        <term>完全外部結合（FULL OUTER JOIN）</term><indexterm><primary sortas="かんぜんがいぶけつごう">完全外部結合</primary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="かんぜんがいぶけつごう">完全外部結合</secondary></indexterm><indexterm><primary>FULL OUTER JOIN</primary></indexterm>

         <listitem>
          <para>
<!--       First, an INNER JOIN is performed.  Then, for each row in
           T1 that does not satisfy the join condition with any row in
           T2, a joined row is returned with null values in columns of
           T2.  Also, for each row of T2 that does not satisfy the
           join condition with any row in T1, a joined row with null
           values in the columns of T1 is returned. -->

	   まず、内部結合が行われます。その後、T1の各行で結合条件を満たさないT2の任意の行については、T2の列はNULL値として結合します。さらに、T2の各行で結合条件を満たさないT1の任意の行については、T1の列はNULL値として結合します。
          </para>
         </listitem>
        </varlistentry>
       </variablelist>
      </listitem>
     </varlistentry>
    </variablelist>

    <para>
<!-- Joins of all types can be chained together or nested: either
     or both of <replaceable>T1</replaceable> and
     <replaceable>T2</replaceable> may be JOINed tables.  Parentheses
     may be used around JOIN clauses to control the join order.  In the
     absence of parentheses, JOIN clauses nest left-to-right. -->

     すべての結合は、互いに結び付けたり、あるいは、入れ子にしたりすることができます。<replaceable>T1</replaceable>と<replaceable>T2</replaceable>のどちらか、あるいは両方が、結合テーブルになることがあります。小かっこは結合の順序を制御するためにJOIN句をくくることに使うことができます。小かっこがない場合、JOIN句は左から右に入れ子にします。
    </para>
   </sect3>

   <sect3 id="queries-subqueries">
<!-- <title>Subqueries</title> -->
    <title>副問い合わせ（Subqueries）</title>
<indexterm><primary sortas="ふくといあわせ">副問い合わせ</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="ふくといあわせ">副問い合わせ</secondary></indexterm>
    <para>
<!-- Subqueries specifying a derived table must be enclosed in
     parentheses and <emphasis>must</emphasis> be named using an AS
     clause.  (See <xref linkend="queries-table-aliases">.) -->

     派生テーブルを特殊化する副問い合わせは、<emphasis>必ず</emphasis>小かっこでくくる必要があります。また、名前にはAS句を使わなければいけません（<xref linkend="queries-table-aliases">を参照）。
    </para>

<programlisting>
FROM (SELECT * FROM table1) AS alias_name
</programlisting>

    <para>
<!-- This example is equivalent to <literal>FROM table1 AS
     alias_name</literal>.  More interesting cases, which can't be
     reduced to a plain join, arise when the subquery involves grouping
     or aggregation. -->

     この例は、<literal>FROM table1 AS alias_name</literal>と同じです。さらに、興味深いケースとして、副問い合わせがグループ化や集約を含んでいる場合、単純結合にまとめることはできないということがあります。
    </para>
   </sect3>

   <sect3 id="queries-table-aliases">
<!-- <title>Table and Column Aliases</title> -->
    <title>テーブルと列の別名</title>
<indexterm><primary sortas="べつめい">別名</primary></indexterm>
<indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="べつめい">別名</secondary></indexterm>

    <para>
<!-- A temporary name can be given to tables and complex table
     references to be used for references to the derived table in
     further processing.  This is called a <firstterm>table
     alias</firstterm>. -->

テーブルや複雑なテーブル参照は、その先の処理のため、派生テーブルを参照するために一時的な名前を与えることができます。これを<firstterm>テーブルの別名</firstterm>（table alias）と呼びます。</para>

<synopsis>
FROM <replaceable>table_reference</replaceable> AS <replaceable>alias</replaceable>
</synopsis>
<!-- Here, <replaceable>alias</replaceable> can be any regular
     identifier.  The alias becomes the new name of the table
     reference for the current query  it is no longer possible to
     refer to the table by the original name.  Thus -->

<para>ここで、<replaceable>alias</replaceable>はどんな通常識別子でもかまいません。別名は、問い合わせでテーブル参照をするときの新しい名前になります。その場合は、オリジナルの名前でテーブルを参照することはできなくなります。つまり、以下の文は、正しいSQLの構文ではありません。</para>

<programlisting>
SELECT * FROM my_table AS m WHERE my_table.a > 5;
</programlisting>
<!-- is not valid SQL syntax.  What will actually happen (this is a
     <productname>Postgres</productname> extension to the standard)
     is that an implicit
     table reference is added to the FROM clause, so the query is
     processed as if it were written as -->

<para>この場合、実際には、FROM句に暗黙のテーブル参照が追加されます（これはSQL標準に対する<productname>Postgres</productname>拡張です）。つまり、次のような問い合わせを書いたものとして処理されます。</para>
<programlisting>
SELECT * FROM my_table AS m, my_table AS my_table WHERE my_table.a > 5;
</programlisting>
<!-- Table aliases are mainly for notational convenience, but it is
     necessary to use them when joining a table to itself, e.g., -->

<para>テーブルの別名は主に表記を簡単にするためにあります。しかし次のように、1つのテーブルが自分自身と結合する場合は、必須となります。</para>

<programlisting>
SELECT * FROM my_table AS a CROSS JOIN my_table AS b ...
</programlisting>
<!-- Additionally, an alias is required if the table reference is a
     subquery. -->
<para>さらに、テーブル参照が副問い合わせの場合に別名が必要になります。
    </para>

    <para>
<!-- Parentheses are used to resolve ambiguities.  The following
     statement will assign the alias <literal>b</literal> to the 
     result of the join, unlike the previous example: -->

     小かっこは、あいまいさをなくすために使われます。次のSQL文は、前の例題と異なり、結合の結果に<literal>b</literal>という別名が与えられます。</para>

<programlisting>
SELECT * FROM (my_table AS a CROSS JOIN my_table) AS b ...
</programlisting>

<synopsis>
FROM <replaceable>table_reference</replaceable> <replaceable>alias</replaceable>
</synopsis>
<!-- This form is equivalent to the previously treated one; the
     <token>AS</token> key word is noise. -->

<para>この形式は前に書いたものと等価です。<token>AS</token>キーワードは省略可能です。
    </para>

<synopsis>
FROM <replaceable>table_reference</replaceable> <optional>AS</optional> <replaceable>alias</replaceable> ( <replaceable>column1</replaceable> <optional>, <replaceable>column2</replaceable> <optional>, ...</optional></optional> )
</synopsis>
<!-- In this form,
     in addition to renaming the table as described above, the columns
     of the table are also given temporary names for use by the surrounding
     query.  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. -->

<para>この形式では、前に説明したようなテーブルの改名に加えてさらに、テーブルの列は、囲んでいる問い合わせの中で一時的な名前として与えられます。もし、実際のテーブルが持つ列よりも少ない数の列の別名が与えれられる場合、残りのカラムは改名されません。この構文は、自己結合あるいは副問い合わせで特に役立ちます。
    </para>

    <para>
<!-- When an alias is applied to the output of a JOIN clause, using any of
     these forms, the alias hides the original names within the JOIN. 
     For example, -->

別名が、JOIN句の結果として適用される場合、これらの形式のいずれかを使うと、別名はJOINの内のオリジナル名を隠します。たとえば、以下の文は正しいSQL文です。</para>

<programlisting>
SELECT a.* FROM my_table AS a JOIN your_table AS b ON ...
</programlisting>
<!-- is valid SQL, but -->
<para>しかし、以下の文は正しくありません。</para>
<programlisting>
SELECT a.* FROM (my_table AS a JOIN your_table AS b ON ...) AS c
</programlisting>
<!-- is not valid: the table alias A is not visible outside the alias C. -->
<para>テールブルの別名Aは、外側の別名Cでは参照することができません。
    </para>
   </sect3>

   <sect3 id="queries-table-expression-examples">
<!-- <title>Examples</title> -->
    <title>例</title>

<programlisting>
FROM T1 INNER JOIN T2 USING (C)
FROM T1 LEFT OUTER JOIN T2 USING (C)
FROM (T1 RIGHT OUTER JOIN T2 ON (T1.C1=T2.C1)) AS DT1
FROM (T1 FULL OUTER JOIN T2 USING (C)) AS DT1 (DT1C1, DT1C2)

FROM T1 NATURAL INNER JOIN T2
FROM T1 NATURAL LEFT OUTER JOIN T2
FROM T1 NATURAL RIGHT OUTER JOIN T2
FROM T1 NATURAL FULL OUTER JOIN T2

FROM (SELECT * FROM T1) DT1 CROSS JOIN T2, T3
FROM (SELECT * FROM T1) DT1, T2, T3
</programlisting>

<!-- Above are some examples of joined tables and complex derived
     tables.  Notice how the AS clause renames or names a derived
     table and how the optional comma-separated list of column names
     that follows renames the columns.  The last two
     FROM clauses produce the same derived table from T1, T2, and T3.
     The AS keyword was omitted in naming the subquery as DT1.  The
     keywords OUTER and INNER are noise that can be omitted also. -->


<para>上記は、結合テーブルと複雑な派生テーブルの例です。AS句がどのように改名、あるいは、派生テーブルに名前を付けるか、さらに、省略可能なカンマで区切られた列名をどのように改名するかに注目してください。最後の2つのFROM句はT1、T2、T3から同じ派生テーブルを作ります。副問い合わせにDT1と名前付けする際のASキーワードは省略されています。さらに、キーワードのOUTER、INNERも省略することができます。
    </para>
   </sect3>

  </sect2>

  <sect2 id="queries-where">
<!--   <title>WHERE clause</title> -->
   <title>WHERE句</title>
<indexterm><primary sortas="WHEREく">WHERE句</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="WHEREく">WHERE句</secondary></indexterm>
   <para>
<!-- The syntax of the WHERE clause is
<synopsis>
WHERE <replaceable>search_condition</replaceable>
</synopsis>
    where <replaceable>search_condition</replaceable> is any value
    expression as defined in <xref linkend="sql-expressions"> that
    returns a value of type <type>boolean</type>. -->

    WHERE句の構文は、以下のとおりです。</para>
<synopsis>
WHERE <replaceable>search_condition</replaceable>
</synopsis>

<para><replaceable>search_condition</replaceable>は、<xref linkend="sql-expressions">で定義した、<type>boolean</type>型を返すどのような評価式も指定できます。
   </para>

   <para>
<!-- After the processing of the FROM clause is done, each row of the
    derived table is checked against the search condition.  If the
    result of the condition is true, the row is kept in the output
    table, otherwise (that is, if the result is false or NULL) it is
    discarded.  The search condition typically references at least some
    column in the table generated in the FROM clause; this is not
    required, but otherwise the WHERE clause will be fairly useless. -->

FROM句の処理が終わった後に、派生テーブルの各行は検索条件と照合されます。条件の結果が真の場合、その行は出力されます。そうでない、すなわち結果が偽またはNULLの場合は、その行は捨てられます。一般的に検索条件は、FORM句で生成されたテーブルのどれかの列を少なくともいくつか指定します。これは、必須ではありませんが、そうしないとFORM句はまったく意味がなくなります。
   </para>

   <note>
    <para>
<!--
     Before the implementation of the JOIN syntax, it was necessary to
     put the join condition of an inner join in the WHERE clause.  For
     example, these table expressions are equivalent:
-->

結合（JOIN）構文が実装される以前では、WHERE句の中に内部結合の結合条件を挿入する必要がありました。たとえば、以下の3つのテーブル式は等価です。</para>

<programlisting>
FROM a, b WHERE a.id = b.id AND b.val &gt; 5
</programlisting>
<!--     and -->
<programlisting>
FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val &gt; 5
</programlisting>
<!-- or perhaps even -->
<programlisting>
FROM a NATURAL JOIN b WHERE b.val &gt; 5
</programlisting>


<!-- Which one of these you use is mainly a matter of style.  The JOIN
     syntax in the FROM clause is probably not as portable to other
     products.  For outer joins there is no choice in any case:  they
     must be done in the FROM clause.  An outer join's ON/USING clause
     is <emphasis>not</> equivalent to a WHERE condition, because it
     determines the addition of rows (for unmatched input rows) as well
     as the removal of rows from the final result. -->

<para>どれを使うかは、主にスタイルの問題です。FROM句のJOIN構文は、おそらく、他の製品への移植性がありません。外部結合については、FROM句でなければならなく、選択の余地はありません。外部結合のON句やUSING句は、WHERE条件とは等しく<emphasis>ありません</emphasis>。なぜなら、最終結果から行を除去すると同様に、マッチしない入力行に対する行の追加も行うからです。
    </para>
   </note>

<programlisting>
FROM FDT WHERE
    C1 > 5

FROM FDT WHERE
    C1 IN (1, 2, 3)
FROM FDT WHERE
    C1 IN (SELECT C1 FROM T2)
FROM FDT WHERE
    C1 IN (SELECT C3 FROM T2 WHERE C2 = FDT.C1 + 10)

FROM FDT WHERE
    C1 BETWEEN (SELECT C3 FROM T2 WHERE C2 = FDT.C1 + 10) AND 100

FROM FDT WHERE
    EXISTS (SELECT C1 FROM T2 WHERE C2 > FDT.C1)
</programlisting>

   <para>
<!-- In the examples above, FDT is the table derived in the FROM
    clause. Rows that do not meet the search condition of the where
    clause are eliminated from FDT. Notice the use of scalar
    subqueries as value expressions.  Just like
    any other query, the subqueries can employ complex table
    expressions.  Notice how FDT is referenced in the subqueries.
    Qualifying C1 as FDT.C1 is only necessary if C1 is also the name of a
    column in the derived input table of the subquery.  Qualifying the
    column name adds clarity even when it is not needed.  This shows how
    the column naming scope of an outer query extends into its inner queries. -->

上記の例で、FDTはFROM句の中から派生されたテーブルです。WHERE句の検索条件を満たさなかった行は、FDTから削除されます。評価式としてのスカラ副問い合わせの使い方に注目してください。他の問い合わせのように、副問い合わせは、複雑なテーブル式を使うことができます。副問い合わせの中でどのようにFDTが参照されるかに注意してください。
C1をFDT.C1のように修飾することは、C1が副問い合わせの入力テーブルから派生した列名でもあるときにだけ必要です。列名の修飾は、必須の場合ではなくても、明確にするために役立ちます。これは、外側の問い合わせの列名に名前を付ける範囲を、どのようにして内側の問い合わせまで拡張するかを示します。
   </para>
  </sect2>


  <sect2 id="queries-group">
   <!-- <title>GROUP BY and HAVING clauses</title> -->	    
   <title>GROUP BY句とHAVING句</title>	   
<indexterm><primary sortas="GROUP BYく">GROUP BY句</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="GROUP BYく">GROUP BY句</secondary></indexterm>
<indexterm><primary sortas="HAVINGく">HAVINGく</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="HAVINGく">HAVING句</secondary></indexterm>
   <para>
<!-- After passing the WHERE filter, the derived input table may be
    subject to grouping, using the GROUP BY clause, and elimination of
    group rows using the HAVING clause. -->

    WHEREフィルターを通した後、派生された入力テーブルは、GROUP BY句でグループ化され、HAVING句を使うことにより不要なグループが取り除かれます。
   </para>

<synopsis>
SELECT <replaceable>select_list</replaceable> FROM ... <optional>WHERE ...</optional> GROUP BY <replaceable>grouping_column_reference</replaceable> <optional>, <replaceable>grouping_column_reference</replaceable></optional>...
</synopsis>

   <para>
<!-- The GROUP BY clause is used to group together rows in a table that
    share the same values in all the columns listed. The order in
    which the columns are listed does not matter (as opposed to an
    ORDER BY clause).  The purpose is to reduce each group of rows
    sharing common values into one group row that is representative of
    all rows in the group.  This is done to eliminate redundancy in
    the output and/or obtain aggregates that apply to these groups. -->

GROUP BY句は、指定された全列で同じ値となる行を、互いにグループ化するために使われます。（ORDER BY句とは違い）指定された列の順番は関係ありません。この目的は、共通する値を持つ行を、代表となる1つのグループ行へまとめることにより、各グループの行を減らすことにあります。これにより、出力の冗長度を排除し、さらにまた、これらのグループに適用される集約が得られます。
   </para>
	  
   <para>
<!--
    Once a table is grouped, columns that are not used in the
    grouping cannot be referenced except in aggregate expressions,
    since a specific value in those columns is ambiguous - which row
    in the group should it come from?  The grouped-by columns can be
    referenced in select list column expressions since they have a
    known constant value per group.  Aggregate functions on the
    ungrouped columns provide values that span the rows of a group,
    not of the whole table.  For instance, a
    <function>sum(sales)</function> on a table grouped by product code
    gives the total sales for each product, not the total sales on all
    products.  Aggregates computed on the ungrouped columns are
    representative of the group, whereas individual values of an ungrouped
    column are not.
-->

いったんテーブルがグループ化されると、グループの中のどの行を使えばよいのかが曖昧となるので、集約式を除いてグループ化に使われない列は参照することができません。
グループごとに既知の一定の値を持つので、選択リストの列評価式でグループ化された列は参照することができます。グループ化で使われない列の集約関数は、テーブル全体ではなく1つのグループでの値を計算します。たとえば、<function>sum(sales)</function>
は、製品コードごとにグループ化された各製品の売り上げ合計であり、すべての製品の売り上げ合計ではありません。グループ化されていない列を計算した集約はグループを代表しますが、グループ化されていない列の個別の値はそうではありません。
   </para>

   <para>
<!--    Example: -->
    例を示します。</para>
<programlisting>
SELECT pid, p.name, (sum(s.units) * p.price) AS sales
  FROM products p LEFT JOIN sales s USING ( pid )
  GROUP BY pid, p.name, p.price;
</programlisting>
<!-- In this example, the columns pid, p.name, and p.price must be in
    the GROUP BY clause since they are referenced in the query select
    list.  The column s.units does not have to be in the GROUP BY list
    since it is only used in an aggregate expression
    (<function>sum()</function>), which represents the group of sales
    of a product.  For each product, a summary row is returned about
    all sales of the product. -->

<para>この例では、pid列、p.name列、p.price列は必ずGROUP BY句で指定しなければいけません。なぜなら、これらは、問い合わせリストの中で使われているためです。s.units列はGROUP BYで指定する必要はありません。これは、製品ごとの売り上げ計算の集約関数（<function>sum()</function>）の中だけで使われるためです。各製品については、製品のすべての販売に関しての合計行が返されます。
   </para>

   <para>
<!-- In strict SQL, GROUP BY can only group by columns of the source
    table but Postgres extends this to also allow GROUP BY to group by
    select columns in the query select list.  Grouping by value
    expressions instead of simple column names is also allowed. -->

    厳密なSQLでは、GROUP BYは、ソーステーブルの列によってグループ化できますが、Postgresはこれを、問い合わせ選択リストの列によるグループ化も許すように拡張しています。単純な列名の代わりに、評価式でグループ化することもできます。
   </para>

<synopsis>
SELECT <replaceable>select_list</replaceable> FROM ... <optional>WHERE ...</optional> GROUP BY ... HAVING <replaceable>boolean_expression</replaceable>
</synopsis>
<!--
    If a table has been grouped using a GROUP BY clause, but then only
    certain groups are of interest, the HAVING clause can be used,
    much like a WHERE clause, to eliminate groups from a grouped
    table.  Postgres allows a HAVING clause to be
    used without a GROUP BY, in which case it acts like another WHERE
    clause, but the point in using HAVING that way is not clear.  A good
    rule of thumb is that a HAVING condition should refer to the results
    of aggregate functions.  A restriction that does not involve an
    aggregate is more efficiently expressed in the WHERE clause.
-->
<para>GROUP BY句を使ってグループ化されたテーブルで決まったグループのみ必要な場合、グループ化されたテーブルから不要なグループを除くのに、WHERE句のようにHAVING句を使うことができます。PostgresはHAVING句をGROUP BY句なしに使うことができますが、その場合、もう1つのWHERE句のように振る舞います。このようにHAVINGを使うポイントは明確ではありませんが、目安としては、HAVING条件が集約関数の結果を参照するということです。集約を含んでいない制約は、WHERE句の中でより効果的に表記されます。
   </para>

   <para>
<!--    Example: -->
        例を示します。</para>
<programlisting>
SELECT pid    AS "Products",
       p.name AS "Over 5000",
       (sum(s.units) * (p.price - p.cost)) AS "Past Month Profit"
  FROM products p LEFT JOIN sales s USING ( pid )
  WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
  GROUP BY pid, p.name, p.price, p.cost
    HAVING sum(p.price * s.units) > 5000;
</programlisting>
<!--
    In the example above, the WHERE clause is selecting rows by a
    column that is not grouped, while the HAVING clause
    restricts the output to groups with total gross sales over 5000.
-->
<para>この例では、WHERE句はグループ化する前の列の行を選択し、その後、HAVING句が、総売上高の合計が5,000より大きいグループを抽出します。
   </para>
  </sect2>
 </sect1>


 <sect1 id="queries-select-lists">
<!--  <title>Select Lists</title> -->
  <title>選択リスト</title>
<indexterm><primary sortas="せんたくりすと">選択リスト</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="せんたくりすと">選択リスト</secondary></indexterm>
  <para>
<!--
   As shown in the previous section,
   the table expression in the <command>SELECT</command> command
   constructs an intermediate virtual table by possibly combining
   tables, views, eliminating rows, grouping, etc.  This table is
   finally passed on to processing by the <firstterm>select list</firstterm>.  The select
   list determines which <emphasis>columns</emphasis> of the
   intermediate table are actually output.  The simplest kind of select list
   is <literal>*</literal> which emits all columns that the table
   expression produces.  Otherwise, a select list is a comma-separated
   list of value expressions (as defined in <xref
   linkend="sql-expressions">).  For instance, it could be a list of
   column names:
-->

   前のセクションで示したように、<command>SELECT</command>コマンド中のテーブル式は、テーブルの結合やビュー、行の抽出、グループ化などにより中間の仮想テーブルを作ります。このテーブルは最終的に<firstterm>選択リスト</firstterm>に渡されます。選択リストは、中間のテーブルのどの<emphasis>列</emphasis>が実際に出力されるかを決めます。テーブルのすべての列を出力する<literal>*</literal>が最も簡単な選択リストです。そうでなければ、選択リストは、カンマで区切られた評価式（<xref linkend="sql-expressions">参照）のリストです。たとえば、列名のリストであってもかまいません。</para>

<programlisting>
SELECT a, b, c FROM ...
</programlisting>
<!--
   The columns names a, b, and c are either the actual names of the
   columns of tables referenced in the FROM clause, or the aliases
   given to them as explained in <xref linkend="queries-table-aliases">.
   The name space available in the select list is the same as in the
   WHERE clause (unless grouping is used, in which case it is the same
   as in the HAVING clause).  If more than one table has a column of
   the same name, the table name must also be given, as in
-->

<para>a、b、cは、FROM句にあるテーブルの実際の列名か、あるいは、<xref linkend="queries-table-aliases">で説明した別名です。選択リストで使える名前はWHERE句と同じです（もしグルーピングされていなければ、それは、HAVING句と同じとなります）。もし、2つ以上のテーブルで列名が同じものを指定する場合は、次のように、テーブル名を必ず指定しなければいけません（<xref linkend="queries-where">を参照）。</para>

<programlisting>
SELECT tbl1.a, tbl2.b, tbl1.c FROM ...
</programlisting>
<!-- (see also <xref linkend="queries-where">). -->

  <para>
<!-- If an arbitrary value expression is used in the select list, it
   conceptually adds a new virtual column to the returned table.  The
   value expression is evaluated once for each retrieved
   row, with the row's values substituted for any column references.  But
   the expressions in the select list do not have to reference any
   columns in the table expression of the FROM clause; they could be
   constant arithmetic expressions as well, for instance. -->

   任意の評価式が選択リストで使われる場合、返されるテーブルは、概念的には新たに仮想的な列を追加したものとなります。評価式は、それぞれの行で、行の値を列の参照とみなして一旦評価されます。しかし選択リストには、FROM句で指定されたテーブルの列である必要はありません。たとえば、それらは定数算術式でもかまいません。
  </para>

  <sect2 id="queries-column-labels">
<!-- <title>Column Labels</title> -->
   <title>列ラベル</title>
<indexterm><primary sortas="れつらべる">列ラベル</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="れつらべる">列ラベル</secondary></indexterm>
   <para>
<!-- The entries in the select list can be assigned names for further
    processing.  The <quote>further processing</quote> in this case is
    an optional sort specification and the client application (e.g.,
    column headers for display).  For example: -->

選択リスト中のエントリは後の処理のために名前を割り当てることができます。この場合の<quote>後の処理</quote>とは、オプションの類の記述とクライアントアプリケーションのことです（たとえば、列へッダを表示するために使います）。例を示します。</para>

<programlisting>
SELECT a AS value, b + c AS sum FROM ...
</programlisting>

   <para>
<!--
     If no output column name is specified via AS, the system assigns a
    default name.  For simple column references, this is the name of the
    referenced column.  For function 
    calls, this is the name of the function.  For complex expressions,
    the system will generate a generic name.
 -->

    もし、ASを使った列名の指定が無かった場合、システムは、デフォルトの名前を割り当てます。単に列を参照するためには、参照された列名となります。関数呼び出しでは、関数名となります。複雑な表現は、システムが特有の名前を生成します。
   </para>

   <note>
    <para>
<!--
     The naming of output columns here is different from that done in
     the FROM clause (see <xref linkend="queries-table-aliases">).  This
     pipeline will in fact allow you to rename the same column twice,
     but the name chosen in the select list is the one that will be
     passed on.
-->

     ここでの出力列の名前は、FROM句（<xref linkend="queries-table-aliases">を参照）で示したものとは異なります。パイプ処理で、同じカラムを2度改名することが可能ですが、選択リストの中で選ばれた名前が渡されます。
    </para>
   </note>
  </sect2>

  <sect2 id="queries-distinct">
   <title>DISTINCT</title>
<indexterm><primary>DISTINCT</primary></indexterm>
   <para>
<!--
     After the select list has been processed, the result table may
    optionally be subject to the elimination of duplicates.  The
    <token>DISTINCT</token> key word is written directly after the 
    <token>SELECT</token> to enable this:
 -->

    選択リストが処理された後、結果テーブルの重複した行を任意で削除したい場合がありますが、<token>DISTINCT</token>キーワードを<token>SELECT</token>の後に書くとこれが可能になります（<token>DISTINCT</token>の代わりとして<token>ALL</token>を指定するとデフォルトの選択となり、すべての行が返ります）。</para>

<synopsis>
SELECT DISTINCT <replaceable>select_list</replaceable> ...
</synopsis>
<!--
    (Instead of <token>DISTINCT</token> the word <token>ALL</token>
    can be used to select the default behavior of retaining all rows.)
-->


   <para>
<!-- Obviously, two rows are considered distinct if they differ in at
    least one column value.  NULLs are considered equal in this
    comparison. -->

    少なくとも1つの列の値が異なる場合、それら2列は別個とみなされます。NULLは、この比較において等しいとみなされます。
   </para>

   <para>
<!-- Alternatively, an arbitrary expression can determine what rows are
    to be considered distinct: -->
    二者択一で、どの行が別であるかを任意に表現できます。</para>

<synopsis>
SELECT DISTINCT ON (<replaceable>expression</replaceable> <optional>, <replaceable>expression</replaceable> ...</optional>) <replaceable>select_list</replaceable> ...
</synopsis>
<!--
    Here <replaceable>expression</replaceable> is an arbitrary value
    expression that is evaluated for all rows.  A set of rows for
    which all the expressions are equal are considered duplicates, and
    only the first row of the set is kept in the output.  Note that the
    <quote>first row</quote> of a set is unpredictable unless the
    query is sorted on enough columns to guarantee a unique ordering
    of the rows arriving at the DISTINCT filter.  (DISTINCT ON processing
    occurs after ORDER BY sorting.)
-->

<para>
<replaceable>expression</replaceable>は、すべての行で評されるの任意の表現です。<replaceable>expression</replaceable>で指定された行の値が等しいときは、重複した行と考えられ、重複した行の集まりの内、最初の行だけが出力されます。独自順序を保証するための十分な列でソートした後でなければ、集まりの内の<quote>最初の行</quote>が予測不可能であることに注意してください（DISTINCT ON処理は、ORDER BYソートの後に行われます）。
   </para>

   <para>
<!--
    The DISTINCT ON clause is not part of the SQL standard and is
    sometimes considered bad style because of the potentially indeterminate
    nature 
    of its results.  With judicious use of GROUP BY and subselects in
    FROM the construct can be avoided, but it is very often the most
    convenient alternative.
-->
    DISTINCT ON句は、SQL標準ではありません。さらに、結果が潜在的に不定となるため、場合によっては悪いスタイルと考えられます。GROUP BYとFROMの中の副問い合わせをうまく使うことによりに回避はできますが、非常に多くの場合最も便利な代案となります。
   </para>
  </sect2>
 </sect1>


 <sect1 id="queries-union">
<!--
  <title>Combining Queries</title>
-->
  <title>問い合わせの結合</title>
<indexterm><primary sortas="といあわせ">問い合わせ</primary><secondary sortas="けつごう">結合</secondary></indexterm>
  <para>
<!--
   The results of two queries can be combined using the set operations
   union, intersection, and difference.  The syntax is
-->

   2つの問い合わせの結果は、和、積、差の集合演算を使って結合することができます。構文は以下のとおりです。</para>

<synopsis>
<replaceable>query1</replaceable> UNION <optional>ALL</optional> <replaceable>query2</replaceable>
<replaceable>query1</replaceable> INTERSECT <optional>ALL</optional> <replaceable>query2</replaceable>
<replaceable>query1</replaceable> EXCEPT <optional>ALL</optional> <replaceable>query2</replaceable>
</synopsis>
<!--
   <replaceable>query1</replaceable> and
   <replaceable>query2</replaceable> are queries that can use any of
   the features discussed up to this point.  Set operations can also
   be nested and chained, for example
-->

<para>
<replaceable>query1</replaceable>と<replaceable>query2</replaceable>は、これまでに述べたいかなる機能にも使うことができる問い合わせです。集合演算は入れ子にしたり、繋げたりすることができます。たとえば、以下の文を見てみましょう。</para>


<synopsis>
<replaceable>query1</replaceable> UNION <replaceable>query2</replaceable> UNION <replaceable>query3</replaceable>
</synopsis>
<!--
   which really says
-->
<para>
上記の文は、本当は以下の文を意味します。</para>

<synopsis>
(<replaceable>query1</replaceable> UNION <replaceable>query2</replaceable>) UNION <replaceable>query3</replaceable>
</synopsis>

  <para>
<!--
   <command>UNION</command> effectively appends the result of
   <replaceable>query2</replaceable> to the result of
   <replaceable>query1</replaceable> (although there is no guarantee
   that this is the order in which the rows are actually returned).
   Furthermore, it eliminates all duplicate rows, in the sense of DISTINCT,
   unless ALL is specified.
-->
   <command>UNION</command>は、<replaceable>query2</replaceable>の結果を<replaceable>query1</replaceable>の結果に付加します（しかし、実際に行が返された順序である保証はありません）。さらに、ALLを指定しないと、DISTINCTと同様に、すべての重複している行を削除します。
  </para>

  <para>
<!--
   <command>INTERSECT</command> returns all rows that are both in the
   result of <replaceable>query1</replaceable> and in the result of
   <replaceable>query2</replaceable>.  Duplicate rows are eliminated
   unless ALL is specified.
-->
   <command>INTERSECT</command>は、<replaceable>query1</replaceable>の結果と<replaceable>query2</replaceable>の結果の両方に含まれているすべての行を返します。重複している行は、ALLを指定しないと削除されます。
  </para>

  <para>
<!--
   <command>EXCEPT</command> returns all rows that are in the result
   of <replaceable>query1</replaceable> but not in the result of
   <replaceable>query2</replaceable>.  Again, duplicates are
   eliminated unless ALL is specified.
-->
   <command>EXCEPT</command>は、<replaceable>query1</replaceable>の結果には含まれているけれども、<replaceable>query2</replaceable>の結果には含まれていないすべての行を返します。繰り返しですが、重複はALLを指定しないと削除されます。
  </para>

  <para>
<!--
   In order to calculate the union, intersection, or difference of two
   queries, the two queries must be <quote>union compatible</quote>,
   which means that they both return the same number of columns, and
   that the corresponding columns have compatible data types, as
   described in <xref linkend="typeconv-union-case">.
-->
   2つの問い合わせの和、積、差を算出するために、そこの2つの問い合わせは<quote>unioncompatible</quote>でなければいけません。つまり、2つの問い合わせが同じ数の列を返し、一致する列は互換性のあるデータ型（<xref linkend="typeconv-union-case">を参照）でなければなりません。
  </para>
 </sect1>


 <sect1 id="queries-order">
<!--
  <title>Sorting Rows</title>
-->
  <title>行の並べ換え</title>
<indexterm><primary sortas="ぎょう">行</primary><secondary sortas="ならべかえ">並べ替え</secondary></indexterm>
<indexterm><primary>ORDERY BY</primary></indexterm>
<indexterm><primary>SQL</primary><secondary>ORDER BY</secondary></indexterm>
  <para>
<!--
   After a query has produced an output table (after the select list
   has been processed) it can optionally be sorted.  If sorting is not
   chosen, the rows will be returned in random order.  The actual
   order in that case will depend on the scan and join plan types and
   the order on disk, but it must not be relied on.  A particular
   output ordering can only be guaranteed if the sort step is explicitly
   chosen.
-->
   1つの問い合わせが1つの出力テーブルを生成した後（selectリストの処理が完了した後）、任意で並べ替えることができます。並べ替えが選ばれなかった場合、行はランダムな順序で返されます。そのような場合、実際の順序は、スキャンや結合プランの種類や、ディスク上に格納されている順序に依存します。しかし、当てにはなりません。特定の順序で出力することは、明白に並べ替える処理を選択することでのみ保証されます。
  </para>

  <para>
<!--
   The ORDER BY clause specifies the sort order:
-->
   ORDER BY句は並べ替えの順番を指定します。</para>

<synopsis>
SELECT <replaceable>select_list</replaceable> FROM <replaceable>table_expression</replaceable> ORDER BY <replaceable>column1</replaceable> <optional>ASC | DESC</optional> <optional>, <replaceable>column2</replaceable> <optional>ASC | DESC</optional> ...</optional>
</synopsis>
<!--
   <replaceable>column1</replaceable>, etc., refer to select list
   columns.  These can be either the output name of a column (see
   <xref linkend="queries-column-labels">) or the number of a column.  Some
   examples:
-->
<para>
<replaceable>column1</replaceable>やその他は、選択リストの列を参照します。これらは列の出力名（<xref linkend="queries-column-labels">を参照）か、列の数になります。以下にいくつか例を示します。</para>
<programlisting>
SELECT a, b FROM table1 ORDER BY a;
SELECT a + b AS sum, c FROM table1 ORDER BY sum;
SELECT a, sum(b) FROM table1 GROUP BY a ORDER BY 1;
</programlisting>

  <para>
<!--
   As an extension to the SQL standard, Postgres also allows ordering
   by arbitrary expressions:
-->
   SQL標準への拡張として、Postgresは任意の評価式で並べ替えを指定することができます。</para>

<programlisting>
SELECT a, b FROM table1 ORDER BY a + b;
</programlisting>
<!--
   References to column names in the FROM clause that are renamed in
   the select list are also allowed:
-->

<para>選択リストで別名を付けられたFROM句の列名を使うこともできます。</para>

<programlisting>
SELECT a AS b FROM table1 ORDER BY a;
</programlisting>

<para>
<!--
   But these extensions do not work in queries involving UNION, INTERSECT,
   or EXCEPT, and are not portable to other DBMSes.
-->
   しかしこれらの拡張は、UNION、INTERSECT、EXCEPTの問い合わせの実行中は機能しません。また、他のDBMSへの移植性もありません。
  </para>

  <para>
<!--
   Each column specification may be followed by an optional ASC or
   DESC to set the sort direction.  ASC is default.  Ascending order
   puts smaller values first, where <quote>smaller</quote> is defined
   in terms of the <literal>&lt;</literal> operator.  Similarly,
   descending order is determined with the <literal>&gt;</literal>
   operator.
-->
   それぞれの列の並び順は、ソートの方向を決めるASCかDESCのどちらかに従います。ASCがデフォルトです。昇順はより小さな値を始めに置きます。<quote>より小さい</quote>は、「<literal>&lt;</literal>」演算子で定義されます。同じように、降順は「<literal>&gt;</literal>」演算子で指定されます。
  </para>

  <para>
<!--
   If more than one sort column is specified, the later entries are
   used to sort rows that are equal under the order imposed by the
   earlier sort specifications.
-->
   1つ以上の列を並べ替えるよう指定すると、後に指定されたものは、前に指定した並べ替えで並べ替えられたものに対して適用されます。
  </para>
 </sect1>

 <sect1 id="queries-limit">
<!--
  <title>LIMIT and OFFSET</title>
-->
  <title>LIMITとOFFSET</title>
<indexterm><primary>LIMIT</primary></indexterm>
<indexterm><primary>OFFSET</primary></indexterm>
<indexterm><primary>SQL</primary><secondary>LIMIT</secondary></indexterm>
<indexterm><primary>SQL</primary><secondary>OFFSET</secondary></indexterm>
<synopsis>
SELECT <replaceable>select_list</replaceable> FROM <replaceable>table_expression</replaceable> <optional>ORDER BY <replaceable>sort_spec</replaceable></optional> <optional>LIMIT { <replaceable>number</replaceable> | ALL }</optional> <optional>OFFSET <replaceable>number</replaceable></optional>
</synopsis>

  <para>
<!--
   LIMIT allows you to retrieve just a portion of the rows that are
   generated by the rest of the query.  If a limit count is given, no
   more than that many rows will be returned.  If an offset is given,
   that many rows will be skipped before starting to return rows.
-->
   LIMITを使うことで、問い合わせの実行で生成された行の一部を取り出すことができます。リミットカウント（LIMIT）が指定されると、その数を越える行は返されません。オフセット（OFFSET）が指定されると、指定した分だけ返す行の開始位置を飛ばします。
  </para>

  <para>
<!--
   When using LIMIT, it is a good idea to use an ORDER BY clause that
   constrains the result rows into a unique order.  Otherwise you will
   get an unpredictable subset of the query's rows-you may be asking
   for the tenth through twentieth rows, but tenth through twentieth
   in what ordering?  The ordering is unknown, unless you specified
   ORDER BY.
-->
   LIMITを使用するときは、結果の行を一意な順序に制約する、ORDER BY句を使用するのがよいでしょう。ORDER BYを使わなければ、予知できない問い合わせの行の部分集合を得ることになるでしょう。10番目から20番目の行を問い合わせることもあるでしょうが、10番目から20番目というのは、どういう順序で並んでいたものでしょうか？ ORDER BYを指定しなければ、並び順はわかりません。
  </para>

  <para>
<!--
   The query optimizer takes LIMIT into account when generating a
   query plan, so you are very likely to get different plans (yielding
   different row orders) depending on what you give for LIMIT and
   OFFSET.  Thus, using different LIMIT/OFFSET values to select
   different subsets of a query result <emphasis>will give
   inconsistent results</emphasis> unless you enforce a predictable
   result ordering with ORDER BY.  This is not a bug; it is an
   inherent consequence of the fact that SQL does not promise to
   deliver the results of a query in any particular order unless ORDER
   BY is used to constrain the order.
-->
   問い合わせのオプティマイザは、問い合わせプランが生成されたときにLIMITを考慮に入れます。そこで、LIMITとOFFSETに与えたものによって、おそらく（異なる行の順序を生む）異なったプランを得ることになります。このように、1つの問い合わせ結果から異なるサブセットを選び出すために、異なるLIMIT/OFFSERTの値を使用することは、ORDER BYで結果の順序を制約しない限りは、<emphasis>矛盾した結果を生むでしょう</emphasis>。これはバグではありません。ORDER BYを使って順序を制約することがない限り、SQLは特定の順序で問い合わせの結果を渡さない、という固有の成り行きの結果です。
  </para>
 </sect1>

</chapter>





