<!--
$Header: /usr/prj/pg/cvsroot/doc/doc/src/sgml/ref/select.sgml,v 1.9 2001/09/14 08:39:34 t-ishii Exp $
Postgres documentation
-->

<refentry id="SQL-SELECT">
 <refmeta>
  <refentrytitle id="sql-select-title">
   SELECT
  </refentrytitle>
  <refmiscinfo>SQL<!-- Language Statements -->言語</refmiscinfo>
 </refmeta>
 <refnamediv>
  <refname>
   SELECT
  </refname>
  <refpurpose>
   <!-- Retrieves rows from a table or view -->
   テーブルやビューから行を検索して取得します。<indexterm><primary>SELECT</primary></indexterm><indexterm><primary>SQL</primary><secondary>SELECT</secondary></indexterm><indexterm><primary sortas="てーぶる">テーブル</primary><secondary sortas="けんさく">検索</secondary></indexterm>
  </refpurpose></refnamediv>
 <refsynopsisdiv>
  <refsynopsisdivinfo>
   <date>2000-12-11</date>
  </refsynopsisdivinfo>
<synopsis>
SELECT [ ALL | DISTINCT [ ON ( <replaceable class="PARAMETER">expression</replaceable> [, ...] ) ] ]
    * | <replaceable class="PARAMETER">expression</replaceable> [ AS <replaceable class="PARAMETER">output_name</replaceable> ] [, ...]
    [ FROM <replaceable class="PARAMETER">from_item</replaceable> [, ...] ]
    [ WHERE <replaceable class="PARAMETER">condition</replaceable> ]
    [ GROUP BY <replaceable class="PARAMETER">expression</replaceable> [, ...] ]
    [ HAVING <replaceable class="PARAMETER">condition</replaceable> [, ...] ]
    [ { UNION | INTERSECT | EXCEPT [ ALL ] } <replaceable class="PARAMETER">select</replaceable> ]
    [ ORDER BY <replaceable class="PARAMETER">expression</replaceable> [ ASC | DESC | USING <replaceable class="PARAMETER">operator</replaceable> ] [, ...] ]
    [ FOR UPDATE [ OF <replaceable class="PARAMETER">tablename</replaceable> [, ...] ] ]
    [ LIMIT { <replaceable class="PARAMETER">count</replaceable> | ALL } [ { OFFSET | , } <replaceable class="PARAMETER">start</replaceable> ]]

where <replaceable class="PARAMETER">from_item</replaceable> can be:

[ ONLY ] <replaceable class="PARAMETER">table_name</replaceable> [ * ]
    [ [ AS ] <replaceable class="PARAMETER">alias</replaceable> [ ( <replaceable class="PARAMETER">column_alias_list</replaceable> ) ] ]
|
( <replaceable class="PARAMETER">select</replaceable> )
    [ AS ] <replaceable class="PARAMETER">alias</replaceable> [ ( <replaceable class="PARAMETER">column_alias_list</replaceable> ) ]
|
<replaceable class="PARAMETER">from_item</replaceable> [ NATURAL ] <replaceable class="PARAMETER">join_type</replaceable> <replaceable class="PARAMETER">from_item</replaceable>
    [ ON <replaceable class="PARAMETER">join_condition</replaceable> | USING ( <replaceable class="PARAMETER">join_column_list</replaceable> ) ]
</synopsis>
  
  <refsect2 id="R2-SQL-SELECT-1">
   <refsect2info>
    <date>2000-12-11</date>
   </refsect2info>
   <title>
    <!-- Inputs -->入力
   </title>

    <variablelist>
     <varlistentry>
      <term><replaceable class="PARAMETER">expression</replaceable></term>
      <listitem>
       <para>
	<!-- The name of a table's column or an expression. -->
        テーブルの列もしくは式の名前です。
       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">output_name</replaceable></term>
      <listitem>
       <para>
	<!-- Specifies another name for an output column using
	the AS clause.  This name is primarily used to label the column
	for display.  It can also be used to refer to the column's value in
	ORDER BY and GROUP BY clauses.  But the
	<replaceable class="PARAMETER">output_name</replaceable>
	cannot be used in the WHERE or HAVING clauses; write out the
	expression instead. -->

        AS句を使い、出力列の別の名前を指定します。この名前は主に表示する列を名付けるために使われます。ほかにはORDER BYとGROUP BY句の中の列の値を参照するのに使われることもあります。しかし<replaceable class="PARAMETER">output_name</replaceable>はWHERE句もしくはHAVING句で使うことはできません。代わりに式を書いてください。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">from_item</replaceable></term>
      <listitem>
       <para>
        <!-- A table reference, sub-SELECT, or JOIN clause.  
        See below for details. -->

        テーブル参照、副SELECT、JOIN句などです。詳細は下記を参照してください。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">condition</replaceable></term>
      <listitem>
       <para>
	<!-- A boolean expression giving a result of true or false.
	See the WHERE and HAVING clause descriptions below.
        -->

        真か偽の結果を返すブーリアン式です。WHERE句とHAVING句の説明は下記を参照してください。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">select</replaceable></term>
      <listitem>
       <para>
        <!-- 
 	A select statement with all features except the ORDER BY, 
        FOR UPDATE, and LIMIT clauses (even those can be used when 
        the select is parenthesized). -->

        ORDER BY、FOR UPDATE、LIMIT句を除くすべての機能でのselect文です（select式をかっこで囲めばORDER BY、FOR UPDATE、LIMITも使用できます）。 
        
       </para>
      </listitem>
     </varlistentry>
     
    </variablelist>

   <para>
    <!-- FROM items can contain: -->
    FROM句には以下のものを含むことができます。
 </para>

    <variablelist>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">table_name</replaceable></term>
      <listitem>
       <para>
        <!-- 
	The name of an existing table or view.  If ONLY is specified, 
        only that table is scanned.  If ONLY is not specified, the 
        table and all its descendant tables (if any) are scanned.  
        * can be appended to the table name to indicate that descendant 
        tables are to be scanned, but as of 
        <Productname>Postgres</Productname> 7.1 this is the default
	behavior.  (In releases before 7.1, ONLY was the default behavior.)
        -->

        既存のテーブルかビューの名前です。もしONLYが指定された場合、そのテーブルのみがスキャンされます。もしONLYが指定されない場合、テーブルとそれを継承するすべてのテーブル（存在する場合）がスキャンされます。継承テーブルがスキャンされることを表すために「*」を付けることができますが、<Productname>Postgres</Productname> 7.1からはこれはデフォルトになりました（7.1より前のリリースでは、ONLYがデフォルトでした）。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">alias</replaceable></term>
      <listitem>
       <para>
	<!-- A substitute name for the preceding
	<replaceable class="PARAMETER">table_name</replaceable>.
	An alias is used for brevity or to eliminate ambiguity for 
        self-joins (where the same table is scanned multiple times).  
        If an alias is written, a column alias list can also be 
        written to provide substitute names for one or more columns 
        of the table. -->

        前にある<replaceable class="PARAMETER">table_name</replaceable>の代わりの名前です。別名は簡潔さもしくは自己結合（同じテーブルが複数回スキャンされる場合です）の曖昧さをなくすために使われます。テーブルの別名と一緒に、そのテーブルの複数の列の別名リストを付け加えることもできます。
        
       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">select</replaceable></term>
      <listitem>
       <para>
        <!-- 
	A sub-SELECT can appear in the FROM clause.  This acts as though
	its output were created as a temporary table for the duration of
	this single SELECT command.  Note that the sub-SELECT must be
	surrounded by parentheses, and an alias <emphasis>must</emphasis>
	be provided for it. -->

        副SELECTはFROM句で使うことができます。これはその出力がこのSELECTコマンド実行時に一時テーブルとして作成されたかのように動作します。副SELECTはかっこで囲まれなければならず、<emphasis>必ず</emphasis>別名が提供されなければなりません。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">join_type</replaceable></term>
      <listitem>
       <para>
       <!-- One of
       <command>[ INNER ] JOIN</command>,
       <command>LEFT [ OUTER ] JOIN</command>,
       <command>RIGHT [ OUTER ] JOIN</command>,
       <command>FULL [ OUTER ] JOIN</command>, or
       <command>CROSS JOIN</command>.
       For INNER and OUTER join types, exactly one of NATURAL,
       ON <replaceable class="PARAMETER">join_condition</replaceable>, or
       USING ( <replaceable class="PARAMETER">join_column_list</replaceable> )
       must appear.  For CROSS JOIN, none of these items may appear.-->

       <command>[ INNER ] JOIN</command>、<command>LEFT [ OUTER ] JOIN</command>、<command>RIGHT [ OUTER ] JOIN</command>、<command>FULL [ OUTER ] JOIN</command>、<command>CROSS JOIN</command>のどれかです。INNERとOUTER結合型では、正確に1つのNATURAL、ON<replaceable class="PARAMETER">join_condition</replaceable>、USING ( <replaceable class="PARAMETER">join_column_list</replaceable> )のいずれかがなくてはいけません。CROSS JOINでは、一切なくてもかまいません。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">join_condition</replaceable></term>
      <listitem>
       <para>
       <!-- 
       A qualification condition.  This is similar to the WHERE condition
       except that it only applies to the two from_items being joined in
       this JOIN clause. -->

       制約条件です。これはWHERE条件と似ていますが、このJOIN句で結合される2つのfrom_itemにのみあてはまるという点が違います。

       </para>
      </listitem>
     </varlistentry>
     
     <varlistentry>
      <term><replaceable class="PARAMETER">join_column_list</replaceable></term>
      <listitem>
       <para>
       <!-- 
       A USING column list ( a, b, ... ) is shorthand for the ON condition
       left_table.a = right_table.a AND left_table.b = right_table.b ...
       -->

       USINGの列リスト（a, b, ...）は、ON条件left_table.a = right_table.a AND left_table.b = right_table.b ...の省略形です。

       </para>
      </listitem>
     </varlistentry>

    </variablelist>
  </refsect2>
  
  <refsect2 id="R2-SQL-SELECT-2">
   <refsect2info>
    <date>1998-09-24</date>
   </refsect2info>
   <title>
    <!-- Outputs -->出力
   </title>

    <variablelist>
     <varlistentry>
      <term>Rows</term>
      <listitem>
       <para>
        <!-- 
	The complete set of rows resulting from the query specification.
        -->

        問い合わせ指定の結果の行の完全な集合です。

       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term>
       <returnvalue><replaceable>count</replaceable></returnvalue>
      </term>
      <listitem>
       <para>
	<!-- The count of rows returned by the query. -->
        問い合わせが返す行の数です。

       </para>
      </listitem>
     </varlistentry>
    </variablelist>
  </refsect2>
 </refsynopsisdiv>

 <refsect1 id="R1-SQL-SELECT-1">
  <refsect1info>
   <date>2000-12-11</date>
  </refsect1info>
  <title>
   <!-- Description -->説明
  </title>
  <para>
   <!-- 
   <command>SELECT</command> will return rows from one or more tables.
   Candidates for selection are rows which satisfy the WHERE condition;
   if WHERE is omitted, all rows are candidates.
   (See <xref linkend="sql-where" endterm="sql-where-title">.)
   -->

   <command>SELECT</command>は、1つ以上のテーブルから行を返します。選択される侯補はWHERE条件を満たす行です。もしWHEREが省略されると、すべての行が侯補になります（<xref linkend="sql-where" endterm="sql-where-title">を参照してください）。

  </para>

  <para>
   <!-- 
   Actually, the returned rows are not directly the rows produced by the
   FROM/WHERE/GROUP BY/HAVING clauses; rather, the output rows are formed
   by computing the SELECT output expressions for each selected row.
   <command>*</command> can be written in the output list as a shorthand
   for all the columns of the selected rows.  Also, one can write
   <replaceable class="PARAMETER">table_name</replaceable>
   <command>.*</command>
   as a shorthand for the columns coming from just that table.
   -->

   実際のところ、返される行はFROM/WHERE/GROUP BY/HAVING句から直接作られる行ではありません。出力される行はそれぞれの選択された行のSELECT出力式を計算することで形成されます。「<command>*</command>は」選択された行のすべての列の省略形としての出力リストに書くことができます。さらに、<command><replaceable class="PARAMETER">table_name</replaceable>.*</command>はそのテーブルのみからくる列の省略形として書くことができます。

  </para>

  <para>
   <!-- 
   <command>DISTINCT</command> will eliminate duplicate rows from the
   result.
   <command>ALL</command> (the default) will return all candidate rows,
   including duplicates. -->

   <command>DISTINCT</command>は結果から重複行を削除します。<command>ALL</command>（デフォルトです）は重複行を含むすべての侯補の行を返します。<indexterm><primary>SELECT</primary><secondary>DISTINCT</secondary></indexterm>

  </para>

  <para>
   <!-- 
   <command>DISTINCT ON</command> eliminates rows that match on all the
   specified expressions, keeping only the first row of each set of
   duplicates.  The DISTINCT ON expressions are interpreted using the
   same rules as for ORDER BY items; see below.
   Note that "the first row" of each set is unpredictable
   unless <command>ORDER BY</command> is used to ensure that the desired
   row appears first.  For example,
<programlisting>
        SELECT DISTINCT ON (location) location, time, report
        FROM weatherReports
        ORDER BY location, time DESC;
</programlisting>
   retrieves the most recent weather report for each location.  But if
   we had not used ORDER BY to force descending order of time values
   for each location, we'd have gotten a report of unpredictable age
   for each location. -->

   <command>DISTINCT ON</command>は、それぞれの重複行の集合の最初の行のみを残し、指定された式に当てはまる行を消します。<command>DISTINCT ON</command>式は<command>ORDER BY</command>と同じルールを使って解釈されます。次の文を見てください。各集合の最初の行は、<command>ORDER BY</command>句によって目的とする行がいちばん始めに出現することを確実にしておかないと予測不可能なことに注意してください。たとえば、以下のSQL文はそれぞれの場所の最新の気象情報を取りだします。<indexterm><primary>SELECT</primary><secondary>DISTINCT ON</secondary></indexterm>
</para>

<programlisting>
        SELECT DISTINCT ON (location) location, time, report
        FROM weatherReports
        ORDER BY location, time DESC;
</programlisting>   
   
<para>
   しかしもしそれぞれの場所の時間値を降順に強制するためにORDER BYを使わなかったとしたら、それぞれの場所の予測できない時代の予報を得ることになってしまいます。

  </para>

  <para>
   <!-- The GROUP BY clause allows a user to divide a table
   into groups of rows that match on one or more values.
   (See <xref linkend="sql-groupby" endterm="sql-groupby-title">.)
   -->

   GROUP BY句によってユーザーがテーブルを、1つ以上の値に当てはまる行のグループにわけることができます（<xref linkend="sql-groupby" endterm="sql-groupby-title">を参照してください）。

  </para>

  <para>
   <!-- 
   The HAVING clause allows selection of only those groups of rows
   meeting the specified condition.
   (See <xref linkend="sql-having" endterm="sql-having-title">.)
   -->

   HAVING句によって、指定された条件にあう行のグループのみを選択することができます（<xref linkend="sql-having" endterm="sql-having-title">を参照してください）。

  </para>
   
  <para>
   <!-- 
   The ORDER BY clause causes the returned rows to be sorted in a specified
   order.  If ORDER BY is not given, the rows are returned in whatever order
   the system finds cheapest to produce.
   (See <xref linkend="sql-orderby" endterm="sql-orderby-title">.) -->

   ORDER BY句は、返された行が指定された順にソートされるようにします。もしORDER BYが与えられないと、行はシステムにとって一番作りやすい順番で返されます（<xref linkend="sql-orderby" endterm="sql-orderby-title">を参照してください）。

  </para>
   
  <para>
   <!-- 
   SELECT queries can be combined using UNION, INTERSECT, and EXCEPT
   operators.  Use parentheses if necessary to determine the ordering
   of these operators. -->

   SELECT問い合わせは、UNION、INTERSECT、EXCEPTなどの演算子を使って組み合わせることができます。もしこれらの演算子の順番を決める必要があるときはかっこを使います。

  </para>
   
  <para>
   <!-- The UNION operator computes the collection of rows
   returned by the queries involved.
   Duplicate rows are eliminated unless ALL is specified.
   (See <xref linkend="sql-union" endterm="sql-union-title">.) -->

   UNION演算子は、関連する問い合わせが返す行の集まりを計算します。重複行はALLが指定されない限り消されます（<xref linkend="sql-union" endterm="sql-union-title">を参照してください）。

  </para>
   
  <para>
   <!-- 
   The INTERSECT operator computes the rows that are common to both queries.
   Duplicate rows are eliminated unless ALL is specified.
   (See <xref linkend="sql-intersect" endterm="sql-intersect-title">.) -->

   INTERSECT演算子は、両方の問い合わせに共通する行を計算します。重複行はALLが指定されない限り削除されます（<xref linkend="sql-intersect" endterm="sql-intersect-title">を参照してください）。

  </para>
   
  <para>
   <!-- 
   The EXCEPT operator computes the rows returned by the first query but
   not the second query.
   Duplicate rows are eliminated unless ALL is specified.
   (See <xref linkend="sql-except" endterm="sql-except-title">.)
   -->

   EXCEPT演算子は、最初の問い合わせからは返されていて2番目の問い合わせからは返されない行を計算します。重複行はALLが指定されない限り削除されます（<xref linkend="sql-except" endterm="sql-except-title">を参照してください）。

  </para>
   
  <para>
   <!-- 
   The FOR UPDATE clause allows the SELECT statement to perform 
   exclusive locking of selected rows. -->

   FOR UPDATE句は、SELECT文が選択された行の排他的ロックを実行することを許可します。<indexterm><primary>SELECT</primary><secondary>FOR UPDATE</secondary></indexterm>

  </para>
   
  <para>
   <!-- 
   The LIMIT clause allows a subset of the rows produced by the query
   to be returned to the user.
   (See <xref linkend="sql-limit" endterm="sql-limit-title">.)
   -->

   LIMIT句は、ユーザーが返すべき問い合わせによって作られる行のサブセットを可能にします（<xref linkend="sql-limit" endterm="sql-limit-title">を参照してください）。<indexterm><primary>SELECT</primary><secondary>LIMIT</secondary></indexterm>

  </para>

  <para>
   <!-- 
   You must have SELECT privilege to a table to read its values
   (See the <command>GRANT</command>/<command>REVOKE</command> statements).
   -->

   テーブルの値を読むためにはSELECT権限を持っていなければなりません（<command>GRANT</command>/<command>REVOKE</command>文を参照してください）。

  </para>
   
  <refsect2 id="SQL-FROM">
   <refsect2info>
    <date>2000-12-11</date>
   </refsect2info>
   <title id="sql-from-title">
    FROM<!-- Clause -->句
   </title>
<indexterm><primary sortas="FROMく">FROM句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>FROM</secondary></indexterm>
   <para>
    <!-- 
    The FROM clause specifies one or more source tables for the SELECT.
    If multiple sources are specified, the result is conceptually the
    Cartesian product of all the rows in all the sources ___ but usually
    qualification conditions are added to restrict the returned rows to
    a small subset of the Cartesian product. -->

    FROM句は、1つ以上のソーステーブルをSELECTに指定します。もし複数のソースが指定されると、結果は概念的にすべてのソースのすべての行の直積になります。しかし通常は制約条件は直積の小さなサブセットを制限するために追加されます。

   </para>

   <para>
    <!-- 
    When a FROM item is a simple table name, it implicitly includes rows
    from sub-tables (inheritance children) of the table.
    <command>ONLY</command> will
    suppress rows from sub-tables of the table.  Before
    <Productname>Postgres</Productname> 7.1,
    this was the default result, and adding sub-tables was done
    by appending <command>*</command> to the table name.
    This old behaviour is available via the command 
    <command>SET SQL_Inheritance TO OFF;</command> -->

    FROM句にただテーブル名が指定されている場合、それは暗黙的にそのテーブルのサブテーブル（継承する子）からの行も含みます。<command>ONLY</command>はそのテーブルのサブテーブルからの行を抑圧します。<Productname>Postgres</Productname> 7.1以前ではONLYがデフォルトの結果で、サブテーブルの追加はテーブル名に「<command>*</command>」を付けて行われていました。この古い方法はコマンド<command>SET SQL_Inheritance TO OFF;</command>で使うことができます。
   </para>

   <para>
    <!-- 
    A FROM item can also be a parenthesized sub-SELECT (note that an
    alias clause is required for a sub-SELECT!).  This is an extremely
    handy feature since it's the only way to get multiple levels of
    grouping, aggregation, or sorting in a single query. -->

    FROM句はかっこで囲まれた副問い合わせ（別名句が副問い合わせには必要なことに注意してください）であってもかまいません。これは単一の問い合わせの複数レベルのグループ分け、集約、ソートなどをする唯一の方法なので、非常に便利な機能です。

   </para>

   <para>
    <!-- 
    Finally, a FROM item can be a JOIN clause, which combines two simpler
    FROM items.  (Use parentheses if necessary to determine the order
    of nesting.) -->

    最後に、FROM句は、2つのより単純なFROM句を組み合わせたJOIN句であることもあります（ネストの順番を決める必要がある場合かっこを使います）。

   </para>

   <para>
    <!-- A CROSS JOIN or INNER JOIN is a simple Cartesian product,
    the same as you get from listing the two items at the top level of FROM.
    CROSS JOIN is equivalent to INNER JOIN ON (TRUE), that is, no rows are
    removed by qualification.  These join types are just a notational
    convenience, since they do nothing you couldn't do with plain FROM and
    WHERE. -->

    CROSS JOINもしくはINNER JOINは単純な直積で、FROMの最上レベルにその2つのアイテムをリストするのと同じものです。CROSS JOINはINNER JOIN ON (TRUE)と等しく、制約ではどの行も削除されません。これらの結合型は記述上の便宜のためだけであり、これらは何もしないので単純なFROMとWHEREは使えません。<indexterm><primary>SELECT</primary><secondary>CROSS JOIN</secondary></indexterm><indexterm><primary>SELECT</primary><secondary>INNER JOIN</secondary></indexterm>

   </para>

   <para>
    <!-- 
    LEFT OUTER JOIN returns all rows in the qualified Cartesian product
    (i.e., all combined rows that pass its ON condition), plus one copy 
    of each row in the left-hand table for which there was no right-hand 
    row that passed the ON condition.  This left-hand row is extended to
    the full width of the joined table by inserting NULLs for the 
    right-hand columns.
    Note that only the JOIN's own ON or USING condition is considered while
    deciding which rows have matches.  Outer ON or WHERE conditions are
    applied afterwards. -->

    LEFT OUTER JOINは条件に合う直積のすべての行（つまりそのON条件を満たすすべての組み合わされた行）、そしてON条件を満たす右側の行を持たない左側のテーブルの各々の行のコピーを返します。この左側の行は右側の行にNULLを挿入することで結合されたテーブルの完全な幅まで拡張されます。どの行が当てはまるものを持っているか決める間、JOIN自身のONかUSING条件のみが考慮されることに注意してください。他のONかWHERE条件は後で適用されます。<indexterm><primary>SELECT</primary><secondary>LEFT OUTER JOIN</secondary></indexterm>
   </para>

   <para>
    <!-- 
    Conversely, RIGHT OUTER JOIN returns all the joined rows, plus one row
    for each unmatched right-hand row (extended with nulls on the left).
    This is just a notational
    convenience, since you could convert it to a LEFT OUTER JOIN by 
    switching the left and right inputs. -->

    逆に、RIGHT OUTER JOINはすべての結合された行と、それぞれの当てはまるものがなかった右側の行（左側はnullで拡張されています）に1行ずつを返します。左と右の入力を入れ換えることでLEFT OUTER JOINに変換することもできるため、これはただの記述上の便宜でしかありません。<indexterm><primary>SELECT</primary><secondary>RIGHT OUTER JOIN</secondary></indexterm>

   </para>

   <para>
    <!-- 
    FULL OUTER JOIN returns all the joined rows, plus one row for each
    unmatched left-hand row (extended with nulls on the right), plus one row
    for each unmatched right-hand row (extended with nulls on the left).
    -->

    FULL OUTER JOINはすべての結合された行と、当てはまるものがなかった左側の行（右側がnullで拡張されている）と、あてはまるものがなかった右側の行（左側がnullで拡張されている）を返します。<indexterm><primary>SELECT</primary><secondary>FULL OUTER JOIN</secondary></indexterm>

   </para>

   <para>
    <!-- For all the JOIN types except CROSS JOIN, you must write
    exactly one of ON <replaceable
    class="PARAMETER">join_condition</replaceable>, USING (
    <replaceable class="PARAMETER">join_column_list</replaceable> ),
    or NATURAL.  ON is the most general case: you can write any
    qualification expression involving the two tables to be joined.  A
    USING column list ( a, b, ... ) is shorthand for the ON condition
    left_table.a = right_table.a AND left_table.b = right_table.b ...
    Also, USING implies that only one of each pair of equivalent
    columns will be included in the JOIN output, not both.  NATURAL is
    shorthand for a USING list that mentions all similarly-named
    columns in the tables. -->

    CROSS JOINを除くすべてのJOIN型では、ON <replaceable class="PARAMETER">join_condition</replaceable>、USING ( <replaceable class="PARAMETER">join_column_list</replaceable> )、NATURALのどれかを正確に書かなければいけません。ONはもっとも一般的な場合です。結合されるべき2つのテーブルに関連するどのような制約式でも書くことができます。USING列リスト（a, b, ...）はON条件left_table.a = right_table.a AND left_table.b = right_table.b ... の簡略バージョンです。さらにUSINGは、JOIN出力に含まれるそれぞれのペアの同等のカラムのうちの両方ではなく1つだけが含まれることを意味します。NATURALはテーブルの中の似たような名前を持つすべての列を挙げるUSINGリストの簡略バージョンです。

   </para>
  </refsect2>
   
  <refsect2 id="SQL-WHERE">
   <refsect2info>
    <date>2000-03-15</date>
   </refsect2info>
   <title id="sql-where-title">
    WHERE<!-- Clause -->句
   </title>
<indexterm><primary sortas="WHEREく">WHERE句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>WHERE</secondary></indexterm>
   <para>
    <!-- The optional WHERE condition has the general form: -->
    オプションのWHERE条件の一般形は次のようになります。
</para>

<synopsis>
WHERE <replaceable class="PARAMETER">boolean_expr</replaceable>
</synopsis>

<para>
    <!-- <replaceable class="PARAMETER">boolean_expr</replaceable>
    can consist of any expression which evaluates to a boolean value.
    In many cases, this expression will be: -->

    <replaceable class="PARAMETER">boolean_expr</replaceable>は論理値として評価できる表現ならどのようなものでも組み合わせて構成することができます。多くの場合、次のようになります。
</para>

<synopsis>
     <replaceable class="PARAMETER">expr</replaceable> <replaceable class="PARAMETER">cond_op</replaceable> <replaceable class="PARAMETER">expr</replaceable>
</synopsis>

<para>
    <!-- or -->
    もしくは<replaceable class="PARAMETER">cond_op</replaceable>に「=」、「&lt;」、「&lt;=」、「&gt;」、「&gt;=」、「&lt;&gt;」のいずれかを使えるところでは、条件演算子がALL、ANY、IN、LIKEもしくはローカルに定義された演算子、そして<replaceable class="PARAMETER">log_op</replaceable>はAND、OR、NOTのいずれかになることができます。SELECTはWHERE条件がTRUEを返さないすべての行を無視します。
</para>

<synopsis>
     <replaceable class="PARAMETER">log_op</replaceable> <replaceable class="PARAMETER">expr</replaceable>
</synopsis>

<para>
    <!-- 
    where <replaceable class="PARAMETER">cond_op</replaceable>
    can be one of: =, &lt;, &lt;=, &gt;, &gt;= or &lt;&gt;,
    a conditional operator like ALL, ANY, IN, LIKE, or a
    locally defined operator, 
    and <replaceable class="PARAMETER">log_op</replaceable> can be one 
    of: AND, OR, NOT.
    SELECT will ignore all rows for which the WHERE condition does not 
    return TRUE. -->

    

   </para>
  </refsect2>
  
  <refsect2 id="SQL-GROUPBY">
   <refsect2info>
    <date>2000-03-15</date>
   </refsect2info>
   <title id="sql-groupby-title">
    GROUP BY<!-- Clause -->句
   </title>
<indexterm><primary sortas="GROUP BYく">GROUP BY句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>GROUP BY</secondary></indexterm>
   <para>
    <!-- GROUP BY specifies a grouped table derived by the application
    of this clause: -->

    GROUP BY句は、この句の要素から作られるグループ化されたテーブルを指定します。
</para>

<synopsis>
GROUP BY <replaceable class="PARAMETER">expression</replaceable> [, ...]
</synopsis>

   <para>
    <!-- 
    GROUP BY will condense into a single row all selected rows that 
    share the same values for the grouped columns.  Aggregate functions, 
    if any, are computed across all rows making up each group, 
    producing a separate value for each group (whereas without GROUP BY, 
    an aggregate produces a single value computed across all the selected
    rows).  When GROUP BY is present, it is not valid for the SELECT
    output expression(s) to refer to
    ungrouped columns except within aggregate functions, since there
    would be more than one possible value to return for an ungrouped column.
    -->

    GROUP BYは、グループ化された列と同じ値を共有するすべての選択された行を1つの行に凝縮します。もしあれば、集約関数はそれぞれのグループを作るすべての行を渡って計算され、それぞれのグループに個別の値を作ります（GROUP BYなしでは集約はすべての選択された行に渡って計算される単一の値を作ります）。GROUP BYが存在する場合、集約関数内以外ではSELECT出力式がグループ分けされていない列を参照することは妥当ではありません。なぜならグループ化されていない列には1つ以上の返却可能な値があるからです。

   </para>

   <para>
    <!-- 
    A GROUP BY item can be an input column name, or the name or 
    ordinal number of an output column (SELECT expression), or it can 
    be an arbitrary expression formed from input-column values.  
    In case of ambiguity, a GROUP BY name will be interpreted as 
    an input-column name rather than an output column name. -->

    GROUP BYには入力列名、出力列の順序の番号の名前（SELECT式）、入力列の値に形成される任意の式などを指定できます。不明瞭な場合は、GROUP BY名は出力列名ではなく入力列名として解釈されます。

   </para>
  </refsect2>

  <refsect2 id="SQL-HAVING">
   <refsect2info>
    <date>2000-03-15</date>
   </refsect2info>
   <title id="sql-having-title">
    HAVING<!-- Clause -->句
   </title>
   <para>
    <!-- The optional HAVING condition has the general form: -->
    オプションであるHAVING条件は、一般的に次の形式です。 
</para>

<synopsis>
HAVING <replaceable class="PARAMETER">boolean_expr</replaceable>
</synopsis>

<para>
    <!-- 
    where <replaceable class="PARAMETER">boolean_expr</replaceable> 
    is the same as specified for the WHERE clause. -->
    ここで<replaceable class="PARAMETER">boolean_expr</replaceable>はWHERE句で指定するものと同一です。 

   </para>
    
   <para>
    <!-- 
    HAVING specifies a grouped table derived by the elimination
    of group rows that do not satisfy the
    <replaceable class="PARAMETER">boolean_expr</replaceable>.
    HAVING is different from WHERE:
    WHERE filters individual rows before application of GROUP BY,
    while HAVING filters group rows created by GROUP BY. -->

    HAVINGによって<replaceable class="PARAMETER">boolean_expr</replaceable>を満たさない行を削除した結果からグループ化されたテーブルを作ることを指示します。HAVINGはWHEREとは違います。WHEREは個別の行をGROUP BYのアプリケーションの前にフィルタしますが、HAVINGはGROUP BYによって作られるグループ行をフィルタします。<indexterm><primary>SELECT</primary><secondary>HAVING</secondary></indexterm><indexterm><primary sortas="HAVINGく">HAVING句</primary></indexterm>
   </para>

   <para>
    <!-- Each column referenced in 
    <replaceable class="PARAMETER">boolean_expr</replaceable> 
    shall unambiguously reference a grouping column, unless 
    the reference appears within an aggregate function.
    -->

    <replaceable class="PARAMETER">boolean_expr</replaceable>で参照される各列は、参照が集約関数内で現れない限り明瞭にグループ化する列を参照します。

   </para>
  </refsect2>
  
  <refsect2 id="SQL-ORDERBY">
   <refsect2info>
    <date>2000-03-15</date>
   </refsect2info>
   <title id="sql-orderby-title">
    ORDER BY<!-- Clause -->句
   </title>
<indexterm><primary sortas="ORDER BYく">ORDER BY句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>ORDER BY</secondary></indexterm>
<synopsis>
ORDER BY <replaceable class="PARAMETER">expression</replaceable> [ ASC | DESC | USING <replaceable class="PARAMETER">operator</replaceable> ] [, ...]
</synopsis>
    
   <para>
    <!-- An ORDER BY item can be the name or ordinal
    number of an output column (SELECT expression), or it can 
    be an arbitrary expression formed from input-column values.  
    In case of ambiguity, an ORDER BY name will be interpreted 
    as an output-column name. -->

    ORDER BYには、名前、出力列（SELECT式）の順序の番号、入力列の値から形成される任意の式などを指定することができます。あいまいな場合は、ORDER BYの名前は出力列名として解釈されます。
    
   </para>
   <para>
    <!-- 
    The ordinal number refers to the ordinal (left-to-right) 
    position of the result column. This feature makes it possible 
    to define an ordering on the basis of a column that does not 
    have a proper name.
    This is never absolutely necessary because it is always possible
    to assign a name to a result column using the AS clause, e.g.:
    -->

    順序の番号は、結果の列の（左から右への）順番の位置を参照します。この機能は正しい名前を持たない列に基づいた順番を定義することを可能にします。これが絶対に必要だという訳ではありません。なぜならAS句を使って結果の列に名前を与えることはいつでも可能だからです。たとえば下記のようになります。
</para>
<programlisting>
SELECT title, date_prod + 1 AS newlen FROM films ORDER BY newlen;
</programlisting>
    
   <para>
    <!-- It is also possible to ORDER BY
    arbitrary expressions (an extension to SQL92),
    including fields that do not appear in the
    SELECT result list.
    Thus the following statement is legal: -->

    SELECTの結果リストに現れないフィールドを含む任意の式（SQL92の拡張）をORDER BYすることも可能です。したがって次の文は正当です。
</para>

<programlisting>
SELECT name FROM distributors ORDER BY code;
</programlisting>

<para>
    <!-- 
    A limitation of this feature is that an ORDER BY clause 
    applying to the result of a UNION, INTERSECT, or EXCEPT 
    query may only specify an output
    column name or number, not an expression. -->

    UNION、INTERSECT、EXCEPT問い合わせの結果に適用するORDER BY句では、式ではなく出力列の名前か番号のみを指定できるので、この機能は使えません。

   </para>
    
   <para>
    <!-- 
    Note that if an ORDER BY item is a simple name that matches 
    both a result column name and an input column name, ORDER BY 
    will interpret it as the result column name.  This is the 
    opposite of the choice that GROUP BY will make in the same 
    situation.  This inconsistency is mandated by the SQL92 standard.
    -->

    もしORDER BYに指定されているのが結果の列名と入力列名の両方に当てはまる単純な名前だった場合、ORDER BYはそれを結果列名として解釈します。これはGROUP BYが同じ状況で行う選択とは逆です。この不一致は標準SQL92からくるものです。

   </para>
    
   <para>
    <!-- 
    Optionally one may add the keyword DESC (descending)
    or ASC (ascending) after each column name in the ORDER BY 
    clause.
    If not specified, ASC is assumed by default.  Alternatively, a
    specific ordering operator name may be specified.  ASC is 
    equivalent to USING &lt; and DESC is equivalent to USING &gt;.
    -->

    オプションとして、ORDER BY句の各カラム名の後にキーワードDESC（逆方向）もしくはASC（順方向）を付けることができます。指定がなければ、デフォルトとしてASCがついているものとします。代わりに特定の順番演算子の名前を指定することもできます。ASCはUSING &lt;と等しく、DESCはUSING &gt;と等しいものです。

   </para>
  </refsect2>
  
  <refsect2 id="SQL-UNION">
   <refsect2info>
    <date>2000-12-11</date>
   </refsect2info>
   <title id="sql-union-title">
    UNION<!-- Clause -->句
   </title>
<indexterm><primary sortas="UNIONく">UNION句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>UNION</secondary></indexterm>

<synopsis>
<replaceable class="PARAMETER">table_query</replaceable> UNION [ ALL ] <replaceable class="PARAMETER">table_query</replaceable>
    [ ORDER BY <replaceable class="PARAMETER">expression</replaceable> [ ASC | DESC | USING <replaceable class="PARAMETER">operator</replaceable> ] [, ...] ]
    [ LIMIT { <replaceable class="PARAMETER">count</replaceable> | ALL } [ { OFFSET | , } <replaceable class="PARAMETER">start</replaceable> ]]
</synopsis>

<para>
    <!-- where
    <replaceable class="PARAMETER">table_query</replaceable>
    specifies any select expression without an ORDER BY, FOR UPDATE,
    or LIMIT clause.  (ORDER BY and LIMIT can be attached to a 
    sub-expression if it is enclosed in parentheses.  Without 
    parentheses, these clauses will be taken to apply to the 
    result of the UNION, not to its right-hand input expression.)
    -->

    ここで、<replaceable class="PARAMETER">table_query</replaceable>は、ORDER BY、FOR UPDATE、LIMITなどの句を持たない任意のselect式を指定できます（ORDER BYとLIMITはselectがかっこで囲まれていると副式に付けることができます。かっこなしでは、これらの句は右側の入力式ではなくUNIONの結果に適用するものとして判断されます）。

   </para>
    
   <para>
    <!-- 
    The UNION operator computes the collection (set union) of 
    the rows returned by the queries involved.
    The two SELECTs that represent the direct operands of the 
    UNION must produce the same number of columns, and 
    corresponding columns must be of compatible data types.
    -->

    UNION演算子は、関連する問い合わせが返す行の集合（和集合）を計算します。UNIONの直接の演算項目を表す2つのSELECTは同じ数の列を作らなければならず、対応する列は互換性のあるデータ型でなければいけません。
   </para>
    
   <para>
    <!-- 
    The result of UNION does not contain any duplicate rows
    unless the ALL option is specified.  ALL prevents elimination of
    duplicates. -->

    UNIONの結果はALLオプションが指定されない限りどのような重複行も含みません。ALLは重複行を削除しません。

   </para>
    
   <para>
    <!-- 
    Multiple UNION operators in the same SELECT statement are
    evaluated left to right, unless otherwise indicated by parentheses.
    -->
    同じSELECT文にある複数のUNION演算子は、かっこで別の順が示されない限り左から右に評価されます。

   </para>
    
   <para>
    <!-- 
    Currently, FOR UPDATE may not be specified either for a UNION 
    result or for the inputs of a UNION. -->

    今のところ、FOR UPDATEはUNIONの結果もしくはUNIONの入力値のどちらにも指定することができません。

   </para>

  </refsect2>

  <refsect2 id="SQL-INTERSECT">
   <refsect2info>
    <date>2000-12-11</date>
   </refsect2info>
   <title id="sql-intersect-title">
    INTERSECT<!-- Clause -->句
   </title>
<indexterm><primary sortas="INTERSECTく">INTERSECT句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>INTERSECT</secondary></indexterm>

<synopsis>
<replaceable class="PARAMETER">table_query</replaceable> INTERSECT [ ALL ] <replaceable class="PARAMETER">table_query</replaceable>
    [ ORDER BY <replaceable class="PARAMETER">expression</replaceable> [ ASC | DESC | USING <replaceable class="PARAMETER">operator</replaceable> ] [, ...] ]
    [ LIMIT { <replaceable class="PARAMETER">count</replaceable> | ALL } [ { OFFSET | , } <replaceable class="PARAMETER">start</replaceable> ]]
</synopsis>

<para>
    <!-- where
    <replaceable class="PARAMETER">table_query</replaceable>
    specifies any select expression without an ORDER BY, FOR UPDATE,
    or LIMIT clause. -->

    ここで、<replaceable class="PARAMETER">table_query</replaceable>は、ORDER BY、FOR UPDATE、LIMITなどの句を持たない任意のselect式を指定できます。

   </para>

   <para>
    <!-- INTERSECT is similar to UNION, except that it produces 
    only rows that appear in both query outputs, rather than rows 
    that appear in either. -->

    INTERSECTはUNIONと似ていますが、どちらかに現れる行ではなく両方の問い合わせ出力に現れる行のみを作るという点が違います。

   </para>
    
   <para>
    <!-- 
    The result of INTERSECT does not contain any duplicate rows
    unless the ALL option is specified.  With ALL, a row that has
    m duplicates in L and n duplicates in R will appear min(m,n) 
    times. -->

    INTERSECTの結果はALLオプションが指定されない限りどのような重複行も含みません。ALLでは、Lにm個の重複を持ち、Rにn個の重複を持つ行はmin(m,n)回現れます。

   </para>
    
   <para>
    <!-- 
    Multiple INTERSECT operators in the same SELECT statement are
    evaluated left to right, unless parentheses dictate otherwise.
    INTERSECT binds more tightly than UNION ___ that is,
    A UNION B INTERSECT C will be read as 
    A UNION (B INTERSECT C) unless otherwise specified by 
    parentheses. -->

    同じSELECT文の中の複数のINTERSECT演算子は、かっこで別の指定がない限り左から右に評価されます。INTERSECTはUNIONよりさらに固く結び付けます。つまりA UNION B INTERSECT Cはかっこで別の指定がない限りA UNION (B INTERSECT C)として読まれます。

   </para>
  </refsect2>

  <refsect2 id="SQL-EXCEPT">
   <refsect2info>
    <date>2000-12-11</date>
   </refsect2info>
   <title id="sql-except-title">
    EXCEPT<!-- Clause -->句
   </title>
<indexterm><primary sortas="EXCEPTく">EXCEPT句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>EXCEPT</secondary></indexterm>

<synopsis>
<replaceable class="PARAMETER">table_query</replaceable> EXCEPT [ ALL ] <replaceable class="PARAMETER">table_query</replaceable>
    [ ORDER BY <replaceable class="PARAMETER">expression</replaceable> [ ASC | DESC | USING <replaceable class="PARAMETER">operator</replaceable> ] [, ...] ]
    [ LIMIT { <replaceable class="PARAMETER">count</replaceable> | ALL } [ { OFFSET | , } <replaceable class="PARAMETER">start</replaceable> ]]
</synopsis>

<para>
    <!-- where
    <replaceable class="PARAMETER">table_query</replaceable>
    specifies any select expression without an ORDER BY, FOR UPDATE,
    or LIMIT clause. -->

    ここで、<replaceable class="PARAMETER">table_query</replaceable>は、ORDER BY、FOR UPDATE、LIMITなどの句を持たない任意のselect式を指定できます。
  
   </para>

   <para>
    <!-- 
    EXCEPT is similar to UNION, except that it produces only rows 
    that appear in the left query's output but not in the right 
    query's output. -->

    EXCEPTはUNIONと似ていますが、右問い合わせの出力ではなく左問い合わせの出力に現れる行を作るという点で違います。
    
   </para>
    
   <para>
    <!-- The result of EXCEPT does not contain any duplicate rows
    unless the ALL option is specified.  With ALL, a row that has
    m duplicates in L and n duplicates in R will appear max(m-n,0) 
    times. -->

    EXCEPTの結果はALLオプションが指定されない限りどのような複写行も含みません。ALLでは、Lにm個の重複を持ちRにn個の重複を持つ行はmax(m-n,0)回現れます。

   </para>
    
   <para>
    <!-- 
    Multiple EXCEPT operators in the same SELECT statement are
    evaluated left to right, unless parentheses dictate otherwise.
    EXCEPT binds at the same level as UNION. -->

    同じSELECT文の中の複数のEXCEPT演算項目は、かっこがそれ以外を指定しない限り左から右に評価されます。EXCEPTはUNIONと同じレベルで結び付けられます。

   </para>
  </refsect2>

  <refsect2 id="SQL-LIMIT">
   <refsect2info>
    <date>2000-02-20</date>
   </refsect2info>
   <title id="sql-limit-title">
    LIMIT<!-- Clause -->句
   </title>
<indexterm><primary sortas="LIMITく">LIMIT句</primary></indexterm><indexterm><primary>SELECT</primary><secondary>LIMIT</secondary></indexterm>

<synopsis>
    LIMIT { <replaceable class="PARAMETER">count</replaceable> | ALL } [ { OFFSET | , } <replaceable class="PARAMETER">start</replaceable> ]
    OFFSET <replaceable class="PARAMETER">start</replaceable>
</synopsis>

<para>
    
    <!-- where
    <replaceable class="PARAMETER">count</replaceable> specifies the
    maximum number of rows to return, and
    <replaceable class="PARAMETER">start</replaceable> specifies the
    number of rows to skip before starting to return rows. -->

    <replaceable class="PARAMETER">count</replaceable>は返される行の最大数を指定し、<replaceable class="PARAMETER">start</replaceable>は行を返し始める前に飛ばす行の数を指定します。

   </para>

   <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は、問い合わせが生成する行の一部のみを取りだすことを可能にします。もし制限数が与えられると、それ以上の行は返されません。もしオフセットが与えられると、返す行が始まる前にそれだけの行が飛ばされます。

   </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?  You don't know 
    what ordering, unless you specified ORDER BY. -->

    LIMITを使うときは、結果の行を一意な順番に強制するORDER BY句を使うのがよい考えです。そうしないと、問い合わせの行の予測不可能なサブセットを得ることになります。10行目から20行目までを出そうとしているかもしれませんが、どの順番の10行目から20行目までなのでしょうか。ORDER BYを指定しない限りどの順番だかわからないのです。

   </para>

   <para>
    <!-- 
    As of <productname>Postgres</productname> 7.0, 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. -->

    <productname>Postgres</productname> 7.0からは、問い合わせオプティマイザは問い合わせプランを作成するときにLIMITを考慮しますので、LIMITとOFFSETに何を与えるかによって（異なる行の順番を生む）異なったプランを得ることになるでしょう。したがって、問い合わせの、異なるサブセットを選択するために異なるLIMIT/OFFSETの値を使うと、ORDER BYで予測可能な結果を強制しない限り、<emphasis>矛盾した結果を返します</emphasis>。これはバグではありません。これはSQLがORDER BYで順番を制御しない限り問い合わせの結果を特定の順番で返すことを約束しないという事実の本質的な結果なのです。 

   </para>
  </refsect2>
 </refsect1>

 <refsect1 id="R1-SQL-SELECT-2">
  <title>
   <!-- Usage -->使用方法
  </title>

  <para>
   <!-- To join the table <literal>films</literal> with the table
   <literal>distributors</literal>: -->

   テーブル<literal>films</literal>をテーブル<literal>distributors</literal>で結合するには下記のようにします。
</para>

<programlisting>
SELECT f.title, f.did, d.name, f.date_prod, f.kind
    FROM distributors d, films f
    WHERE f.did = d.did

           title           | did |   name           | date_prod  | kind
---------------------------+-----+------------------+------------+----------
 The Third Man             | 101 | British Lion     | 1949-12-23 | Drama
 The African Queen         | 101 | British Lion     | 1951-08-11 | Romantic
 Une Femme est une Femme   | 102 | Jean Luc Godard  | 1961-03-12 | Romantic
 Vertigo                   | 103 | Paramount        | 1958-11-14 | Action
 Becket                    | 103 | Paramount        | 1964-02-03 | Drama
 48 Hrs                    | 103 | Paramount        | 1982-10-22 | Action
 War and Peace             | 104 | Mosfilm          | 1967-02-12 | Drama
 West Side Story           | 105 | United Artists   | 1961-01-03 | Musical
 Bananas                   | 105 | United Artists   | 1971-07-13 | Comedy
 Yojimbo                   | 106 | Toho             | 1961-06-16 | Drama
 There's a Girl in my Soup | 107 | Columbia         | 1970-06-11 | Comedy
 Taxi Driver               | 107 | Columbia         | 1975-05-15 | Action
 Absence of Malice         | 107 | Columbia         | 1981-11-15 | Action
 Storia di una donna       | 108 | Westward         | 1970-08-15 | Romantic
 The King and I            | 109 | 20th Century Fox | 1956-08-11 | Musical
 Das Boot                  | 110 | Bavaria Atelier  | 1981-11-11 | Drama
 Bed Knobs and Broomsticks | 111 | Walt Disney      |            | Musical
(17 rows)
</programlisting>

  <para>
   <!-- 
   To sum the column <literal>len</literal> of all films and group
   the results by <literal>kind</literal>: -->

   すべての映画の列<literal>len</literal>を合計し<literal>kind</literal>の結果をグループ化するには下記のようにします。
</para>

<programlisting>
SELECT kind, SUM(len) AS total FROM films GROUP BY kind;

   kind   | total
----------+-------
 Action   | 07:34
 Comedy   | 02:58
 Drama    | 14:28
 Musical  | 06:42
 Romantic | 04:38
(5 rows)
</programlisting>

  <para>
   <!-- 
   To sum the column <literal>len</literal> of all films, group
   the results by <literal>kind</literal> and show those group 
   totals that are less than 5 hours: -->

   すべての映画の列<literal>len</literal>を合計し<literal>kind</literal>の結果をグループ化し、合計が5時間より少ないグループの合計を表示します。
</para>

<programlisting>
SELECT kind, SUM(len) AS total
    FROM films
    GROUP BY kind
    HAVING SUM(len) < INTERVAL '5 hour';

 kind     | total
----------+-------
 Comedy   | 02:58
 Romantic | 04:38
(2 rows)
</programlisting>

  <para>
   <!-- 
   The following two examples are identical ways of sorting the 
   individual results according to the contents of the second column
   (<literal>name</literal>): -->

   以下の2つの例は個別の結果を2番目の列（<literal>name</literal>）の内容に基づいてソートする、同じ方法です。
</para>

<programlisting>
SELECT * FROM distributors ORDER BY name;
SELECT * FROM distributors ORDER BY 2;

 did |       name
-----+------------------
 109 | 20th Century Fox
 110 | Bavaria Atelier
 101 | British Lion
 107 | Columbia
 102 | Jean Luc Godard
 113 | Luso films
 104 | Mosfilm
 103 | Paramount
 106 | Toho
 105 | United Artists
 111 | Walt Disney
 112 | Warner Bros.
 108 | Westward
(13 rows)
</programlisting>

  <para>
   <!-- 
   This example shows how to obtain the union of the tables
   <literal>distributors</literal> and
   <literal>actors</literal>, restricting the results to those that begin
   with letter W in each table.  Only distinct rows are wanted, so the
   ALL keyword is omitted: -->

   この例は、結果をそれぞれのテーブルで「W」で始まるものだけに制限して、どのようにテーブル<literal>distributors</literal>と<literal>actors</literal>の結合を獲得するかを表しています。特定の行のみが必要なので、ALLキーワードは省略されています。
</para>
 
<programlisting>
distributors:               actors:
 did |     name              id |     name
-----+--------------        ----+----------------
 108 | Westward               1 | Woody Allen
 111 | Walt Disney            2 | Warren Beatty
 112 | Warner Bros.           3 | Walter Matthau
 ...                         ...

SELECT distributors.name
    FROM   distributors
    WHERE  distributors.name LIKE 'W%'
UNION
SELECT actors.name
    FROM   actors
    WHERE  actors.name LIKE 'W%';

      name
----------------
 Walt Disney
 Walter Matthau
 Warner Bros.
 Warren Beatty
 Westward
 Woody Allen
</programlisting>
 </refsect1>
 
 <refsect1 id="R1-SQL-SELECT-3">
  <title>
   <!-- Compatibility -->互換性
  </title>
  
  <refsect2 id="R2-SQL-SELECT-4">
   <refsect2info>
    <date>1998-09-24</date>
   </refsect2info>
   <title>
    <acronym><!-- Extensions -->拡張</acronym>
   </title>

   <para>
<!--   
<productname>Postgres</productname> allows one to omit 
the <command>FROM</command> clause from a query. This feature
was retained from the original PostQuel query language.  It has
a straightforward use to compute the results of simple constant
expressions: -->

<productname>Postgres</productname>では問い合わせで<command>FROM</command>句を省略できます。これは元のPostQuel問い合わせ言語の機能が保存されていることによるものです。このようにして単純な数式の計算を簡単に行うことができます。
</para>

<programlisting>
SELECT 2+2;

 ?column?
----------
        4
</programlisting>

<para>
<!-- 
Some other DBMSes cannot do this except by introducing a dummy one-row
table to do the select from.  A less obvious use is to abbreviate a
normal select from one or more tables: -->

他のDBMSは、select fromを行うためのダミーの1行テーブルを使う以外はこれを行うことができないものがあります。これほど明確ではない使用法としては1つ以上のテーブルからselectすることを次のように省略して書くことができます。
</para>

<programlisting>
SELECT distributors.* WHERE distributors.name = 'Westward';

 did | name
-----+----------
 108 | Westward
</programlisting>

<para>
<!-- 
This works because an implicit FROM item is added for each table 
that is referenced in the query but not mentioned in FROM.  
While this is a convenient shorthand, it's easy to misuse.  
For example, the query -->

これは暗黙のFROMアイテムが、問い合わせで参照されるけれどもFROMでは記述されないそれぞれのテーブルに追加されるので、動作します。これは便利な省略形ですが、間違って使いやすいものです。たとえば、下記の問い合わせはおそらく間違いです。
</para>

<programlisting>
SELECT distributors.* FROM distributors d;
</programlisting>

<para>
<!-- is probably a mistake; most likely the user meant -->
ユーザーが意図していたのは以下のようなものでしょう。
</para>

<programlisting>
SELECT d.* FROM distributors d;
</programlisting>

<para>
<!-- rather than the unconstrained join -->
しかし、実際に得られるのは下記のような制約のない結合です。
</para>

<programlisting>
SELECT distributors.* FROM distributors d, distributors distributors;
</programlisting>

<para>
<!-- that he will actually get.  To help detect this sort of mistake,
<Productname>Postgres</Productname> 7.1
and later will warn if the implicit-FROM feature is used in a query 
that also contains an explicit FROM clause.
-->

このような間違いの発見を助けるために<Productname>Postgres</Productname> 7.1とそれ以降では、もし暗黙のFROM機能が明示的なFROM句も持つ問い合わせで使われる場合警告を出します。

   </para>
  </refsect2>

  <refsect2 id="R2-SQL-SELECT-5">
   <refsect2info>
    <date>1998-09-24</date>
   </refsect2info>
   <title>
    <acronym>SQL92</acronym>
   </title>
   <para>
   </para>
   
   <refsect3 id="R3-SQL-SELECT-1">
    <refsect3info>
     <date>1998-04-15</date>
    </refsect3info>
    <title>
     SELECT <!-- Clause -->句
    </title>
    <para>
     <!-- 
     In the <acronym>SQL92</acronym> standard, the optional keyword "AS"
     is just noise and can be omitted without affecting the meaning.
     The <productname>Postgres</productname> parser requires this 
     keyword when renaming output columns because the type 
     extensibility features lead to parsing ambiguities
     in this context.  "AS" is optional in FROM items, however.
     -->

     <acronym>SQL92</acronym>標準では、オプションのキーワード「AS」はただのノイズなので、意味に影響することなく省略することが可能です。<productname>Postgres</productname>パーサーは出力列の名前を変更する際にこのキーワードを要求します。なぜなら型の拡張機能を考えるとこのコンテキストでは構文解析の不明瞭さにつながるからです。しかし、FROMアイテムでは「AS」はオプションです。

    </para>
     
    <para>
     <!-- 
     The DISTINCT ON phrase is not part of <acronym>SQL92</acronym>.
     Nor are LIMIT and OFFSET. -->

     DISTINCT ON文は<acronym>SQL92</acronym>の一部ではありません。LIMITもOFFSETもそうです。 

    </para>
     
    <para>
     <!-- 
     In <acronym>SQL92</acronym>, an ORDER BY clause may only use 
     result column names or numbers, while a GROUP BY clause may 
     only use input column names.
     <productname>Postgres</productname> extends each of these 
     clauses to allow the other choice as well (but it uses the 
     standard's interpretation if there is ambiguity).
     <productname>Postgres</productname> also allows both clauses 
     to specify arbitrary expressions.  Note that names appearing 
     in an expression will
     always be taken as input-column names, not as result-column names.
     -->

     <acronym>SQL92</acronym>ではORDER BY句は結果の列名か順番の数のみを使うことができ、GROUP BY句は入力列名のみを使うことができます。<productname>Postgres</productname>はこれらの句がそれぞれ他の選択も認めるように拡張します（しかしもし不明瞭さがある場合は標準の解釈を使います）。<productname>Postgres</productname>はどちらの句も任意の式を指定するよう認めています。式で使われる名前は常に結果の列名ではなく入力列名としてみなれることに注意してください。

    </para>
   </refsect3>

   <refsect3 id="R3-SQL-UNION-1">
    <refsect3info>
     <date>1998-09-24</date>
    </refsect3info>
    <title>
     UNION/INTERSECT/EXCEPT <!-- Clause -->句
    </title>
    <para>
     <!-- 
     The <acronym>SQL92</acronym> syntax for UNION/INTERSECT/EXCEPT 
     allows an additional CORRESPONDING BY option: -->

     <acronym>SQL92</acronym>のUNION/INTERSECT/EXCEPTの構文ではCORRESPONDING BYオプションを追加することができます。
</para>

<synopsis> 
<replaceable class="PARAMETER">table_query</replaceable> UNION [ALL]
    [CORRESPONDING [BY (<replaceable class="PARAMETER">column</replaceable> [,...])]]
    <replaceable class="PARAMETER">table_query</replaceable>
</synopsis>

    <para>
     <!-- The CORRESPONDING BY clause is not supported by
     <productname>Postgres</productname>. -->

     CORRESPONDING BY句は<productname>Postgres</productname>ではサポートされていません。

    </para>
   </refsect3>
   
  </refsect2>
 </refsect1>
</refentry>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:nil
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
sgml-parent-document:nil
sgml-default-dtd-file:"../reference.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:"/usr/lib/sgml/catalog"
sgml-local-ecat-files:nil
End:
-->
