<!--
$Header: /usr/prj/pg/cvsroot/doc/doc/src/sgml/syntax.sgml,v 1.9 2001/08/18 05:27:53 sugita Exp $
-->

<chapter id="sql-syntax">
 <!-- <title>SQL Syntax</title> -->
 <title>SQLの構文</title>
<indexterm><primary>SQL</primary><secondary sortas="こうぶん">構文</secondary></indexterm>
  <abstract>
   <para>
    <!-- A description of the general syntax of SQL. -->
    一般的なSQLの構文についての説明。

   </para>
  </abstract>

 <sect1 id="sql-syntax-lexical">
  <!-- <title>Lexical Structure</title> -->
  <title>語彙の構造</title>
<indexterm><primary>SQL</primary><secondary sortas="ごいのこうぞう">語彙の構造</secondary></indexterm>
  <para>
   <!-- SQL input consists of a sequence of
   <firstterm>commands</firstterm>.  A command is composed of a
   sequence of <firstterm>tokens</firstterm>, terminated by a
   semicolon (<quote>;</quote>).  The end of the input stream also
   terminates a command.  Which tokens are valid depends on the syntax
   of the particular command. 
   -->

   SQL入力は、一連の<firstterm>コマンド</firstterm>で構成されます。コマンドは一連の<firstterm>トークン</firstterm>で構成され、最後はセミコロン（<quote>;</quote>）で終わります。入力ストリームの終了もやはりコマンドを終わらせます。どのトークンが有効かは特定のコマンドの構文によります。
  </para>

  <para>
   <!-- A token can be a <firstterm>key word</firstterm>, an
   <firstterm>identifier</firstterm>, a <firstterm>quoted
   identifier</firstterm>, a <firstterm>literal</firstterm> (or
   constant), or a special character symbol.  Tokens are normally
   separated by whitespace (space, tab, newline), but need not be if
   there is no ambiguity (which is generally only the case if a
   special character is adjacent to some other token type).
   -->

   トークンは<firstterm>キーワード</firstterm>、<firstterm>識別子</firstterm>、<firstterm>引用符で囲まれた識別子</firstterm>、<firstterm>リテラル</firstterm>（もしくは定数）、特別な文字シンボルであることが可能です。トークンは通常空白（スペース、タブ、改行）で区切られますが、あいまいさがなければ（一般的には特別な文字が他のトークン型と隣接している場合のみ）必要ありません。
  </para>

  <para>
   <!-- Additionally, <firstterm>comments</firstterm> can occur in SQL
   input.  They are not tokens, they are effectively equivalent to
   whitespace.
   -->

   さらに、入力されたSQLに<firstterm>コメント</firstterm>が含まれていても構いません。それらはトークンではありませんが、効果は空白と同じです。
  </para>

  <informalexample id="sql-syntax-ex-commands">
   <para>
    <!-- For example, the following is (syntactically) valid SQL input:
    -->

    たとえば、以下のものは（構文的に）有効なSQL入力です。</para>

<programlisting>
SELECT * FROM MY_TABLE;
UPDATE MY_TABLE SET A = 5;
INSERT INTO MY_TABLE VALUES (3, 'hi there');
</programlisting>
    <!-- 
    This is a sequence of three commands, one per line (although this
    is not required; more than one command can be on a line, and
    commands can usefully be split across lines).
    -->

<para>これは3つのコマンドが順番に並んでいて、1行に1つのコマンドが記述されています（必ずしも1つのコマンドを1行で書く必要はありません。1行に複数のコマンドを入力することも可能ですし、1つのコマンドを複数行に分けて記述することも可能です）。
   </para>
  </informalexample>

  <para>
   <!-- The SQL syntax is not very consistent regarding what tokens
   identify commands and which are operands or parameters.  The first
   few tokens are generally the command name, so in the above example
   we would usually speak of a <quote>SELECT</quote>, an
   <quote>UPDATE</quote>, and an <quote>INSERT</quote> command.  But
   for instance the <command>UPDATE</command> command always requires
   a <token>SET</token> token to appear in a certain position, and
   this particular variation of <command>INSERT</command> also
   requires a <token>VALUES</token> in order to be complete.  The
   precise syntax rules for each command are described in the
   <citetitle>Reference Manual</citetitle>.
   -->

   SQL構文は、どのトークンがコマンドを識別し、どれがオペランドでどれがパラメータか、という意味ではあまり一貫していません。最初のいくつかのトークンは一般的にはコマンド名なので、上記の例では<quote>SELECT</quote>、<quote>UPDATE</quote>、<quote>INSERT</quote>のコマンドにあたります。しかしたとえば<command>UPDATE</command>コマンドは、<token>SET</token>トークンがいつも特定の位置で使われることを要求しますし、この例で使われている<command>INSERT</command>コマンドは、完結するためには<token>VALUES</token>トークンを要求します。それぞれのコマンドの正確な構文のルールは<citetitle>&reference-guide;</citetitle>で説明されています。 
  </para>

  <sect2 id="sql-syntax-identifiers">
   <!-- <title>Identifiers and Key Words</title> -->
   <title>識別子とキーワード</title>
<indexterm><primary>SQL</primary><secondary sortas="しきべつし">識別子</secondary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="きーわーど">キーワード</secondary></indexterm>
   <para>
    <!-- Tokens such as <token>SELECT</token>, <token>UPDATE</token>, or
    <token>VALUES</token> in the example above are examples of
    <firstterm>key words</firstterm>, that is, words that have a fixed
    meaning in the SQL language.  The tokens <token>MY_TABLE</token>
    and <token>A</token> are examples of
    <firstterm>identifiers</firstterm>.  They identify names of
    tables, columns, or other database objects, depending on the
    command they are used in.  Therefore they are sometimes simply
    called <quote>names</quote>.  Key words and identifiers have the
    same lexical structure, meaning that one cannot know whether a
    token is an identifier or a key word without knowing the language.
    A complete list of key words can be found in <xref
    linkend="sql-keywords-appendix">. -->

    上記の例に出てくる<token>SELECT</token>、<token>UPDATE</token>、もしくは<token>VALUES</token>のようなトークンは<firstterm>キーワード</firstterm>の一例です。キーワードとは、SQL言語で固定された意味を持つ単語です。<token>MY_TABLE</token>トークンや<token>A</token>トークンは<firstterm>識別子</firstterm>の一例です。これらは、使われるコマンドによって、テーブル、カラム、他のデータベースオブジェクトの名前を識別します。したがって、これらは<quote>名前</quote>とだけ呼ばれることもあります。キーワードと識別子は同じ語彙の構造を持つため、言語を知らなくてはトークンが識別子なのかキーワードなのかわからないということになります。キーワードの完全なリストは<xref linkend="sql-keywords-appendix">で見ることができます。
   </para>

   <para>
    <!-- SQL identifiers and key words must begin with a letter
    (<literal>a</literal>-<literal>z</literal>) or underscore
    (<literal>_</literal>).  Subsequent characters in an identifier or
    key word can be letters, digits
    (<literal>0</literal>-<literal>9</literal>), or underscores,
    although the SQL standard will not define a key word that contains
    digits or starts or ends with an underscore.
    -->

    SQL識別子とキーワードは、アルファベット（「<literal>a</literal>」〜「<literal>z</literal>」）かアンダースコア（「<literal>_</literal>」）で始まらなければいけません。識別子またはキーワードの中で続く文字は、アルファベット、数字（<literal>0</literal>〜<literal>9</literal>）、アンダースコアが使えますが、SQL標準では数字を持つ、あるいはアンダースコアで始まるか終わるキーワードは定義されません。
   </para>

   <para>
    <!-- The system uses no more than <symbol>NAMEDATALEN</symbol>-1
    characters of an identifier; longer names can be written in
    commands, but they will be truncated.  By default,
    <symbol>NAMEDATALEN</symbol> is 32 so the maximum identifier length
    is 31 (but at the time the system is built,
    <symbol>NAMEDATALEN</symbol> can be changed in
    <filename>src/include/postgres_ext.h</filename>).
    -->

    システムは<symbol>NAMEDATALEN</symbol>-1以上の識別子の文字は使いません。さらに長い名前はコマンドで書くことはできますが、短く切られてしまいます。デフォルトでは<symbol>NAMEDATALEN</symbol>は32なので、識別子の最長は31です（システムの構築時には<symbol>NAMEDATALEN</symbol>という名前は<filename>src/include/postgres_ext.h</filename>で変えることができます）。
   </para>

   <para>
    <!-- Identifier and key word names are case insensitive.  Therefore
    -->
    識別子とキーワード名は大文字と小文字を区別しません。したがって、以下の2つの文は同じ意味になります。<indexterm><primary>SQL</primary><secondary sortas="おおもじこもじのくべつ">大文字/小文字の区別</secondary></indexterm></para>

<programlisting>
UPDATE MY_TABLE SET A = 5;
</programlisting>
    <!-- can equivalently be written as -->
<programlisting>
uPDaTE my_TabLE SeT a = 5;
</programlisting>
    <!-- A convention often used is to write key words in upper
    case and names in lower case, e.g., -->

<para>慣習的には、キーワードを大文字で、名前を小文字で書きます。たとえば下記のようになります。</para>

<programlisting>
UPDATE my_table SET a = 5;
</programlisting>

   <para>
    <!-- 
    There is a second kind of identifier:  the <firstterm>delimited
    identifier</firstterm> or <firstterm>quoted
    identifier</firstterm>.  It is formed by enclosing an arbitrary
    sequence of characters in double-quotes
    (<literal>"</literal>).--> <!-- " font-lock mania --> <!-- A delimited
    identifier is always an identifier, never a key word.  So
    <literal>"select"</literal> could be used to refer to a column or
    table named <quote>select</quote>, whereas an unquoted
    <literal>select</literal> would be taken as a key word and
    would therefore provoke a parse error when used where a table or
    column name is expected.  The example can be written with quoted
    identifiers like this:
    -->

    二種類目の識別子もあります。<firstterm>区切り識別子</firstterm><indexterm><primary sortas="くぎりしきべつし">区切り識別子</primary></indexterm>あるいは<firstterm>引用符付き識別子</firstterm><indexterm><primary sortas="いんようふつきしきべつし">引用符付き識別子</primary></indexterm>です。これは文字の特定の並びを二重引用符（「<literal>"</literal>」）<!-- " font-lock mania -->で囲むことによって作られます。区切り識別子は常に識別子であり、キーワードではありません。ですから「<literal>"select"</literal>」は<quote>select</quote>という名前のカラムあるいはテーブルを問い合わせるために使えますが、引用符のつかない「<literal>select</literal>」はキーワードとして理解され、したがってテーブルもしくはカラム名が期待される部分ではパースエラーを起こします。引用符付き識別子は下記の例のように書くことができます。</para>

<programlisting>
UPDATE "my_table" SET "a" = 5;
</programlisting>

   <para>
    <!--
    Quoted identifiers can contain any character other than a double
    quote itself.  This allows constructing table or column names that
    would otherwise not be possible, such as ones containing spaces or
    ampersands.  The length limitation still applies.
    -->
    
    引用符付き識別子は、二重引用符以外ならどのような文字も含むことができます。これにより、そうでなければ不可能な、スペースやアンパサンドを含むようなテーブルもしくはカラム名を作ることが可能になります（この場合も長さの制限は適用されます）。
   </para>

   <para>
    <!-- Quoting an identifier also makes it case-sensitive, whereas
    unquoted names are always folded to lower case.  For example, the
    identifiers <literal>FOO</literal>, <literal>foo</literal> and
    <literal>"foo"</literal> are considered the same by
    <productname>Postgres</productname>, but <literal>"Foo"</literal>
    and <literal>"FOO"</literal> are different from these three and
    each other.
    -->

    引用符がつかない名前は常に小文字に解釈されますが、識別子を引用符で囲むことによって大文字/小文字が区別されるようになります。たとえば、識別子「<literal>FOO</literal>」、「<literal>foo</literal>」、「<literal>"foo"</literal>」は<productname>Postgres</productname>には同じものとして解釈されますが、「<literal>"Foo"</literal>」と「<literal>"FOO"</literal>」は、上記の3つともお互いとも違ったものとして解釈されます。
    <footnote>
     <para>
     <!--  
     <productname>Postgres</productname>' folding of unquoted names to lower
      case is incompatible with the SQL standard, which says that unquoted
      names should be folded to upper case.  Thus, <literal>foo</literal>
      should be equivalent to <literal>"FOO"</literal> not
      <literal>"foo"</literal> according to the standard.  If you want to
      write portable applications you are advised to always quote a particular
      name or never quote it. -->

<productname>Postgres</productname>が引用符の付かない名前を小文字として解釈することはSQL標準とは相容れないもので、SQL標準では引用符の付かない名前は大文字に解釈されるべきだとされています。したがってSQL標準によれば、「<literal>foo</literal>」は「<literal>"FOO"</literal>」と同じであるべきで、「<literal>"foo"</literal>」ではないはずなのです。もし移植可能なアプリケーションを書きたいならば特定の名前は常に引用符で囲む、あるいは常に囲まない、ということをお勧めします。
     </para>
    </footnote>
   </para>
  </sect2>


  <sect2 id="sql-syntax-constants">
   <!-- <title>Constants</title> -->
   <title>定数</title>
<indexterm><primary sortas="ていすう">定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="ていすう">定数</secondary></indexterm>
   <para>
    <!-- There are four kinds of <firstterm>implicitly typed
    constants</firstterm> in <productname>Postgres</productname>:
    strings, bit strings, integers, and floating point numbers.
    Constants can also be specified with explicit types, which can
    enable more accurate representation and more efficient handling by
    the system. The implicit constants are described below; explicit
    constants are discussed afterwards.
    -->

    <productname>Postgres</productname>には、4つの<firstterm>暗黙に型付けされる定数</firstterm>があります。文字列、ビット文字列、整数、浮動小数点です。定数は明示的な型で指定されることもでき、その場合システムによるより正確な表現と効率のよい操作が可能になります。暗黙の定数については下記で説明します。明示的な定数は後ほど説明します。
   </para>

   <sect3 id="sql-syntax-strings">
    <!-- <title>String Constants</title> -->
    <title>文字列定数</title>
<indexterm><primary sortas="もじれつていすう">文字列定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="もじれつていすう">文字列定数</secondary></indexterm>
    <para>
     <!-- 
     A string constant in SQL is an arbitrary sequence of characters
     bounded by single quotes (<quote>'</quote>), e.g., <literal>'This
     is a string'</literal>.  SQL allows single quotes to be embedded
     in strings by typing two adjacent single quotes (e.g.,
     <literal>'Dianne''s horse'</literal>).  In
     <productname>Postgres</productname> single quotes may
     alternatively be escaped with a backslash (<quote>&bsol;</quote>,
     e.g., <literal>'Dianne&bsol;'s horse'</literal>).
     -->

     SQLの文字列定数は任意の文字の並びを一重引用符（「'」）で囲ったもので、「<literal>'This is a string'</literal>」のようになります。SQLでは2つ連続した一重引用符を入力することにより、一重引用符を文字列の中に埋め込むことができます（例：<literal>'Dianne''s horse'</literal>）。<productname>Postgres</productname>では、一重引用符の代わりにバックスラッシュ（<quote>&bsol;</quote>）を使うこともできます。（例：<literal>'Dianne&bsol;'s horse'</literal>）
    </para>

    <para>
     <!-- C-style backslash escapes are also available:
     <literal>&bsol;b</literal> is a backspace, <literal>&bsol;f</literal> is a
     form feed, <literal>&bsol;n</literal> is a newline,
     <literal>&bsol;r</literal> is a carriage return, <literal>&bsol;t</literal>
     is a tab, and <literal>&bsol;<replaceable>xxx</replaceable></literal>,
     where <replaceable>xxx</replaceable> is an octal number, is the
     character with the corresponding ASCII code.  Any other character
     following a backslash is taken literally.  Thus, to include a
     backslash in a string constant, type two backslashes.
     -->

     C言語形式のバックスラッシュコマンドも有効です。「<literal>&bsol;b</literal>」はバックスペース、「<literal>&bsol;f</literal>」は改頁、「<literal>&bsol;n</literal>」は改行、「<literal>&bsol;r</literal>」はキャリッジリターン、「<literal>&bsol;t</literal>」はタブ、<replaceable>xxx</replaceable>が八進数である場合、「<literal>&bsol;<replaceable>xxx</replaceable></literal>」は対応するASCIIコードを意味します。ここに示した以外のバックスラッシュに続く文字は、遂字的に解釈されます。したがって、文字列定数にバックスラッシュを含む場合は、バックスラッシュを2つ入力してください。
    </para>

    <para>
     <!-- The character with the code zero cannot be in a string constant.
     -->

     文字コード0の文字は文字列定数の中には含められません。

    </para>

    <para>
     <!-- Two string constants that are only separated by whitespace
     <emphasis>with at least one newline</emphasis> are concatenated
     and effectively treated as if the string had been written in one
     constant.  For example:
     -->

     2つの文字列定数が、<emphasis>少なくとも1つの改行</emphasis>を含んだ空白で区切られているとします。それらは、連結され、1つの定数であるような振る舞いをします。たとえば、以下の2つの表現は同じものとして扱われます。</para>

<programlisting>
SELECT 'foo'
'bar';
</programlisting>
     <!-- is equivalent to -->

<programlisting>
SELECT 'foobar';
</programlisting>

<para>ただし、以下の表現は有効な構文ではありません。</para>

     <!-- but -->
<programlisting>
SELECT 'foo'      'bar';
</programlisting>
     <!-- is not valid syntax. -->

   </sect3>

   <sect3 id="sql-syntax-bit-strings">
    <!-- <title>Bit String Constants</title> -->
    <title>ビット文字列定数</title>
<indexterm><primary sortas="びっともじれつていすう">ビット文字列定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="びっともじれつていすう">ビット文字列定数</secondary></indexterm>
    <para>
     <!-- Bit string constants look like string constants with a
     <literal>B</literal> (upper or lower case) immediately before the
     opening quote (no intervening whitespace), e.g.,
     <literal>B'1001'</literal>.  The only characters allowed within
     bit string constants are <literal>0</literal> and
     <literal>1</literal>.  Bit string constants can be continued
     across lines in the same way as regular string constants.
     -->

    ビット文字列定数は「<literal>B</literal>」（大文字もしくは小文字）が引用符の始まりの前についている（間に空白はありません）文字列定数のように見えます。たとえば「<literal>B'1001'</literal>」のようになります。ビット文字列定数の中で許可される文字は「<literal>0</literal>」と「<literal>1</literal>」のみです。ビット文字列定数は、標準の文字列定数と同じように行を越えて続けることが可能です。

    </para>
   </sect3>

   <sect3>
    <!-- <title>Integer Constants</title> -->
    <title>整数定数</title>
<indexterm><primary sortas="せいすうていすう">整数定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="せいすうていすう">整数定数</secondary></indexterm>
    <para>
     <!-- 
     Integer constants in SQL are sequences of decimal digits (0
     though 9) with no decimal point.  The range of legal values
     depends on which integer data type is used, but the plain
     <type>integer</type> type accepts values ranging from -2147483648
     to +2147483647.  (The optional plus or minus sign is actually a
     separate unary operator and not part of the integer constant.)
     -->

    SQLの整数定数は、十進数（0〜9）の連続で、小数点が付かないものです。正当な値の範囲はどの整数データ型が使われているかによりますが、単なる<type>integer</type>型は-2,147,483,648から+2,147,483,647までの範囲を受け付けます（プラス記号やマイナス記号は実際はオプションの別の単項演算子で、整数定数の一部ではありません）。
    </para>
   </sect3>

   <sect3>
    <!-- <title>Floating Point Constants</title> -->
    <title>浮動小数点定数</title>
<indexterm><primary sortas="ふどうしょうすうてんていすう">浮動小数点定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="ふどうしょうすうてんていすう">浮動小数点定数</secondary></indexterm>
    <para>
     <!-- Floating point constants are accepted in these general forms:
     -->
     浮動小数点定数は下記の一般的な形で認められます。</para>

<synopsis>
 
<replaceable>digits</replaceable>.<optional><replaceable>digits</replaceable>
</optional><optional>e<optional>+-</optional><replaceable>digits</replaceable>
</optional>
<optional><replaceable>digits</replaceable></optional>.<replaceable>digits</replaceable><optional>e<optional>+-</optional><replaceable>digits</replaceable></optional><replaceable>digits</replaceable>e<optional>+-</optional><replaceable>digits</replaceable>

</synopsis>
     <!-- where <replaceable>digits</replaceable> is one or more decimal
     digits.  At least one digit must be before or after the decimal
     point, and after the <literal>e</literal> if you use that option.
     Thus, a floating point constant is distinguished from an integer
     constant by the presence of either the decimal point or the
     exponent clause (or both).  There must not be a space or other
     characters embedded in the constant.
     -->
<para><replaceable>digits</replaceable>とあるのは1つ以上の十進数字です。少なくとも1つの数字が小数点の前か後になくてはならず、<literal>e</literal>の付く形式を使う場合には<literal>e</literal>の後にも少なくとも1つの数字がなければいけません。したがって、浮動小数点定数は、小数点もしくは指数句（もしくは両方）の存在により整数定数から区別されます。スペースや他の文字は定数の中に埋めこむことはできません。
    </para>

    <informalexample>
     <para>
      <!-- These are some examples of valid floating point constants:
      -->

      下記は有効な浮動小数点定数のいくつかの例です。

<literallayout>
3.5
4.
.001
5e2
1.925e-3
</literallayout>
     </para>
    </informalexample>

    <para>
     <!-- Floating point constants are of type <type>DOUBLE
     PRECISION</type>. <type>REAL</type> can be specified explicitly
     by using <acronym>SQL</acronym> string notation or
     <productname>Postgres</productname> type notation:
     -->

     浮動小数点定数は<type>DOUBLE PRECISION</type>型です。<type>REAL</type>は<acronym>SQL</acronym>文字列表記か<productname>Postgres</productname>型表記を使って明示的に指定できます。</para>

<programlisting>
REAL '1.23'  -- 文字列表記
'1.23'::REAL -- Postgres型表記
</programlisting>
   </sect3>

   <sect3 id="sql-syntax-constants-generic">
    <!-- <title>Constants of Other Types</title> -->
    <title>他の型の定数</title>
<indexterm><primary sortas="にんいのかたのていすう">任意の型の定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="にんいのかたのていすう">任意の型の定数</secondary></indexterm>
    <para>
     <!-- A constant of an <emphasis>arbitrary</emphasis> type can be
     entered using any one of the following notations:
     -->

     <emphasis>任意の</emphasis>型の定数は下記の表記のいずれかを使って入力することが可能です。</para>

<synopsis>
 <replaceable>type</replaceable> '<replaceable>string</replaceable>'
'<replaceable>string</replaceable>'::<replaceable>type</replaceable>
CAST ( '<replaceable>string</replaceable>' AS <replaceable>type</replaceable> )

</synopsis>
     <!-- The value inside the string is passed to the input conversion
     routine for the type called <replaceable>type</replaceable>. The
     result is a constant of the indicated type.  The explicit type
     cast may be omitted if there is no ambiguity as to the type the
     constant must be (for example, when it is passed as an argument
     to a non-overloaded function), in which case it is automatically
     coerced.
     -->

<para>文字列の中の値は<replaceable>type</replaceable>と呼ばれる型の入力変換ルーチンへと渡されます。結果は指示された型の定数です。明示的な型キャストは、もし定数がどの型でなければならないかについて曖昧な点がなければ（たとえば引数がオーバーロードされていない関数に渡される場合）省略されても構いません。その場合自動的に型強制されます。
    </para>

    <para>
     <!-- 
     It is also possible to specify a type coercion using a function-like
     syntax:
     -->

     関数のような構文を使って型強制を指定することも可能です。</para>

<synopsis>
 <replaceable>typename</replaceable> ( <replaceable>value</replaceable> )
</synopsis>
     <!-- 
     although this only works for types whose names are also valid as
     function names.  (For example, <literal>double precision</literal>
     can't be used this way ___ but the equivalent <literal>float8</literal>
     can.)
     -->

<para>しかしこれは、名前が関数名としても有効な型にのみ使うことができます（たとえば、<literal>double precision</literal>はこのように使うことができません。しかし同じ意味の<literal>float8</literal>はできます）。
    </para>

    <para>
     <!-- The <literal>::</literal>, <literal>CAST()</literal>, and
     function-call syntaxes can also be used to specify the type of
     arbitrary expressions, but the form
     <replaceable>type</replaceable>
     '<replaceable>string</replaceable>' can only be used to specify
     the type of a literal constant.
     -->

    <literal>::</literal>、<literal>CAST()</literal>、関数呼び出し構文もや、はり任意の式の型を指定するために使うことができますが、<replaceable>type</replaceable>'<replaceable>string</replaceable>'という形式はリテラル定数を指定する場合にのみ使うことができます。
    </para>
   </sect3>

   <sect3>
    <!-- <title>Array constants</title> -->
    <title>配列定数</title>
<indexterm><primary sortas="はいれつていすう">配列定数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="はいれつていすう">配列定数</secondary></indexterm>
    <para>
     <!-- The general format of an array constant is the following: -->

     一般的な配列定数のフォーマットは以下のとおりです。</para>

<synopsis>
'{ <replaceable>val1</replaceable> <replaceable>delim</replaceable> <replaceable>val2</replaceable> <replaceable>delim</replaceable> ... }'
</synopsis>
     <!-- where <replaceable>delim</replaceable> is the delimiter character
     for the type, as recorded in its <literal>pg_type</literal>
     entry.  (For all built-in types, this is the comma character
     ",".)  Each <replaceable>val</replaceable> is either a constant
     of the array element type, or a sub-array.  An example of an
     array constant is -->

<para><replaceable>delim</replaceable>は型の区切り文字で、<literal>pg_type</literal>の項目に書かれているものです（すべての組み込み型にとって、これはカンマ「,」です）。それぞれの<replaceable>val</replaceable>は配列要素の型の定数か部分配列です。配列定数の例は以下のようになります。</para>

<programlisting>
'{{1,2,3},{4,5,6},{7,8,9}}'
</programlisting>
     <!-- 
     This constant is a two-dimensional, 3 by 3 array consisting of three
     sub-arrays of integers.
     -->

<para>この定数は二次元で、整数の3つの部分配列によって成り立つ3×3の配列です。
    </para>

    <para>
     <!-- 
     Individual array elements can be placed between double-quote
     marks (<literal>"</literal>)--> <!-- " --><!-- to avoid ambiguity
     problems with respect to white space.  Without quote marks, the
     array-value parser will skip leading white space.
     -->

    個々の配列要素は、空白の曖昧さの問題を回避するため、二重引用符（「<literal>"</literal>」）<!-- " -->の間に置くことができます。引用符なしでは、配列値のパーサーは最初の空白をとばしてしまいます。
    </para>

    <para>
     <!-- 
     (Array constants are actually only a special case of the generic
     type constants discussed in the previous section.  The constant
     is initially treated as a string and passed to the array input
     conversion routine.  An explicit type specification might be
     necessary.)
     -->

     <!--（-->配列定数は実際は、前節で説明された一般的な型の定数の特別な事例
     でしかありません。配列定数は始めは文字列として扱われ、配列
     入力変換ルーチンに渡されます。明示的な型の指定が必要な場合が
     あるかもしれません。<!--）-->

    </para>
   </sect3>
  </sect2>


  <sect2 id="sql-syntax-operators">
   <!-- <title>Operators</title> -->
   <title>演算子</title>
<indexterm><primary sortas="えんざんし">演算子</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="えんざんし">演算子</secondary></indexterm>
   <para>
     <!-- 
     An operator is a sequence of up to <symbol>NAMEDATALEN</symbol>-1
    (31 by default) characters from the following list:
     -->

     演算子は<symbol>NAMEDATALEN</symbol>-1までの（デフォルトは31です）長さの、以下に示すリストに含まれる文字の並びです。

<literallayout>
+ - * / &lt; &gt; = ~ ! @ # % ^ &amp; | ` ? $
</literallayout>

    <!-- There are a few restrictions on operator names, however:
    -->

    しかし、演算子の名前にはいくつかの制約があります。</para>

    <itemizedlist>
     <listitem>
      <para>
       <!-- 
       "$" (dollar) cannot be a single-character operator, although it
       can be part of a multi-character operator name.
       -->

      「$」（ドル記号）は、複数文字の演算子名になることはできますが、単一文字の演算子にはなることができません。

      </para>
     </listitem>

     <listitem>
      <para>
       <!-- 
       <literal>__</literal> and <literal>/*</literal> cannot appear
       anywhere in an operator name, since they will be taken as the
       start of a comment.
       -->

       「<literal>--</literal>」と「<literal>/*</literal>」は演算子名の中に使うことができません。なぜならこれらはコメントの始まりと解釈されるからです。

      </para>
     </listitem>

     <listitem>
      <para>
       <!-- A multi-character operator name cannot end in "+" or "-",
       unless the name also contains at least one of these characters:
       -->

       複数文字の演算子名は、その名前が少なくとも下記の文字の1つ以上を含まない限り、「+」や「-」で終わることができません。

<literallayout>
~ ! @ # % ^ &amp; | ` ? $
</literallayout>
       <!--
       For example, <literal>@-</literal> is an allowed operator name,
       but <literal>*-</literal> is not.  This restriction allows
       <productname>Postgres</productname> to parse SQL-compliant
       queries without requiring spaces between tokens.
       -->

       たとえば、「<literal>@-</literal>」は演算子名として認められていますが、「<literal>*-</literal>」は認められていません。この制限は<productname>Postgres</productname>がSQLに準拠する問い合わせを、トークン同士の間に空白を要求することなしに解析することを許可します。

      </para>
     </listitem>
    </itemizedlist>

   <para>
    <!-- 
    When working with non-SQL-standard operator names, you will usually
    need to separate adjacent operators with spaces to avoid ambiguity.
    For example, if you have defined a left-unary operator named "@",
    you cannot write <literal>X*@Y</literal>; you must write
    <literal>X* @Y</literal> to ensure that
    <productname>Postgres</productname> reads it as two operator names
    not one.
    -->

    非SQL標準の演算子名を使う場合、通常は曖昧さを回避するために、隣り合った演算子を空白で区切る必要があります。たとえば、もし「@」という左単項演算子を定義したとすると<literal>X*@Y</literal>とは書けません。<productname>Postgres</productname>が1つではなく2つの演算子名として解釈することを確実にするためには、<literal>X* @Y</literal>と書かなくてはいけません。

   </para>
  </sect2>

  <sect2>
   <!-- <title>Special Characters</title> -->
   <title>特殊文字</title>
<indexterm><primary sortas="とくしゅもじ">特殊文字</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="とくしゅもじ">特殊文字</secondary></indexterm>
  <para>
   <!-- 
   Some characters that are not alphanumeric have a special meaning
   that is different from being an operator.  Details on the usage can
   be found at the location where the respective syntax element is
   described.  This section only exists to advise the existence and
   summarize the purposes of these characters.
   -->

   英数字ではないいくつかの文字は、演算子であることとは異なる特殊な意味を持っています。使用法の詳細はそれぞれの構文要素が説明されている場所で見つけることができます。この節の目的は単に存在をアドバイスし、これらの文字の目的をまとめることに留めます。</para>

   <itemizedlist>
    <listitem>
     <para>
      <!-- 
      A dollar sign (<literal>$</literal>) followed by digits is used
      to represent the positional parameters in the body of a function
      definition.  In other contexts the dollar sign may be part of an
      operator name.
      -->

      直後に数字が続くドル記号（「<literal>$</literal>」）は、関数定義の本体中の位置パラメータを表すために使われます。他の文脈ではドル記号は演算子名の一部であるかもしれません。

     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      Parentheses (<literal>()</literal>) have their usual meaning to
      group expressions and enforce precedence.  In some cases
      parentheses are required as part of the fixed syntax of a
      particular SQL command.
      -->

      かっこ（「<literal>()</literal>」）は、通常どおり式をまとめ優先するという意味を持ちます。場合によってはかっこは、特定のSQLコマンドの固定構文の一部として要求されることがあります。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      Brackets (<literal>[]</literal>) are used to select the elements
      of an array.  See <xref linkend="arrays"> for more information
      on arrays.
      -->

      大かっこ（「<literal>[]</literal>」）は、配列要素を選択するために使われます。配列に関する詳しい情報は<xref linkend="arrays">を参照してください。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      Commas (<literal>,</literal>) are used in some syntactical
      constructs to separate the elements of a list.
      -->

      カンマ（「<literal>,</literal>」）は、リストの要素を区切るために構文的構造体で使われることがあります。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      The semicolon (<literal>;</literal>) terminates an SQL command.
      It cannot appear anywhere within a command, except within a
      string constant or quoted identifier.
      -->

      セミコロン（「<literal>;</literal>」）は、SQLコマンドの終わりを意味します。文字列定数または引用符付き識別子以外では、コマンドの途中では使うことができません。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- The colon (<literal>:</literal>) is used to select
      <quote>slices</quote> from arrays. (See <xref
      linkend="arrays">.)  In certain SQL dialects (such as Embedded
      SQL), the colon is used to prefix variable names.
      -->

      コロン（「<literal>:</literal>」）は、配列から<quote>スライス</quote>を取りだすために使われます（<xref linkend="arrays">を参照）。いくつかのSQL通用語（埋め込みSQLなど）では、コロンは変数名の接頭辞として使われます。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- The asterisk (<literal>*</literal>) has a special meaning when
      used in the <command>SELECT</command> command or with the
      <function>COUNT</function> aggregate function.
      -->

      アスタリスク（「<literal>*</literal>」）は、<command>SELECT</command>コマンドの中、あるいは<function>COUNT</function>集計関数と一緒に使われる場合、特殊な意味を持ちます。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      The period (<literal>.</literal>) is used in floating point
      constants, and to separate table and column names.
      -->

     ピリオド（「<literal>.</literal>」）は、浮動小数点定数の中で使われ、テーブルとカラム名を区切るために使われます。
     </para>
    </listitem>
   </itemizedlist>

  </sect2>

  <sect2 id="sql-syntax-comments">
   <!-- <title>Comments</title> -->
   <title>コメント</title>
<indexterm><primary sortas="こめんと">コメント</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="こめんと">コメント</secondary></indexterm>
   <para>
    <!-- 
    A comment is an arbitrary sequence of characters beginning with
    double dashes and extending to the end of the line, e.g.:
    -->

    コメントは二重ハイフンで始まる任意の文字の並びで、行の終わりまで続きます。たとえば以下のようになります。</para>

<programlisting>
<!-- __ This is a standard SQL92 comment -->
    --これは標準SQL92のコメントです
</programlisting>

    <!-- Alternatively, C-style block comments can be used:
    -->
<para>代わりに、C言語形式のブロックコメントも使えます。<indexterm><primary sortas="こめんと">コメント</primary><secondary sortas="ぶろっく">ブロック</secondary></indexterm></para>

<programlisting>
<!-- /* multi-line comment
 * with nesting: /* nested block comment */
 */
-->
/* ネスト付き
 * 複数行コメント /* ネストされたブロックコメント */
 */
</programlisting>
    <!-- 
    where the comment begins with <literal>/*</literal> and extends to
    the matching occurrence of <literal>*/</literal>. These block
    comments nest, as specified in SQL99 but unlike C, so that one can
    comment out larger blocks of code that may contain existing block
    comments.
    -->

<para>ブロックコメントは「<literal>/*</literal>」で始まり、対応する「<literal>*/</literal>」で終わります。これらのブロックコメントは、SQL99で指定されていますがCとは違い、ネストできるので、既存のブロックコメントを含む可能性のある大きなコードのブロックをコメントアウトすることができます。
   </para>

   <para>
    <!-- 
    A comment is removed from the input stream before further syntax
    analysis and is effectively replaced by whitespace.
    -->

    コメントは、さらに構文解析が行われる前に入力ストリームから取り去られ、空白によって適切に置き換えられます。
   </para>
  </sect2>
 </sect1>


  <sect1 id="sql-syntax-columns">
   <!-- <title>Columns</title> -->
   <title>カラム</title>
<indexterm><primary sortas="からむ">カラム</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="からむ">カラム</secondary></indexterm>
    <para>
     <!-- A <firstterm>column</firstterm>
     is either a user-defined column of a given table or one of the
     following system-defined columns:
     -->

     <firstterm>カラム</firstterm>は、与えられたテーブルのユーザー定義カラムか、もしくは下記のシステム定義カラムのどちらかです。</para>

     <variablelist>
      <varlistentry>
       <term>oid</term>
       <listitem>
	<para>
         <!-- 
	 The unique identifier (object ID) of a row.  This is a serial number
	 that is added by Postgres to all rows automatically. OIDs are not
	 reused and are 32-bit quantities.
         -->

         行の一意な識別子（オブジェクトID）。これはPostgresがすべての行に自動的に加える通版の数です。OIDは再使用されることはなく、32ビット長です。
	</para>
       </listitem>
      </varlistentry>

      <varlistentry>
      <term>tableoid</term>
       <listitem>
	<para>
         <!-- 
	 The OID of the table containing this row.  This attribute is
	 particularly handy for queries that select from inheritance
	 hierarchies, since without it, it's difficult to tell which
	 individual table a row came from.  The tableoid can be joined
	 against the OID attribute of pg_class to obtain the table name.
         -->

        この行を含むテーブルのOIDです。この属性は特に、継承階層からのSELECT文では便利です。この属性がないと、どのテーブルからその行が来たのかわかりにくいからです。tableoidはテーブル名を得るためにpg_classのOID属性に結合することができます。
	</para>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>xmin</term>
       <listitem>
	<para>
         <!-- 
	 The identity (transaction ID) of the inserting transaction for
	 this tuple.  (Note: a tuple is an individual state of a row;
	 each UPDATE of a row creates a new tuple for the same logical row.)
         -->

         このタプルの挿入トランザクションの識別情報（トランザクションID）です（注：タプルは行の個別の状態です。行のそれぞれのUPDATEは同じ論理行のための新しいタプルを作ります）。
	</para>
       </listitem>
      </varlistentry>

      <varlistentry>
      <term>cmin</term>
       <listitem>
	<para>
         <!-- 
	 The command identifier (starting at zero) within the inserting
	 transaction. -->

         挿入トランザクション内のコマンド識別子（0から始まる）です。

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

      <varlistentry>
      <term>xmax</term>
       <listitem>
	<para>
         <!-- The identity (transaction ID) of the deleting transaction,
	 or zero for an undeleted tuple.  In practice, this is never nonzero
	 for a visible tuple.
         -->

         削除トランザクションの識別情報（トランザクションID）です。削除されていないタプルでは0（ゼロ）です。実際には、目に見えるタプルについては0以外であることはありません。
	</para>
       </listitem>
      </varlistentry>

      <varlistentry>
      <term>cmax</term>
       <listitem>
	<para>
         <!-- 
	 The command identifier within the deleting transaction, or zero.
	 Again, this is never nonzero for a visible tuple.
         -->

         削除トランザクション内のコマンド識別子、もしくは0（ゼロ）です。これも同じく、目に見えるタプルについては0以外であることはありません。
	</para>
       </listitem>
      </varlistentry>

      <varlistentry>
      <term>ctid</term>
       <listitem>
	<para>
         <!-- 
	 The tuple ID of the tuple within its table.  This is a pair
	 (block number, tuple index within block) that identifies the
	 physical location of the tuple.  Note that although the ctid
	 can be used to locate the tuple very quickly, a row's ctid
	 will change each time it is updated or moved by VACUUM.
	 Therefore ctid is useless as a long-term row identifier.
	 The OID, or even better a user-defined serial number, should
	 be used to identify logical rows.
         -->

         そのテーブル内のタプルのタプルIDです。これは組（ブロック数、ブロック内のタプルインデックス）でタプルの物理的位置を識別します。ctidはタプルをすばやく見つけるために使うことができますが、行のctidは更新されるたびに、あるいはバキュームで動かされるたびに変わります。したがって、ctidは長期の行識別子としては使えません。OID、あるいはさらによいのはユーザー定義の通番数ですが、論理行を識別するためにはこれらを使うべきです。
	</para>
       </listitem>
      </varlistentry>
     </variablelist>

    <para>
     <!-- 
     For further information on the system attributes consult
     <xref linkend="STON87a" endterm="STON87a">.
     Transaction and command identifiers are 32-bit quantities.
     -->

     システム属性のさらに詳しい情報については<xref linkend="STON87a" endterm="STON87a">を参照してください。トランザクションとコマンド識別子は32ビットです。
    </para>

  </sect1>


 <sect1 id="sql-expressions">
  <!-- <title>Value Expressions</title> -->
  <title>評価式</title>
<indexterm><primary sortas="ひょうかしき">評価式</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="ひょうかしき">評価式</secondary></indexterm>
  <para>
   <!-- 
   Value expressions are used in a variety of contexts, such
   as in the target list of the <command>SELECT</command> command, as
   new column values in <command>INSERT</command> or
   <command>UPDATE</command>, or in search conditions in a number of
   commands.  The result of a value expression is sometimes called a
   <firstterm>scalar</firstterm>, to distinguish it from the result of
   a table expression (which is a table).  Value expressions are
   therefore also called <firstterm>scalar expressions</firstterm> (or
   even simply <firstterm>expressions</firstterm>).  The expression
   syntax allows the calculation of values from primitive parts using
   arithmetic, logical, set, and other operations.
   -->

   評価式は、たとえば<command>SELECT</command>コマンドのターゲットリストとして、<command>INSERT</command>や<command>UPDATE</command>の新しいカラム値として、もしくはいくつかのコマンドの検索条件としてさまざまな文脈のなかで使われます。評価式の結果は、テーブル式の結果（つまりテーブル）から区別するために、<firstterm>スカラー</firstterm><indexterm><primary sortas="すからー">スカラー</primary></indexterm>と呼ばれることもあります。したがって、評価式は<firstterm>スカラー式</firstterm>（もしくはもっと簡単に<firstterm>式</firstterm>）とも呼ばれます。式の構文は、算術、論理、集合、他の演算子などの基本的な要素の値での計算が認められます。
  </para>

  <para>
   <!-- A value expression is one of the following: -->
   評価式は下記のうちのどれかです。</para>

   <itemizedlist>
    <listitem>
     <para>
      <!-- 
      A constant or literal value; see <xref linkend="sql-syntax-constants">.
      -->

      定数あるいはリテラル値（<xref linkend="sql-syntax-constants">を参照）。

     </para>
    </listitem>

    <listitem>
     <para>
      <!--  A column reference -->
      カラムの参照。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- An operator invocation: -->
      演算子の呼び出し。</para>
      <simplelist>
   <!-- <member><replaceable>expression</replaceable> <replaceable>operator</replaceable> <replaceable>expression</replaceable> (binary infix operator)</member>
       <member><replaceable>operator</replaceable> <replaceable>expression</replaceable> (unary prefix operator)</member>
       <member><replaceable>expression</replaceable> <replaceable>operator</replaceable> (unary postfix operator)</member>
   -->

       <member><replaceable>式</replaceable> <replaceable>演算子</replaceable> 
<replaceable>式</replaceable>（二項中置演算子）</member>
       <member><replaceable>演算子</replaceable> 
     <replaceable>式</replaceable>（単項接頭演算子）</member>
       <member><replaceable>式</replaceable> <replaceable>演算子</replaceable> 
（単項接尾演算子）</member>
      </simplelist>
      <!-- 
      where <replaceable>operator</replaceable> follows the syntax
      rules of <xref linkend="sql-syntax-operators"> or is one of the
      tokens <token>AND</token>, <token>OR</token>, and
      <token>NOT</token>.  Which particular operators exist and whether
      they are unary or binary depends on what operators have been
      defined by the system or the user.  <xref linkend="functions">
      describes the built-in operators.
      -->

<para><replaceable>演算子</replaceable>は、<xref linkend="sql-syntax-operators">の構文ルールに従うか、トークン<token>AND</token>、<token>OR</token>、<token>NOT</token>のうちのいずれかであるかです。演算子にどんなものがあり、それぞれが単項であるか二項であるかは、システムあるいはユーザーにどの演算子が定義されているかによります。<xref linkend="functions">では組み込み演算子について説明しています。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- 
      Parentheses are used to group subexpressions and override precedence.
      -->
      かっこ（副式をまとめ優先順位を変更するために使われます）。</para>
<!--  
<synopsis>( <replaceable>expression</replaceable> )</synopsis>
--> 
<synopsis>( <replaceable>式</replaceable> )</synopsis>
    </listitem>

    <listitem>
     <para>
      <!-- 
      A positional parameter reference, in the body of a function declaration.
      -->
      関数宣言の本体の中の、位置パラメータの参照。

     </para>
    </listitem>

    <listitem>
     <para>
      <!-- A function call -->
      関数呼び出し。
     </para>
    </listitem>

    <listitem>
     <para>
      <!-- An aggregate expression -->
      集計式。
     </para>
    </listitem>

    <listitem>
     <para>
      <!--  A scalar subquery.  This is an ordinary
      <command>SELECT</command> in parentheses that returns exactly one
      row with one column.  It is an error to use a subquery that
      returns more than one row or more than one column in the context
      of a value expression. -->

      スカラー副問い合わせ。これは通常の<command>SELECT</command>にかっこを付けたもので、1つのカラムに付き正確に1つの行を返します。評価式の中で、1つ以上の行あるいはカラムを返す副問い合わせを使うことは間違いです。
     </para>
    </listitem>
   </itemizedlist>

  <para>
   <!-- 
   In addition to this list, there are a number of constructs that can
   be classified as an expression but do not follow any general syntax
   rules.  These generally have the semantics of a function or
   operator and are explained in the appropriate location in <xref
   linkend="functions">.  An example is the <literal>IS NULL</literal>
   clause. -->

   これ以外にも、式として分類されるけれども一般的な構文ルールには従わないいくつかの構成要素があります。これらは一般的に関数あるいは演算子の意味を持ちます。<xref linkend="functions">で説明されていますが、例としては<literal>IS NULL</literal>があります。
  </para>

  <para>
   <!-- We have already discussed constants in <xref
   linkend="sql-syntax-constants">.  The following sections discuss
   the remaining options.
   -->

    <xref linkend="sql-syntax-constants">ですでに定数については説明しました。続く節では残りのオプションについて説明します。
  </para>

  <sect2>
   <!-- <title>Column References</title> -->
   <title>カラムの参照</title>
<indexterm><primary sortas="からむ">カラム</primary><secondary sortas="さんしょう">参照</secondary></indexterm>
   <para>
    <!-- A column can be referenced in the form: -->
    カラムは下記のような形式で参照することができます。</para>

<synopsis>
<!-- 
<replaceable>correlation</replaceable>.<replaceable>columnname</replaceable> `['<replaceable>subscript</replaceable>`]'
-->
<replaceable>相関名</replaceable>.<replaceable>カラム名</replaceable> `['<replaceable>配列要素</replaceable>`]'
 
</synopsis>
    <!-- 
    <replaceable>correlation</replaceable> is either the name of a
    table, an alias for a table defined by means of a FROM clause, or
    the keyword <literal>NEW</literal> or <literal>OLD</literal>.
    (NEW and OLD can only appear in the action portion of a rule,
    while other correlation names can be used in any SQL statement.)
    The correlation name can be omitted if the column name is unique
    across all the tables being used in the current query.  If
    <replaceable>column</replaceable> is of an array type, then the
    optional <replaceable>subscript</replaceable> selects a specific
    element in the array.  If no subscript is provided, then the whole
    array is selected.  Refer to the description of the particular
    commands in the <citetitle>PostgreSQL Reference Manual</citetitle>
    for the allowed syntax in each case.
    -->

<para><replaceable>相関名</replaceable>は、テーブル名、FROM句で定義されたテーブルの別名、キーワード<literal>NEW</literal>、キーワード<literal>OLD</literal>のいずれかです（NEWとOLDはルールのアクション部分でしか使えませんが、他の相関名はどのSQL文でも使うことができます）。相関名は、もしカラム名が現在の問い合わせで使われるすべてのテーブルを通して一意である場合は省略してもかまいません。もし<replaceable>カラム名</replaceable>が配列型の場合には、オプションの<replaceable>配列要素</replaceable>で配列から特定の要素を選択します。もし配列要素が提供されない場合、配列全体が選択されます。それぞれの場合の許可される構文は<citetitle>&reference-guide;</citetitle>の特定のコマンドの説明を見てください。
   </para>
  </sect2>

  <sect2>
   <!-- <title>Positional Parameters</title> -->
   <title>位置パラメータ</title>
<indexterm><primary sortas="いちぱらめーた">位置パラメータ</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="いちぱらめーた">位置パラメータ</secondary></indexterm>
   <para>
    <!-- 
    A positional parameter reference is used to indicate a parameter
    in an SQL function.  Typically this is used in SQL function
    definition statements.  The form of a parameter is:
    -->

    位置パラメータの参照はSQL関数のパラメータを示すために使われます。これは典型的にSQL関数定義ステートメントで使われます。パラメータの形式は以下です。</para>

<synopsis>
<!-- $<replaceable>number</replaceable> -->
$<replaceable>数字</replaceable>
</synopsis>

   <para>
    <!-- For example, consider the definition of a function,
    <function>dept</function>, as
    -->

    たとえば、関数<function>dept</function>の定義が以下のようにされたとします。</para>

<programlisting>
CREATE FUNCTION dept (text) RETURNS dept
  AS 'select * from dept where name = $1'
  LANGUAGE 'sql';
</programlisting>
    <!-- 
    Here the <literal>$1</literal> will be replaced by the first
    function argument when the function is invoked.
    -->

<para>ここでは<literal>$1</literal>は関数が呼び出されるときに最初の関数引数によって置き換えられます。

   </para>
  </sect2>

  <sect2>
   <!-- <title>Function Calls</title> -->
   <title>関数呼び出し</title>
<indexterm><primary sortas="かんすう">関数</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="かんすう">関数</secondary></indexterm>
   <para>
    <!-- The syntax for a function call is the name of a function
    (which is subject to the syntax rules for identifiers of <xref
    linkend="sql-syntax-identifiers">), followed by its argument list
    enclosed in parentheses: -->

    関数呼び出しの構文は関数名（これは<xref linkend="sql-syntax-identifiers">の識別子の構文ルールの対象です）のあとにかっこで閉じた引数リストがあるものです。</para>

<synopsis>
<!-- <replaceable>function</replaceable> (<optional><replaceable>expression</replaceable> <optional>, <replaceable>expression</replaceable> ... </optional></optional> )-->

<replaceable>関数</replaceable> (<optional><replaceable>式</replaceable> 
<optional>, <replaceable>式</replaceable> ... </optional></optional> )

</synopsis>

   <para>
    <!-- For example, the following computes the square root of 2: -->
    たとえば、以下のものは2の平方根を計算します。</para>
<programlisting>
sqrt(2)
</programlisting>

   <para>
    <!-- The list of built-in functions is in <xref linkend="functions">.
    Other functions may be added by the user. -->

    組み込み関数のリストは<xref linkend="functions">にあります。他の関数はユーザーによって追加できます。

   </para>
  </sect2>

  <sect2 id="syntax-aggregates">
   <!-- <title>Aggregate Expressions</title> -->
   <title>集計式</title>
<indexterm><primary sortas="しゅうけいしき">集計式</primary></indexterm>
<indexterm><primary>SQL</primary><secondary sortas="しゅうけいしき">集計式</secondary></indexterm>
   <para>
    <!-- 
    An <firstterm>aggregate expression</firstterm> represents the
    application of an aggregate function across the rows selected by a
    query.  An aggregate function reduces multiple inputs to a single
    output value, such as the sum or average of the inputs.  The
    syntax of an aggregate expression is one of the following: -->

    <firstterm>集計式</firstterm>は、問い合わせによって選択される行にある集計関数のアプリケーションを表します。集計関数は、たとえば入力の合計や平均などのように、複数の入力を単一の出力値にします。集計式の構文は下記のうちのいずれかです。</para>

    <simplelist>
     <member><replaceable>aggregate_name</replaceable> (<replaceable>expression</replaceable>)</member>
     <member><replaceable>aggregate_name</replaceable> (ALL <replaceable>expression</replaceable>)</member>
     <member><replaceable>aggregate_name</replaceable> (DISTINCT <replaceable>expression</replaceable>)</member>
     <member><replaceable>aggregate_name</replaceable> ( * )</member>
    </simplelist>

    <!-- 
    where <replaceable>aggregate_name</replaceable> is a previously
    defined aggregate, and <replaceable>expression</replaceable> is
    any expression that does not itself contain an aggregate
    expression. -->

<para><replaceable>aggregate_name</replaceable>は前もって定義された集計で、<replaceable>expression</replaceable>はそれ自体は集計式を含まない式です。
   </para>

   <para>
    <!-- 
    The first form of aggregate expression invokes the aggregate
    across all input rows for which the given expression yields a
    non-NULL value.  (Actually, it is up to the aggregate function
    whether to ignore NULLs or not ___ but all the standard ones do.)
    The second form is the same as the first, since
    <literal>ALL</literal> is the default.  The third form invokes the
    aggregate for all distinct non-NULL values of the expression found
    in the input rows.  The last form invokes the aggregate once for
    each input row regardless of NULL or non-NULL values; since no
    particular input value is specified, it is generally only useful
    for the <function>count()</function> aggregate function. -->

    集計式の最初の形式は、与えられた式が非NULL値を生み出すすべての入力行で、集計を呼び出します（実際は、NULLを無視するかどうかは集計関数しだいですが、すべての標準のものは無視します）。二番目の形式は<literal>ALL</literal>がデフォルトなので最初のものと同じです。三番目の形式は、入力行の中で見つけられる式のすべての別個の非NULL値のための集計を呼び出します。最後の形式はNULLか非NULL値かにかかわらず、それぞれの入力行に対して一回ずつ集計を呼び出します。特定の入力値が指定されていないため、これは一般的に<function>count()</function>集計関数でのみ役に立ちます。
   </para>

   <para>
    <!-- 
    For example, <literal>count(*)</literal> yields the total number
    of input rows; <literal>count(f1)</literal> yields the number of
    input rows in which <literal>f1</literal> is non-NULL;
    <literal>count(distinct f1)</literal> yields the number of
    distinct non-NULL values of <literal>f1</literal>.
    -->

    たとえば、<literal>count(*)</literal>は入力行の合計数を出します。<literal>count(f1)</literal>は<literal>f1</literal>が非NULLである入力行の数を出します。<literal>count(distinct f1)</literal>は<literal>f1</literal>の別個の非NULL値の数を出します。
   </para>

   <para>
    <!-- The predefined aggregate functions are described in <xref
    linkend="functions-aggregate">.  Other aggregate functions may be added
    by the user. -->

    すでに定義された集計関数は<xref linkend="functions-aggregate">で説明されています。他の集計関数はユーザーによって追加することができます。
   </para>
  </sect2>

 </sect1>


  <sect1 id="sql-precedence">
   <!-- <title>Lexical Precedence</title> -->
   <title>語彙の優先順位</title>
<indexterm><primary>SQL</primary><secondary sortas="ごいのゆうせんじゅんい">語彙の優先順位</secondary></indexterm>
   <para>
    <!-- 
    The precedence and associativity of the operators is hard-wired
    into the parser.  Most operators have the same precedence and are
    left-associative.  This may lead to non-intuitive behavior; for
    example the Boolean operators "&lt;" and "&gt;" have a different
    precedence than the Boolean operators "&lt;=" and "&gt;=".  Also,
    you will sometimes need to add parentheses when using combinations
    of binary and unary operators.  For instance -->

    演算子の優先順位と結合性はパーサーに組み込まれています。ほとんどの演算子は同じ優先順位を持ち左結合します。これは非直感的な動作に導く可能性があります。たとえばブーリアン演算子「&lt;」と「&gt;」は、ブーリアン演算子「&lt;=」と「&gt;=」とは違った優先順位を持ちます。さらに、二項と単項演算子を組み合わせて使う場合はかっこを加える必要がある場合があります。たとえば下記のような場合です。</para>

<programlisting>
SELECT 5 ! - 6;
</programlisting>
   <!-- will be parsed as -->
<para>これは下記のように解析されます。</para>
<programlisting>
SELECT 5 ! (- 6);
</programlisting>
    <!-- 
    because the parser has no idea __ until it is too late __ that
    <token>!</token> is defined as a postfix operator, not an infix one.
    To get the desired behavior in this case, you must write
    -->

<para>なぜならば、パーサーは「<token>!</token>」が中置ではなく接尾演算子として定義されていることに最後まで気がつかないためです。この場合、求める結果を得るためには下記のように書く必要があります。</para>

<programlisting>
SELECT (5 !) - 6;
</programlisting>
    <!-- This is the price one pays for extensibility. -->
<para>これが拡張性に支払われる代償です。

   </para>

   <table tocentry="1">
    <!-- <title>Operator Precedence (decreasing)</title> -->
    <title>演算子の優先順位（強いものから）</title>

    <tgroup cols="2">
     <thead>
      <row>
       <!-- <entry>Operator/Element</entry>
       <entry>Associativity</entry>
       <entry>Description</entry> -->

       <entry>演算子/要素</entry>
       <entry>結合性</entry>
       <entry>説明</entry>

      </row>
     </thead>

     <tbody>
      <row>
       <entry><token>::</token></entry>
       <!-- <entry>left</entry> -->
        <entry>左</entry>
       <!-- 
       <entry><productname>Postgres</productname>-style typecast</entry>
       -->
       <entry><productname>Postgres</productname>方式の型キャスト</entry>
      </row>

      <row>
       <entry><token>[</token> <token>]</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>array element selection</entry> -->
       <entry>配列要素選択</entry>
      </row>

      <row>
       <entry><token>.</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>table/column name separator</entry> -->
       <entry>テーブル/カラム名の区切り</entry>
      </row>

      <row>
       <entry><token>-</token></entry>
       <!-- <entry>right</entry> -->
       <entry>右</entry> 
       <!-- <entry>unary minus</entry> -->
       <entry>単項減算</entry>
      </row>

      <row>
       <entry><token>^</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>exponentiation</entry> -->
       <entry>羃乗</entry>  
      </row>

      <row>
       <entry><token>*</token> <token>/</token> <token>%</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>multiplication, division, modulo</entry> -->
       <entry>積算、割算、剰余</entry>
      </row>

      <row>
       <entry><token>+</token> <token>-</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>addition, subtraction</entry> -->
       <entry>加算、減算</entry>
      </row>

      <row>
       <entry><token>IS</token></entry>
       <entry></entry>
       <!-- <entry>test for TRUE, FALSE, NULL</entry> -->
       <entry>TRUE, FALSE, NULLかどうかを試す</entry>
      </row>

      <row>
       <entry><token>ISNULL</token></entry>
       <entry></entry>
       <!-- <entry>test for NULL</entry> -->
       <entry>NULLかどうかを試す</entry>
      </row>

      <row>
       <entry><token>NOTNULL</token></entry>
       <entry></entry>
       <!-- <entry>test for NOT NULL</entry> -->
       <entry>NOT NULLかどうかを試す</entry>
      </row>

      <row>
       <!-- <entry>(any other)</entry> -->
       <entry>（その他すべて）</entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>all other native and user-defined operators</entry>
       -->
       <entry>その他すべての組み込み、あるいはユーザー定義の演算子</entry>
      </row>

      <row>
       <entry><token>IN</token></entry>
       <entry></entry>
       <!-- <entry>set membership</entry> -->
       <entry>メンバーシップを設定する</entry>  
      </row>

      <row>
       <entry><token>BETWEEN</token></entry>
       <entry></entry>
       <!-- <entry>containment</entry> -->
       <entry>囲み</entry>

      </row>

      <row>
       <entry><token>OVERLAPS</token></entry>
       <entry></entry>
       <!-- <entry>time interval overlap</entry> -->
       <entry>時間間隔の重複</entry>
      </row>

      <row>
       <entry><token>LIKE</token> <token>ILIKE</token></entry>
       <entry></entry>
       <!-- <entry>string pattern matching</entry> -->
       <entry>文字列パターンのマッチング</entry>
      </row>

      <row>
       <entry><token>&lt;</token> <token>&gt;</token></entry>
       <entry></entry>
       <!-- <entry>less than, greater than</entry> -->
       <entry>小なり、大なり</entry>
      </row>

      <row>
       <entry><token>=</token></entry>
       <!-- <entry>right</entry> -->
       <entry>右</entry>
       <!-- <entry>equality, assignment</entry> -->
       <entry>等しい、代入</entry>
      </row>

      <row>
       <entry><token>NOT</token></entry>
       <!-- <entry>right</entry> -->
       <entry>右</entry>
       <!-- <entry>logical negation</entry> -->
       <entry>論理否定</entry>
      </row>

      <row>
       <entry><token>AND</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>logical conjunction</entry> -->
       <entry>論理積</entry>
      </row>

      <row>
       <entry><token>OR</token></entry>
       <!-- <entry>left</entry> -->
       <entry>左</entry>
       <!-- <entry>logical disjunction</entry> -->
       <entry>論理和</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    <!-- 
    Note that the operator precedence rules also apply to user-defined
    operators that have the same names as the built-in operators
    mentioned above.  For example, if you define a
    <quote>+</quote> operator for some custom data type it will have
    the same precedence as the built-in <quote>+</quote> operator, no
    matter what yours does. -->

    演算子優先順位のルールは、上記で触れた組み込み演算子と同じ名前を持つユーザー定義演算子にも当てはまります。たとえばもし<quote>+</quote>演算子をあるカスタムデータ型に定義すると、新しい演算子が何をするかにかかわらず、組み込まれた<quote>+</quote>演算子と同じ優先順位を持つようになります。
   </para>
  </sect1>

</chapter>

<!-- 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:
-->
