<!--
$Header: /usr/prj/pg/cvsroot/doc/doc/src/sgml/xfunc.sgml,v 1.15 2001/09/13 06:07:40 junichi Exp $
-->

 <chapter id="xfunc">
  <!--<title id="xfunc-title">Extending <acronym>SQL</acronym>: Functions</title>-->
  <title id="xfunc-title"><acronym>SQL</acronym>の拡張――関数</title>
<indexterm><primary>SQL</primary><secondary sortas="かくちょう">拡張</secondary><tertiary sortas="かんすう">関数</tertiary></indexterm>
  <para>
   <!--As  it  turns  out,  part of defining a new type is the
   definition of functions  that  describe  its  behavior.
   Consequently,  while  it  is  possible  to define a new
   function without defining a new type,  the  reverse  is
   not  true.   We therefore describe how to add new functions 
   to <productname>Postgres</productname> before  describing  
   how  to  add  new types.-->

   新しい型の定義を行うことは、結局のところ、その関数の動作の定義を行うということになります。したがって、新しい型を定義せずに新しい関数を定義する事は可能ですが、その逆はできません。そこで、この章では新しい型を定義する前に新しい関数を<productname>Postgres</productname>に追加する方法を記します。
  </para>

  <para>
   <!--<productname>Postgres</productname> <acronym>SQL</acronym>  
   provides  three types of functions:-->

   <productname>Postgres</productname> <acronym>SQL</acronym>では、下記の3つの関数を提供しています。
   </para>

   <itemizedlist>
    <listitem>
     <para>
      <!--query language functions 
      (functions written in <acronym>SQL</acronym>)-->

      問い合わせ言語関数（<acronym>SQL</acronym>で書かれた関数）<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="といあわせげんごかんすう">問い合わせ言語関数</secondary></indexterm>
     </para>
    </listitem>
    <listitem>
     <para>
      <!--procedural language 
      functions (functions written in, for example, PLTCL or PLSQL)-->

      手続き型言語関数（PLTCLやPLSQLなどで書かれた関数）<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="てつづきがたげんごかんすう">手続き型言語関数</secondary></indexterm>
     </para>
    </listitem>
    <listitem>
     <para>
      <!--programming  
      language  functions  (functions  written in a compiled 
      programming language such as <acronym>C</acronym>)-->

      プログラミング言語関数（<acronym>C</acronym>などの、コンパイルされたプログラミング言語で書かれた関数）<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="ぷろぐらみんぐげんごかんすう">プログラミング言語関数</secondary></indexterm>
     </para>
    </listitem>
   </itemizedlist>

<para>
   <!--Every kind
   of  function  can take a base type, a composite type or
   some combination as arguments (parameters).   In  addition, 
   every kind of function can return a base type or
   a composite type.  It's easiest to define <acronym>SQL</acronym> 
   functions, so we'll start with those.  Examples in this section 
   can also be found in <filename>funcs.sql</filename> 
   and <filename>funcs.c</filename>.-->

   すべての関数は、基本型、複合型、または変数（引数）の組み合わせを受け付けることが可能です。また、すべての関数は基本型、または複合型を返すことが可能です。SQL関数の定義の方法は簡単ですので、そちらから説明します。この章の例は<filename>funcs.sql</filename>と<filename>funcs.c</filename>でも参照することができます。
  </para>

  <sect1 id="xfunc-sql">
   <!--<title>Query Language (<acronym>SQL</acronym>) Functions</title>-->
   <title>問い合わせ言語（<acronym>SQL</acronym>）関数</title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="てつづきがたげんごかんすう">手続き型言語関数</secondary></indexterm>
   <para>
    <!--SQL functions execute an arbitrary list of SQL queries, returning
    the results of the last query in the list.  SQL functions in general
    return sets.  If their returntype is not specified as a
    <literal>setof</literal>,
    then an arbitrary element of the last query's result will be returned.-->

    SQL関数は、任意なSQL問い合わせリストを実行し、そのリストの最終結果を返します。SQL関数は、一般的には組（set）を返します。<literal>setof</literal>で返り型が設定されていない場合は、問い合わせの最終結果の任意の要素が返されます。</para>

   <para>
    <!--The body of a SQL function following AS
    should be a list of queries separated by semicolons and
    bracketed within single-quote marks.  Note that quote marks used in
    the queries must be escaped, by preceding them with a backslash.-->

    ASの後に続くSQL関数の本文は、問い合わせのリストで構成され、それぞれの問い合わせがセミコロンで区切られ、なおかつ一重引用符で囲まれている必要があります。問い合わせで使用されたクォーテーションマークはその前にバックスラッシュを入れてエスケープさせる必要があります。
   </para>

   <para>
    <!--Arguments to the SQL function may be referenced in the queries using
    a $n syntax: $1 refers to the first argument, $2 to the second, and so
    on.  If an argument is complex, then a <firstterm>dot</firstterm>
    notation (e.g. "$1.emp") may be
    used to access attributes of the argument or
    to invoke functions.-->

    SQL関数の引数は問い合わせ内で$nを使って表すことができます。つまり、$1は第1引数を示し、$2は第2引数を...となります。引数が複雑な場合、「$1.emp」のような<firstterm>ドット</firstterm>表記で引数の属性にアクセスしたり関数を呼び出すことができます。
   </para>

   <sect2>
    <title><!--Examples-->例</title>

    <para>
     <!--To illustrate a simple SQL function, consider the following,
     which might be used to debit a bank account:-->

     簡単なSQL関数の例として、下記の銀行口座のからお金を引き出す例を見てみましょう。
   </para>

<programlisting>
CREATE FUNCTION tp1 (int4, float8) 
    RETURNS int4
    AS 'UPDATE bank 
        SET balance = bank.balance - $2
        WHERE bank.acctountno = $1;
        SELECT 1;'
LANGUAGE 'sql';
</programlisting>

<para>
     <!--A user could execute this function to debit account 17 by $100.00 as
     follows:-->

     ユーザーは下記の関数を使って、口座番号17から100ドルを引き出すことが可能です。
</para>

<programlisting>
SELECT tp1( 17,100.0);
</programlisting>

    <para>
     <!--The following more interesting example takes a single argument of type
     EMP, and retrieves multiple results:-->

     下記の関数はEMP型の引数を1つを持った関数の例です。これは引数は1つですが、複数の結果を返すものです。
</para>

<programlisting>
CREATE FUNCTION hobbies (EMP) RETURNS SETOF hobbies
    AS 'SELECT hobbies.* FROM hobbies
        WHERE $1.name = hobbies.person'
    LANGUAGE 'sql';
</programlisting>
   </sect2>

   <sect2>
    <!--<title><acronym>SQL</acronym> Functions on Base Types</title>-->
    <title>基本型を使った<acronym>SQL</acronym>関数</title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="きほんけいSQLかんすう">基本型SQL関数</secondary></indexterm>
    <para>
     <!--The simplest possible <acronym>SQL</acronym> function has no arguments and
     simply returns a base type, such as <literal>int4</literal>:-->

     最も簡単な<acronym>SQL</acronym>関数は、引数がなく、返す型が<literal>int4</literal>などの基本型の場合です。
</para>

<programlisting>
CREATE FUNCTION one() 
    RETURNS int4
    AS 'SELECT 1 as RESULT;' 
    LANGUAGE 'sql';

SELECT one() AS answer;

+-------+
|answer |
+-------+
|1      |
+-------+
</programlisting>

    <para>
     <!--Notice that we defined a column name for  the  function's result
     (with  the  name  RESULT),  but this column name is not visible
     outside the function.  Hence,  the  result  is labelled answer
     instead of one.-->

      上記の関数内で、RESULTという名前を関数の結果の列名として指定しましたが、関数の外ではその指定した名前は見えないので、列名がanswerとなっていることに注意してください。
    </para>
    <para>
     <!--It's almost as easy to define <acronym>SQL</acronym> functions  
     that take base types as arguments.  In the example below, notice
     how we refer to the arguments within the function as $1
     and $2:-->

     基本型を引数として持つ<acronym>SQL</acronym>関数を定義することも同じように簡単です。下記の例において、関数内で引数を参照するために$1と$2をどのように使用しているかに注意してください。
</para>

<programlisting>
CREATE FUNCTION add_em(int4, int4) 
    RETURNS int4
    AS 'SELECT $1 + $2;' 
    LANGUAGE 'sql';

SELECT add_em(1, 2) AS answer;

+-------+
|answer |
+-------+
|3      |
+-------+
</programlisting>
   </sect2>

   <sect2>
    <!--<title><acronym>SQL</acronym> Functions on Composite Types</title>-->
    <title>複合型を使った<acronym>SQL</acronym>関数</title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="ふくごうがたSQLかんすう">複合型SQL関数</secondary></indexterm>
    <para>
     <!--When  specifying  functions with arguments of composite
     types (such as EMP), we must  not  only  specify  which
     argument  we  want (as we did above with $1 and $2) but
     also the attributes of  that  argument.   For  example,
     take the function double_salary that computes what your
     salary would be if it were doubled:-->

     EMPなどのような複合型の引数を持つ関数を指定するときには、使用する引数を上記の例では単に$1、$2としていましたが、それに加えて引数の属性も指定する必要があります。たとえば、下記のような給料が倍になったらいくらになるのかを計算するdouble_salary関数を見てみましょう。
</para>

<programlisting>
CREATE FUNCTION double_salary(EMP) 
    RETURNS int4
    AS 'SELECT $1.salary * 2 AS salary;' 
    LANGUAGE 'sql';

SELECT name, double_salary(EMP) AS dream
    FROM EMP
    WHERE EMP.cubicle ~= point '(2,1)';


+-----+-------+
|name | dream |
+-----+-------+
|Sam  | 2400  |
+-----+-------+
</programlisting>

    <para>
     <!--Notice the use of the syntax $1.salary.
     Before launching into the  subject  of  functions  that
     return  composite  types,  we  must first introduce the
     function notation for projecting attributes.  The  simple  way 
     to explain this is that we can usually use the
     notations attribute(table)  and  table.attribute  interchangably:-->

     $1.salaryという使い方に注意してください。複合型を返す関数の話に進む前に、まず、属性を引き出すための関数記述方法を紹介しなくてはいけません。簡単に説明すると、通常は属性(テーブル)、つまり「attribute(table)」、またはクラス名.属性、つまり「table.attribute」のどちらの記述方法でも使用できます。
</para>

<programlisting>
--
-- this is the same as:
--  SELECT EMP.name AS youngster FROM EMP WHERE EMP.age &lt; 30
--
SELECT name(EMP) AS youngster
    FROM EMP
    WHERE age(EMP) &lt; 30;

+----------+
|youngster |
+----------+
|Sam       |
+----------+
</programlisting>

    <para>
     <!--As  we shall see, however, this is not always the case.
     This function notation is important when we want to use
     a  function that returns a single row.  We do this
     by assembling the entire row within the  function,
     attribute  by attribute.  This is an example of a function 
     that returns a single EMP row:-->

     見てわかるように、これは常に成り立つわけではありません。思います。この関数記述方法は、1つの行を返す関数を使いたいときには重要になります。それを行うには、関数内で1つの行すべてを属性ごとに組み立てます。以下に1つのEMP行を返す関数の例を示します。
</para>

<programlisting>
CREATE FUNCTION new_emp() 
    RETURNS EMP
    AS 'SELECT text ''None'' AS name,
        1000 AS salary,
        25 AS age,
        point ''(2,2)'' AS cubicle'
    LANGUAGE 'sql';
</programlisting>

    <para>
     <!--In this case we have specified each of  the  attributes
     with  a  constant value, but any computation or expression 
     could have been substituted for these constants.
     Defining a function like this can be tricky.   Some  of
     the more important caveats are as follows:-->

     この例では、各属性を定数を使って指定していますが、これらの定数を演算や式に置き換える事も可能です。このような関数の定義はコツが必要になります。より重要な注意点のうちの数点を下記に示します。
</para>

<itemizedlist>
      <listitem>
       <para>
	<!--The  target  list  order must be exactly the same as
	that in which the attributes appear  in  the  CREATE
	TABLE statement that defined the composite type.-->

        対象リストの順番はCREATE TABLE行（または.*クエリを実行したとき）に書かれている属性と正確に同じである必要があります。
       </para>
      </listitem>
      <listitem>
       <para>
	<!--You must typecast the expressions to match the
	composite type's definition, or you will get errors like this:-->

        型キャストを行う必要があります。行わない場合、下記のようなエラーメッセージが表示されます。
   </para>
<programlisting>
	 <computeroutput>
ERROR:  function declared to return emp returns varchar instead of text at column 1
	 </computeroutput>
</programlisting>
      </listitem>
      <listitem>
       <para>
	<!--When calling a function that returns a row, we
        cannot retrieve the entire row.  We must either
        project an attribute out of the row or pass the
        entire row into another function.-->

        行を返す関数を呼び出すときには、行全体を取り出すことはできません。その行から属性を引き出すか、別の関数にそのまま渡すかを
        する必要があります。
   </para>

<programlisting>
SELECT name(new_emp()) AS nobody;

+-------+
|nobody |
+-------+
|None   |
+-------+
</programlisting>
      </listitem>
      <listitem>
       <para>
	<!--The reason why, in general, we must use the function
        syntax  for projecting attributes of function return
        values is that the parser  just  doesn't  understand
        the  other (dot) syntax for projection when combined
        with function calls.-->

        一般的に、関数の戻り値の属性を引き出すためにその関数構文を使用しなければいけない理由は、関数の呼び出しが組み合わさったとき反映用のもう一方の（ドット）文法をパーサーが理解する事ができないためです。
   </para>

<programlisting>
SELECT new_emp().name AS nobody;
NOTICE:parser: syntax error at or near "."
</programlisting>
      </listitem>
     </itemizedlist>

    <para>
     <!--Any collection of commands in the  <acronym>SQL</acronym>  query  
     language can be packaged together and defined as a function.
     The commands can include updates (i.e.,
     <command>INSERT</command>, <command>UPDATE</command>, and
     <command>DELETE</command>) as well
     as <command>SELECT</command> queries.  However, the final command 
     must be a <command>SELECT</command> that returns whatever is
     specified as the function's returntype.-->

     <acronym>SQL</acronym>問い合わせ言語のコマンドの集まりはすべて、一緒にまとめて、1つの関数として定義することが可能です。コマンドは更新系（<command>INSERT</command>文、<command>UPDATE</command>文、<command>DELETE</command>文など）や、<command>SELECT</command>文を使用できます。しかし、関数の最後のコマンドは関数の返り型として指定されたものを返す<command>SELECT</command>文である必要があります。
</para>

<programlisting>
CREATE FUNCTION clean_EMP () 
    RETURNS int4
    AS 'DELETE FROM EMP 
        WHERE EMP.salary &lt;= 0;
        SELECT 1 AS ignore_this;'
    LANGUAGE 'sql';

SELECT clean_EMP();

+----------+
|clean_EMP |
+----------+
|1         |
+----------+
</programlisting>
   </sect2>
  </sect1>

  <sect1 id="xfunc-pl">
   <title><!--Procedural Language Functions-->
          手続型言語関数
   </title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="てつづきがたげんごかんすう">手続き型言語関数</secondary></indexterm>
   <para>
    <!--Procedural languages aren't built into Postgres. They are offered
    by loadable modules. Please refer to the documentation for the
    PL in question for details about the syntax and how the AS
    clause is interpreted by the PL handler.-->

    Postgresには、手続型言語はあらかじめ組み込まれておらず、動的ロード可能モジュールとして提供されています。構文の詳細に関しては、手続型言語のドキュメントを参照してください。また、AS句が手続型言語のハンドラにどのように認識されるかに関してもドキュメントを参照してください。
   </para>

   <para>
    <!--There are currently three procedural languages available in the standard
    <productname>Postgres</productname> distribution (PLSQL, PLTCL and
    PLPERL), and other languages can be defined.
    Refer to <xref linkend="xplang"> for
    more information.-->

    現在、標準の<productname>Postgres</productname>ディストリビューションでは、3つの手続型言語（PLSQL、PLTCL、PLPERL）が使用可能となっており、その他の言語も定義することが可能です。詳細は<xref linkend="xplang">を参照してください。
   </para>
  </sect1>

  <sect1 id="xfunc-internal">
   <title><!--Internal Functions-->内部関数</title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="ないぶかんすう">内部関数</secondary></indexterm>
   <para>
    <!--Internal functions are functions written in C that have been statically
    linked into the <productname>Postgres</productname> backend
    process. The AS
    clause gives the C-language name of the function, which need not be the
    same as the name being declared for SQL use.
    (For reasons of backwards compatibility, an empty AS
    string is accepted as meaning that the C-language function name is the
    same as the SQL name.)  Normally, all internal functions present in the
    backend are declared as SQL functions during database initialization,
    but a user could use <command>CREATE FUNCTION</command>
    to create additional alias names for an internal function.-->

    内部関数は、C言語で書かれていて、静的に<productname>Postgres</productname>のバックエンドプロセスにリンクされたものです。AS句は、C言語が名前の由来となっていて、SQLの仕様とは異なります（旧バージョンとの互換性のため、空のAS文字列はC言語の関数名とSQLの名称は等しいとし、許可されます）。一般的に、バックエンドにあるすべての内部関数はデータベースの初期化の際にはSQL関数として定義されます。しかし、ユーザーは内部関数の別名を新たに作成するときに、<command>CREATE FUNCTION</command>を使用することもできます。
   </para>

   <para>
    <!--Internal functions are declared in <command>CREATE FUNCTION</command>
    with language name <literal>internal</literal>.-->

    内部関数は、<literal>internal</literal>という言語名で<command>CREATE FUNCTION</command>に定義されています。
   </para>
  </sect1>

  <sect1 id="xfunc-c">
   <title><!--Compiled (C) Language Functions-->
          コンパイルされたC言語関数
   </title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="こんぱいるずみCげんごかんすう">コンパイル済みC言語関数</secondary></indexterm>
   <para>
    <!--Functions written in C can be compiled into dynamically loadable
    objects (also called shared libraries), and used to implement user-defined
    SQL functions.  The first time a user-defined function in a particular
    loadable object file is called in a backend session,
    the dynamic loader loads that object file into memory so that the
    function can be called.  The <command>CREATE FUNCTION</command>
    for a user-defined function must therefore specify two pieces of
    information for the function: the name of the loadable
    object file, and the C name (link symbol) of the specific function to call
    within that object file.  If the C name is not explicitly specified then
    it is assumed to be the same as the SQL function name.-->

    C言語で書かれた関数は動的にロード可能なオブジェクト（共有ライブラリ）にコンパイルすることができ、ユーザー定義されたSQL関数の実効の際に使用されます。バックエンドセッションで、特定のロード可能オブジェクトファイルで初めてユーザー定義関数が呼ばれたとき、動的ローダーは、関数を呼び出し可能とするために、そのオブジェクトファイルをメモリにロードします。したがって、ユーザー定義関数のための<command>CREATE FUNCTION</command>では関数に関する2つの情報、ロード可能オブジェクトファイル名とそのオブジェクトファイル内で呼び出すための、特定の関数のC言語名（リンクシンボル）を明記する必要があります。C言語名が明記されていない場合は、SQL関数名と同じ関数名として認識されます。
</para>

    <note>
     <para>
      <!--After it is used for the first time, a dynamically loaded user
      function is retained in memory, and future calls to the function
      in the same session will only incur the small overhead of a symbol table
      lookup.-->

      関数が一度使用されたら、動的にロードされたユーザー関数はメモリに記憶され、その関数が後に同じセッション内で呼ばれたときにはシンボルテーブルを参照するための極わずかなオーバーヘッドしかかからなくなります。
     </para>
    </note>

   <para>
    <!--The string that specifies the object file (the first string in the AS
    clause) should be the <emphasis>full path</emphasis> of the object
    code file for the function, bracketed by single quote marks.  If a
    link symbol is given in the AS clause, the link symbol should also be
    bracketed by single quote marks, and should be exactly the
    same as the name of the function in the C source code. On Unix systems
    the command <command>nm</command> will print all of the link
    symbols in a dynamically loadable object.-->

    オブジェクトファイルを指定する文字列（AS句の最初の文字列）はその関数のオブジェクトコードファイルの<emphasis>絶対パス</emphasis>であり、一重引用符で囲まれている必要があります。AS句でリンクシンボルが与えられている場合は、そのリンクシンボルも一重引用符で囲まれている必要があり、Cのソースコード内に記述されている関数名とまったく等しくなければいけません。Unixシステムの<command>nm</command>コマンドは、動的にロード可能なオブジェクトのすべてのリンクシンボルを表示させます。
</para>

    <note>
     <para>
      <!--<productname>Postgres</productname> will not compile a function
      automatically; it must be compiled before it is used in a CREATE
      FUNCTION command.  See below for additional information.-->

      <productname>Postgres</productname>では、自動的に関数をコンパイルしません。CREATE FUNCTIONコマンドで使用される前にコンパイルされる必要があります。詳細は下記を参照してください。
     </para>
    </note>

   <para>
    <!--Two different calling conventions are currently used for C functions.
    The newer "version 1" calling convention is indicated by writing
    a <literal>PG_FUNCTION_INFO_V1()</literal> macro call for the function,
    as illustrated below.  Lack of such a macro indicates an old-style
    ("version 0") function.  The language name specified in CREATE FUNCTION
    is 'C' in either case.  Old-style functions are now deprecated
    because of portability problems and lack of functionality, but they
    are still supported for compatibility reasons.-->

    C言語関数では、現在2つの呼び出し規約が使用されています。新しい「version 1」呼び出し規約は、下記のように、関数の<literal>PG_FUNCTION_INFO_V1()</literal>マクロ呼び出しを記述して示されています。このようなマクロの欠如は古いスタイル（「version 0」）関数を示します。CREATE FUNCTIONで指定された言語名は、どちらの場合ともC言語です。古いスタイルの関数は、移植性の問題と機能不足の問題がありますが、互換性の理由のためのみに今も存在しています。
   </para>

   <sect2>
    <title><!--Base Types in C-Language Functions-->
           C言語関数の基本型
    </title>

    <para>
     <!--The following table gives the C type required for parameters in the C
     functions that will be loaded into Postgres.  The "Defined In"
     column gives the actual header file (in the
     <filename>.../src/backend/</filename>
     directory) that the equivalent C type is defined.  Note that you should
     always include <filename>postgres.h</filename> first, and that in turn
     includes <filename>c.h</filename>.-->

     以下に示すテーブルは、PostgresにロードされるC言語関数の引数で必要とされるC言語の型の一覧です。「定義場所」（Defined In）列では、同等のC言語の型が定義されている実際のヘッダーファイル（<filename>.../src/backend/</filename>ディレクトリ）を示しています。必ず始めに<filename>postgres.h</filename>をインクルードし、それが<filename>c.h</filename>をインクルードすることに注意してください。
</para>

     <table tocentry="1">
      <title><!--Equivalent C Types
       for Built-In <productname>Postgres</productname> Types-->

        <productname>Postgres</productname>の基本型（組み込みの型）と同等なC言語型
      </title>
      <titleabbrev><!--Equivalent C Types-->同等C言語型</titleabbrev>
      <tgroup cols="3">
       <thead>
	<row>
	 <entry><!--Built-In Type-->組み込みの型
	 </entry>
	 <entry><!--C Type-->C言語型
	 </entry>
	 <entry><!--Defined In-->定義場所
	 </entry>
	</row>
       </thead>
       <tbody>
	<row>
	 <entry>abstime<indexterm><primary>abstime</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>abstime</secondary></indexterm></entry>
	 <entry>AbsoluteTime<indexterm><primary>AbsoluteTime</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>AbsoluteTime</secondary></indexterm></entry>
	 <entry>utils/nabstime.h</entry>
	</row>
	<row>
	 <entry>bool<indexterm><primary>bool</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>bool</secondary></indexterm></entry>
	 <entry>bool<indexterm><primary>bool</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>bool</secondary></indexterm></entry>
	 <entry>include/c.h</entry>
	</row>
	<row>
	 <entry>box<indexterm><primary>box</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>box</secondary></indexterm></entry>
	 <entry>(BOX *)<indexterm><primary>(BOX *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(BOX *)</secondary></indexterm></entry>
	 <entry>utils/geo-decls.h</entry>
	</row>
	<row>
	 <entry>bytea<indexterm><primary>bytea</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>bytea</secondary></indexterm></entry>
	 <entry>(bytea *)<indexterm><primary>(bytea *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(bytea *)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>"char"<indexterm><primary>"char"</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>"char"</secondary></indexterm></entry>
	 <entry>char<indexterm><primary>char</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>char</secondary></indexterm></entry>
	 <entry>N/A</entry>
	</row>
	<row>
	 <entry>cid<indexterm><primary>cid</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>cid</secondary></indexterm></entry>
	 <entry>CID<indexterm><primary>CID</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>CID</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>datetime<indexterm><primary>datetime</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>datetime</secondary></indexterm></entry>
	 <entry>(DateTime *)<indexterm><primary>(DateTime *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(DateTime *)</secondary></indexterm></entry>
	 <entry>include/c.h or include/postgres.h</entry>
	</row>
	<row>
	 <entry>int2<indexterm><primary>int2</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>int2</secondary></indexterm></entry>
	 <entry>int2<!-- or -->またはint16</entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>int2vector<indexterm><primary>int2vector</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>int2vector</secondary></indexterm></entry>
	 <entry>(int2vector *)<indexterm><primary>(int2vector *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(int2vector *)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>int4<indexterm><primary>int4</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>int4</secondary></indexterm></entry>
	 <entry>int4またはint32<indexterm><primary>int32</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>int32</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>float4<indexterm><primary>float4</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>float4</secondary></indexterm></entry>
	 <entry>(float4 *)<indexterm><primary>(float4 *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(float4 *)</secondary></indexterm></entry>
	<entry>include/c.h or include/postgres.h</entry>
	</row>
	<row>
	 <entry>float8<indexterm><primary>float8</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>float8</secondary></indexterm></entry>
	 <entry>(float8 *)<indexterm><primary>(float8 *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(float8 *)</secondary></indexterm></entry>
	 <entry>include/c.h or include/postgres.h</entry>
	</row>
	<row>
	 <entry>lseg<indexterm><primary>lseg</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>lseg</secondary></indexterm></entry>
	 <entry>(LSEG *)<indexterm><primary>(LSEG *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(LSEG *)</secondary></indexterm></entry>
	 <entry>include/geo-decls.h</entry>
	</row>
	<row>
	 <entry>name<indexterm><primary>name</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>name</secondary></indexterm></entry>
	 <entry>(Name)<indexterm><primary>(Name)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(Name)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>oid<indexterm><primary>oid</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>oid</secondary></indexterm></entry>
	 <entry>oid<indexterm><primary>oid</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>oid</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>oidvector<indexterm><primary>oidvector</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>oidvector</secondary></indexterm></entry>
	 <entry>(oidvector *)<indexterm><primary>(oidvector *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(oidvector *)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>path<indexterm><primary>path</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>path</secondary></indexterm></entry>
	 <entry>(PATH *)<indexterm><primary>(PATH *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(PATH *)</secondary></indexterm></entry>
	 <entry>utils/geo-decls.h</entry>
	</row>
	<row>
	 <entry>point<indexterm><primary>point</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>point</secondary></indexterm></entry>
	 <entry>(POINT *)<indexterm><primary>(POINT *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(POINT *)</secondary></indexterm></entry>
	 <entry>utils/geo-decls.h</entry>
	</row>
	<row>
	 <entry>regproc<indexterm><primary>regproc</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>regproc</secondary></indexterm></entry>
	 <entry>regproc<!-- or -->またはREGPROC<indexterm><primary>REGPROC</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>REGPROC</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>reltime<indexterm><primary>reltime</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>reltime</secondary></indexterm></entry>
	 <entry>RelativeTime<indexterm><primary>RelativeTime</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>RelativeTime</secondary></indexterm></entry>
	 <entry>utils/nabstime.h</entry>
	</row>
	<row>
	 <entry>text<indexterm><primary>text</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>text</secondary></indexterm></entry>
	 <entry>(text *)<indexterm><primary>(text *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(text *)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
	<row>
	 <entry>tid<indexterm><primary>tid</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>tid</secondary></indexterm></entry>
	 <entry>ItemPointer<indexterm><primary>ItemPointer</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>ItemPointer</secondary></indexterm></entry>
	 <entry>storage/itemptr.h</entry>
	</row>
	<row>
	 <entry>timespan<indexterm><primary>timespan</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>timespan</secondary></indexterm></entry>
	 <entry>(TimeSpan *)<indexterm><primary>(TimeSpan *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(TimeSpan *)</secondary></indexterm></entry>
	 <entry>include/c.h or include/postgres.h</entry>
	</row>
	<row>
	 <entry>tinterval<indexterm><primary>tinterval</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>tinterval</secondary></indexterm></entry>
	 <entry>TimeInterval<indexterm><primary>TimeInterval</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>TimeInterval</secondary></indexterm></entry>
	 <entry>utils/nabstime.h</entry>
	</row>
	<row>
	 <entry>xid<indexterm><primary>xid</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>xid</secondary></indexterm></entry>
	 <entry>(XID *)<indexterm><primary>(XID *)</primary></indexterm><indexterm><primary sortas="でーたがた">データ型</primary><secondary>(XID *)</secondary></indexterm></entry>
	 <entry>include/postgres.h</entry>
	</row>
       </tbody>
      </tgroup>
     </table>

    <para>
     <!--Internally, <productname>Postgres</productname> regards a
     base type as a "blob  of memory."   The  user-defined  
     functions that you define over a type in turn define the 
     way  that  <productname>Postgres</productname> can operate  
     on  it.  That is, <productname>Postgres</productname> will 
     only store and retrieve the data from disk and use  your  
     user-defined functions to input, process, and output the data.
     Base types can have one of three internal formats:-->

     <productname>Postgres</productname>の内部では、基本型を「blob of memory（メモリの斑点）」とみなしています。ある型について定義したユーザー定義関数は、同様に<productname>Postgres</productname>がその型をどのように実装するかを定義しています。つまり、<productname>Postgres</productname>はデータをディスクに保存し、ディスクからデータを受取り、ユーザー定義関数でそのデータを入力値として受け取り、処理/出力するために使用します。基本型は下記の3つのいずれかの内部フォーマットを使用しています。
</para>

     <itemizedlist>
      <listitem>
       <para>
	<!--pass by value, fixed-length-->
         値として渡す、固定長<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="あたいわたしのこていちょう">値渡しの固定長</secondary></indexterm><indexterm><primary sortas="あたいわたしひきすう">値渡し引数</primary></indexterm>
       </para>
      </listitem>
      <listitem>
       <para>
	<!--pass by reference, fixed-length-->
        参照として渡す、固定長<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="さんしょうわたしのこていちょう">参照渡しの固定長</secondary></indexterm><indexterm><primary sortas="さんしょうわたしひきすう">参照渡し引数</primary></indexterm><indexterm><primary sortas="こていちょうひきすう">固定長引数</primary></indexterm>
       </para>
      </listitem>
      <listitem>
       <para>
	<!--pass by reference, variable-length-->
        参照として渡す、可変長<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="さんしょうわたしのかへんちょう">参照渡しの可変長</secondary></indexterm><indexterm><primary sortas="かへんちょうひきすう">可変長引数</primary></indexterm>
       </para>
      </listitem>
     </itemizedlist>

    <para>
     <!--By-value  types  can  only be 1, 2 or 4 bytes in length
     (also 8 bytes, if sizeof(Datum) is 8 on your machine).
     You should be careful 
     to define your types such that  they  will  be  the  same  
     size (in bytes) on all architectures.  For example, the 
     <literal>long</literal> type is dangerous because  it  
     is 4 bytes on some machines and 8 bytes on others, whereas 
     <literal>int</literal>  type  is  4  bytes  on  most  
     Unix machines  (though  not  on most 
     personal computers).  A reasonable implementation of  
     the  <literal>int4</literal>  type  on  Unix
     machines might be:-->

     値として渡す型は1、2、4バイト長のみ可能です（使用するマシンのsizeof(Datum)が8の場合は8バイトも可能です）。データ型を定義する際、その型がすべてのアーキテクチャにおいて同一の大きさ（バイト数）となるように定義することに注意してください。たとえば、<literal>long</literal>型はマシンによっては4バイトであったり、8バイトであったりして危険ですが、<literal>int</literal>型はほとんどのUnixマシンでは4バイトです（しかし、多くのパーソナルコンピュータでは異なります）。Unixマシンの一般的な<literal>int4</literal>型の実装は下記のようなものとなります。
</para>

<programlisting>
/* 4-byte integer, passed by value */
typedef int int4;
</programlisting>

    <para>
     <!--On  the  other hand, fixed-length types of any size may
     be passed by-reference.  For example, here is a  sample
     implementation of a <productname>Postgres</productname> type:-->

     一方、任意の大きさの固定長の型は参照として引き渡すことが可能です。下記の、<productname>Postgres</productname>の型の実装サンプルを参照してください。
</para>

<programlisting>
/* 16-byte structure, passed by reference */
typedef struct
{
    double  x, y;
} Point;
</programlisting>

    <para>
     <!--Only  pointers  to  such types can be used when passing
     them in and out of <productname>Postgres</productname> functions.
     To return a value of such a type, allocate the right amount of
     memory with <literal>palloc()</literal>, fill in the allocated memory,
     and return a pointer to it.  (Alternatively, you can return an input
     value of the same type by returning its pointer.  <emphasis>Never</>
     modify the contents of a pass-by-reference input value, however.)-->

     それらの型のポインタのみが<productname>Postgres</productname>関数の入出力時に使用できます。それらの型を返すためには、<literal>palloc()</literal>を使用して正しい大きさのメモリ領域を割り当て、そのメモリ領域に値を入力し、それのポインタを返します（あるいは、ポインタを返すことによって同じ型の入力値を返すことも可能です。しかし、参照として渡すものの入力値の内容は<emphasis>決して</>変更しないでください）。
    </para>

    <para>
     <!--Finally, all variable-length types must also be  passed
     by  reference.   All  variable-length  types must begin
     with a length field of exactly 4 bytes, and all data to
     be  stored within that type must be located in the memory 
     immediately  following  that  length  field.   The
     length  field  is  the  total  length  of the structure
     (i.e.,  it  includes  the  size  of  the  length  field
     itself).  We can define the text type as follows:-->

     すべての可変長型は参照として引き渡す必要があります。また、すべての可変長型は正確に4バイトのlengthフィールドから始まる必要があり、その型に格納されるすべてのデータはlengthフィールドのすぐ後のメモリ領域に置かれる必要があります。lengthフィールドはその構造体の総長です（つまり、lengthフィールドそのものもその大きさに含まれます）。text型を定義するには、下記のように行えます。
</para>

<programlisting>
typedef struct {
    int4 length;
    char data[1];
} text;
</programlisting>

    <para>
     <!--Obviously,  the  data  field shown here is not long enough to hold
     all possible strings; it's impossible to declare such
     a  structure  in  <acronym>C</acronym>.  When manipulating 
     variable-length types, we must  be  careful  to  allocate  
     the  correct amount  of memory and initialize the length field.  
     For example, if we wanted to  store  40  bytes  in  a  text
     structure, we might use a code fragment like this:-->

     ここで示されているデータフィールドは、明らかにすべての取り得る文字列を保持できる長さではありません。<acronym>C言語</acronym>ではこのような構造を定義することは不可能です。可変長型を操作する場合、正しいメモリ領域を割り当て、lengthフィールドを初期化しなければいけません。たとえば、text構造に40バイト保持したい場合は、下記のようなコードを実行します。
</para>

<programlisting>
#include "postgres.h"
...
char buffer[40]; /* our source data */
...
text *destination = (text *) palloc(VARHDRSZ + 40);
destination-&gt;length = VARHDRSZ + 40;
memmove(destination-&gt;data, buffer, 40);
...
</programlisting>

    <para>
     <!--Now that we've gone over all of the possible structures
     for base types, we can show some examples of real functions.-->

      これで基本型用のすべてのあり得る構造体についての説明が完了しましたので、実際の関数の例をいくつか示します。
    </para>
   </sect2>

   <sect2>
    <title><!--Version-0 Calling Conventions for C-Language Functions-->
           C言語関数のためのVersion-0の呼び出し規約
    </title>
<indexterm><primary sortas="かんすう">関数</primary><secondary>Version-0</secondary></indexterm>
    <para>
     <!--We present the <quote>old style</quote> calling convention first - although
     this approach is now deprecated, it's easier to get a handle on
     initially.  In the version-0 method, the arguments and result
     of the C function are just declared in normal C style, but being
     careful to use the C representation of each SQL data type as shown
     above.-->

     まず最初に使用できませんが、理解しやすいので、<quote>古いスタイル（old style）</quote>の呼び出し規約を記述します。Version-0メソッドでは、C言語関数の引数を結果は、通常のCのプログラムの記述の方法と同じような形式で行いますが、上記の説明のように、各SQLのデータ型を示すC言語を使用する際には注意してください。
    </para>

    <para>
     <!--Here are some examples:-->
     以下に例を示します。
</para>

<programlisting>
#include "postgres.h"
#include &lt;string.h&gt;

/* <!--By Value-->値渡し */

int
add_one(int arg)
{
    return arg + 1;
}

/* <!--By Reference, Fixed Length-->参照渡し、固定長 */

float8 *
add_one_float8(float8 *arg)
{
    float8    *result = (float8 *) palloc(sizeof(float8));

    *result = *arg + 1.0;
       
    return result;
}

Point *
makepoint(Point *pointx, Point *pointy)
{
    Point     *new_point = (Point *) palloc(sizeof(Point));

    new_point->x = pointx->x;
    new_point->y = pointy->y;
       
    return new_point;
}

/* <!--By Reference, Variable Length-->参照渡し、可変長 */

text *
copytext(text *t)
{
    /*
     * VARSIZE is the total size of the struct in bytes.
     */
    text *new_t = (text *) palloc(VARSIZE(t));
    VARATT_SIZEP(new_t) = VARSIZE(t);
    /*
     * VARDATA is a pointer to the data region of the struct.
     */
    memcpy((void *) VARDATA(new_t), /* destination */
           (void *) VARDATA(t),     /* source */
           VARSIZE(t)-VARHDRSZ);    /* how many bytes */
    return new_t;
}

text *
concat_text(text *arg1, text *arg2)
{
    int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
    text *new_text = (text *) palloc(new_text_size);

    VARATT_SIZEP(new_text) = new_text_size;
    memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ);
    memcpy(VARDATA(new_text) + (VARSIZE(arg1)-VARHDRSZ),
           VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ);
    return new_text;
}
</programlisting>

    <para>
     <!--Supposing that the above code has been prepared in file
     <filename>funcs.c</filename> and compiled into a shared object,
     we could define the functions to <productname>Postgres</productname>
     with commands like this:-->

     上記のコードが<filename>funcs.c</filename>というファイルにあらかじめ用意され、共有オブジェクトにコンパイルされていたとすると、<productname>Postgres</productname>には下記のコマンドを使って定義できます。
</para>

<programlisting>
CREATE FUNCTION add_one(int4) RETURNS int4
     AS '<replaceable>PGROOT</replaceable>/tutorial/funcs.so' LANGUAGE 'c'
     WITH (isStrict);

-- <!--note overloading of SQL function name add_one()-->オーバーロードのSQL関数add_one()に注意
CREATE FUNCTION add_one(float8) RETURNS float8
     AS '<replaceable>PGROOT</replaceable>/tutorial/funcs.so',
        'add_one_float8'
     LANGUAGE 'c' WITH (isStrict);

CREATE FUNCTION makepoint(point, point) RETURNS point
     AS '<replaceable>PGROOT</replaceable>/tutorial/funcs.so' LANGUAGE 'c'
     WITH (isStrict);

CREATE FUNCTION copytext(text) RETURNS text
     AS '<replaceable>PGROOT</replaceable>/tutorial/funcs.so' LANGUAGE 'c'
     WITH (isStrict);

CREATE FUNCTION concat_text(text, text) RETURNS text
     AS '<replaceable>PGROOT</replaceable>/tutorial/funcs.so' LANGUAGE 'c'
     WITH (isStrict);
</programlisting>

    <para>
     <!--Here <replaceable>PGROOT</replaceable> stands for the full path to
     the <productname>Postgres</productname> source tree.  Note that
     depending on your system, the filename for a shared object might
     not end in <literal>.so</literal>, but in <literal>.sl</literal>
     or something else; adapt accordingly.-->

     ここで<replaceable>PGROOT</replaceable>は<productname>Postgres</productname>の
     ソースツリーの絶対パスを意味します。システムによっては、共有オブジェクトのファイル名の拡張子が<literal>.so</literal>ではなく、<literal>.sl</literal>の場合や、それ以外の可能性もあるので、システムによって変更しなければならないことに注意してください。
    </para>

    <para>
     <!--Notice that we have specified the functions as "strict", meaning that
     the system should automatically assume a NULL result if any input
     value is NULL.  By doing this, we avoid having to check for NULL inputs
     in the function code.  Without this, we'd have to check for NULLs
     explicitly, for example by checking for a null pointer for each
     pass-by-reference argument.  (For pass-by-value arguments, we don't
     even have a way to check!)-->

     ここで、関数を「厳格」と特定していること（isStrict）に注目してください。それは、もし入力された値がNULLであった場合に、システムが自動的に返り値もNULLであるとみなすことを意味します。これを行うことによって、関数のコードで入力値がNULLであるかどうかのチェックを行う必要がなくなります。これがなければ、各参照渡しの要素に対してそれがNULLのポインタであるかどうかのチェックを行うなどの、NULLの明示的なチェックを行う必要性が出てきます（値渡しに関しては、チェックを行う方法は存在しません）。<indexterm><primary sortas="げんかく">厳格</primary></indexterm><indexterm><primary sortas="かんすう">関数</primary><secondary sortas="げんかく">厳格</secondary></indexterm>
    </para>

    <para>
     <!--Although this calling convention is simple to use,
     it is not very portable; on some architectures there are problems
     with passing smaller-than-int data types this way.  Also, there is
     no simple way to return a NULL result, nor to cope with NULL arguments
     in any way other than making the function strict.  The version-1
     convention, presented next, overcomes these objections.-->

     これらの呼び出し規約は容易ですが、この方法は、int型のより小さいデータ型を引き渡す部分で問題を抱えているアーキテクチャでは、移植性の面ではあまり優れていません。また、関数の結果としてNULLを返す簡単な方法はありません。その上、引数としてNULLを処理する方法としては、関数を精密なものにする以外方法はありません。次に説明のあるVersion-1の規約ではこれらの問題が解決されています。
    </para>
   </sect2>

   <sect2>
    <title><!--Version-1 Calling Conventions for C-Language Functions-->
           C言語関数のためのVersion-1の呼び出し規約           
    </title>
<indexterm><primary sortas="かんすう">関数</primary><secondary>Version-1</secondary></indexterm>
    <para>
     <!--The version-1 calling convention relies on macros to suppress most
     of the complexity of passing arguments and results.  The C declaration
     of a version-1 function is always-->

     Version-1の呼び出し規約では、引数と結果の引き渡しの複雑さをなくすためにマクロを使用しています。Version-1関数のC言語宣言は必ず下記のように行います。
</para>

<programlisting>
Datum funcname(PG_FUNCTION_ARGS)
</programlisting>

<para>
     <!--In addition, the macro call-->
 
      また、以下のマクロの呼び出しが必ず同じソースファイルに書かれている必要があります（規約では、関数の直前で書かれています）。
</para>

<programlisting>
PG_FUNCTION_INFO_V1(funcname);
</programlisting>

<para>
     <!--must appear in the same source file (conventionally it's written
     just before the function itself).  This macro call is not needed
     for "internal"-language functions, since Postgres currently assumes
     all internal functions are version-1.  However, it is
     <emphasis>required</emphasis> for dynamically-loaded functions.-->

     現在Postgresではすべての内部関数はVersion-1であると認識するので、このマクロの呼び出しは内部言語関数では必要ありません。しかし、動的にロードされる関数では<emphasis>必要です</emphasis>。
    </para>

    <para>
     <!--In a version-1 function, each actual argument is fetched using a
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function>
     macro that corresponds to the argument's datatype, and the result
     is returned using a
     <function>PG_RETURN_<replaceable>xxx</replaceable>()</function>
     macro for the return type.-->

     Version-1関数では、それぞれの実際の引数は、引数の型に合った<function>PG_GETARG_<replaceable>xxx</replaceable>()</function>マクロを使用して呼び出され、結果は返り型に合った<function>PG_RETURN_<replaceable>xxx</replaceable>()</function>マクロを使用して返されます。<indexterm><primary>PG_GETARG_XXX</primary></indexterm><indexterm><primary>PG_RETURN_XXX</primary></indexterm>
    </para>

    <para>
     <!--Here we show the same functions as above, coded in version-1 style:-->
     下記は上記と同じ関数をVersion-1形式で記述したものです。
</para>

<programlisting>
#include "postgres.h"
#include &lt;string.h&gt;
#include "fmgr.h"

/* <!--By Value-->値渡し */

PG_FUNCTION_INFO_V1(add_one);
         
Datum
add_one(PG_FUNCTION_ARGS)
{
    int32   arg = PG_GETARG_INT32(0);

    PG_RETURN_INT32(arg + 1);
}

/* <!--By Reference, Fixed Length-->参照渡し、固定長 */

PG_FUNCTION_INFO_V1(add_one_float8);

Datum
add_one_float8(PG_FUNCTION_ARGS)
{
    /* The macros for FLOAT8 hide its pass-by-reference nature */
    float8   arg = PG_GETARG_FLOAT8(0);

    PG_RETURN_FLOAT8(arg + 1.0);
}

PG_FUNCTION_INFO_V1(makepoint);

Datum
makepoint(PG_FUNCTION_ARGS)
{
    /* Here, the pass-by-reference nature of Point is not hidden */
    Point     *pointx = PG_GETARG_POINT_P(0);
    Point     *pointy = PG_GETARG_POINT_P(1);
    Point     *new_point = (Point *) palloc(sizeof(Point));

    new_point->x = pointx->x;
    new_point->y = pointy->y;
       
    PG_RETURN_POINT_P(new_point);
}

/* <!--By Reference, Variable Length-->参照渡し、可変長 */

PG_FUNCTION_INFO_V1(copytext);

Datum
copytext(PG_FUNCTION_ARGS)
{
    text     *t = PG_GETARG_TEXT_P(0);
    /*
     * VARSIZE is the total size of the struct in bytes.
     */
    text     *new_t = (text *) palloc(VARSIZE(t));
    VARATT_SIZEP(new_t) = VARSIZE(t);
    /*
     * VARDATA is a pointer to the data region of the struct.
     */
    memcpy((void *) VARDATA(new_t), /* destination */
           (void *) VARDATA(t),     /* source */
           VARSIZE(t)-VARHDRSZ);    /* how many bytes */
    PG_RETURN_TEXT_P(new_t);
}

PG_FUNCTION_INFO_V1(concat_text);

Datum
concat_text(PG_FUNCTION_ARGS)
{
    text  *arg1 = PG_GETARG_TEXT_P(0);
    text  *arg2 = PG_GETARG_TEXT_P(1);
    int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
    text *new_text = (text *) palloc(new_text_size);

    VARATT_SIZEP(new_text) = new_text_size;
    memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ);
    memcpy(VARDATA(new_text) + (VARSIZE(arg1)-VARHDRSZ),
           VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ);
    PG_RETURN_TEXT_P(new_text);
}
</programlisting>

    <para>
     <!--The <command>CREATE FUNCTION</command> commands are the same as
     for the version-0 equivalents.-->

     <command>CREATE FUNCTION</command>コマンドは、Version-0と同じものです。
    </para>

    <para>
     <!--At first glance, the version-1 coding conventions may appear to
     be just pointless obscurantism.  However, they do offer a number
     of improvements, because the macros can hide unnecessary detail.
     An example is that in coding add_one_float8, we no longer need to
     be aware that float8 is a pass-by-reference type.  Another
     example is that the GETARG macros for variable-length types hide
     the need to deal with fetching "toasted" (compressed or
     out-of-line) values.  The old-style <function>copytext</function>
     and <function>concat_text</function> functions shown above are
     actually wrong in the presence of toasted values, because they
     don't call <function>pg_detoast_datum()</function> on their
     inputs.  (The handler for old-style dynamically-loaded functions
     currently takes care of this detail, but it does so less
     efficiently than is possible for a version-1 function.)-->

     一見Version-1のコードは無意味なものに見えるかもしれませんが、マクロが必要のない情報を隠蔽しているので、多数の改良が行われています。たとえば、add_one_float8のコードでは、float8が参照渡しであることを意識する必要がなくなっています。また別の例としては、可変長型のGETARGマクロは「toasted」値（圧縮、または行外）を呼び出す詳細を隠蔽します。上記にある、古いスタイルの<function>copytext</function>関数と<function>concat_text</function>関数は、toasted値としては、入力に<function>pg_detoast_datum()</function>を使用しないので、実際は誤ったものとなります（古いスタイルの動的にロードされる関数のハンドラは、現在、この問題に対処していますが、Version-1関数で実行可能なことよりも劣ります）。
    </para>

    <para>
     <!--One big improvement in version-1 functions is better handling of NULL
     inputs and results.  The macro <function>PG_ARGISNULL(n)</function>
     allows a function to test whether each input is NULL (of course, doing
     this is only necessary in functions not declared <quote>strict</>).
     As with the
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function> macros,
     the input arguments are counted beginning at zero.
     To return a NULL result, execute <function>PG_RETURN_NULL()</function>;
     this works in both strict and non-strict functions.-->

     Version-1関数の1つの大きな改善点は、NULLの入力/結果の処理能力です。<function>PG_ARGISNULL(n)</function>マクロ関数は各入力がNULLであるかどうかのテストを可能としています（これは、<quote>厳格に</>関数が定義されていない場合のみ必要です）。<function>PG_GETARG_<replaceable>xxx</replaceable>()</function>マクロでは、入力された引数は始まり値を0として数え上げられます。結果としてNULLを返す場合は、<function>PG_RETURN_NULL()</function>を実行します。これは、厳格な関数と厳格でない関数の両方で使用可能です。
    </para>

    <para>
     <!--The version-1 function call conventions make it possible to
     return <quote>set</quote> results and implement trigger functions and
     procedural-language call handlers.  Version-1 code is also more
     portable than version-0, because it does not break ANSI C restrictions
     on function call protocol.  For more details see
     <filename>src/backend/utils/fmgr/README</filename> in the source
     distribution.-->

     Version-1関数呼び出し規約では、<quote>セット（set）</quote>の結果を返すことが可能で、トリガ関数と手続型言語の呼び出しハンドラを実行しています。また、Version-1コードはANSI Cの制約が関数呼び出しプロトコルで守られているので、Version-0よりも移植性があります。詳細はソースディストリビューションの<filename>src/backend/utils/fmgr/README</filename>を参照してください。
    </para>
   </sect2>

   <sect2>
    <title><!--Composite Types in C-Language Functions-->
           複合型を使用したC言語関数
    </title>
<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="ふくごうがたCげんごかんすう">複合型C言語関数</secondary></indexterm>
    <para>
     <!--Composite types do not  have  a  fixed  layout  like  C
     structures.   Instances of a composite type may contain
     null fields.  In addition,  composite  types  that  are
     part  of  an  inheritance  hierarchy may have different
     fields than other members of the same inheritance hierarchy.    
     Therefore,  <productname>Postgres</productname>  provides  
     a  procedural interface for accessing fields of composite types  
     from C.  As <productname>Postgres</productname> processes 
     a set of rows, each row will be passed into your 
     function as an  opaque  structure of type <literal>TUPLE</literal>.
     Suppose we want to write a function to answer the query-->

     複合型では、C言語のような固定のレイアウトがありません。複合型のインスタンスはNULLフィールドを持つ可能性があります。また、複合型で、継承階層の一部であるものは同じ継承の階層の他のメンバとは異なるフィールドを持つ可能性もあります。そのため、<productname>Postgres</productname>はC言語から複合型のフィールドにアクセスするための手続きのインターフェイスを提供します。<productname>Postgres</productname>が行の集合を処理するにつれ、各行は不明瞭な<literal>TUPLE</literal>型の構造体として引き渡されます。問い合わせを答える以下のような関数を書こうとしていると仮定します。
</para>

<programlisting>
SELECT name, c_overpaid(emp, 1500) AS overpaid
FROM emp
WHERE name = 'Bill' OR name = 'Sam';
</programlisting>

<para>
     <!--In the query above, we can define c_overpaid as:-->
     上記の問い合わせでは、c_overpaidを下記のように定義することができます。
</para>

<programlisting>
#include "postgres.h"
#include "executor/executor.h"  /* for GetAttributeByName() */

bool
c_overpaid(TupleTableSlot *t, /* the current row of EMP */
           int32 limit)
{
    bool isnull;
    int32 salary;

    salary = DatumGetInt32(GetAttributeByName(t, "salary", &amp;isnull));
    if (isnull)
        return (false);
    return salary &gt; limit;
}

/* In version-1 coding, the above would look like this: */

PG_FUNCTION_INFO_V1(c_overpaid);

Datum
c_overpaid(PG_FUNCTION_ARGS)
{
    TupleTableSlot  *t = (TupleTableSlot *) PG_GETARG_POINTER(0);
    int32            limit = PG_GETARG_INT32(1);
    bool isnull;
    int32 salary;

    salary = DatumGetInt32(GetAttributeByName(t, "salary", &amp;isnull));
    if (isnull)
        PG_RETURN_BOOL(false);
    /* Alternatively, we might prefer to do PG_RETURN_NULL() for null salary */

    PG_RETURN_BOOL(salary &gt; limit);
}
</programlisting>

    <para>
     <!--<function>GetAttributeByName</function> is the 
     <productname>Postgres</productname> system function that
     returns attributes out of the current row.  It has
     three arguments: the argument of type <type>TupleTableSlot*</type> passed into
     the  function, the name of the desired attribute, and a
     return parameter that tells whether  the  attribute
     is  null.   <function>GetAttributeByName</function> returns a Datum
     value that you can convert to the proper datatype by using the
     appropriate <function>DatumGet<replaceable>XXX</replaceable>()</function> macro.-->

     <function>GetAttributeByName</function>は、現在の行から属性を返す、<productname>Postgres</productname>システム関数です。これには3つの引数があります。それらは<type>TupleTableSlot*</type>型が関数に引き渡されたときの引数、求められた属性の名前、属性がNULLであるかどうかの返りパラメータです。<function>GetAttributeByName</function>は適切な<function>DatumGet<replaceable>XXX</replaceable>()</function>マクロを使用して適切なデータ型に変換可能なDatum型の値を返します。
    </para>

    <para>
     <!--The  following  query  lets  <productname>Postgres</productname>  
     know  about  the <function>c_overpaid</function> function:-->

     下記の問い合わせは、<productname>Postgres</productname>に<function>c_overpaid</function>関数を認識させるものです。
</para>

<programlisting>
CREATE FUNCTION c_overpaid(emp, int4) 
RETURNS bool
AS '<replaceable>PGROOT</replaceable>/tutorial/obj/funcs.so' 
LANGUAGE 'c';
</programlisting>

    <para>
     <!--While there are ways to construct new rows or modify  
     existing rows from within a C function, these
     are far too complex to discuss in this manual.-->

     C言語を使って新しい行を作成したり、現存する行を変更させたりする方法もありますが、ここで述べるには難易度がとても高いので、省略します。
    </para>
   </sect2>

   <sect2>
    <title><!--Writing Code-->コードを書く</title>

    <para>
     <!--We now turn to the more difficult task of writing  
     programming  language  functions.  Be warned: this section
     of the manual will not make you a programmer.  You must
     have  a  good  understanding of <acronym>C</acronym>
     (including the use of pointers and the malloc memory manager)  
     before  trying to write <acronym>C</acronym> functions for 
     use with <productname>Postgres</productname>. While  it may 
     be possible to load functions written in languages other 
     than <acronym>C</acronym> into  <productname>Postgres</productname>,  
     this  is  often difficult  (when  it  is possible at all) 
     because other languages, such as <acronym>FORTRAN</acronym> 
     and <acronym>Pascal</acronym> often do not follow the same 
     <firstterm>calling convention</firstterm>
     as <acronym>C</acronym>.  That is, other
     languages  do  not  pass  argument  and  return  values
     between functions in the same way.  For this reason, we
     will assume that your  programming  language  functions
     are written in <acronym>C</acronym>.-->

     ここからは、より難易度の高い、プログラミング言語関数の説明となります。注意してほしいのは、このセクションの主旨は、プログラマを養成することではないということです。<productname>Postgres</productname>で<acronym>C</acronym>関数を書く前に、<acronym>C</acronym>言語についてよく理解している必要があります（ポインタやmallocメモリ管理も含みます）。<acronym>C</acronym>言語以外の言語で記述した関数を<productname>Postgres</productname>に組み込みむことは可能ですが、たとえば<acronym>FORTRAN</acronym>や<acronym>Pascal</acronym>といった言語は<acronym>C</acronym>言語と同じ<firstterm>呼び出し規定</firstterm>ではないので、多くの場合、困難です。それはつまり、他の言語では同じ方法で引数を渡したり結果を返すことを行わないということです。このため、プログラミング言語関数は<acronym>C</acronym>言語で書かれているものと仮定します。<indexterm><primary sortas="かんすう">関数</primary><secondary sortas="ぷろぐらみんぐげんごかんすう">プログラミング言語関数</secondary></indexterm>
    </para>

    <para>
     <!--The  basic  rules  for building <acronym>C</acronym> functions 
     are as follows:-->

     <acronym>C</acronym>関数を作成するときの基本的な規則は下記のものです。
</para>

     <itemizedlist>
      <listitem>
       <para>
        <!--The relevant header (include) files are installed under
	<filename>/usr/local/pgsql/include</filename> or equivalent.-->

        適切なヘッダー（インクルード）ファイルが<filename>/usr/local/pgsql/include</filename>、もしくは同等な場所にインストールされている必要があります。システム（または利用予定のシステム）での場所は<literal>pg_config --includedir</literal><!--to find
	out where it is on your system (or the system that your
	users will be running on).  For very low-level work you might
	need to have a complete <productname>PostgreSQL</productname>
	source tree available.-->
を使用して見つけることが可能です。非常に低レベルな作業を行うには、完全な<productname>PostgreSQL</productname>のソースツリーが必要になるかもしれません。
       </para>
      </listitem>

      <listitem>
       <para>
	<!--When allocating memory, use the
	<productname>Postgres</productname> routines
	<function>palloc</function> and <function>pfree</function>
	instead of the corresponding <acronym>C</acronym> library
	routines <function>malloc</function> and
	<function>free</function>.  The memory allocated by
	<function>palloc</function> will be freed automatically at the
	end of each transaction, preventing memory leaks.-->

        メモリを割り当てる際、<acronym>C</acronym>ライブラリの<function>malloc</function>と<function>free</function>ではなく、<productname>Postgres</productname>の<function>palloc</function>と<function>pfree</function>を使用してください。<function>palloc</function>で割り当てられたメモリは各トランザクションの終わりに自動的に解放され、メモリリークを防ぎます。
       </para>
      </listitem>

      <listitem>
       <para>
	<!--Always zero the bytes of your structures using
	<function>memset</function> or <function>bzero</function>.
	Several routines (such as the hash access method, hash join
	and the sort algorithm) compute functions of the raw bits
	contained in your structure.  Even if you initialize all
	fields of your structure, there may be several bytes of
	alignment padding (holes in the structure) that may contain
	garbage values.-->

        <function>memset</function>または<function>bzero</function>を使用して、構造体を必ず0クリアにしてください。複数のルーチン（ハッシュアクセスメソッド、ハッシュ結合、ソートアルゴリズム）は構造体に含まれている生のビットの関数を計算します。すべてのフィールドを初期化しても必要のない値を持っている、数バイトの提携されたものが残っている可能性があります。
       </para>
      </listitem>

      <listitem>
       <para>
        <!--Most of the internal <productname>Postgres</productname> types
	are declared in <filename>postgres.h</filename>, while the function
	manager interfaces (<symbol>PG_FUNCTION_ARGS</symbol>, etc.)
	are in <filename>fmgr.h</filename>, so you will need to
	include at least these two files.  For portability reasons it's best
	to include <filename>postgres.h</filename> <emphasis>first</>,
	before any other system or user header files.
	Including <filename>postgres.h</filename> will also include
	<filename>c.h</filename>,
	<filename>elog.h</filename> and <filename>palloc.h</filename>
	for you.-->

        ほとんどの<productname>Postgres</productname>の内部型は<filename>postgres.h</filename>に定義されています。一方、関数管理インターフェイス（<symbol>PG_FUNCTION_ARGS</symbol>など）は<filename>fmgr.h</filename>で定義されています。したがって、おそらくこの2つのファイルをインクルードする必要があります。移植性に関する理由により、<filename>postgres.h</filename>をその他のシステムファイルよりも<emphasis>先に</>インクルードしておくべきでしょう。<filename>postgres.h</filename>を含めるということは<filename>c.h</filename>、<filename>elog.h</filename>、<filename>palloc.h</filename>も含めることになります。
       </para>
      </listitem>

      <listitem>
       <para>
        <!--Symbol names defined within object files must not conflict
        with each other or with symbols defined in the
        <productname>PostgreSQL</productname> server executable.  You
        will have to rename your functions or variables if you get
        error messages to this effect.-->

        オブジェクトファイルで定義されているシンボル名は互いに異なる必要があり、また、<productname>PostgreSQL</productname>サーバー実行で定義されているものと異なっている必要があります。これに関するエラーが表示される場合は、関数名または変数を変更する必要があります。
       </para>
      </listitem>

      <listitem>
       <para>
	<!--Compiling and linking your object code  so  that
	it  can  be  dynamically  loaded  into  
	<productname>Postgres</productname>
	always requires special flags.
	See <xref linkend="dfunc">
	for  a  detailed explanation of how to do it for
	your particular operating system.-->

        <productname>Postgres</productname>にオブジェクトコードを動的にロードが可能とするためにオブジェクトコードをコンパイル/リンクするときには、特別なフラグが必要となります。その方法を特有のオペレーティングシステムで行う場合の詳細は<xref linkend="dfunc">を参照してください。
       </para>
      </listitem>
     </itemizedlist>
   </sect2>

&dfunc;

  </sect1>

  <sect1 id="xfunc-overload">
   <title><!--Function Overloading-->関数のオーバーロード</title>
<indexterm><primary sortas="おーばーろーど">オーバーロード</primary></indexterm><indexterm><primary sortas="かんすう">関数</primary><secondary sortas="おーばーろーど">オーバーロード</secondary></indexterm>
   <para>
    <!--More than one function may be defined with the same name, so long as
    the arguments they take are different.  In other words, function names
    can be <firstterm>overloaded</firstterm>.
    A function may also have the same name as an attribute.  In the case
    that there is an ambiguity between a function on a complex type and
    an attribute of the complex type, the attribute will always be used.-->

    使用する引数が異なるのであれば、同じ名前の関数を定義することができます。つまり、関数名は<firstterm>オーバーロード</firstterm>が可能です。関数は同じ属性に同じ名前を持つこともできます。複合型の関数と複合型の属性とであいまいさが存在する場合は、必ず属性が使用されます。

   </para>

   <sect2>
    <title><!--Name Space Conflicts-->名前空間の衝突</title>
<indexterm><primary sortas="なまえくうかん">名前空間</primary></indexterm>
    <para>
     <!--As of <productname>Postgres</productname> 7.0, the alternative
     form of the AS clause for the SQL
     <command>CREATE FUNCTION</command> command
     decouples the SQL function name from the function name in the C
     source code. This is now the preferred technique to accomplish
     function overloading.-->

     <productname>Postgres</productname>7.0から、SQLの<command>CREATE FUNCTION</command>のAS句の代替形式はSQL関数名とCソースコードとを分離させています。現在これは関数のオーバーロードを克服する、推奨されたテクニックです。
    </para>

    <sect3>
     <title><!--Pre-7.0-->7.0以前</title>

     <para>
      <!--For functions written in C, the SQL name declared in
      <command>CREATE FUNCTION</command>
      must be exactly the same as the actual name of the function in the
      C code (hence it must be a legal C function name).-->

      C言語で書かれた関数において、<command>CREATE FUNCTION</command>で定義されたSQL名は、実際にC言語のコードの関数内で書かれている名前と等しい必要があります（また、それはC言語の正しい関数名である必要があります）。
     </para>

     <para>
      <!--There is a subtle implication of this restriction: while the
      dynamic loading routines in most operating systems are more than 
      happy to allow you to load any number of shared libraries that 
      contain conflicting (identically-named) function names, they may 
      in fact botch the load in interesting ways.  For example, if you
      define a dynamically-loaded function that happens to have the
      same name as a function built into Postgres, the DEC OSF/1 dynamic 
      loader causes Postgres to call the function within itself rather than 
      allowing Postgres to call your function.  Hence, if you want your
      function to be used on different architectures, we recommend that 
      you do not overload C function names.-->

      この制約には密接な関係があります。それはつまり、ほとんどのオペレーティングシステムの動的ロードのルーチンには、異なった/等しい関数名を持っている、いくつもの共有ライブラリを含めることは可能ですが、実際にはそれらを興味深い方法で継ぎ接ぎにしているということです。たとえば、Postgresに存在している関数名と同じ名前の関数を動的にロードするように定義した場合、DEC OSF/1動的ローダーはPostgresに対して、作成された関数ではなく、Postgres自身の関数を呼び出すように指示します。したがって、異なったアーキテクチャで自作の関数を呼び出したい場合はC言語の関数名と同じものを使用しないことをお勧めします。
     </para>

     <para>
      <!--There is a clever trick to get around the problem just described.
      Since there is no problem overloading SQL functions, you can 
      define a set of C functions with different names and then define 
      a set of identically-named SQL function wrappers that take the
      appropriate argument types and call the matching C function.-->

      上記の問題を解決するための賢い方法があります。SQL関数名と同じ関数名を持つことは問題がありませんので、C言語関数を異なった関数名で定義し、また、適切な引数型を使用し、一致するC言語の関数を呼び出す、同じ名前のSQL関数ラッパーを定義することによって問題を回避することが可能となります。
     </para>

     <para>
      <!--Another solution is not to use dynamic loading, but to link your
      functions into the backend statically and declare them as INTERNAL
      functions.  Then, the functions must all have distinct C names but
      they can be declared with the same SQL names (as long as their
      argument types differ, of course).  This way avoids the overhead of
      an SQL wrapper function, at the cost of more effort to prepare a
      custom backend executable.  (This option is only available in version
      6.5 and later, since prior versions required internal functions to
      have the same name in SQL as in the C code.)-->

      もう一方の方法としては、動的ロードを使用せずに、自作の関数をバックエンドに静的にリンクし、その関数を内部関数として定義する方法です。この場合、関数はすべて明確なC言語名を持つ必要がありますが、SQL名と同じ名前で定義することができます（引数の型が異なる場合のみ）。この方法は、カスタムな実行バックエンドを準備することによって、SQLラッパー関数の重複を防ぎます（6.5以前のバージョンでは、内部関数はSQL関数名とC言語関数名は同じでなければならないという制約があったため、このオプションは、バージョン6.5以降から使用可能となっています）。
     </para>
    </sect3>
   </sect2>
  </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:
-->
