<!--
$Header: /usr/prj/pg/cvsroot/doc/doc/src/sgml/jdbc.sgml,v 1.13 2001/09/14 02:10:56 yatabe Exp $
-->

 <chapter id="jdbc">
  <title><acronym>JDBC</acronym><!--Interface-->インターフェイス</title>
<indexterm><primary>JDBC</primary></indexterm>
<indexterm><primary>PostgreSQL</primary><secondary>JDBC</secondary></indexterm>
  <note>
   <!-- <title>Author</title> -->
   <title>著者</title>
   <para>
    <!-- Written by Peter T. Mount (<email>peter@retep.org.uk</email>), the
    author of the <acronym>JDBC</acronym> driver. -->
    JDBCドライバの作者である、Peter T. Mount（<email>peter@retep.org.uk</email>）によって記述されました。
   </para>
  </note>

  <para>
   <!-- <acronym>JDBC</acronym> is a core <acronym>API</acronym> of Java 1.1 and later.
   It provides a standard set of
   interfaces to <acronym>SQL</acronym>-compliant databases. -->
   <acronym>JDBC</acronym>は、Java 1.1以降のコア<acronym>API</acronym>です。<acronym>SQL</acronym>に準拠したデータベースへのインターフェイスの標準セットを提供します。
  </para>

  <para>
   <!-- <application>Postgres</application> provides a <firstterm>type
   4</firstterm> <acronym>JDBC</acronym> Driver.  Type 4 indicates
   that the driver is written in Pure Java, and communicates in the
   database system's own network protocol. Because of this, the driver
   is platform independent; once compiled, the driver can be used on
   any system. -->
   <application>Postgres</application>は、<firstterm>タイプ4</firstterm>の<acronym>JDBC</acronym>ドライバを提供します。タイプ4とは、ドライバがPure Javaで記述され、データベース自身のネットワークプロトコルで通信を行うことを意味します。このため、ドライバはプラットフォームに依存しません。一度コンパイルを行えば、そのドライバはどのプラットフォームでも使用することができます。
  </para>

  <para>
   <!-- This chapter is not intended as a complete guide to
   <acronym>JDBC</acronym> programming, but should help to get you
   started. For more information refer to the standard
   <acronym>JDBC</acronym> <acronym>API</acronym> documentation.
   Also, take a look at the examples included with the source. The
   basic example is used here. -->
   この章は、<acronym>JDBC</acronym>プログラミングの完全なガイドを意図したものではありませんが、これから始めようという場合に役にたちます。より詳細については、標準の<acronym>JDBC</acronym> <acronym>API</acronym>の資料を参照してください。また、ソースに付随している例も見てください。例にあるbasicはここで使用されています<footnote><para>訳注：example/basic.javaのことです</para></footnote>。
  </para>

 <sect1 id="jdbc-setup">
  <!-- <title>Setting up the <acronym>JDBC</acronym> Driver</title> -->
  <title><acronym>JDBC</acronym>ドライバのセットアップ</title>
<indexterm><primary>JDBC</primary><secondary sortas="どらいばのせとあっぷ">ドライバのセットアップ</secondary></indexterm>
  <sect2 id="jdbc-build">
   <!-- <title>Building the Driver</title> -->
   <title>ドライバのビルド</title>

   <para>
    <!-- Precompiled versions of the driver are regularly made available on
    the <ulink
    url="http://jdbc.postgresql.org"><productname>PostgreSQL</productname>
    <acronym>JDBC</acronym> web site</ulink>.  Here we describe how to
    build the driver manually. -->
    ドライバのコンパイルされたバージョンは、<ulink url="http://jdbc.postgresql.org"><productname>PostgreSQL</productname> <acronym>JDBC</acronym>のWebサイト</ulink><![%book-publish;[（http://jdbc.postgresql.org/）]]>から入手できます。ここでは、手作業でドライバをビルドする方法を解説します。
   </para>

   <para>
    <!-- Starting with <productname>PostgreSQL</productname> version 7.1,
    the <acronym>JDBC</acronym> driver is built using
    <application>Ant</application>, a special tool for building
    Java-based packages.  You should download
    <application>Ant</application> from the <ulink
    url="http://jakarta.apache.org/ant/index.html"><application>Ant</application>
    web site</ulink> and install it before proceeding.  Precompiled
    <application>Ant</application> distributions are typically set up
    to read a file <filename>.antrc</filename> in the current user's
    home directory for configuration.  For example, to use a different
    <acronym>JDK</acronym> than the default, this may work: -->
    <productname>PostgreSQL</productname>のバージョン7.1から、<acronym>JDBC</acronym>ドライバは<application>Ant</application>（Javaベースのパッケージをビルドするための特別なツール）を使ってビルドされます。<ulink url="http://jakarta.apache.org/ant/index.html"><application>Ant</application> Webサイト</ulink><![%book-publish;[（http://jakarta.apache.org/ant/index.html）]]>から<application>Ant</application>をダウンロードして、最初にインストールする必要があります。コンパイル済み<application>Ant</application>ディストリビューションは、普通は構成のためにカレントユーザーのホームディレクトリから<filename>.antrc</filename>ファイルを読む設定です。たとえば、異なる<acronym>JDK</acronym>を使う場合に有効かもしれません。
</para>

<programlisting>
JAVA_HOME=/usr/local/sun-jdk1.3
JAVACMD=$JAVA_HOME/bin/java
</programlisting>

   <para>
    <!-- The build the driver, add the <option>__with-java</option> option to your
    <filename>configure</filename> command line, e.g., -->
    ドライバをビルドするには、<option>--with-java</option>オプションを<filename>configure</filename>コマンドに追加します。たとえば以下のようになります。
</para>

<screen>
<prompt>$</prompt> <userinput>./configure --prefix=<replaceable>xxx</replaceable> --with-java ...</userinput>
</screen>

<para>
    <!-- This will build and install the driver along with the rest of the
    <productname>PostgreSQL</productname> package when you issue the
    <literal>gmake</literal> and <literal>gmake install</literal>
    commands.  If you only want to build the driver and not the rest
    of <productname>PostgreSQL</productname>, change into the
    directory <filename
    class="directory">src/interfaces/jdbc</filename> and issue the
    respective <literal>make</literal> command there.  Refer to the
    <productname>PostgreSQL</productname> installation instructions
    for more information about the configuration and build process. -->

    <literal>gmake</literal>コマンドと<literal>gmake install</literal>コマンドを実行すると、<productname>PostgreSQL</productname>パッケージと共にドライバがビルドされてインストールされます。ドライバのみをビルドしたい場合には、<filename class="directory">src/interfaces/jdbc</filename>ディレクトリに移動して、そこで<literal>make</literal>コマンドを実行します。構成とビルド方法の詳細については、<productname>PostgreSQL</productname>のインストール方法を参照してください。
   </para>

   <note>
    <para>
     <!-- Do not try to build by calling <command>javac</command> directly,
     as the driver uses some dynamic loading techniques for
     performance reasons, and <command>javac</command> cannot cope.
     Do not try to run <command>ant</command> directly either, because
     some configuration information is communicated through the
     makefiles.  Running <command>ant</command> directly without
     providing these parameters will result in a broken driver. -->

     <command>javac</command>を直接実行してビルドしないでください。ドライバは性能向上のために動的読み込み技術をいくつか使用していますが、<command>javac</command>では処理できません。いくつかの構成情報がメイクファイルによって渡されるので、<command>ant</command>も直接実行しないでください。これらのパラメータを与えられることなく<command>ant</command>を直接実行すると、壊れたドライバになってしまいます。
    </para>
   </note>
  </sect2>

  <sect2 id="jdbc-classpath">
   <!-- <title>Setting up the Class Path</title> -->
   <title>Class Pathの設定</title>
<indexterm><primary>JDBC</primary><secondary sortas="class pathのせってい">class pathの設定</secondary></indexterm>
   <para>
    <!-- To use the driver, the jar archive
    <filename>postgresql.jar</filename> needs to be included in the
    class path, either by putting it in the <envar>CLASSPATH</envar>
    environment variable, or by using flags on the
    <command>java</command> command line.  By default, the jar archive
    is installed in the directory <filename
    class="directory">/usr/local/pgsql/share/java</filename>.  You may
    have it in a different directory if you used the
    <option>__prefix</option> option when you ran
    <filename>configure</filename>. -->
    ドライバを使うためには、<filename>postgresql.jar</filename>がクラスパスに含まれる必要があります。そのためには、<envar>CLASSPATH</envar>環境変数が指す場所に置くか、<command>java</command>コマンドのオプションで指定します。デフォルトでは、<filename class="directory">/usr/local/pgsql/share/java</filename>ディレクトリにインストールされます。<filename>configure</filename>を実行したとき<option>--prefix</option>オプションを使ったならば、違うディレクトリにあるかもしれません。<indexterm><primary>CLASSPATH</primary></indexterm><indexterm><primary sortas="かんきょうへんすう">環境変数</primary><secondary>CLASSPATH</secondary></indexterm>
   </para>

   <informalexample>
    <para>
     <!-- For instance, I have an application that uses the
     <acronym>JDBC</acronym> driver to access a large database
     containing astronomical objects. I have the application and the
     <acronym>JDBC</acronym> driver installed in the <filename
     class="directory">/usr/local/lib</filename> directory, and the
     Java <acronym>JDK</acronym> installed in
     <filename>/usr/local/jdk1.1.6</filename>.  To run the
     application, I would use: -->

     例として、天体データを含む巨大なデータベースにアクセスするために、<acronym>JDBC</acronym>ドライバを使うアプリケーションがあるとします。このアプリケーションとJDBCドライバを<filename class="directory">/usr/local/lib</filename>ディレクトリに、また、Java <acronym>JDK</acronym>を<filename>/usr/local/jdk1.1.6</filename>ディレクトリにインストールします。その場合、このアプリケーションを実行するには次のようにします。
</para>

<programlisting>
export CLASSPATH=/usr/local/lib/finder.jar<co id="co.jdbc-finder">:/usr/local/pgsql/share/java/postgresql.jar:.
java uk.org.retep.finder.Main
</programlisting>
     <calloutlist>
      <callout arearefs="co.jdbc-finder">
       <para>
        <!-- <filename>finder.jar</filename> contains my application. -->
        <filename>finder.jar</filename>は、このアプリケーションを含みます。
       </para>
      </callout>
     </calloutlist>

    <para>
     <!-- Loading the driver from within the application is covered in
     <xref linkend="jdbc-use">. -->
     アプリケーションの中からドライバを読み込むことについては、<xref linkend="jdbc-use">に示します。
    </para>
   </informalexample>
  </sect2>

  <sect2 id="jdbc-prepare">
   <!-- <title>Preparing the Database for <acronym>JDBC</acronym></title> -->
   <title><acronym>JDBC</acronym>のためのデータベースの準備</title>
<indexterm><primary>JDBC</primary><secondary sortas="でーたべーすのじゅんび">データベースの準備</secondary></indexterm>
   <para>
    <!-- Because Java can only use TCP/IP connections, the
    <application>Postgres</application> server must be configured to
    accept TCP/IP connections, for instance by supplying the
    <option>-i</option> option flag when starting the
    <command>postmaster</command>. -->
    JavaはTCP/IP接続しか使用しませんので、<application>Postgres</application>サーバーはTCP/IP接続を受け入れるための構成が必要です。たとえば、<command>postmaster</command>の起動時の<option>-i</option>オプションがあります。
   </para>

   <para>
    <!-- Also, the client authentication setup in the
    <filename>pg_hba.conf</filename> file may need to be configured.
    Refer to the <citetitle>Administrator's Guide</citetitle> for
    details.  The <acronym>JDBC</acronym> Driver supports trust,
    ident, password, and crypt authentication methods. -->
    また、<filename>pg_hba.conf</filename>ファイルによるクライアント認証の設定が必要かもしれません。詳細は<citetitle>&admin-guide;</citetitle>を参照してください。JDBCドライバは、ident、password、cryptの認証方法をサポートします。
   </para>
  </sect2>
 </sect1>

 <sect1 id="jdbc-use">
  <!-- <title>Using the Driver</title> -->
  <title>ドライバの使用</title>
<indexterm><primary>JDBC</primary><secondary sortas="どらいばのしよう">ドライバの使用</secondary></indexterm>
  <sect2 id="jdbc-import">
   <!-- <title>Importing <acronym>JDBC</acronym></title> -->
   <title><acronym>JDBC</acronym>のインポート</title>
<indexterm><primary>JDBC</primary><secondary sortas="いんぽーと">インポート</secondary></indexterm>
   <para>
    <!-- Any source that uses <acronym>JDBC</acronym> needs to import the
    <literal>java.sql</literal> package, using: -->
    <acronym>JDBC</acronym>を使うどんなソースでも、<literal>java.sql</literal>パッケージをインポートする必要があります。次のように使います。
</para>

<programlisting>
import java.sql.*;
</programlisting>

    <important>
     <para>
      <!-- Do not import the <literal>org.postgresql</literal> package. If
      you do, your source will not compile, as
      <command>javac</command> will get confused. -->
      <literal>org.postgresql</literal>パッケージをインポートしないでください。
      そうした場合、<command>javac</command>が混乱してしまい、ソースをコンパイルすることができません。
     </para>
    </important>
  </sect2>

  <sect2 id="jdbc-load">
   <!-- <title>Loading the Driver</title> -->
   <title>ドライバの読み込み</title>
<indexterm><primary>JDBC</primary><secondary sortas="どらいばのよみこみ">ドライバの読み込み</secondary></indexterm>
   <para>
    <!-- Before you can connect to a database, you need to load the
    driver. There are two methods available, and it depends on your
    code which is the best one to use. -->
    データベースに接続する前に、ドライバを読み込む必要があります。2つの方法があり、どちらが最適なのかは作成するコードに依存します。
   </para>

   <para>
    <!-- In the first method, your code implicitly loads the driver using the
    <function>Class.forName()</function> method.
    For <application>Postgres</application>, you would use: -->
    最初の方法は、コードの中で明示的に<function>Class.forName()</function>メソッドを使ってドライバを読み込みます。<application>Postgres</application>の場合は、次のように記述します。<indexterm><primary>JDBC</primary><secondary sortas="Class.forName()めそっど">Class.forName()メソッド</secondary></indexterm>
</para>

<programlisting>
Class.forName("org.postgresql.Driver");
</programlisting>

<para>
    <!-- This will load the driver, and while loading, the driver will automatically
    register itself with <acronym>JDBC</acronym>. -->
    これでドライバが読み込まれます。読み込まれると、ドライバは自動的に自分自身を<acronym>JDBC</acronym>に登録します。
</para>

    <note>
     <para>
      <!-- The <function>forName()</function> method can throw a
      <classname>ClassNotFoundException</classname> if the driver is
      not available. -->
      ドライバが利用できない場合に、<function>forName()</function>メソッドは<classname>ClassNotFoundException</classname>の例外を送出（throw）します。
     </para>
    </note>

   <para>
    <!-- This is the most common method to use, but restricts your code to
    use just <productname>Postgres</productname>.  If your code may
    access another database system in the future, and you do not use
    any <productname>Postgres</productname>-specific extensions, then
    the second method is advisable. -->
    これは最も一般的に使われる方法ですが、そのコードは<productname>Postgres</productname>だけでしか使えなくなります。今後、他のデータベースにアクセスする可能性があり、また、拡張機能を使用しないのならば、次に紹介する2番目の方法を勧めます。
   </para>

   <para>
    <!-- The second method passes the driver as a parameter to the
    <acronym>JVM</acronym> as it starts, using the <option>-D</option>
    argument. Example: -->
    2番目の方法は、<option>-D</option>オプションを使用して、ドライバをパラメータとして<acronym>JVM</acronym>の起動時に渡すことです。例を以下に示します。
</para>

<programlisting>
java -Djdbc.drivers=org.postgresql.Driver example.ImageViewer
</programlisting>

<para>
    <!-- In this example, the <acronym>JVM</acronym> will attempt to load
    the driver as part of its initialization. Once done, the
    <classname>ImageViewer</classname> is started. -->
    この例では、<acronym>JVM</acronym>はその初期化段階の一部としてドライバの読み込みを試みます。読み込みが完了したところで、<classname>ImageViewer</classname>が起動します。<indexterm><primary>ImageViewer</primary></indexterm>
   </para>

   <para>
    <!-- Now, this method is the better one to use because it allows your
    code to be used with other database packages without recompiling
    the code. The only thing that would also change is the connection
    <acronym>URL</acronym>, which is covered next. -->
    さて、コードをコンパイルし直すことなく他のデータベースにも使うことができますので、この方法は1番目の方法よりも優れています。唯一の変更点は接続のための<acronym>URL</acronym>だけです。これについては、次節で説明します。
   </para>

   <para>
    <!-- One last thing: When your code then tries to open a
    <classname>Connection</classname>, and you get a <errorname>No
    driver available</errorname> <classname>SQLException</classname>
    being thrown, this is probably caused by the driver not being in
    the class path, or the value in the parameter not being correct. -->
    最後に注意点ですが、コード内で<classname>Connection</classname>を開こうとしたときに、利用できるドライバがない（<errorname>No driver available</errorname>）というSQLの例外（<classname>SQLException</classname>）が送出された場合、たいていはドライバがクラスパスにないこと、もしくはパラメータの値が正しくないことが原因です。
   </para>
  </sect2>

  <sect2 id="jdbc-connect">
   <!-- <title>Connecting to the Database</title> -->
   <title>データベースへの接続</title>
<indexterm><primary>JDBC</primary><secondary sortas="でーべーすへのせつぞく">データベースへの接続</secondary></indexterm>
   <para>
    <!-- With <acronym>JDBC</acronym>, a database is represented by a
    <acronym>URL</acronym> (Uniform Resource Locator).  With
    <application>Postgres</application>, this takes one of the
    following forms: -->
    <acronym>JDBC</acronym>を使用する場合、データベースは<acronym>URL</acronym>（Uniform Resource Locator）で表されます。<application>Postgres</application>では次の形式のどれかになります。
</para>

    <itemizedlist>
     <listitem><emphasis><para>パターン1</para></emphasis>
<synopsis>
jdbc:postgresql:<replaceable class="parameter">database</replaceable>
</synopsis>
     </listitem>

     <listitem><emphasis><para>パターン2</para></emphasis>
<synopsis>
jdbc:postgresql://<replaceable class="parameter">host</replaceable>/<replaceable class="parameter">database</replaceable>
</synopsis>
     </listitem>

     <listitem><emphasis><para>パターン3</para></emphasis>
<synopsis>
jdbc:postgresql://<replaceable class="parameter">host</replaceable>:<replaceable class="parameter">port</replaceable>/<replaceable class="parameter">database</replaceable>
</synopsis>
     </listitem>
    </itemizedlist>

<para>
    <!-- where: -->
    それぞれの意味は以下のとおりです。
</para>

    <variablelist>
     <varlistentry>
      <term>
       <replaceable class="parameter">host</replaceable>
      </term>
      <listitem>
       <para>
        <!-- The host name of the server. Defaults to <literal>localhost</literal>. -->
        サーバーのホスト名。デフォルトは<literal>localhost</literal>です。
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term>
       <replaceable class="parameter">port</replaceable>
      </term>
      <listitem>
       <para>
        <!-- The port number the server is listening on. Defaults to the
        Postgres standard port number (5432). -->
        サーバーが監視しているポート番号。デフォルトはPostgresの標準的なポート番号（5432）です。
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term>
       <replaceable class="parameter">database</replaceable>
      </term>
      <listitem>
       <para>
        <!-- The database name. -->
        データベース名。
       </para>
      </listitem>
     </varlistentry>
    </variablelist>

   <para>
    <!-- To connect, you need to get a <classname>Connection</classname> instance from 
    <acronym>JDBC</acronym>. To do this,
    you would use the <function>DriverManager.getConnection()</function> method: -->
    接続するために、<acronym>JDBC</acronym>から<classname>Connection</classname>のインスタンスを取得します。これには、次のように<function>DriverManager.getConnection()</function>メソッドを使います。
</para>


<programlisting>
Connection db = DriverManager.getConnection(url, username, password);
</programlisting>
  </sect2>

  <sect2 id="jdbc-disconnect">
   <!-- <title>Closing the Connection</title> -->
   <title>接続を閉じる</title>

   <para>
    <!-- To close the database connection, simply call the
    <function>close()</function> method to the <classname>Connection</classname>: -->
    データベースへの接続を閉じるためには、単に<classname>Connection</classname>の<function>close()</function>メソッドを呼びます。<indexterm><primary>JDBC</primary><secondary sortas="Connectionくらす">Connectionクラス</secondary><tertiary sortas="close()めそっど">close()メソッド</tertiary></indexterm>
</para>

<programlisting>
db.close();
</programlisting>
  </sect2>
 </sect1>


  <sect1 id="jdbc-query">
   <!-- <title>Issuing a Query and Processing the Result</title> -->
   <title>問い合わせの発行と結果の処理</title>
<indexterm><primary>JDBC</primary><secondary sortas="といあわせのはっこう">問い合わせの発行</secondary></indexterm>
<indexterm><primary>JDBC</primary><secondary sortas="といあわせけっかのしょり">問い合わせ結果の処理</secondary></indexterm>
   <para>
    <!-- Any time you want to issue <acronym>SQL</acronym> statements to
    the database, you require a <classname>Statement</classname>
    instance. Once you have a <classname>Statement</classname>, you
    can use the <function>executeQuery()</function> method to issue a
    query. This will return a <classname>ResultSet</classname>
    instance, which contains the entire result.  <xref
    linkend="jdbc-query-example"> illustrates this process. -->
    <acronym>SQL</acronym>文をデータベースに発行するときには必ず、<classname>Statement</classname>のインスタンスが必要です。<classname>Statement</classname>のインスタンスがあれば、<classname>Statement</classname>のメソッドを使って問い合わせを発行できます。このメソッドは、結果全体を保持する<classname>ResultSet</classname>のインスタンスを返します。次に示す<xref linkend="jdbc-query-example">は、このプロセスを示します。

   </para>

   <example id="jdbc-query-example">
    <!-- <title>Processing a Simple Query in <acronym>JDCB</acronym></title> -->
    <title><acronym>JDCB</acronym>で簡単な問い合わせを処理</title>

    <para>
     <!-- This example with issue a simple query and print out the first
     column of each row. -->
     この例は、簡単な問い合わせで、各行の最初のカラムを表示します。
</para>

<programlisting >
Statement st = db.createStatement();
ResultSet rs = st.executeQuery("SELECT * FROM mytable");
while(rs.next()) {
    System.out.print("Column 1 returned ");
    System.out.println(rs.getString(1));
}
rs.close();
st.close();
</programlisting>
   </example>

   <sect2>
    <!-- <title>Using the <classname>Statement</classname> Interface</title> -->
    <title><classname>Statement</classname>インターフェイスの使用</title>
<indexterm><primary>JDBC</primary><secondary sortas="Statementいんたーふぇいす">Statementインターフェイス</secondary></indexterm>
    <para>
     <!-- The following must be considered when using the
     <classname>Statement</classname> interface: -->
     <classname>Statement</classname>インターフェイスを使用する際は、以下のことを考慮しなければいけません。
</para>

     <itemizedlist>
      <listitem>
       <para>
        <!-- You can use a single <classname>Statement</classname> instance
        as many times as you want. You could create one as soon as you
        open the connection and use it for the connection's
        lifetime. But you have to remember that only one
        <classname>ResultSet</classname> can exist per
        <classname>Statement</classname>. -->
        必要なときには何回でも1つの<classname>Statement</classname>のインスタンスを使用できます。接続を開いたらすぐにこのインスタンスを作成でき、この接続が有効な期間内で使用することができます。しかし、1つの<classname>Statement</classname>には1つの<classname>ResultSet</classname>しかあり得ないことを覚えておかなければいけません。
       </para>
      </listitem>

      <listitem>
       <para>
        <!-- If you need to perform a query while processing a
        <classname>ResultSet</classname>, you can simply create and
        use another <classname>Statement</classname>. -->
        <classname>ResultSet</classname>の処理中に問い合わせを実行する必要があれば、単純に別の<classname>Statement</classname>を作成して、それを使用してください。
       </para>
      </listitem>

      <listitem>
       <para>
        <!-- If you are using threads, and several are using the database,
        you must use a separate <classname>Statement</classname> for
        each thread. Refer to <xref linkend="jdbc-thread"> if you are
        thinking of using threads, as it covers some important points. -->
        スレッドを使用し、複数スレッドがデータベースを使用する場合、各スレッドに<classname>Statement</classname>インスタンスを分けて使わなければいけません。スレッドの使用を考えているのなら、<xref linkend="jdbc-thread">を参照してください。いくつか重要な点が記載されています。
       </para>
      </listitem>
     </itemizedlist>
   </sect2>

   <sect2>
    <!-- <title>Using the <classname>ResultSet</classname> Interface</title> -->
    <title><classname>ResultSet</classname>インターフェイスの使用</title>
<indexterm><primary>JDBC</primary><secondary sortas="ResultSetいんたーふぇいす">ResultSetインターフェイス</secondary></indexterm>
    <para>
     <!-- The following must be considered when using the
     <classname>ResultSet</classname> interface: -->
     <classname>ResultSet</classname>インターフェイスを使用する際、以下のことを考慮しなければいけません。
</para>

     <itemizedlist>
      <listitem>
       <para>
        <!-- Before reading any values, you must call
        <function>next()</function>. This returns true if there is a
        result, but more importantly, it prepares the row for
        processing. -->
        値を読む前に必ず、<function>next()</function>を呼び出してください。結果があれば真を返します。しかし重要なことは、これにより処理のための行が準備されるということです。
       </para>
      </listitem>

      <listitem>
       <para>
        <!-- Under the <acronym>JDBC</acronym> specification, you should
        access a field only once. It is safest to stick to this rule,
        although at the current time, the
        <productname>Postgres</productname> driver will allow you to
        access a field as many times as you want. -->
        <acronym>JDBC</acronym>の仕様では、1回しかフィールドにアクセスできません。この規則を厳守することは最も安全なのですが、現時点での<productname>Postgres</productname>のドライバでは、必要ならば何回でもフィールドにアクセスすることができます。
       </para>
      </listitem>

      <listitem>
       <para>
        <!-- You must close a <classname>ResultSet</classname> by calling
        <function>close()</function> once you have finished using it. -->
        <classname>ResultSet</classname>に対する処理が完了したら、<function>close()</function>を呼び出して<classname>ResultSet</classname>を閉じなければいけません。
       </para>
      </listitem>

      <listitem>
       <para>
        <!-- Once you make another query with the
        <classname>Statement</classname> used to create a
        <classname>ResultSet</classname>, the currently open
        <classname>ResultSet</classname> instance is closed
        automatically. -->
        <classname>ResultSet</classname>を作成するときに使用していた<classname>Statement</classname>に別の問い合わせを作ると、その時点で開いていた<classname>ResultSet</classname>インスタンスは自動的に閉じられます。
       </para>
      </listitem>
     </itemizedlist>
   </sect2>
  </sect1>

  <sect1 id="jdbc-update">
   <!-- <title>Performing Updates</title> -->
   <title>更新処理</title>
<indexterm><primary>JDBC</primary><secondary sortas="こうしんしょり">更新処理</secondary></indexterm>
   <para>
    <!-- To perform an update (or any other <acronym>SQL</acronym>
    statement that does not return a result), you simply use the
    <function>executeUpdate()</function> method: -->
    更新（または、その他の結果を返さない<acronym>SQL</acronym>文）を実行するには、単に<function>executeUpdate()</function>メソッドを使用します。<indexterm><primary>JDBC</primary><secondary sortas="executeUpdate()めそっど">executeUpdate()メソッド</secondary></indexterm>
</para>

<programlisting>
st.executeUpdate("CREATE TABLE basic (a int, b int)");
</programlisting>
  </sect1>

 <sect1 id="jdbc-lo">
  <!-- <title>Using Large Objects</title> -->
  <title>ラージオブジェクトの使用</title>
<indexterm><primary>JDBC</primary><secondary sortas="らーじおぶじぇくとのしよう">ラージオブジェクトの使用</secondary></indexterm><indexterm><primary sortas="らーじおぶじぇくと">ラージオブジェクト</primary><secondary>JDBC</secondary></indexterm>
  <para>
   <!-- In <application>Postgres</application>, <firstterm>Large
   Objects</firstterm> (also known as <acronym>BLOB</acronym>s) are
   used to hold data in the database that cannot be stored in a normal
   SQL table. They are stored in a separate table in a special format,
   and are referred to from your own tables by an OID value. -->
   <application>Postgres</application>では、ラージオブジェクト（<acronym>BLOB</acronym>としても知られます）が、普通のSQLテーブルでは保存できないデータをデータベースに保存するために使われます。これらは特別なフォーマットでテーブルとは別に格納されて、テーブルからはOID値で参照されます。
  </para>

  <important>
   <para>
    <!-- For <productname>Postgres</productname>, you must access Large
    Objects within an <acronym>SQL</acronym> transaction.  You would
    open a transaction by using the
    <function>setAutoCommit()</function> method with an input
    parameter of <literal>false</literal>: -->
    <productname>Postgres</productname>では、ラージオブジェクトにアクセスするには<acronym>SQL</acronym>のトランザクション内であることが必要です。パラメータをfalseとして<function>setAutoCommit()</function>を使うことで、トランザクションを開きます。<indexterm><primary>JDBC</primary><secondary sortas="setAutoCommit()めそっど">setAutoCommit()メソッド</secondary></indexterm>
</para>

<programlisting>
Connection mycon;
...
mycon.setAutoCommit(false);
... // now use Large Objects
</programlisting>
  </important>


   <para>
    <!-- There are two methods of using Large Objects. The first is the
    standard <acronym>JDBC</acronym> way, and is documented here. The
    other, uses <productname>PostgreSQL</productname> extensions to
    the <acronym>API</acronym>, which presents the libpq large object
    <acronym>API</acronym> to Java, providing even better access to
    large objects than the standard. Internally, the driver uses the
    extension to provide large object support. -->
    ラージオブジェクトを使うには2つの方法があります。1番目は、標準<acronym>JDBC</acronym>による方法で、ここに記載します。もう1つの方法はこのドライバ独自のAPIを拡張したものを使用します。これはlibpqでのラージオブジェクト<acronym>API</acronym>をJavaで表現したもので、標準のものよりもより優れたラージオブジェクトへのアクセス手段を提供します。ドライバの内部では、この拡張を使用してラージオブジェクトのサポートを提供しています。
   </para>

   <para>
    <!-- In <acronym>JDBC</acronym>, the standard way to access Large
    Objects is using the <function>getBinaryStream()</function> method
    in <classname>ResultSet</classname>, and
    <function>setBinaryStream()</function> method in
    <classname>PreparedStatement</classname>. These methods make the
    large object appear as a Java stream, allowing you to use the
    <literal>java.io</literal> package, and others, to manipulate the
    object.  <xref linkend="jdbc-lo-example"> illustrates the usage of
    this approach. -->
    <acronym>JDBC</acronym>でのラージオブジェクトにアクセスする標準的な方法は、<classname>ResultSet</classname>の<function>getBinaryStream()</function>メソッドと<classname>PreparedStatement</classname>の<function>setBinaryStream()</function>メソッドを使用することです。これらのメソッドはラージオブジェクトをJavaのストリームとして表現しますので、<literal>java.io</literal>パッケージなどを使用してラージオブジェクトを扱うことができるようになります。次の<xref linkend="jdbc-lo-example">は、この使用方法を示します。<indexterm><primary>JDBC</primary><secondary sortas="ResultSetクラス">ResultSetクラス</secondary><tertiary sortas="getBinaryStream()めそっど">getBinaryStream()メソッド</tertiary></indexterm><indexterm><primary>JDBC</primary><secondary sortas="PreparedStatementくらす">PreparedStatementクラス</secondary><tertiary sortas="setBinaryStream()めそっど">setBinaryStream()メソッド</tertiary></indexterm>
   </para>

  <example id="jdbc-lo-example">
   <!-- <title>Using the <acronym>JDBC</acronym> Large Object Interface</title> -->
   <title><acronym>JDBC</acronym>のラージオブジェクトインターフェイスの使用</title>

   <para>
    <!-- For example, suppose you have a table containing the file name of
    an image and you have a large object containing that image: -->
    たとえば、次のように画像のファイル名と画像用のラージオブジェクトで構成されているテーブルがあるとします。
</para>

<programlisting>
CREATE TABLE images (imgname text, imgoid oid);
</programlisting>

   <para>
    <!-- To insert an image, you would use: -->
    画像を挿入する場合、次のようにします。
</para>

<programlisting>
File file = new File("myimage.gif");
FileInputStream fis = new FileInputStream(file);
PreparedStatement ps = conn.prepareStatement("INSERT INTO images VALUES (?, ?)"); <co id="co.jdbc-qmark">
ps.setString(1, file.getName());
ps.setBinaryStream(2, fis, file.length());
ps.executeUpdate();
ps.close();
fis.close();
</programlisting>
    <calloutlist>
     <callout arearefs="co.jdbc-qmark">
      <para>
       <!-- The question marks must appear literally.  The actual data is
       substituted by the next lines. -->
       「?」記号は、次の行によって実際のデータに置換されます。
      </para>
     </callout>
    </calloutlist>

<para>
    <!-- Here, <function>setBinaryStream</function> transfers a set number
    of bytes from a stream into a Large Object, and stores the OID
    into the field holding a reference to it.  Notice that the
    creation of the Large Object itself in the database happens
    transparently. -->
    ここで、<function>setBinaryStream</function>はストリーム経由でラージオブジェクトに設定されたバイト数を転送し、その参照を保持するフィールドにOIDを保存します。データベースでラージオブジェクトの作成が透過的に成されることを知ってください。
   </para>

   <para>
    <!-- Retrieving an image is even easier.  (We use
    <classname>PreparedStatement</classname> here, but the
    <classname>Statement</classname> class can equally be used.) -->
    画像を取り出すことはもっと簡単です（ここでは<classname>PreparedStatement</classname>を使っていますが、<classname>Statement</classname>でも同様に使うことができます） 。
   </para>

<programlisting>
PreparedStatement ps = con.prepareStatement("SELECT imgoid FROM images WHERE imgname=?");
ps.setString(1, "myimage.gif");
ResultSet rs = ps.executeQuery();
if (rs != null) {
    while(rs.next()) {
        InputStream is = rs.getBinaryStream(1);
        // use the stream in some way here
        is.close();
    }
    rs.close();
}
ps.close();
</programlisting>

   <para>
    （注）PostgreSQL 7.1.XのJDBCドライバではバグがあり、このコードでは正常にラージオブジェクトを読み出すことはできないことがあります。
   </para>

   <para>
    <!-- Here you can see how the Large Object is retrieved as an
    <classname>InputStream</classname>.  You will also notice that we
    close the stream before processing the next row in the
    result. This is part of the <acronym>JDBC</acronym> specification,
    which states that any <classname>InputStream</classname> returned
    is closed when <function>ResultSet.next()</function> or
    <function>ResultSet.close()</function> is called. -->
    ここでは、ラージオブジェクトが<classname>InputStream</classname>として取り出されていることがわかるでしょう。結果の次の行を処理する前に、このストリームを閉じていることにも注意してください。これは、<function>ResultSet.next()</function>または<function>ResultSet.close()</function>が呼び出されるときにすべての<classname>InputStream</classname>から返される状態は閉ざされるという<acronym>JDBC</acronym>仕様の一部です。<indexterm><primary>JDBC</primary><secondary sortas="InputStreamくらす">InputStreamクラス</secondary></indexterm>
   </para>
  </example>
 </sect1>


 <sect1 id="jdbc-ext">
  <!-- <title><application>PostgreSQL</application> Extensions to the
    <acronym>JDBC</acronym> <acronym>API</acronym></title> -->
  <title><application>PostgreSQL</application>の<acronym>JDBC</acronym> <acronym>API</acronym>への拡張</title>
<indexterm><primary>JDBC</primary><secondary>API</secondary></indexterm>
  <para>
   <!-- <productname>Postgres</productname> is an extensible database
   system.  You can add your own functions to the backend, which can
   then be called from queries, or even add your own data types.  As
   these are facilities unique to <productname>Postgres</productname>,
   we support them from Java, with a set of extension
   <acronym>API</acronym>'s. Some features within the core of the
   standard driver actually use these extensions to implement Large
   Objects, etc. -->
   <productname>Postgres</productname>は拡張可能なデータベースシステムです。クエリから呼び出すことができる、独自の関数をバックエンドに追加することができます。独自の型さえも追加することができます。こういった独特な機構がありますので、Javaでもこれを<acronym>API</acronym>の拡張セットを用意してサポートします。実際、標準ドライバの中核でも、ラージオブジェクトなどの実装のためにこの拡張を使用しています。
  </para>

  <sect2>
   <!-- <title>Accessing the Extensions</title> -->
   <title>拡張機能へのアクセス</title>
<indexterm><primary>JDBC</primary><secondary sortas="かくちょうきのう">拡張機能</secondary></indexterm>
   <para>
    <!-- To access some of the extensions, you need to use some extra
    methods in the <classname>org.postgresql.Connection</classname>
    class. In this case, you would need to case the return value of
    <function>Driver.getConnection()</function>.  For example: -->
    いくつかの拡張APIにアクセスするには、<classname>org.postgresql.Connection</classname>クラスの追加メソッドのいくつかを使用しなければいけません。この場合、<function>Driver.getConnection()</function>からの戻り値をキャストしなければいけません。たとえば、以下のようにします。
</para>

<programlisting>
Connection db = Driver.getConnection(url, username, password);
// ...
// later on
Fastpath fp = ((org.postgresql.Connection)db).getFastpathAPI();
</programlisting>

   <sect3>
    <!-- <title>Class <classname>org.postgresql.Connection</classname></title> -->
    <title><classname>org.postgresql.Connection</classname>クラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Connectionくらす">org.postgresql.Connectionクラス</secondary></indexterm>
<synopsis>
public class Connection extends Object implements Connection

java.lang.Object
   |
   +----org.postgresql.Connection
</synopsis>

    <para>
     <!-- These are the extra methods used to gain access to
     <productname>PostgreSQL</productname>'s extensions. Methods
     defined by <classname>java.sql.Connection</classname> are not
     listed. -->
     ここには、拡張APIにアクセスするために使用される追加メソッドがあります。<classname>java.sql.Connection</classname>で定義されたメソッドは示しません。
    </para>

    <sect4>
     <!-- <title>Methods</title> -->
     <title>メソッド</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>Fastpath</para></emphasis>
<synopsis>
public Fastpath getFastpathAPI() throws SQLException
</synopsis>
       <para>
        <!-- This returns the Fastpath <acronym>API</acronym> for the
        current connection.  It is primarily used by the Large Object
        <acronym>API</acronym>. -->
        現在の接続用のFastpath <acronym>API</acronym>を返します。主にLargeObject <acronym>API</acronym>で使用されます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Connectionくらす">org.postgresql.Connectionクラス</secondary><tertiary sortas="getFastpathAPI()めそっど">getFastpathAPI()メソッド</tertiary></indexterm>

       </para>

       <para>
        <!-- The best way to use this is as follows: -->
        この関数を使用する最善の方法は次のようなものです。
</para>

<programlisting>
import org.postgresql.fastpath.*;
...
Fastpath fp = ((org.postgresql.Connection)myconn).getFastpathAPI();
</programlisting>

<para>
        <!-- where myconn is an open Connection to <productname>PostgreSQL</productname>. -->
        ここで、myconnは開いている<productname>PostgreSQL</productname>へのConnectionオブジェクトです。
       </para>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <para>
         <!-- Fastpath object allowing access to functions on the
         <productname>PostgreSQL</productname> backend. -->
         <productname>PostgreSQL</productname>バックエンドにある関数へのアクセスを可能にするFastpathオブジェクト。
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Throws:</title> -->
        <title>例外</title>
        <para>
         <!-- SQLException by Fastpath when initializing for first time -->
         SQLExceptionがFastpathの初回の初期化時に投げられる可能性があります
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>LargeObjectManager</para></emphasis>
<synopsis>
public LargeObjectManager getLargeObjectAPI() throws SQLException
</synopsis>

<para>
        <!-- This returns the Large Object <acronym>API</acronym> for the
        current connection. -->
        現在の接続用のラージオブジェクト<acronym>API</acronym>を返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Connectionくらす">org.postgresql.Connectionクラス</secondary><tertiary sortas="getLargeObjectAPI()めそっど">getLargeObjectAPI()メソッド</tertiary></indexterm>
       </para>

       <para>
        <!-- The best way to use this is as follows: -->
        この関数を使用する最善の方法は次のようなものです。
</para>

<programlisting>
import org.postgresql.largeobject.*;
...
LargeObjectManager lo = ((org.postgresql.Connection)myconn).getLargeObjectAPI();
</programlisting>

<para>
        <!-- where myconn is an open Connection to
        <productname>PostgreSQL</productname>. -->
        ここで、myconnは開いている<productname>PostgreSQL</productname>へのConnectionオブジェクトです。
       </para>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <para>
         <!-- LargeObject object that implements the <acronym>API</acronym> -->
         <acronym>API</acronym>を実装したLargeObjectオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Throws:</title> -->
        <title>例外</title>
        <para>
         <!-- SQLException by LargeObject when initializing for first time -->
         SQLExceptionがLargeObjectの初回の初期化時に投げられる可能性があります
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>addDataType</para></emphasis>
<synopsis>
public void addDataType(String type, String name)
</synopsis>

       <para>
        <!-- This allows client code to add a handler for one of
        PostgreSQL's more unique data types. Normally, a data type not
        known by the driver is returned by ResultSet.getObject() as a
        PGobject instance.  This method allows you to write a class
        that extends PGobject, and tell the driver the type name, and
        class name to use. The down side to this, is that you must
        call this method each time a connection is made. -->
        これによってクライアントのコードが、多くのPostgreSQL独特のデータ型のためのハンドラを追加することができます。通常、ドライバで認識されないデータ型は、PGobjectのインスタンスとしてResultSet.getObject()から返されます。このメソッドを使って、PGobjectを拡張したクラスを書くことや、ドライバに型名と使用するクラス名を通知することができます。欠点は、接続を確立するたびにこのメソッドを呼び出さなければならないことです。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Connectionくらす">org.postgresql.Connectionクラス</secondary><tertiary sortas="addDataType()めそっど">addDataType()メソッド</tertiary></indexterm>
       </para>

       <para>
        <!-- The best way to use this is as follows: -->
        この関数を使用する最善の方法は次のようなものです。
</para>

<programlisting>
 ...
((org.postgresql.Connection)myconn).addDataType("mytype","my.class.name");
 ...
</programlisting>

<para>
        <!-- where myconn is an open Connection to
        <productname>PostgreSQL</productname>.  The handling class must
        extend <classname>org.postgresql.util.PGobject</classname>. -->
        ここで、myconnは開いている<productname>PostgreSQL</productname>へのConnectionオブジェクトです。取り扱うクラスは<classname>org.postgresql.util.PGobject</classname>を継承する必要があります。
       </para>
      </listitem>
     </itemizedlist>
    </sect4>
   </sect3>


   <sect3>
    <!-- <title>Class <classname>org.postgresql.Fastpath</classname></title> -->
    <title><classname>org.postgresql.Fastpath</classname>クラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.fastpath.Fastpath
</programlisting>

<synopsis>
public class Fastpath extends Object
</synopsis>

    <para>
     <!-- <classname>Fastpath</classname> is an <acronym>API</acronym> that
     exists within the libpq C interface, and allows a client machine
     to execute a function on the database backend.  Most client code
     will not need to use this method, but it is provided because the
     Large Object <acronym>API</acronym> uses it. -->
     <classname>Fastpath</classname>はlibpq Cインターフェイス内に存在する<acronym>API</acronym>で、これによってクライアントマシンはデータベースバックエンドにある関数を実行することができます。ほとんどのクライアントコードでは、このメソッドを使用する必要がありません。しかし、ラージオブジェクト<acronym>API</acronym>で使用するために用意されています。
    </para>

    <para>
     <!-- To use, you need to import the
     <classname>org.postgresql.fastpath</classname> package, using the
     line: -->
     使用するためには、次のようにして<classname>org.postgresql.fastpath</classname>パッケージをインポートしなければいけません。
</para>

<programlisting>
import org.postgresql.fastpath.*;
</programlisting>

<para>
     <!-- Then, in your code, you need to get a
     <classname>FastPath</classname> object: -->
     そして、<classname>FastPath</classname>オブジェクトを入手したいときに次のコードを書きます。
</para>

<programlisting>
Fastpath fp = ((org.postgresql.Connection)conn).getFastpathAPI();
</programlisting>

<para>
     <!-- This will return an instance associated with the database
     connection that you can use to issue commands. The casing of
     <classname>Connection</classname> to
     <classname>org.postgresql.Connection</classname> is required, as
     the <function>getFastpathAPI()</function> is an extension method,
     not part of <acronym>JDBC</acronym>.  Once you have a
     <classname>Fastpath</classname> instance, you can use the
     <function>fastpath()</function> methods to execute a backend
     function. -->
     これはデータベース接続に関連付けられた、コマンドを発行する際に使用するインスタンスを返します。<function>getFastpathAPI()</function>は<acronym>JDBC</acronym>の標準メソッドではないので、<classname>Connection</classname>オブジェクトを<classname>org.postgresql.Connection</classname>オブジェクトにキャストする必要があります。<classname>Fastpath</classname>インスタンスを所有すれば、<function>fastpath()</function>メソッドを使用してバックエンドの関数を実行することができます。
    </para>

    <formalpara>
     <!-- <title>See Also:</title> -->
     <title>参照</title>
     <para>
      <classname>FastpathFastpathArg</classname>, <classname>LargeObject</classname>
     </para>
    </formalpara>

    <sect4>
     <!-- <title>Methods</title> -->
     <title>メソッド</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>fastpath</para></emphasis>
<synopsis>
public Object fastpath(int fnid,
                       boolean resulttype,
                       FastpathArg args[]) throws SQLException
</synopsis>
       <para>
        <!-- Send a function call to the PostgreSQL backend. -->
        関数呼び出しをPostgreSQLバックエンドに送ります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="fastpath()めそっど">fastpath()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
          <itemizedlist>
                <!-- fnid - Function id
                resulttype - True if the result is an integer, false 
for
                other results
                args――FastpathArguments to pass to fastpath -->
            <listitem><para>fnid――関数ID</para></listitem>
            <listitem><para>resulttype――結果が整数ならば真、その他の場合は偽</para></listitem>
            <listitem><para>args――fastpathに渡すFastpathArguments</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <para>
         <!-- null if no data, Integer if an integer result, or byte[]
         otherwise -->
         データがない場合はnull、整数の結果ならばInteger型、さもなくばbyte[]
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>fastpath</para></emphasis>
<synopsis>
public Object fastpath(String name,
                       boolean resulttype,
                       FastpathArg args[]) throws SQLException
</synopsis>
       <para>
        <!-- Send a function call to the PostgreSQL backend by name. -->
        名前によってPostgreSQLバックエンドに関数呼び出しを送ります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="fastpath()めそっど">fastpath()メソッド</tertiary></indexterm>
       </para>

       <note>
        <para>
         <!-- The mapping for the procedure name to function id needs to
         exist, usually to an earlier call to addfunction(). This is
         the preferred method to call, as function id's can/may change
         between versions of the backend. For an example of how this
         works, refer to org.postgresql.LargeObject -->
         通常は事前にaddfunction()を呼び出して、プロシージャ名を関数IDに割り当てておく必要があります。関数IDはバックエンドのバージョンによって異なりますので、このメソッドの呼び出しは推奨されています。このメソッドの使用例についてはorg.postgresql.LargeObjectを参照してください。
        </para>
       </note>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
          <itemizedlist>
                <!-- name - Function name
                resulttype - True if the result is an integer, false 
for
                other results
                args――FastpathArguments to pass to fastpath -->
            <listitem><para>name――関数名</para></listitem>
            <listitem><para>resulttype――結果が整数ならば真、さもなくば偽</para></listitem>
            <listitem><para>args――fastpathに渡すFastpathArgumentsオブジェクト</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <para>
         <!-- null if no data, Integer if an integer result, or byte[]
         otherwise -->
         データがなければnull、整数の結果であればInteger型、さもなくばbyte[]
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>See Also:</title> -->
        <title>参照</title>
        <para><classname>LargeObject</classname></para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getInteger</para></emphasis>
<synopsis>
public int getInteger(String name,
                      FastpathArg args[]) throws SQLException
</synopsis>
       <para>
        <!-- This convenience method assumes that the return value is an Integer -->
        この簡易メソッドは結果の値が整数であることを仮定しています。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="getInteger()めそっど">getInteger()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
          <itemizedlist>
                <!-- name - Function name
                args - Function arguments -->
            <listitem><para>name――関数名</para></listitem>
            <listitem><para>args――関数への引数</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <!-- <para>integer result</para> -->
        <para>整数の結果</para>
       </formalpara>

       <formalpara>
        <!-- <title>Throws:</title> -->
        <title>例外</title>
        <para>
         <!-- SQLException if a database-access error occurs or no result -->
         SQLException――データベースアクセスエラーが発生した場合、または、結果がない場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getData</para></emphasis>
<synopsis>
public byte[] getData(String name,
                      FastpathArg args[]) throws SQLException
</synopsis>
       <para>
        <!-- This convenience method assumes that the return value is binary
        data. -->
        この簡易メソッドは結果の値がバイナリデータであると仮定しています。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="getData()めそっど">getData()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
          <itemizedlist>

                <!-- name - Function name
                args - Function arguments -->
            <listitem><para>name――関数名</para></listitem>
            <listitem><para>args――関数への引数</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <!-- <title>Returns:</title> -->
        <title>戻り値</title>
        <!-- <para>byte[] array containing result</para> -->
        <para>結果を持つbyte[]配列</para>
       </formalpara>

       <formalpara>
        <!-- <title>Throws:</title> -->
        <title>例外</title>
        <para>
         <!-- SQLException if a database-access error occurs or no result -->
         SQLException――データベースアクセスエラーが発生した場合、または、結果がない場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>addFunction</para></emphasis>
<synopsis>
public void addFunction(String name,
                        int fnid)
</synopsis>
       <para>
        <!-- This adds a function to our look-up table.  User code should
        use the <function>addFunctions</function> method, which is based upon a query,
        rather than hard coding the oid. The oid for a function is not
        guaranteed to remain static, even on different servers of the
        same version. -->
        これは関数を検索テーブルに追加します。ユーザーコードは<function>addFunctions</function>メソッドを使用しなければいけません。このメソッドはoidを直接記述しておらず問い合わせに基づいたものです。関数のoidは静的のままであることは保証されていませんし、同一のバージョンのサーバー間でさえも異なります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="addFunction()めそっど">addFunction()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>addFunctions</para></emphasis>
<synopsis>
public void addFunctions(ResultSet rs) throws SQLException
</synopsis>
       <para>
        <!-- This takes a <classname>ResultSet</classname> containing two columns. Column 1
        contains the function name, Column 2 the oid.  It reads the
        entire <classname>ResultSet</classname>, loading the values into the function table. -->
        このメソッドは2つのカラムを持つ<classname>ResultSet</classname>を引数としてとります。カラム1は関数名、カラム2はoidを持ちます。<classname>ResultSet</classname>全体を読み取り、その値を関数テーブル中に読み込みます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="addFunctions()めそっど">addFunctions()メソッド</tertiary></indexterm>
       </para>

       <important>
        <para>
         <!-- Remember to <function>close()</function> the
         <classname>ResultSet</classname> after calling this! -->
         このメソッドを呼び出した後に<classname>ResultSet</classname>を<function>close()</function>することを忘れないでください。
        </para>
       </important>

       <note>
        <!-- <title>Implementation note about function name look-ups</title> -->
        <title>関数名の検索に関する実装時の注意書き</title>
<indexterm><primary>JDBC</primary><secondary sortas="かんすうめいのけんさく">関数名の検索</secondary></indexterm>
        <para>
         <!-- PostgreSQL stores the function id's and their corresponding
         names in the pg_proc table. To speed things up locally,
         instead of querying each function from that table when
         required, a <classname>Hashtable</classname> is used. Also, only the function's
         required are entered into this table, keeping connection
         times as fast as possible. -->
         PostgreSQLは関数IDとIDに対応する名前をpg_procテーブルに保存します。ローカルに処理速度を上げるために、要求に応じてこのテーブルに関数を問い合わせるのではなく<classname>Hashtable</classname>が使用されています。また、関数の必須項目のみがこのテーブルに登録されていますので、接続を維持しておくことでできるだけ処理速度を向上させます。
        </para>

        <para>
         <!-- The <classname>org.postgresql.LargeObject</classname> class
         performs a query upon its start-up, and passes the returned
         <classname>ResultSet</classname> to the
         <function>addFunctions()</function> method here.  Once this
         has been done, the Large Object <acronym>API</acronym> refers
         to the functions by name. -->
         <classname>org.postgresql.LargeObject</classname>クラスは、その起動時に問い合わせを行い、この段階で返された<classname>ResultSet</classname>を<function>addFunctions()</function>メソッドに渡します。これを行った後、LargeObject <acronym>API</acronym>はその関数を名前で参照します。
        </para>

        <para>
         <!-- Do not think that manually converting them to the oid's will
         work. Okay, they will for now, but they can change during
         development (there was some discussion about this for V7.0),
         so this is implemented to prevent any unwarranted headaches
         in the future. -->
         手作業によるoidへの変換ができるとは考えないでください。ただし、これらは現時点のものです。開発を通して変更されます（V7.0でもこの問題について議論が何回かありました）。ですから、これは将来の不当な問題を防ぐために実装されています。</para>
       </note>

       <formalpara>
        <!-- <title>See Also:</title> -->
        <title>参照</title>
        <para>
         <classname>LargeObjectManager</classname>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getID</para></emphasis>
<synopsis>
public int getID(String name) throws SQLException
</synopsis>
       <para>
        <!-- This returns the function id associated by its name If
        addFunction() or addFunctions() have not been called for this
        name, then an SQLException is thrown. -->
        このメソッドは名前に関連付けられた関数IDを返します。addFunction()またはaddFunctions()がこの名前を使って呼び出されていなければ、SQLExceptionが投げられます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.Fastpathくらす">org.postgresql.Fastpathクラス</secondary><tertiary sortas="getID()めそっど">getID()メソッド</tertiary></indexterm>
       </para>
      </listitem>
     </itemizedlist>
    </sect4>
   </sect3>


   <sect3>
    <!-- <title>Class <classname>org.postgresql.fastpath.FastpathArg</classname></title> -->
    <title><classname>org.postgresql.fastpath.FastpathArg</classname>クラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.fastpath.FastpathArgくらす">クラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.fastpath.FastpathArg
</programlisting>

<synopsis>
public class FastpathArg extends Object
</synopsis>


    <para>
     <!-- Each fastpath call requires an array of arguments, the number and
     type dependent on the function being called.  This class
     implements methods needed to provide this capability. -->
     各fastpath呼び出しは引数の配列、引数の数、呼び出される関数に依存する型を必要とします。このクラスはこの能力を提供するために必要なメソッドを実装します。
    </para>

    <para>
     <!-- For an example on how to use this, refer to the
     <classname>org.postgresql.LargeObject</classname> package. -->
     このクラスの使用例については、<classname>org.postgresql.LargeObject</classname>パッケージを参照してください。
    </para>

    <formalpara>
     <!-- <title>See Also:</title> -->
     <title>参照</title>
     <para>
      <classname>Fastpath</classname>、<classname>LargeObjectManager</classname>、<classname>LargeObject</classname>
     </para>
    </formalpara>

    <sect4>
     <!-- <title>Constructors</title> -->
     <title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.fastpath.FastpathArgくらす">org.postgresql.fastpath.FastpathArgクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
     <itemizedlist>
      <listitem>
      <emphasis><para>FastpathArg</para></emphasis>
<synopsis>
public FastpathArg(int value)
</synopsis>
       <para>
        <!-- Constructs an argument that consists of an integer value -->
        整数値の引数で構築します。
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
         <!-- value - int value to set -->
            value――設定する整数値
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>FastpathArg</para></emphasis>
<synopsis>
public FastpathArg(byte bytes[])
</synopsis>
       <para>
        <!-- Constructs an argument that consists of an array of bytes -->
        byte型配列の引数で構築します。
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
         <!-- bytes - array to store -->
            bytes――保存する配列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>FastpathArg</para></emphasis>
<synopsis>
public FastpathArg(byte buf[],
                   int off,
                   int len)
</synopsis>
       <para>
        <!-- Constructs an argument that consists of part of a byte array -->
        byte型配列の一部の引数で構築します。
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>buf――元となる配列</para></listitem>
            <!-- <simpara>source array</simpara> -->

            <listitem><para>off――配列内のオフセット</para></listitem>
            <!-- <simpara>offset within array</simpara> -->

            <listitem><para>len――含めるべきデータ長</para></listitem>
            <!-- <simpara>length of data to include</simpara> -->
         </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>FastpathArg</para></emphasis>
<synopsis>
public FastpathArg(String s)
</synopsis>
       <para>
        <!-- Constructs an argument that consists of a String. -->
        文字列の引数で構築します。
       </para>
      </listitem>
     </itemizedlist>
    </sect4>
   </sect3>
  </sect2>


  <sect2>
   <!-- <title>Geometric Data Types</title> -->
   <title>幾何データ型</title>

   <para>
    <!-- <productname>PostgreSQL</productname> has a set of data types that
    can store geometric features into a table. These include single
    points, lines, and polygons.  We support these types in Java with
    the org.postgresql.geometric package.  It contains classes that
    extend the org.postgresql.util.PGobject class.  Refer to that
    class for details on how to implement your own data type handlers. -->
    <productname>PostgreSQL</productname>は、幾何的な特徴をテーブルに保存できるデータ型の集合を持ちます。これらは1つの点、線、多角形を扱います。Javaではorg.postgresql.geometricパッケージを使用してこれらの型をサポートします。ここにはorg.postgresql.util.PGobjectクラスを継承したクラスがあります。どのように独自のデータ型ハンドラを実装するのかについての詳細はこのクラスを参照してください。
   </para>

   <sect3>
<!-- Class org.postgresql.geometric.PGbox -->
<title>org.postgresql.geometric.PGboxクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGbox
</programlisting>

<synopsis>
public class PGbox extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!-- This represents the box data type within <productname>PostgreSQL</productname>. -->
<para>
   このクラスは<productname>PostgreSQL</productname>におけるboxデータ型を表します。
</para>

<sect4>
<!-- Variables -->
<title>変数</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary><tertiary sortas="pointへんすう">point変数</tertiary></indexterm>
<synopsis>
public PGpoint point[]
</synopsis>
<!--      These are the two corner points of the box. -->
<para>
          ボックスの角を示す2つの点があります。
</para>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGbox</para></emphasis>
<synopsis>
public PGbox(double x1,
             double y1,
             double x2,
             double y2)
</synopsis>
<!--
        Parameters:
                x1 - first x coordinate
                y1 - first y coordinate
                x2 - second x coordinate
                y2 - second y coordinate
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x1――1番目のx座標</para></listitem>
            <listitem><para>y1――1番目のy座標</para></listitem>
            <listitem><para>x2――2番目のx座標</para></listitem>
            <listitem><para>y2――2番目のy座標</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGbox</para></emphasis>
<synopsis>
public PGbox(PGpoint p1,
             PGpoint p2)
</synopsis>
<!--
        Parameters:
                p1 - first point
                p2 - second point
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>p1――1番目の点</para></listitem>
            <listitem><para>p2――2番目の点</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGbox</para></emphasis>
<synopsis>
public PGbox(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Box definition in PostgreSQL syntax

        Throws: SQLException
                if definition is invalid
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQL構文によるボックス定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――定義が無効であった場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGbox</para></emphasis>
<synopsis>
public PGbox()
</synopsis>
<!--
          Required constructor
-->
<para>          必須のコンストラクタ</para>
      </listitem>
     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>

    <itemizedlist>

      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String value) throws SQLException
</synopsis>
<!--
          This method sets the value of this object. It should be 
overridden, but still called by subclasses.

        Parameters:
                value - a string representation of the value of the 
object
        Throws: SQLException
                thrown if value is invalid for this type

        Overrides:
                setValue in class PGobject
-->
       <para>
          このメソッドはこのオブジェクトの値を設定します。これはサブクラスでオーバーライドしなければいけませんが、サブクラスからも呼び出されます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            value――このオブジェクトの値の文字列表現
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――値がこの型では無効であった場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary><tertiary sortas="equals()めそっど">equals()メソッド</tertiary></indexterm>
<!--
        Parameters:
                obj - Object to compare with
                
        Returns:
                true if the two boxes are identical
          
        Overrides:
                equals in class PGobject
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つのボックスが同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>

<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGboxくらす">org.postgresql.geometric.PGboxクラス</secondary><tertiary sortas="clone()めそっど">clone()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGbox in the syntax expected by <productname>PostgreSQL</productname>

        Overrides:
                getValue in class PGobject
-->
       <formalpara>
        <title>戻り値</title>
        <para>
               <productname>PostgreSQL</productname>で期待された構文で表したPGbox
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGcircle -->
<title>org.postgresql.geometric.PGcircleクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGcircle
</programlisting>

<synopsis>
public class PGcircle extends PGobject implements Serializable, 
Cloneable
</synopsis>

<!--
   This represents <productname>PostgreSQL</productname>'s circle data type, consisting of a point 
and a radius

Variables
-->
<para>このクラスは、<productname>PostgreSQL</productname>の点と半径からなるcircleデータ型を表します。</para>

<sect4>
<title>変数</title>

    <itemizedlist>
      <listitem>
      <emphasis><para>center</para></emphasis>
<synopsis>
public PGpoint center
</synopsis>
<!--
          This is the center point
-->
<para>
          中心点です。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="centerへんすう">center変数</tertiary></indexterm>
</para>

      </listitem>

      <listitem>
      <emphasis><para>radius</para></emphasis>
<synopsis>
double radius
</synopsis>
<!--
          This is the radius
-->
<para>
          半径です。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="radiusへんすう">radius変数</tertiary></indexterm>
</para>
      </listitem>
    </itemizedlist>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGcircle</para></emphasis>
<synopsis>
public PGcircle(double x,
                double y,
                double r)
</synopsis>
<!--
        Parameters:
               x - coordinate of center
                y - coordinate of center
                r - radius of circle
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――中心座標</para></listitem>
            <listitem><para>y――中心座標</para></listitem>
            <listitem><para>r――円の半径</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGcircle</para></emphasis>
<synopsis>
public PGcircle(PGpoint c,
                double r)
</synopsis>
<!--
        Parameters:
                c - PGpoint describing the circle's center
                r - radius of circle
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>c――円の中心を示すPGpoint</para></listitem>
            <listitem><para>r――円の半径</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGcircle</para></emphasis>
<synopsis>
public PGcircle(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - definition of the circle in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した円の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGcircle</para></emphasis>
<synopsis>
public PGcircle()
</synopsis>
<!--
          This constructor is used by the driver.
-->
       <para>
          ドライバによって使用されるコンストラクタ
       </para>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>

    <itemizedlist>

      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s――definition of the circle in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した円の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj――Object to compare with
            
        Returns:
                true if the two circles are identical

        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの円が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGcircle in the syntax expected by <productname>PostgreSQL</productname>
        
        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGcircleくらす">org.postgresql.geometric.PGcircleクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGcircle
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>

     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGline -->
<title>org.postgresql.geometric.PGlineクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGline
</programlisting>

<!--
   public class PGline extends PGobject implements Serializable, 
Cloneable

   This implements a line consisting of two points. Currently line is 
not yet implemented in the backend, but this class ensures that when 
it's done were ready for it.
-->
<para>
   このクラスは2点から構成される線を実装します。今のところまだ、線はバックエンド内で実装されていませんが、このクラスはバックエンドでの実装がなされればすぐに使えることを保証します。
</para>

<sect4>
<!-- Variables -->
<title>変数</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="pointへんすう">point変数</tertiary></indexterm>
<synopsis>
 public PGpoint point[]
</synopsis>
<!--
          These are the two points.
-->
       <para>
          2つの点があります。
       </para>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGline</para></emphasis>
<synopsis>
public PGline(double x1,
              double y1,
              double x2,
              double y2)
</synopsis>
<!--
        Parameters:
                x1 - coordinate for first point
                y1 - coordinate for first point
                x2 - coordinate for second point
                y2 - coordinate for second point
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x1――1番目の座標</para></listitem>
            <listitem><para>y1――1番目の座標</para></listitem>
            <listitem><para>x2――2番目の座標</para></listitem>
            <listitem><para>y2――2番目の座標</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGline</para></emphasis>
<synopsis>
public PGline(PGpoint p1,
              PGpoint p2)
</synopsis>
<!--
        Parameters:
                p1 - first point
                p2 - second point
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>p1――1番目の点</para></listitem>
            <listitem><para>p2――2番目の点</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGline</para></emphasis>
<synopsis>
public PGline(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - definition of the line in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した線の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――変換に失敗した場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGline</para></emphasis>
<synopsis>
public PGline()
</synopsis>
<!--
          required by the driver
-->
       <para>
          ドライバで必要とされます。
       </para>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>

    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
 public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of the line segment in PostgreSQL's 
syntax

        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した線分の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
           SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj――Object to compare with
               
        Returns:
                true if the two lines are identical
   
        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの線が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
<para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
</para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGline in the syntax expected by <productname>PostgreSQL</productname>
        
        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlineくらす">org.postgresql.geometric.PGlineクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGline 
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>

     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGlseg -->
<title>org.postgresql.geometric.PGlsegクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGlseg
</programlisting>

<synopsis>
public class PGlseg extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!--
   This implements a lseg (line segment) consisting of two points
-->
<para>
   2つの点からなるlseg（線分）を実装します。
</para>

<sect4>
<!-- Variables -->
<title>変数</title>

<synopsis>
public PGpoint point[]
</synopsis>
<!--
          These are the two points.
-->
<para>
          2つの点があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="pointへんすう">point変数</tertiary></indexterm>
</para>

</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGlseg</para></emphasis>
<synopsis>
public PGlseg(double x1,
              double y1,
              double x2,
              double y2)
</synopsis>
<!--
        Parameters:

                x1 - coordinate for first point
                y1 - coordinate for first point
                x2 - coordinate for second point
                y2 - coordinate for second point
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x1――1番目の座標</para></listitem>
            <listitem><para>y1――1番目の座標</para></listitem>
            <listitem><para>x2――2番目の座標</para></listitem>
            <listitem><para>y2――2番目の座標</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGlseg</para></emphasis>
<synopsis>
public PGlseg(PGpoint p1,
              PGpoint p2)
</synopsis>
<!--
        Parameters:
                p1 - first point
                p2 - second point
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>p1――1番目の点</para></listitem>
            <listitem><para>p2――2番目の点</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGlseg</para></emphasis>
<synopsis>
public PGlseg(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - definition of the line segment in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した線分の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――変換に失敗した場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGlseg</para></emphasis>
<synopsis>
public PGlseg()
</synopsis>
<!--
          required by the driver
-->
<para>          ドライバによって必要とされます。</para>
      </listitem>


     </itemizedlist>
</sect4>


<sect4>
<!-- Methods -->
<title>メソッド</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of the line segment in PostgreSQL's 
syntax

        Throws: SQLException
                on conversion failure
     
        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した線分の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj - Object to compare with
               
        Returns:
                true if the two line segments are identical
   
        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="equals()めそっど">equals()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの線分が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
               clone in class PGobject
-->
<para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="clone()めそっど">clone()メソッド</tertiary></indexterm>
</para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGlseg in the syntax expected by <productname>PostgreSQL</productname>
        
        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGlsegくらす">org.postgresql.geometric.PGlsegクラス</secondary><tertiary sortas="getValue()めそっど">getValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGlseg 
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGpath -->
<title>org.postgresql.geometric.PGpathクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpath
</programlisting>

<synopsis>
public class PGpath extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!--
   This implements a path (a multiply segmented line, which may be 
closed)
-->
       <para>
   経路（閉じている可能性がある複数の線分）を実装します
       </para>

<sect4>
<!-- Variables -->
<title>変数</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>open</para></emphasis>
<synopsis>
public boolean open
</synopsis>
<!--
          True if the path is open, false if closed
-->
       <para>
          開いた経路ならば真、閉じた経路ならば偽。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="openへんすう">open変数</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>points</para></emphasis>
<synopsis>
public PGpoint points[]
</synopsis>
<!--
          The points defining this path
-->
       <para>
          この経路を定義する点。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="pointsへんすう">points変数</tertiary></indexterm>
       </para>
      </listitem>


     </itemizedlist>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGpath</para></emphasis>
<synopsis>
public PGpath(PGpoint points[],
              boolean open)
</synopsis>
<!--
        Parameters:
                points - the PGpoints that define the path
                open - True if the path is open, false if closed
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>points――経路を定義するPGpoint</para></listitem>
            <listitem><para>open――開いた経路ならば真、閉じた経路ならば偽</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGpath</para></emphasis>
<synopsis>
public PGpath()
</synopsis>
<!--
          Required by the driver
-->
       <para>
          ドライバで必要とされます。
       </para>

      </listitem>

      <listitem>
      <emphasis><para>PGpath</para></emphasis>
<synopsis>
public PGpath(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - definition of the path in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した経路の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>

    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of the path in PostgreSQL's syntax
           
        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した経路の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj - Object to compare with

        Returns:
                true if the two pathes are identical

        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="equals()めそっど">equals()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの経路が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="clone()めそっど">clone()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
          This returns the path in the syntax expected by 
<productname>PostgreSQL</productname>

        Overrides:
                getValue in class PGobject
-->
       <para>
        PostgreSQLで期待される構文で表した経路を返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="getValue()めそっど">getValue()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>isOpen</para></emphasis>
<synopsis>
public boolean isOpen()
</synopsis>
<!--
     This returns true if the path is open
-->
       <para>
     開いた経路ならば真を返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="isOpen()めそっど">isOpen()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>isClosed</para></emphasis>
<synopsis>
public boolean isClosed()
</synopsis>
<!--
     This returns true if the path is closed
-->
       <para>
     閉じた経路ならば偽を返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="isClosed()めそっど">isClosed()メソッド</tertiary></indexterm>
        </para>
      </listitem>

      <listitem>
      <emphasis><para>closePath</para></emphasis>
<synopsis>
public void closePath()
</synopsis>
<!--
     Marks the path as closed
-->
       <para>
     閉じた経路として印を付けます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="closePath()めそっど">closePath()メソッド</tertiary></indexterm>
        </para>
      </listitem>

      <listitem>
      <emphasis><para>openPath</para></emphasis>
<synopsis>
public void openPath()
</synopsis>
<!--
     Marks the path as open
-->
       <para>
     開いた経路として印を付けます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpathくらす">org.postgresql.geometric.PGpathクラス</secondary><tertiary sortas="openPath()めそっど">openPath()メソッド</tertiary></indexterm>
        </para>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGpoint -->
<title>org.postgresql.geometric.PGpointクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpoint
</programlisting>

<synopsis>
public class PGpoint extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!--
   This implements a version of java.awt.Point, except it uses double 
to represent the coordinates.

   It maps to the point data type in <productname>PostgreSQL</productname>.
-->
       <para>
   これは、その座標をdouble型で使用している点を除き、java.awt.Pointのある版を実装したものです。PostgreSQLのpointデータ型に割り当てます。
       </para>

<sect4>
<!-- Variables -->
<title>変数</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>x</para></emphasis>
<synopsis>
public double x
</synopsis>
<!--
          The X coordinate of the point
-->
       <para>
          点のX座標です。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="xへんすう">x変数</tertiary></indexterm>
        </para>
      </listitem>

      <listitem>
      <emphasis><para>y</para></emphasis>
<synopsis>
public double y
</synopsis>
<!--
          The Y coordinate of the point
-->
       <para>
          点のY座標です。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="yへんすう">y変数</tertiary></indexterm>
       </para>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGpoint</para></emphasis>
<synopsis>
public PGpoint(double x,
               double y)
</synopsis>
<!--
        Parameters:
                x - coordinate
                y - coordinate
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――座標値</para></listitem>
            <listitem><para>y――座標値</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGpoint</para></emphasis>
<synopsis>
public PGpoint(String value) throws SQLException
</synopsis>
<!--
          This is called mainly from the other geometric types, when a 
point is embedded within their definition.
             
        Parameters:
                value - Definition of this point in PostgreSQL's 
syntax
-->
       <para>
          主に、その定義に点を含む、他の幾何データ型から呼び出されます。
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            value――PostgreSQLの構文で表された点の定義
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGpoint</para></emphasis>
<synopsis>
public PGpoint()
</synopsis>
<!--
          Required by the driver
-->
       <para>
          ドライバで必要とされます。
       </para>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of this point in PostgreSQL's syntax

        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した点の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj - Object to compare with

        Returns:
                true if the two points are identical

        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="equals()めそっど">equals()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの点が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="clone()めそっど">clone()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGpoint in the syntax expected by <productname>PostgreSQL</productname>

        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="getValue()めそっど">getValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGpoint
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>translate</para></emphasis>
<synopsis>
public void translate(int x,
                      int y)
</synopsis>
<!--
          Translate the point with the supplied amount.

        Parameters:
                x - integer amount to add on the x axis
                y - integer amount to add on the y axis
-->
       <para>
          点を指定した量分移動します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="translate()めそっど">translate()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――x座標に加える整数量</para></listitem>
            <listitem><para>y――y座標に加える整数量</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>translate</para></emphasis>
<synopsis>
public void translate(double x,
                      double y)
</synopsis>
<!--
          Translate the point with the supplied amount.
 
        Parameters:
                x - double amount to add on the x axis
                y - double amount to add on the y axis
-->
       <para>
          点を指定した量分移動します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="translate()めそっど">translate()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――x座標に加えるdouble型で示された量</para></listitem>
            <listitem><para>y――y座標に加えるdouble型で示された量</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>move</para></emphasis>
<synopsis>
public void move(int x,
                 int y)
</synopsis>
<!--
          Moves the point to the supplied coordinates.

        Parameters:
                x - integer coordinate
                y - integer coordinate
-->
       <para>
          点を指定座標に移動します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="move()めそっど">move()メソッド</tertiary></indexterm>
       </para>


       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――座標（整数）</para></listitem>
            <listitem><para>y――座標（整数）</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>move</para></emphasis>
<synopsis>
public void move(double x,
                 double y)
</synopsis>
<!--
          Moves the point to the supplied coordinates.

        Parameters:
                x - double coordinate
                y - double coordinate
-->
       <para>
          点を指定座標に移動します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="move()めそっど">move()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――座標（double型）</para></listitem>
            <listitem><para>y――座標（double型）</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>setLocation</para></emphasis>
<synopsis>
public void setLocation(int x,
                        int y)
</synopsis>
<!--
          Moves the point to the supplied coordinates. refer to
          java.awt.Point for description of this

        Parameters:
                x - integer coordinate
                y - integer coordinate

        See Also:
                Point
-->
       <para>
          点を指定座標に移動します。この記述についてはjava.awt.Pointを参照してください。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="setLocation()めそっど">setLocation()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>x――座標（整数）</para></listitem>
            <listitem><para>y――座標（整数）</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>参照</title>
        <para>
                Point
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>setLocation</para></emphasis>
<synopsis>
public void setLocation(Point p)
</synopsis>
<!--
          Moves the point to the supplied java.awt.Point refer to
          java.awt.Point for description of this

        Parameters:
                p - Point to move to

        See Also:
                Point
-->
       <para>
          点を与えられたjava.awt.Pointに移動します。この記述についてはjava.awt.Pointを参照してください。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpointくらす">org.postgresql.geometric.PGpointクラス</secondary><tertiary sortas="setLocation()めそっど">setLocation()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            p――移動先を示すPoint
        </para>
       </formalpara>

       <formalpara>
        <title>参照</title>
        <para>
                Point
        </para>
       </formalpara>
      </listitem>

     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.geometric.PGpolygon -->
<title>org.postgresql.geometric.PGpolygonクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpolygon
</programlisting>

<synopsis>
public class PGpolygon extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!--
   This implements the polygon data type within PostgreSQL.
-->
       <para>
   PostgreSQLのpolygonデータ型を実装します。
       </para>

<sect4>
<!-- Variables -->
<title>変数</title>
<synopsis>
public PGpoint points[]
</synopsis>
<!--
          The points defining the polygon
-->
       <para>
          多角形を定義する点。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="pointsへんすう">points変数</tertiary></indexterm>
       </para>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGpolygon</para></emphasis>
<synopsis>
public PGpolygon(PGpoint points[])
</synopsis>
<!--
          Creates a polygon using an array of PGpoints

        Parameters:
                points - the points defining the polygon
-->
       <para>
          PGpointの配列を使用して多角形を生成します。
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            points――多角形を定義する点
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGpolygon</para></emphasis>
<synopsis>
public PGpolygon(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - definition of the polygon in PostgreSQL's syntax.

        Throws: SQLException
                on conversion failure
-->
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した多角形の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGpolygon</para></emphasis>
<synopsis>
public PGpolygon()
</synopsis>
<!--
          Required by the driver
-->
       <para>
ドライバで必要とされます。
       </para>
      </listitem>

     </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of the polygon in PostgreSQL's syntax

        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="setValue()めそっど">setValue89メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQLの構文で表した多角形の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
        SQLException――変換に失敗した場合
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj - Object to compare with
                                
        Returns:
                true if the two polygons are identical

        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの多角形が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGpolygon in the syntax expected by <productname>PostgreSQL</productname>

        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.geometric.PGpolygonくらす">org.postgresql.geometric.PGpolygonクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGpolygon 
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
   </sect4>
  </sect3>
  </sect2>


  <sect2>
   <!-- <title>Large Objects</title> -->
   <title>ラージオブジェクト</title>
<indexterm><primary>JDBC</primary><secondary sortas="らーじおぶじぇくと">ラージオブジェクト</secondary></indexterm><indexterm><primary sortas="らーじおぶじぇくと">ラージオブジェクト</primary><secondary>JDBC</secondary></indexterm>
   <para>
    <!-- Large objects are supported in the standard
    <acronym>JDBC</acronym> specification.  However, that interface is
    limited, and the <acronym>API</acronym> provided by PostgreSQL allows for random
    access to the objects contents, as if it was a local file. -->
    ラージオブジェクトは標準<acronym>JDBC</acronym>仕様でサポートされています。しかし、そのインターフェイスには制限があり、また、PostgreSQLで用意される<acronym>API</acronym>では、ローカルファイル同様にオブジェクトの内容にランダムアクセスを行うことができます。
   </para>

   <para>
    <!-- The org.postgresql.largeobject package provides to Java the libpq
    C interface's large object <acronym>API</acronym>. It consists of
    two classes, <classname>LargeObjectManager</classname>, which deals with creating,
    opening and deleting large objects, and <classname>LargeObject</classname> which deals
    with an individual object. -->
    org.postgresql.largeobjectパッケージは、Javaに対し、libpq Cインタフェースにあるラージオブジェクト<acronym>API</acronym>を提供します。ラージオブジェクトの生成、オープン、削除を扱う<classname>LargeObjectManager</classname>と、個別のオブジェクトを扱う<classname>LargeObject</classname>という2つのクラスから構成されています。
   </para>

   <sect3>
    <!-- <title>Class <classname>org.postgresql.largeobject.LargeObject</classname></title> -->
    <title><classname>org.postgresql.largeobject.LargeObject</classname>クラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary></indexterm>
<synopsis>
public class LargeObject extends Object
</synopsis>

<programlisting>
java.lang.Object
   |
   +----org.postgresql.largeobject.LargeObject
</programlisting>

    <para>
     <!-- This class implements the large object interface to
     <productname>PostgreSQL</productname>. -->
     このクラスは<productname>PostgreSQL</productname>のラージオブジェクトインターフェイスを実装します。
    </para>

    <para>
     <!-- It provides the basic methods required to run the interface, plus
     a pair of methods that provide <classname>InputStream</classname> and <classname>OutputStream</classname>
     classes for this object. -->
     インターフェイスの実行に必要な基本的なメソッドと、このオブジェクト用の<classname>InputStream</classname>と<classname>OutputStream</classname>クラスの組み合わせを提供するためのメソッドを提供します。
    </para>

    <para>
     <!-- Normally, client code would use the getAsciiStream,
     getBinaryStream, or getUnicodeStream methods in <classname>ResultSet</classname>, or
     setAsciiStream, setBinaryStream, or setUnicodeStream methods in
     <classname>PreparedStatement</classname> to access Large Objects. -->
     通常クライアントコードでは、ラージオブジェクトにアクセスするために<classname>ResultSet</classname>のメソッドgetAsciiStream、getBinaryStream、getUnicodeStream、もしくは<classname>PreparedStatement</classname>のメソッドsetAsciiStream、setBinaryStream、setUnicodeStreamを使用します。
    </para>

    <para>
     <!-- However, sometimes lower level access to Large Objects are
     required, that are not supported by the <acronym>JDBC</acronym>
     specification. -->
     しかし、もっと低レベルなラージオブジェクトへのアクセスが必要となることがあります。これは<acronym>JDBC</acronym>仕様ではサポートされていません。
    </para>

    <para>
     <!-- Refer to org.postgresql.largeobject.LargeObjectManager on how to
     gain access to a Large Object, or how to create one. -->
     どのようにラージオブジェクトへのアクセスを得るかや、どうやって生成するかについてはorg.postgresql.largeobject.LargeObjectManagerを参照してください。
    </para>

    <formalpara>
     <!-- <title>See Also:</title> -->
     <title>参照</title>
     <para><classname>LargeObjectManager</classname></para>
    </formalpara>

    <sect4>
     <!-- <title>Variables</title> -->
     <title>変数</title>

     <variablelist>
      <varlistentry>
       <term>public static final int SEEK_SET</term>
       <listitem>
        <!-- <para>Indicates a seek from the beginning of a file</para> -->
        <para>ファイルの先頭からシークすることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="SEEK_SETへんすう">SEEK_SET変数</tertiary></indexterm></para>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>public static final int SEEK_CUR</term>
       <listitem>
        <!-- <para>Indicates a seek from the current position</para> -->
        <para>現在位置からシークすることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="SEEK_CURへんすう">SEEK_CUR変数</tertiary></indexterm></para>
       </listitem>
      </varlistentry>

      <varlistentry>
       <term>public static final int SEEK_END</term>
       <listitem>
        <!-- <para>Indicates a seek from the end of a file</para> -->
        <para>ファイルの終端からシークすることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="SEEK_ENDへんすう">SEEK_END変数</tertiary></indexterm></para>
       </listitem>
      </varlistentry>
     </variablelist>
    </sect4>

    <sect4>
     <!-- <title>Methods</title> -->
     <title>メソッド</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>getOID</para></emphasis>
<synopsis>
public int getOID()
</synopsis>
       <para>
        <!-- Returns the OID of this <classname>LargeObject</classname> -->
        <classname>LargeObject</classname>のOIDを返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="getOID()めそっど">getOID()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>close</para></emphasis>
<synopsis>
public void close() throws SQLException
</synopsis>
       <para>
        <!-- This method closes the object. You must not call methods in
        this object after this is called. -->
        オブジェクトを閉じます。このメソッドを呼び出した後にそのオブジェクトのメソッドを呼び出してはいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="close()めそっど">close()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>read</para></emphasis>
<synopsis>
public byte[] read(int len) throws SQLException
</synopsis>
       <para>
        <!-- Reads some data from the object, and return as a byte[] array -->
        オブジェクトからデータを一部読み取り、byte[]型の配列として返します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="read()めそっど">read()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>read</para></emphasis>
<synopsis>
public int read(byte buf[],
                int off,
                int len) throws SQLException
</synopsis>
       <para>
        <!-- Reads some data from the object into an existing array -->
        オブジェクトからデータの一部分を既存の配列に読み込みます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="read()めそっど">read()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
         <itemizedlist>
           <listitem><para>buf――コピー先の配列</para>
            <!-- <simpara>destination array</simpara> -->
           </listitem>

           <listitem><para>off――配列内のオフセット</para>
            <!-- <simpara>offset within array</simpara> -->
           </listitem>

           <listitem><para>len――読み取るバイト数</para>
            <!-- <simpara>number of bytes to read</simpara> -->
           </listitem>
         </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>write</para></emphasis>
<synopsis>
public void write(byte buf[]) throws SQLException
</synopsis>
       <para>
        <!-- Writes an array to the object -->
        配列をオブジェクトに書き込みます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="write()めそっど">write()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>write</para></emphasis>
<synopsis>
public void write(byte buf[],
                  int off,
                  int len) throws SQLException
</synopsis>
       <para>
        <!-- Writes some data from an array to the object -->
        配列の一部のデータをオブジェクトに書き込みます。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectくらす">org.postgresql.largeobject.LargeObjectクラス</secondary><tertiary sortas="write()めそっど">write()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <!-- <title>Parameters:</title> -->
        <title>パラメータ</title>
        <para>
         <itemizedlist>
           <listitem>
            <!-- <simpara>destination array</simpara> -->
            <para>buf――コピー元となる配列</para>
           </listitem>
           <listitem>
            <!-- <simpara>offset within array</simpara> -->
            <para>off――配列内のオフセット</para>
           </listitem>
           <listitem>
            <!-- <simpara>number of bytes to write</simpara> -->
            <para>len――書き込むバイト数</para>
           </listitem>
         </itemizedlist>
        </para>
       </formalpara>
      </listitem>

<!--
 public void seek(int pos,
                  int ref) throws SQLException

          Sets the current position within the object.

          This is similar to the fseek() call in the standard C 
library.It allows you to have random access to the large object.

        Parameters:
                pos - position within object
                ref - Either SEEK_SET, SEEK_CUR or SEEK_END
        Throws: SQLException
                if a database-access error occurs.

 public void seek(int pos) throws SQLException

          Sets the current position within the object.

          This is similar to the fseek() call in the standard C 
library.It allows you to have random access to the large object.

        Parameters:
                pos - position within object from begining

        Throws: SQLException
                if a database-access error occurs.

 public int tell() throws SQLException

        Returns:
                the current position within the object

        Throws: SQLException
                if a database-access error occurs.

 public int size() throws SQLException

          This method is inefficient, as the only way to find out the 
size of the object is to seek to the end, record the current position, 
then return to the original position.

          A better method will be found in the future.

        Returns:
                the size of the large object

        Throws: SQLException
                if a database-access error occurs.

 public InputStream getInputStream() throws SQLException

          Returns an InputStream from this object.

          This InputStream can then be used in any method that 
requires an InputStream.

        Throws: SQLException
                if a database-access error occurs.

 public OutputStream getOutputStream() throws SQLException

          Returns an OutputStream to this object

          This OutputStream can then be used in any method that 
requires an OutputStream.

        Throws: SQLException
                if a database-access error occurs.
-->
     </itemizedlist>
    </sect4>
   </sect3>


   <sect3>
    <!-- <title>Class <classname>org.postgresql.largeobject.LargeObjectManager</classname></title> -->
    <title><classname>org.postgresql.largeobject.LargeObjectManager</classname>クラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary></indexterm>
<synopsis>
public class LargeObjectManager extends Object
</synopsis>

<programlisting>
java.lang.Object
   |
   +----org.postgresql.largeobject.LargeObjectManager
</programlisting>

    <para>
     <!-- This class implements the large object interface to
     <productname>PostgreSQL</productname>.  It provides methods that
     allow client code to create, open and delete large objects from
     the database. When opening an object, an instance of
     <classname>org.postgresql.largeobject.LargeObject</classname> is
     returned, and its methods then allow access to the object. -->
     クライアントコードにて、ラージオブジェクトの生成、オープン、削除を可能にするためのメソッドを提供します。オブジェクトを開くと、<classname>org.postgresql.largeobject.LargeObject</classname>のインスタンスが返され、そのインスタンスのメソッドを使ってラージオブジェクトにアクセスできます。
    </para>

    <para>
     <!-- This class can only be created by org.postgresql.Connection.  To
     get access to this class, use the following segment of code: -->
     このクラスはorg.postgresql.Connectionによってのみ作成できます。このクラスへのアクセスを得るには、次のようなコードの一部を使用します。
    </para>

<programlisting>
import org.postgresql.largeobject.*;
Connection  conn;
LargeObjectManager lobj;
<!-- // ... code that opens a connection ... -->
// ... 接続を開くコード ...
lobj = ((org.postgresql.Connection)myconn).getLargeObjectAPI();
</programlisting>

    <para>
     <!-- Normally, client code would use the getAsciiStream,
     getBinaryStream, or getUnicodeStream methods in ResultSet, or
     setAsciiStream, setBinaryStream, or setUnicodeStream methods in
     PreparedStatement to access Large Objects.  However, sometimes
     lower level access to Large Objects are required, that are not
     supported by the <acronym>JDBC</acronym> specification. -->
     通常クライアントコードでは、ラージオブジェクトにアクセスするためにResultSetのメソッドgetAsciiStream、getBinaryStream、getUnicodeStreamや、PreparedStatementのメソッドsetAsciiStream、setBinaryStream、setUnicodeStreamを使用します。しかし、もっと低レベルなラージオブジェクトへのアクセスが必要となることがあります。これは<acronym>JDBC</acronym>仕様ではサポートされていません。
    </para>

    <para>
     <!-- Refer to org.postgresql.largeobject.LargeObject on how to
     manipulate the contents of a Large Object. -->
     どのようにラージオブジェクトの内容を扱うのかについては、org.postgresql.largeobject.LargeObjectを参照してください。
    </para>

    <sect4>
     <!-- <title>Variables</title> -->
     <title>変数</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>WRITE</para></emphasis>
<synopsis>
public static final int WRITE
</synopsis>
        <!-- <simpara>This mode indicates we want to write to an object.</simpara> -->
        <para>このモードはオブジェクトに書き込みを行う予定であることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="WRITEへんすう">WRITE変数</tertiary></indexterm></para>
       </listitem>

      <listitem>
      <emphasis><para>READ</para></emphasis>
<synopsis>
public static final int READ
</synopsis>

        <!-- <simpara>This mode indicates we want to read an object.</simpara> -->
        <para>このモードはオブジェクトに読み取りを行う予定であることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="READへんすう">READ変数</tertiary></indexterm></para>
       </listitem>

      <listitem>
      <emphasis><para>READWRITE</para></emphasis>
<synopsis>
public static final int READWRITE
</synopsis>
        <!-- <simpara>This mode is the default. It indicates we want read and write access to a large object.</simpara> -->
        <para>このモードがデフォルトです。オブジェクトに読み取り/書き込みを行う予定であることを示します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="READWRITEへんすう">READWRITE変数</tertiary></indexterm></para>
       </listitem>
     </itemizedlist>
    </sect4>

    <sect4>
     <!-- <title>Methods</title> -->
     <title>メソッド</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>open</para></emphasis>
<synopsis>
public LargeObject open(int oid) throws SQLException
</synopsis>
       <para>
        <!-- This opens an existing large object, based on its OID. This
        method assumes that READ and WRITE access is required (the
        default). -->
        既存のラージオブジェクトを、そのOIDに基づいて開きます。このメソッドは、（デフォルトである）READとWRITEアクセスが要求されているものと仮定します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="open()めそっど">open()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>open</para></emphasis>
<synopsis>
public LargeObject open(int oid,
                        int mode) throws SQLException
</synopsis>
       <para>
        <!-- This opens an existing large object, based on its OID, and
        allows setting the access mode. -->
        既存のラージオブジェクトを、そのOIDに基づいて開きます。そして、アクセスモードのセットを許します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="open()めそっど">open()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>create</para></emphasis>
<synopsis>
public int create() throws SQLException
</synopsis>
       <para>
        <!-- This creates a large object, returning its OID.
        It defaults to READWRITE for the new object's attributes. -->
        ラージオブジェクトを作成し、そのOIDを返します。新しいオブジェクトの属性のデフォルトはREADWRITEです。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="create()めそっど">create()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>create</para></emphasis>
<synopsis>
public int create(int mode) throws SQLException
</synopsis>
       <para>
        <!-- This creates a large object, returning its OID, and sets the
        access mode. -->
        ラージオブジェクトを作成し、そのOIDを返します。そして、アクセスモードをセットします。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="create()めそっど">create()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>delete</para></emphasis>
<synopsis>
public void delete(int oid) throws SQLException
</synopsis>
       <para>          
        <!-- This deletes a large object. -->
        ラージオブジェクトを削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="delete()めそっど">delete()メソッド</tertiary></indexterm>
       </para>
      </listitem>

      <listitem>
      <emphasis><para>unlink</para></emphasis>
<synopsis>
public void unlink(int oid) throws SQLException
</synopsis>
       <para>
        <!-- This deletes a large object.  It is identical to the delete
        method, and is supplied as the C <acronym>API</acronym> uses
        <quote>unlink</quote>. -->
        ラージオブジェクトを削除します。deleteメソッドと同一です。これはC <acronym>API</acronym>同様に<quote>unlink</quote>を使用するために用意されています。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.largeobject.LargeObjectManagerくらす">org.postgresql.largeobject.LargeObjectManagerクラス</secondary><tertiary sortas="unlink()めそっど">unlink()メソッド</tertiary></indexterm>
       </para>
      </listitem>
     </itemizedlist>
    </sect4>
   </sect3>
  </sect2>


  <sect2>
   <!-- <title>Object Serialization</title> -->
   <title>オブジェクト直列化</title>
<indexterm><primary>JDBC</primary><secondary sortas="おぶじぇくとちょくれつか">オブジェクト直列化</secondary></indexterm>
   <para>
    <!-- <productname>PostgreSQL</productname> is not a normal
    <acronym>SQL</acronym> database.  It is more extensible than most
    other databases, and does support object oriented features that
    are unique to it. -->
    PostgreSQLはごく普通のSQLデータベースではありません。他のほとんどのデータベースよりも拡張性があり、特有のオブジェクト指向機能をサポートしています。
   </para>

   <para>
    <!-- One of the consequences of this, is that you can have one table
    refer to a row in another table.  For example: -->
    他のテーブルにある行を参照するテーブルを持つことができるということはこの結果の1つです。たとえば、以下のようになります。
    </para>

<screen>
test=> create table users (username name,fullname text);
CREATE
test=> create table server (servername name,adminuser users);
CREATE
test=> insert into users values ('peter','Peter Mount');
INSERT 2610132 1
test=> insert into server values ('maidast',2610132::users);
INSERT 2610133 1
test=> select * from users;
username|fullname      
--------+--------------
peter   |Peter Mount   
(1 row)

test=> select * from server;
servername|adminuser
----------+---------
maidast   |  2610132
(1 row)
</screen>

   <para>
    <!-- Okay, the above example shows that we can use a table name as a
    field, and the row's oid value is stored in that field. -->
    上の例では、テーブルの名前をフィールドとして持つことができ、行のoidがそのフィールドに埋め込まれていることを示しています。
   </para>

   <para>
    <!-- What does this have to do with Java? -->
    Javaではこれをどう扱わなければいけないのでしょうか。
   </para>

   <para>
    <!-- In Java, you can store an object to a Stream as long as it's class
    implements the java.io.Serializable interface. This process, known
    as Object Serialization, can be used to store complex objects into
    the database. -->
    Javaではjava.io.Serializableインターフェイスを実装するクラスならばストリームにオブジェクトを保存することができます。オブジェクト直列化として知られるこの処理は、複雑なオブジェクトをデータベースに保存することに使用することができます。
   </para>

   <para>
    <!-- Now, under <acronym>JDBC</acronym>, you would have to use a
    Large Object to store them.  However, you cannot perform queries on
    those objects. -->
    さて、JDBCでは、それらを保存する際にLargeObjectを使用しなければいけません。しかし、これらのオブジェクトに問い合わせを行うことができません。
   </para>

   <para>
    <!-- What the org.postgresql.util.Serialize class does, is provide a
    means of storing an object as a table, and to retrieve that object
    from a table. In most cases, you would not need to access this
    class direct, but you would use the PreparedStatement.setObject()
    and ResultSet.getObject() methods. Those methods will check the
    objects class name against the table's in the database. If a match
    is found, it assumes that the object is a Serialized object, and
    retrieves it from that table. As it does so, if the object
    contains other serialized objects, then it recurses down the tree. -->
    org.postgresql.util.Serializeクラスが行うことは、オブジェクトをテーブルとして保存する手段と、テーブルからオブジェクトを取り出す手段を提供することです。ほとんどの場合では、このクラスに直接アクセスする必要はなく、PreparedStatement.setObject()メソッドとResultSet.getObject()メソッドを使うことになります。これらのメソッドは、オブジェクトのクラス名をデータベース内のテーブル名で照合します。合うものがあれば、そのオブジェクトは直列化されたオブジェクトとみなし、そのテーブルから取り出します。その処理の際にそのオブジェクトが直列化された別のオブジェクトを持つ場合、再帰的にそのツリーを辿ります。
   </para>

   <para>
    <!-- Sound's complicated? In fact, it's simpler than what I wrote -
    it's just difficult to explain. -->
    複雑に見えるかもしれませんが、実際は、ここで述べたことよりは簡単です。説明することが難しいだけです。
   </para>

   <para>
    <!-- The only time you would access this class, is to use the create()
    methods. These are not used by the driver, but issue one or more
    "create table" statements to the database, based on a Java Object
    or Class that you want to serialize. -->
    このクラスにアクセスする機会は、create()メソッド群を使用するときだけです。これらはドライバから使用されるものではありませんが、直列化要求のあったJavaのオブジェクトやクラスに基づいた1つ以上の「create table」文をデータベースに対して発行します。
   </para>

   <para>
    <!-- Oh, one last thing. If your object contains a line like: -->
    さて、これが最後ですが、もし対象とするオブジェクトが以下のような行を含むのならば、テーブルからオブジェクトを取り出す際に、そこにテーブル内のoidが設定されます。
   </para>

<programlisting>
public int oid;
</programlisting>

   <para>
    <!-- then, when the object is retrieved from the table, it is set to
    the oid within the table. Then, if the object is modified, and re-
    serialized, the existing entry is updated. -->
そして、オブジェクトが変更され、再度直列化されると、既存のエントリは更新されます。
   </para>

   <para>
    <!-- If the oid variable is not present, then when the object is
    serialized, it is always inserted into the table, and any existing
    entry in the table is preserved. -->
    oid変数がなければ、オブジェクトが直列化されたときに常に挿入され、そして、テーブルに既存のエントリはすべて保存されます。
   </para>

   <para>
    <!-- Setting oid to 0 before serialization, will also cause the object
    to be inserted. This enables an object to be duplicated in the
    database. -->
    直列化前にoid変数を0にすると、そのオブジェクトは挿入されるようになります。これにより、あるオブジェクトをデータベース内に複数持たせることができます。
   </para>

<sect3>
<!-- Class org.postgresql.util.Serialize -->
<title>org.postgresql.util.Serializeクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.Serialize
</programlisting>

<synopsis>
public class Serialize extends Object
</synopsis>
<!--
   This class uses PostgreSQL's object oriented features to store Java 
Objects. It does this by mapping a Java Class name to a table in the 
database. Each entry in this new table then represents a Serialized 
instance of this class. As each entry has an OID (Object IDentifier), 
this OID can be included in another table. This is too complex to show 
here, and will be documented in the main documents in more detail.
-->
   <para>
   このクラスは、Javaのオブジェクトを保存するためにPostgreSQLのオブジェクト指向機能を使用します。このクラスでは、Javaのクラス名をデータベース内のテーブルに対応させることでそれを行います。この新しいテーブル各エントリはこのクラスの直列化されたインスタンスを表します。各エントリはOID（オブジェクト識別子）を持ちますので、このOIDを別のテーブルに持たせることができます。このクラスはここで示すには複雑過ぎますので、より詳細については主文書にて記載させる予定です。
   </para>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
<synopsis>
public Serialize(org.postgresql.Connection c,
                 String type) throws SQLException
</synopsis>
<!--
          This creates an instance that can be used to serialize 
or deserialize a Java object from a PostgreSQL table.
-->
<para>
          このメソッドは、PostgreSQLのテーブルからあるJavaオブジェクトを直列化または復号化するために使用できる、インスタンスを生成します。
</para>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>

     <itemizedlist>
      <listitem>
      <emphasis><para>fetch</para></emphasis>
<synopsis>
public Object fetch(int oid) throws SQLException
</synopsis>
<!--
          This fetches an object from a table, given it's OID

        Parameters:
                oid - The oid of the object

        Returns:
                Object relating to oid

        Throws: SQLException
                on error
-->

          <para>指定したOIDのオブジェクトをテーブルから入手します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="fetch()めそっど">fetch()メソッド</tertiary></indexterm></para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            oid――オブジェクトのoid
        </para>
       </formalpara>


       <formalpara>
        <title>戻り値</title>
        <para>
          oidに対応するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――エラー時
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>store</para></emphasis>
<synopsis>
public int store(Object o) throws SQLException
</synopsis>
<!--
          This stores an object into a table, returning it's OID.

          If the object has an int called OID, and it is > 0, then 
that value is used for the OID, and the table will be updated. If the 
value of OID is 0, then a new row will be created, and the value of 
OID will be set in the object. This enables an object's value in the 
database to be updateable. If the object has no int called OID, then 
the object is stored. However if the object is later retrieved, 
amended and stored again, it's new state will be appended to the 
table, and will not overwrite the old entries.

        Parameters:
                o - Object to store (must implement Serializable)

        Returns:
                oid of stored object

        Throws: SQLException
                on error
-->
       <para>
          テーブルにオブジェクトを保存し、そのOIDを返します。そのオブジェクトがOIDという名前の整数型変数をもち、それが0より大きい場合、その値がOIDとして使われ、テーブルは更新されます。OID変数が0ならば、新しい行が作成され、行のOIDがそのオブジェクトに設定されます。これにより、データベース内のオブジェクトの値が更新可能になります。オブジェクトがOIDという整数型変数を持たない場合、オブジェクトは保存されます。しかし、その後にそのオブジェクトを取り出し、修正し、再度保存した場合に、その新しい状態はテーブルに追加され、古いエントリを上書きしません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="store()めそっど">store()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            o――保存するオブジェクト（Serializableを実装する必要があります）
        </para>
       </formalpara>


       <formalpara>
        <title>戻り値</title>
        <para>
            保存したオブジェクトのoid
        </para>
       </formalpara>


       <formalpara>
        <title>例外</title>
        <para>
            SQLException――エラー時
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>create</para></emphasis>
<synopsis>
public static void create(org.postgresql.Connection con,
                          Object o) throws SQLException
</synopsis>
<!--
          This method is not used by the driver, but it creates a 
table, given a Serializable Java Object. It should be used before 
serializing any objects.

        Parameters:
                c - Connection to database
                o - Object to base table on

        Throws: SQLException
                on error
-->
       <para>
          このメソッドはドライバで使われませんが、Serializableを実装した指定Javaオブジェクトに対応するテーブルを作成します。オブジェクトの直列化を行う前に使用しなければいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="create()めそっど">create()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>c――データベースへのConnectionオブジェクト</para></listitem>
            <listitem><para>o――テーブルに基づくオブジェクト</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
            SQLException――エラー時
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>create</para></emphasis>
<synopsis>
public static void create(org.postgresql.Connection con,
                          Class c) throws SQLException
</synopsis>
<!--
          This method is not used by the driver, but it creates a 
table, given a Serializable Java Object. It should be used before 
serializing any objects.

        Parameters:
                c - Connection to database
                o - Class to base table on

        Throws: SQLException
                on error
-->
       <para>
          このメソッドはドライバで使われませんが、Serializableを実装した指定Javaオブジェクトに対応するテーブルを作成します。オブジェクトの直列化を行う前に使用しなければいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="create()めそっど">create()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>c――データベースへのConnectionオブジェクト</para></listitem>
            <listitem><para>o――テーブルに基づくオブジェクト</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
            SQLException――エラー時
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>toPostgreSQL</para></emphasis>
<synopsis>
public static String toPostgreSQL(String name) throws SQLException
</synopsis>
<!--
          This converts a Java Class name to a <productname>PostgreSQL</productname> table, by
          replacing . with _

          Because of this, a Class name may not have _ in the name.

          Another limitation, is that the entire class name (including
          packages) cannot be longer than 31 characters (a limit 
forced by PostgreSQL).

        Parameters:
                name - Class name

        Returns:
                PostgreSQL table name

        Throws: SQLException
                on error
-->
       <para>
          Javaのクラス名の「.」を「_」に置換してPostgreSQLテーブルに変換します。この理由は、クラス名は「_」を持つことができないからです。他の制限として、（パッケージを含めた）完全なクラス名は31文字を越えられないことがあります（これはPostgreSQLによる制限です）。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="toPostgreSQL()めそっど">toPostgreSQL()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            name――クラス名
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLのテーブル名
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
            SQLException――エラー時
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>toClassName</para></emphasis>
<synopsis>
public static String toClassName(String name) throws SQLException
</synopsis>
<!--
          This converts a <productname>PostgreSQL</productname> table to a Java Class name, by
          replacing _ with .

        Parameters:
                name - PostgreSQL table name
  
        Returns:
                Class name

        Throws: SQLException
                on error
-->
       <para>
          PostgreSQLのテーブルを「_」を「.」に置換してJavaのクラス名に変換します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.Serializeくらす">org.postgresql.util.Serializeクラス</secondary><tertiary sortas="toClassName()めそっど">toClassName()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            name――PostgreSQLテーブル名
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                クラス名
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>SQLException――エラー時
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>
</sect2>

<sect2>
<!-- **************************************************************** -->
<!-- Utility Classes -->
<title>ユーティリティクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="ゆーてぃりてぃくらす">ユーティリティクラス</secondary></indexterm>
<!-- The org.postgresql.util package contains classes used by the internals of 
the main driver, and the other extensions. -->
<para>org.postgresql.utilパッケージには、主ドライバやその他の拡張機能の内部で使用されるクラスがあります。</para>

<!-- Class org.postgresql.util.PGmoney -->
<sect3>
<title>
org.postgresql.util.PGmoneyクラス<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary></indexterm>
</title>

<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.util.PGmoney
</programlisting>

<synopsis>
public class PGmoney extends PGobject implements Serializable, 
Cloneable
</synopsis>
<!--
   This implements a class that handles the PostgreSQL money type
-->
       <para>
PostgreSQLmoney型を取り扱うクラスを実装したものです。
       </para>

<sect4>
<!-- Variables -->
<title>変数</title>

<synopsis>
public double val
</synopsis>
       <para>
<!--
          The value of the field
-->
          フィールドの値です。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="valへんすう">val変数</tertiary></indexterm>
       </para>
</sect4>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
    <itemizedlist>
      <listitem>
      <emphasis><para>PGmoney</para></emphasis>
<synopsis>
public PGmoney(double value)
</synopsis>
<!--
        Parameters:
                value - of field
-->

       <formalpara>
        <title>パラメータ</title>
        <para>
            value――フィールドの値
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGmoney</para></emphasis>
<synopsis>
public PGmoney(String value) throws SQLException
</synopsis>
<!--
          Create a money.

        Parameters:
                value - Definition of this money in PostgreSQL's 
syntax
-->
        <para>
          金額を作ります。
       </para>
       <formalpara>
        <title>パラメータ</title>
        <para>
            value――PostgreSQLの構文で表した金額の定義
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>PGmoney</para></emphasis>
<synopsis>
public PGmoney()
</synopsis>
<!--
          Required by the driver
-->
        <para>
          ドライバで必要とされます。
       </para>
      </listitem>
    </itemizedlist>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>
    <itemizedlist>
      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String s) throws SQLException
</synopsis>
<!--
        Parameters:
                s - Definition of this money in PostgreSQL's syntax

        Throws: SQLException
                on conversion failure

        Overrides:
                setValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            s――PostgreSQL構文によるこの金額の定義
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――変換失敗時
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのsetValue
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
        Parameters:
                obj - Object to compare with
                                
        Returns:
                true if the two moneys are identical

        Overrides:
                equals in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つの金額が同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class PGobject
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
        Returns:
                the PGmoney in the syntax expected by <productname>PostgreSQL</productname>

        Overrides:
                getValue in class PGobject
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGmoneyくらす">org.postgresql.util.PGmoneyクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                PostgreSQLで期待される構文で表したPGmoney
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                PGobjectクラスのgetValue
        </para>
       </formalpara>
      </listitem>
   </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.util.PGobject -->
<title>org.postgresql.util.PGobjectクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGobject
</programlisting>

<synopsis>
public class PGobject extends Object implements Serializable, 
Cloneable
</synopsis>
<!--
   This class is used to describe data types that are unknown by
     <acronym>JDBC</acronym> 
Standard.
    A call to org.postgresql.Connection permits a class that extends this 
class to be associated with a named type. This is how the 
org.postgresql.geometric package operates.
    ResultSet.getObject() will return this class for any type that is 
not recognized on having it's own handler. Because of this, any 
<productname>PostgreSQL</productname> data type is supported.
-->
<para>
  このクラスは、JDBCの標準では未知のデータ型を記述するために使用されます。org.postgresql.Connectionへの呼び出しでは、指定した型に関連付けられた、このクラスを継承したクラスを使用することができます。これはorg.postgresql.geometricパッケージが動作する方法です。ResultSet.getObject()は、ハンドラを使って認識できなかった型の場合、すべてこのクラスを返します。これにより任意のPostgreSQLのデータ型がサポートされます。
</para>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
<synopsis>
public PGobject()
</synopsis>
<!--
          This is called by org.postgresql.Connection.getObject() to 
create the object.
-->
       <para>
          オブジェクトを作成するときにorg.postgresql.Connection.getObject()
          から呼び出されます。
       </para>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>
<itemizedlist>
      <listitem>
      <emphasis><para>setType</para></emphasis>
<synopsis>
public final void setType(String type)
</synopsis>
<!--
          This method sets the type of this object.

          It should not be extended by subclasses, hence its final

        Parameters:
                type - a string describing the type of the object
-->
       <para>
          このメソッドはこのオブジェクトの型を設定します。サブクラスで継承されてはいけませんので、finalメソッドです。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="setType()めそっど">setType()メソッド</tertiary></indexterm>

       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            type――オブジェクトの型を示す文字列
        </para>
       </formalpara>
      </listitem>


      <listitem>
      <emphasis><para>setValue</para></emphasis>
<synopsis>
public void setValue(String value) throws SQLException
</synopsis>
<!--
          This method sets the value of this object. It must be 
overridden.

        Parameters:
                value - a string representation of the value of the
                object

        Throws: SQLException
                thrown if value is invalid for this type
-->
       <para>
          このオブジェクトに値を設定します。オーバーライドされなければいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="setValue()めそっど">setValue()メソッド</tertiary></indexterm>
       </para>


       <formalpara>
        <title>パラメータ</title>
        <para>
            value――そのオブジェクトの値の文字列表現
        </para>
       </formalpara>

       <formalpara>
        <title>例外</title>
        <para>
          SQLException――値がこの型で無効だった場合
         </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getType</para></emphasis>
<synopsis>
public final String getType()
</synopsis>
<!--
          As this cannot change during the life of the object, it's 
final.

        Returns:
                the type name of this object
-->
       <para>
          このオブジェクトが有効である間に変更することができないように、finalとします。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="getType()めそっど">getType()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>戻り値</title>
        <para>このオブジェクトの型名
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getValue</para></emphasis>
<synopsis>
public String getValue()
</synopsis>
<!--
          This must be overridden, to return the value of the object, 
in the form required by <productname>PostgreSQL</productname>.

        Returns:
                the value of this object
-->
       <para>
          オブジェクトの値をPostgreSQLで要求された形式で返すために、これはオーバーライドされなければいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="getType()めそっど">getType()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>戻り値</title>
        <para>
                オブジェクトの値
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>equals</para></emphasis>
<synopsis>
public boolean equals(Object obj)
</synopsis>
<!--
          This must be overridden to allow comparisons of objects

        Parameters:
                obj - Object to compare with

        Returns:
                true if the two objects are identical

        Overrides:
                equals in class Object
-->
       <para>
          オブジェクトの比較ができるように、オーバーライドされなければいけません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="equals()めそっど">equals()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            obj――比較するオブジェクト
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2つのオブジェクトが同一ならば真
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                Objectクラスのequals
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>clone</para></emphasis>
<synopsis>
public Object clone()
</synopsis>
<!--
          This must be overridden to allow the object to be cloned

        Overrides:
                clone in class Object
-->
       <para>
          このメソッドはオブジェクトの複製を可能にするためにオーバーライドする必要があります。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="clone()めそっど">clone()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                Objectクラスのclone
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>toString</para></emphasis>
<synopsis>
public String toString()
</synopsis>
<!--
          This is defined here, so user code need not override it.
          
        Returns:
                the value of this object, in the syntax expected by 
<productname>PostgreSQL</productname>

        Overrides:
                toString in class Object
-->
       <para>
          ここで定義されています。ユーザーのコードでオーバーライドする必要はありません。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGobjectくらす">org.postgresql.util.PGobjectクラス</secondary><tertiary sortas="toString()めそっど">toString()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>戻り値</title>
        <para>
              PostgreSQLで期待される構文を使ったこのオブジェクトの値
        </para>
       </formalpara>

       <formalpara>
        <title>オーバーライド</title>
        <para>
                ObjectクラスのtoString
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.util.PGtokenizer -->
<title>org.postgresql.util.PGtokenizerクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.PGtokenizer
</programlisting>

<synopsis>
public class PGtokenizer extends Object
</synopsis>
<!--
   This class is used to tokenize the text output of <productname>PostgreSQL</productname>.

   We could have used StringTokenizer to do this, however, we needed 
to handle nesting of '(' ')' '[' ']' '<' and '>' as these are used by 
the geometric data types.

   It's mainly used by the geometric classes, but is useful in parsing 
any output from custom data types output from <productname>PostgreSQL</productname>.
                 
   See Also:
          PGbox, PGcircle, PGlseg, PGpath, PGpoint, PGpolygon
-->
       <para>
   このクラスは、PostgreSQLのテキスト出力のトークン化に使用されます。以前はStringTokenizerを使用していましたが、幾何データ型で使用される、入れ子状の 「(」、「)」、「[」、「]」、「&lt;」、「&gt;」を扱う必要がありました。主に幾何クラスにて使用されますが、PostgreSQLから生成されるどのようなカスタムデータ型の出力の解析にも使用できます。
       </para>

       <formalpara>
        <title>参照</title>
        <para>
          PGbox、PGcircle、PGlseg、PGpath、PGpoint、PGpolygon
        </para>
       </formalpara>

<sect4>
<!-- Constructors -->
<title>コンストラクタ</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="こんすとらくた">コンストラクタ</tertiary></indexterm>
<synopsis>
public PGtokenizer(String string,
                   char delim)
</synopsis>
<!--
          Create a tokenizer.
        
        Parameters:
                string - containing tokens
                delim - single character to split the tokens
-->
       <para>
          トークン化機構を生成します。
       </para>


       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>string――トークン化する文字列</para></listitem>
            <listitem><para>delim――トークンをわける1つの文字</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
</sect4>

<sect4>
<!-- Methods -->
<title>メソッド</title>
    <itemizedlist>

      <listitem>
      <emphasis><para>tokenize</para></emphasis>
<synopsis>
public int tokenize(String string,
                    char delim)
</synopsis>
<!--
          This resets this tokenizer with a new string and/or 
delimiter.

        Parameters:
                string - containing tokens
                delim - single character to split the tokens
-->
       <para>
          新しい文字列と区切り文字でトークン化機構をリセットします。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="tokenize()めそっど">tokenize()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>string――トークン化する文字列</para></listitem>
            <listitem><para>delim――トークンをわける1つの文字</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getSize</para></emphasis>
<synopsis>
public int getSize()
</synopsis>
<!--
        Returns:
                the number of tokens available
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="getSize()めそっど">getSize()メソッド</tertiary></indexterm>
       <formalpara>
        <title>戻り値</title>
        <para>
                利用可能なトークン数
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>getToken</para></emphasis>
<synopsis>
public String getToken(int n)
</synopsis>
<!--
        Parameters:
                n - Token number ( 0 ... getSize()-1 )

        Returns:
                The token value
-->
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="getToken()めそっど">getToken()メソッド</tertiary></indexterm>
       <formalpara>
        <title>パラメータ</title>
        <para>
            n――トークン番号（0 ... getSize()-1）
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                トークンの値
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>tokenizeToken</para></emphasis>
<synopsis>
public PGtokenizer tokenizeToken(int n, char delim)
</synopsis>
<!--
          This returns a new tokenizer based on one of our tokens. The 
geometric data types use this to process nested tokens (usually 
PGpoint).

        Parameters:
                n - Token number ( 0 ... getSize()-1 )
                delim - The delimiter to use

        Returns:
                A new instance of PGtokenizer based on the token
-->
       <para>
          トークンの1つに基づく新しいトークン化機構を返します。幾何データ型（通常はPGpoint）はこれを使用して入れ子状のトークンを処理します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="tokenizeToken()めそっど">tokenizeToken()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>n――トークン番号（0 ... getSize()-1）</para></listitem>
            <listitem><para>delim――使用する区切り文字</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                トークンに基づく新しいPGtokenizerインスタンス
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>remove</para></emphasis>
<synopsis>
public static String remove(String s,
                            String l,
                            String t)
</synopsis>
<!--
          This removes the lead/trailing strings from a string

        Parameters:
                s - Source string
                l - Leading string to remove
                t - Trailing string to remove
                
        Returns:
                String without the lead/trailing strings
-->
       <para>
          文字列の前/後ろの文字列を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="remove()めそっど">remove()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>s――元となる文字列</para></listitem>
            <listitem><para>l――前から削除する文字列</para></listitem>
            <listitem><para>t――後ろから削除する文字列</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                前/後ろの文字列を削除した文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>remove</para></emphasis>
<synopsis>
public void remove(String l,
                   String t)
</synopsis>
<!--
          This removes the lead/trailing strings from all tokens

        Parameters:
                l - Leading string to remove
                t - Trailing string to remove
-->
       <para>
          すべてのトークンから前/後ろの文字列を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="remove()めそっど">remove()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>l――前から削除する文字列</para></listitem>
            <listitem><para>t――後ろから削除する文字列</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>removePara</para></emphasis>
<synopsis>
public static String removePara(String s)
</synopsis>
<!--
          Removes ( and ) from the beginning and end of a string

        Parameters:
                s - String to remove from

        Returns:
                String without the ( or )
-->
       <para>
          文字列の始めと終わりにある「(」と「)」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removePara()めそっど">removePara()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            s――削除対象文字列
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                「(」と「)」を削除した文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>removePara</para></emphasis>
<synopsis>
public void removePara()
</synopsis>
<!--
          Removes ( and ) from the beginning and end of all tokens
-->
       <para>
          すべてのトークンの始めと終わりにある「(」と「)」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removePara()めそっど">removePara()メソッド</tertiary></indexterm>
       </para>

      </listitem>

      <listitem>
      <emphasis><para>removeBox</para></emphasis>
<synopsis>
public static String removeBox(String s)
</synopsis>
<!--
          Removes [ and ] from the beginning and end of a string

        Parameters:
                s - String to remove from
   
        Returns:
                String without the [ or ]
-->
       <para>
          文字列の始めと終わりにある「[」と「]」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removeBox()めそっど">removeBox()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            s――削除対象文字列
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                「[」と「]」を削除した文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>removeBox</para></emphasis>
<synopsis>
public void removeBox()
</synopsis>
<!--
          Removes [ and ] from the beginning and end of all tokens
-->
       <para>
          すべてのトークンの始めと終わりにある「[」と「]」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removeBox()めそっど">removeBox()メソッド</tertiary></indexterm>
        </para>
      </listitem>

      <listitem>
      <emphasis><para>removeAngle</para></emphasis>
<synopsis>
public static String removeAngle(String s)
</synopsis>
<!--
          Removes < and > from the beginning and end of a string

        Parameters:
                s - String to remove from

        Returns:
                String without the < or >
-->
       <para>
          文字列の始めと終わりにある「&lt;」と「&gt;」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removeAngle()めそっど">removeAngle()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            s――削除対象文字列
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
               「&lt;」と「&gt;」を削除した文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>removeAngle</para></emphasis>
<synopsis>
public void removeAngle()
</synopsis>
<!--
          Removes < and > from the beginning and end of all tokens
-->
       <para>
          すべてのトークンの始めと終わりにある「&lt;」と「&gt;」を削除します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.PGtokenizerくらす">org.postgresql.util.PGtokenizerクラス</secondary><tertiary sortas="removeAngle()めそっど">removeAngle()メソッド</tertiary></indexterm>
       </para>
      </listitem>
     </itemizedlist>
</sect4>
</sect3>

<sect3>
<!-- **************************************************************** -->
<!-- Class org.postgresql.util.Serialize -->
<title>org.postgresql.util.Serializeクラス</title>

<!-- This was documented earlier under Object Serialization. -->
<para>このクラスは上のオブジェクト直列化の節で説明されました。</para>
</sect3>


<sect3>
<!-- Class org.postgresql.util.UnixCrypt -->
<title>org.postgresql.util.UnixCryptクラス</title>
<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.UnixCryptくらす">org.postgresql.util.UnixCryptクラス</secondary></indexterm>
<programlisting>
java.lang.Object
   |
   +----org.postgresql.util.UnixCrypt
</programlisting>

<synopsis>
public class UnixCrypt extends Object
</synopsis>
<!--
   This class provides us with the ability to encrypt passwords when 
sent over the network stream

   Contains static methods to encrypt and compare passwords with Unix 
encrypted passwords.

   See John Dumas's Java Crypt page for the original source.
-->
<para>
   このクラスは、ネットワークに暗号化パスワードを送信する能力を提供します。暗号化とUnixの暗号化パスワードと比較する静的メソッドを持ちます。
</para>

<sect4>
<!-- Methods -->
<title>メソッド</title>
<itemizedlist>

      <listitem>
      <emphasis><para>crypt</para></emphasis>
<synopsis>
public static final String crypt(String salt,
                                 String original)
</synopsis>
<!--
          Encrypt a password given the clear-text password and a 
"salt".
   
        Parameters:
                salt - A two-character string representing the salt 
used
                to iterate the encryption engine in lots of different
                ways. If you are generating a new encryption then this
                value should be randomized.
                original - The password to be encrypted.

        Returns:
                A string consisting of the 2-character salt followed 
by
                the encrypted password.
-->
       <para>
         指定された平文パスワードと「ソルト」でパスワードを暗号化します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.UnixCryptくらす">org.postgresql.util.UnixCryptクラス</secondary><tertiary sortas="crypt()めそっど">crypt()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>salt――暗号化エンジンを多くの異なった方法で繰り返させるために使用するソルトを表した2文字の文字列。新しく暗号を生成したい場合は、この値を乱数化しなければいけません</para></listitem>
            <listitem><para>original――暗号化対象のパスワード</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2文字のソルトとそれに続く暗号化パスワードで構成される文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>crypt</para></emphasis>
<synopsis>
public static final String crypt(String original)
</synopsis>
<!--
          Encrypt a password given the clear-text password. This method 
generates a random salt using the 'java.util.Random' class.

        Parameters:
                original - The password to be encrypted.
   
        Returns: 
                A string consisting of the 2-character salt followed 
by
                the encrypted password.
-->
       <para>
         指定された平文パスワードを暗号化します。このメソッドはjava.util.Randomクラスを使用して乱数化されたソルトを生成します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.UnixCryptくらす">org.postgresql.util.UnixCryptクラス</secondary><tertiary sortas="crypt()めそっど">crypt()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
            original――暗号化対象パスワード
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
                2文字のソルトとそれに続く暗号化パスワードで構成される文字列
        </para>
       </formalpara>
      </listitem>

      <listitem>
      <emphasis><para>matches</para></emphasis>
<synopsis>
public static final boolean matches(String encryptedPassword,
                                    String enteredPassword)
</synopsis>
<!--
          Check that enteredPassword encrypts to encryptedPassword.
               
        Parameters:
                encryptedPassword - The encryptedPassword. The first 
two characters are assumed to be the salt. This string would be the 
same as one found in a Unix /etc/passwd file.
                enteredPassword - The password as entered by the user 
(or otherwise acquired).

        Returns:
                true if the password should be considered correct.
-->
       <para>
          引数enteredPasswordを暗号化し、引数encryptedPasswordと照合します。<indexterm><primary>JDBC</primary><secondary sortas="org.postgresql.util.UnixCryptくらす">org.postgresql.util.UnixCryptクラス</secondary><tertiary sortas="matches()めそっど">matches()メソッド</tertiary></indexterm>
       </para>

       <formalpara>
        <title>パラメータ</title>
        <para>
          <itemizedlist>
            <listitem><para>encryptedPassword――暗号化されたパスワード。最初の2文字はソルトと仮定されます。この文字列はUnixの/etc/passwdファイルにあるものと同一のものです</para></listitem>
            <listitem><para>enteredPassword――ユーザーが入力した（または別の方法で入手した）パスワード</para></listitem>
          </itemizedlist>
        </para>
       </formalpara>

       <formalpara>
        <title>戻り値</title>
        <para>
              パスワードが正しいとみなされた場合、真
        </para>
       </formalpara>
      </listitem>
     </itemizedlist>
    </sect4>
   </sect3>
  </sect2>

 </sect1>
<!-- **************************************************************** -->

 <sect1 id="jdbc-thread">
  <!-- <title>Using the driver in a multi-threaded or a servlet environment</title> -->
  <title>複数のスレッド、サーブレット環境におけるドライバの使用</title>
<indexterm><primary>JDBC</primary><secondary sortas="ふくすうのすれっどさーぶれっと">複数のスレッド/サーブレット</secondary></indexterm>
  <para>
   <!-- A problem with many <acronym>JDBC</acronym> drivers is that only
   one thread can use a <classname>Connection</classname> at any one
   time __ otherwise a thread could send a query while another one is
   receiving results, and this would be a bad thing for the database
   engine. -->
   多くの<acronym>JDBC</acronym>ドライバでは、ある時点でたった1つのスレッドだけが<classname>Connection</classname>オブジェクトを使用できるという問題があります。あるスレッドが結果を受け取っているときに別のスレッドが問い合わせを送る場合は別です。このことはデータベースエンジンにとって有害です。
  </para>

  <para>
   <!-- <productname>PostgreSQL</productname> 6.4 brought thread safety to
   the entire driver.  (Standard <acronym>JDBC</acronym> was thread
   safe in 6.3, but the Fastpath <acronym>API</acronym> was not.)
   Consequently, if your application uses multiple threads then you do
   not have to worry about complex algorithms to ensure that only one
   uses the database at any time. -->
   <productname>PostgreSQL</productname> 6.4で、ドライバ全体をスレッドセーフにしました（標準<acronym>JDBC</acronym>は6.3の段階でスレッドセーフでしたが、Fastpath <acronym>API</acronym>はそうではありませんでした）。したがって、アプリケーションで複数のスレッドを使用する場合、同時にデータベースを使用するスレッドがないことを確実にするための複雑なアルゴリズムを考える必要がありません。
  </para>

  <para>
   <!-- If a thread attempts to use the connection while another one is
   using it, it will wait until the other thread has finished its
   current operation.  If it is a regular <acronym>SQL</acronym>
   statement, then the operation consists of sending the statement and
   retrieving any <classname>ResultSet</classname> (in full).  If it
   is a <classname>Fastpath</classname> call (e.g., reading a block
   from a <classname>LargeObject</classname>) then it is the time to
   send and retrieve that block. -->
   スレッドが別のスレッドが使用しているときに接続を使用しようとすると、他のスレッドが完了するまでその操作は待たされます。標準<acronym>SQL</acronym>文の場合、操作とは文を送信し、何らかの<classname>ResultSet</classname>を（完全に）受け取ることです。<classname>Fastpath</classname>呼び出し（つまり<classname>LargeObject</classname>からブロックを読むこと）の場合、それはブロックを送信する、または、受け取る瞬間です。
  </para>

  <para>
   <!-- This is fine for applications and applets but can cause a
   performance problem with servlets.  With servlets you can have a
   heavy load on the connection. If you have several threads
   performing queries then each but one will pause, which may not be what
   you are after. -->
   これはアプリケーションやアプレットでは優れていますが、サーブレットの場合は性能に関する問題を発生させます。サーブレットでは、その接続に重い負荷をかけることができます。問い合わせを行う複数のスレッドがある場合、それぞれは待たされ、そして、それがその次に行われるとは限りません。
  </para>

  <para>
   <!-- To solve this, you would be advised to create a pool of
   connections.  When ever a thread needs to use the database, it asks
   a manager class for a <classname>Connection</classname>. The
   manager hands a free connection to the thread and marks it as
   busy. If a free connection is not available, it opens one.  Once
   the thread has finished with it, it returns it to the manager who
   can then either close it or add it to the pool. The manager would
   also check that the connection is still alive and remove it from
   the pool if it is dead. -->
   これを解消するために、<classname>Connection</classname>オブジェクトのプールを作成することをお勧めします。接続をそのスレッドに渡し、その接続に使用中と印を付けます。空き接続がなければ、接続を開きます。スレッドが処理を終えた段階で、管理クラスに返却します。管理クラスはその接続を閉じることも、また、プールに追加することもできます。また、管理クラスは接続が現在も有効かどうか点検し、もし無効であればそれをプールから削除します。
  </para>

  <para>
   <!-- So, with servlets, it is up to you to use either a single
   connection, or a pool. The plus side for a pool is that threads
   will not be hit by the bottle neck caused by a single network
   connection. The down side is that it increases the load on the
   server, as a backend process is created for each
   <classname>Connection</classname>.  It is up to you and your
   applications requirements. -->
   ですので、サーブレットでは、1つの接続を使用するかプールを使用するかは設計者に依存します。プールの場合の利点は、そのスレッドが1つのネットワーク接続が原因となるボトルネックの影響を受けないことです。欠点は、バックエンドプロセスが各接続用に生成されることで、サーバーの負荷が増大することです。設計者と、アプリケーションの要求仕様に依存します。
  </para>
 </sect1>


 <sect1 id="jdbc-reading">
  <!-- <title>Further Reading</title> -->
  <title>今後に読むべきもの</title>

  <para>
   <!-- If you have not yet read it, I'd advise you read the
   <acronym>JDBC</acronym> <acronym>API</acronym> Documentation
   (supplied with Sun's <acronym>JDK</acronym>), and the
   <acronym>JDBC</acronym> Specification.  Both are available from
   <ulink
   url="http://java.sun.com/products/jdbc/index.html">http://java.sun.com/products/jdbc/index.html</ulink>. -->
   まだ読んでいなければ、（Sun Microsystems社の<acronym>JDK</acronym>に内包された）<acronym>JDBC</acronym> <acronym>API</acronym>文書と<acronym>JDBC</acronym>仕様書を読むことをお勧めします。両方とも<ulink url="http://java.sun.com/products/jdbc/index.html">http://java.sun.com/products/jdbc/index.html</ulink>から入手できます。
  </para>

  <para>
   <!-- <ulink
   url="http://jdbc.postgresql.org">http://jdbc.postgresql.org/</ulink>
   contains updated information not included in this document, and
   also includes precompiled drivers. -->
   <ulink url="http://jdbc.postgresql.org">http://jdbc.postgresql.org/</ulink>では、この文書に含まれていない情報を更新しています。また、コンパイル済みのドライバもあります。
  </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:
-->
