Index: doc/src/sgml/docguide.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/docguide.sgml,v
retrieving revision 1.44
diff -c -r1.44 docguide.sgml
*** doc/src/sgml/docguide.sgml	6 Jun 2003 14:17:08 -0000	1.44
--- doc/src/sgml/docguide.sgml	11 Sep 2003 21:01:34 -0000
***************
*** 497,504 ****
    <para>
     Before you can build the documentation you need to run the
     <filename>configure</filename> script as you would when building
!    the PostgreSQL programs themselves.  Check the output near the end
!    of the run, it should look something like this:
  <screen>
  <computeroutput>
  checking for onsgmls... onsgmls
--- 497,505 ----
    <para>
     Before you can build the documentation you need to run the
     <filename>configure</filename> script as you would when building
!    the <productname>PostgreSQL</productname> programs themselves.
!    Check the output near the end of the run, it should look something
!    like this:
  <screen>
  <computeroutput>
  checking for onsgmls... onsgmls
***************
*** 640,646 ****
     <title>Print Output via <acronym>RTF</acronym></title>
  
     <para>
!     You can also create a printable version of the PostgreSQL
      documentation by converting it to <acronym>RTF</acronym> and
      applying minor formatting corrections using an office suite.
      Depending on the capabilities of the particular office suite, you
--- 641,647 ----
     <title>Print Output via <acronym>RTF</acronym></title>
  
     <para>
!     You can also create a printable version of the <productname>PostgreSQL</productname>
      documentation by converting it to <acronym>RTF</acronym> and
      applying minor formatting corrections using an office suite.
      Depending on the capabilities of the particular office suite, you
***************
*** 651,657 ****
  
     <note>
      <para>
!      It appears that current versions of the PostgreSQL documentation
       trigger some bug in or exceed the size limit of OpenJade.  If the
       build process of the <acronym>RTF</acronym> version hangs for a
       long time and the output file still has size 0, then you may have
--- 652,658 ----
  
     <note>
      <para>
!      It appears that current versions of the <productname>PostgreSQL</productname> documentation
       trigger some bug in or exceed the size limit of OpenJade.  If the
       build process of the <acronym>RTF</acronym> version hangs for a
       long time and the output file still has size 0, then you may have
Index: doc/src/sgml/ecpg.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ecpg.sgml,v
retrieving revision 1.50
diff -c -r1.50 ecpg.sgml
*** doc/src/sgml/ecpg.sgml	9 Sep 2003 10:54:44 -0000	1.50
--- doc/src/sgml/ecpg.sgml	11 Sep 2003 21:02:21 -0000
***************
*** 1153,1162 ****
      condition.  A successful state is indicated by the code
      <literal>00000</literal>.  Further information about the codes can
      be found XXX.  The <literal>SQLSTATE</literal> codes are for the
!     most part defined in the SQL standard.  The PostgreSQL server
!     natively supports <literal>SQLSTATE</literal> error codes;
!     therefore a high degree of consistency can be achieved by using
!     this error code scheme throughout all applications.
     </para>
  
     <para>
--- 1153,1163 ----
      condition.  A successful state is indicated by the code
      <literal>00000</literal>.  Further information about the codes can
      be found XXX.  The <literal>SQLSTATE</literal> codes are for the
!     most part defined in the SQL standard.  The
!     <productname>PostgreSQL</productname> server natively supports
!     <literal>SQLSTATE</literal> error codes; therefore a high degree
!     of consistency can be achieved by using this error code scheme
!     throughout all applications.
     </para>
  
     <para>
***************
*** 1168,1178 ****
      affected zero rows, and no specific negative values.  Therefore,
      this scheme can only achieve poor portability and does not have a
      hierarchical code assignment.  Historically, the embedded SQL
!     processor for PostgreSQL has assigned some specific
!     <literal>SQLCODE</literal> values for its use, which are listed
!     below with their numeric value and their symbolic name.  Remember
!     that these are not portable to other SQL implementations.  To
!     simplify the porting of applications to the
      <literal>SQLSTATE</literal> scheme, the corresponding
      <literal>SQLSTATE</literal> is also listed.  There is, however, no
      one-to-one or one-to-many mapping between the two schemes (indeed
--- 1169,1179 ----
      affected zero rows, and no specific negative values.  Therefore,
      this scheme can only achieve poor portability and does not have a
      hierarchical code assignment.  Historically, the embedded SQL
!     processor for <productname>PostgreSQL</productname> has assigned
!     some specific <literal>SQLCODE</literal> values for its use, which
!     are listed below with their numeric value and their symbolic name.
!     Remember that these are not portable to other SQL implementations.
!     To simplify the porting of applications to the
      <literal>SQLSTATE</literal> scheme, the corresponding
      <literal>SQLSTATE</literal> is also listed.  There is, however, no
      one-to-one or one-to-many mapping between the two schemes (indeed
***************
*** 1291,1299 ****
       <term>-208 (<symbol>ECPG_EMPTY</symbol>)</term>
       <listitem>
        <para>
!        The statement sent to the PostgreSQL server was empty.  (This
!        cannot normally happen in an embedded SQL program, so it may
!        point to an internal error.)  (SQLSTATE YE002)
        </para>
       </listitem>
      </varlistentry>
--- 1292,1301 ----
       <term>-208 (<symbol>ECPG_EMPTY</symbol>)</term>
       <listitem>
        <para>
!        The statement sent to the <productname>PostgreSQL</productname>
!        server was empty.  (This cannot normally happen in an embedded
!        SQL program, so it may point to an internal error.)  (SQLSTATE
!        YE002)
        </para>
       </listitem>
      </varlistentry>
Index: doc/src/sgml/extend.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/extend.sgml,v
retrieving revision 1.24
diff -c -r1.24 extend.sgml
*** doc/src/sgml/extend.sgml	31 Aug 2003 17:32:18 -0000	1.24
--- doc/src/sgml/extend.sgml	11 Sep 2003 21:02:47 -0000
***************
*** 69,82 ****
     </para>
  
     <para>
!     The PostgreSQL server can moreover incorporate user-written code into
!     itself through dynamic loading.  That is, the user  can
!     specify  an  object code file (e.g., a shared library) that implements a new type or  function,
!     and <productname>PostgreSQL</productname> will load it as required.  Code written 
!     in <acronym>SQL</acronym> is even more trivial to add to the  server.
!     This ability to modify its operation <quote>on the fly</quote> makes
!     <productname>PostgreSQL</productname> uniquely suited for rapid prototyping  of  new
!     applications and storage structures.
     </para>
    </sect1>
  
--- 69,84 ----
     </para>
  
     <para>
!     The <productname>PostgreSQL</productname> server can moreover
!     incorporate user-written code into itself through dynamic loading.
!     That is, the user can specify an object code file (e.g., a shared
!     library) that implements a new type or function, and
!     <productname>PostgreSQL</productname> will load it as required.
!     Code written in <acronym>SQL</acronym> is even more trivial to add
!     to the server.  This ability to modify its operation <quote>on the
!     fly</quote> makes <productname>PostgreSQL</productname> uniquely
!     suited for rapid prototyping of new applications and storage
!     structures.
     </para>
    </sect1>
  
Index: doc/src/sgml/features.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/features.sgml,v
retrieving revision 2.18
diff -c -r2.18 features.sgml
*** doc/src/sgml/features.sgml	13 Mar 2003 01:30:28 -0000	2.18
--- doc/src/sgml/features.sgml	11 Sep 2003 21:03:14 -0000
***************
*** 63,73 ****
    In the following two sections, we provide a list of those features
    that <productname>PostgreSQL</productname> supports, followed by a
    list of the features defined in SQL99 which are not yet supported in
!   PostgreSQL.  Both of these lists are approximate: There may be minor
!   details that are nonconforming for a feature that is listed as
!   supported, and large parts of an unsupported feature may in fact be
!   implemented.  The main body of the documentation always contains the
!   most accurate information about what does and does not work.
   </para>
  
   <note>
--- 63,74 ----
    In the following two sections, we provide a list of those features
    that <productname>PostgreSQL</productname> supports, followed by a
    list of the features defined in SQL99 which are not yet supported in
!   <productname>PostgreSQL</productname>.  Both of these lists are
!   approximate: There may be minor details that are nonconforming for a
!   feature that is listed as supported, and large parts of an
!   unsupported feature may in fact be implemented.  The main body of
!   the documentation always contains the most accurate information
!   about what does and does not work.
   </para>
  
   <note>
Index: doc/src/sgml/history.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/history.sgml,v
retrieving revision 1.21
diff -c -r1.21 history.sgml
*** doc/src/sgml/history.sgml	8 Sep 2003 23:02:28 -0000	1.21
--- doc/src/sgml/history.sgml	11 Sep 2003 21:04:01 -0000
***************
*** 206,213 ****
    </para>
  
    <para>
!    Details about what has happened in PostgreSQL since then can be
!    found in <xref linkend="release">.
    </para>
   </sect2>
  </sect1>
--- 206,213 ----
    </para>
  
    <para>
!    Details about what has happened in <productname>PostgreSQL</> since
!    then can be found in <xref linkend="release">.
    </para>
   </sect2>
  </sect1>
Index: doc/src/sgml/indices.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/indices.sgml,v
retrieving revision 1.43
diff -c -r1.43 indices.sgml
*** doc/src/sgml/indices.sgml	31 Aug 2003 17:32:19 -0000	1.43
--- doc/src/sgml/indices.sgml	11 Sep 2003 21:04:25 -0000
***************
*** 194,204 ****
  </synopsis>
     <note>
      <para>
!      Testing has shown PostgreSQL's hash indexes to be similar or slower
!      than B-tree indexes, and the index size and build time for hash
!      indexes is much worse. Hash indexes also suffer poor performance
!      under high concurrency. For these reasons, hash index use is
!      presently discouraged.
      </para>
     </note>  
    </para>
--- 194,204 ----
  </synopsis>
     <note>
      <para>
!      Testing has shown <productname>PostgreSQL</productname>'s hash
!      indexes to be similar or slower than B-tree indexes, and the
!      index size and build time for hash indexes is much worse. Hash
!      indexes also suffer poor performance under high concurrency. For
!      these reasons, hash index use is presently discouraged.
      </para>
     </note>  
    </para>
Index: doc/src/sgml/information_schema.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/information_schema.sgml,v
retrieving revision 1.6
diff -c -r1.6 information_schema.sgml
*** doc/src/sgml/information_schema.sgml	29 Jun 2003 15:14:41 -0000	1.6
--- doc/src/sgml/information_schema.sgml	11 Sep 2003 21:10:04 -0000
***************
*** 12,22 ****
    information about the objects defined in the current database.  The
    information schema is defined in the SQL standard and can therefore
    be expected to be portable and remain stable --- unlike the system
!   catalogs, which are specific to PostgreSQL and are modelled after
    implementation concerns.  The information schema views do not,
!   however, contain information about PostgreSQL-specific features; to
!   inquire about those you need to query the system catalogs or other
!   PostgreSQL-specific views.
   </para>
  
   <sect1 id="infoschema-schema">
--- 12,24 ----
    information about the objects defined in the current database.  The
    information schema is defined in the SQL standard and can therefore
    be expected to be portable and remain stable --- unlike the system
!   catalogs, which are specific to
!   <productname>PostgreSQL</productname> and are modelled after
    implementation concerns.  The information schema views do not,
!   however, contain information about
!   <productname>PostgreSQL</productname>-specific features; to inquire
!   about those you need to query the system catalogs or other
!   <productname>PostgreSQL</productname>-specific views.
   </para>
  
   <sect1 id="infoschema-schema">
***************
*** 319,330 ****
    </para>
  
    <para>
!    In PostgreSQL, you can only grant privileges on entire tables, not
!    individual columns.  Therefore, this view contains the same
!    information as <literal>table_privileges</literal>, just
!    represented through one row for each column in each appropriate
!    table, but it only convers privilege types where column granularity
!    is possible: <literal>SELECT</literal>, <literal>INSERT</literal>,
     <literal>UPDATE</literal>, <literal>REFERENCES</literal>.  If you
     want to make your applications fit for possible future
     developements, it is generally the right choice to use this view
--- 321,333 ----
    </para>
  
    <para>
!    In <productname>PostgreSQL</productname>, you can only grant
!    privileges on entire tables, not individual columns.  Therefore,
!    this view contains the same information as
!    <literal>table_privileges</literal>, just represented through one
!    row for each column in each appropriate table, but it only convers
!    privilege types where column granularity is possible:
!    <literal>SELECT</literal>, <literal>INSERT</literal>,
     <literal>UPDATE</literal>, <literal>REFERENCES</literal>.  If you
     want to make your applications fit for possible future
     developements, it is generally the right choice to use this view
***************
*** 404,411 ****
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of PostgreSQL will possibly prohibit having
!    users and groups with the same name.
    </para>
   </sect1>
  
--- 407,414 ----
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of <productname>PostgreSQL</productname>
!    will possibly prohibit having users and groups with the same name.
    </para>
   </sect1>
  
***************
*** 415,423 ****
    <para>
     The view <literal>column_udt_usage</literal> identifies all columns
     that use data types owned by the current user.  Note that in
!    PostgreSQL, built-in data types behave like user-defined types, so
!    they are included here as well.  See also <xref
!    linkend="infoschema-columns"> for details.
    </para>
  
    <table>
--- 418,426 ----
    <para>
     The view <literal>column_udt_usage</literal> identifies all columns
     that use data types owned by the current user.  Note that in
!    <productname>PostgreSQL</productname>, built-in data types behave
!    like user-defined types, so they are included here as well.  See
!    also <xref linkend="infoschema-columns"> for details.
    </para>
  
    <table>
***************
*** 595,601 ****
        <entry>
         If <literal>data_type</literal> identifies a character type,
         the maximum possible length in octets (bytes) of a datum (this
!        should not be of concern to PostgreSQL users); null for all
         other data types.
        </entry>
       </row>
--- 598,604 ----
        <entry>
         If <literal>data_type</literal> identifies a character type,
         the maximum possible length in octets (bytes) of a datum (this
!        should not be of concern to <productname>PostgreSQL</productname> users); null for all
         other data types.
        </entry>
       </row>
***************
*** 800,823 ****
  
    <para>
     Since data types can be defined in a variety of ways in SQL, and
!    PostgreSQL contains additional ways to define data types, their
!    representation in the information schema can be somewhat difficult.
!    The column <literal>data_type</literal> is supposed to identify the
!    underlying built-in type of the column.  In PostgreSQL, this means
!    that the type is defined in the system catalog schema
     <literal>pg_catalog</literal>.  This column may be useful if the
     application can handle the well-known built-in types specially (for
     example, format the numeric types differently or use the data in
     the precision columns).  The columns <literal>udt_name</literal>,
     <literal>udt_schema</literal>, and <literal>udt_catalog</literal>
     always identify the underlying data type of the column, even if the
!    column is based on a domain.  (Since PostgreSQL treats built-in
!    types like user-defined types, built-in types appear here as well.
!    This is an extension of the SQL standard.)  These columns should be
!    used if an application wants to process data differently according
!    to the type, because in that case it wouldn't matter if the column
!    is really based on a domain.  If the column is based on a domain,
!    the identity of the domain is stored in the columns
     <literal>domain_name</literal>, <literal>domain_schema</literal>,
     and <literal>domain_catalog</literal>.  If you want to pair up
     columns with their associated data types and treat domains as
--- 803,828 ----
  
    <para>
     Since data types can be defined in a variety of ways in SQL, and
!    <productname>PostgreSQL</productname> contains additional ways to
!    define data types, their representation in the information schema
!    can be somewhat difficult.  The column <literal>data_type</literal>
!    is supposed to identify the underlying built-in type of the column.
!    In <productname>PostgreSQL</productname>, this means that the type
!    is defined in the system catalog schema
     <literal>pg_catalog</literal>.  This column may be useful if the
     application can handle the well-known built-in types specially (for
     example, format the numeric types differently or use the data in
     the precision columns).  The columns <literal>udt_name</literal>,
     <literal>udt_schema</literal>, and <literal>udt_catalog</literal>
     always identify the underlying data type of the column, even if the
!    column is based on a domain.  (Since
!    <productname>PostgreSQL</productname> treats built-in types like
!    user-defined types, built-in types appear here as well.  This is an
!    extension of the SQL standard.)  These columns should be used if an
!    application wants to process data differently according to the
!    type, because in that case it wouldn't matter if the column is
!    really based on a domain.  If the column is based on a domain, the
!    identity of the domain is stored in the columns
     <literal>domain_name</literal>, <literal>domain_schema</literal>,
     and <literal>domain_catalog</literal>.  If you want to pair up
     columns with their associated data types and treat domains as
***************
*** 1141,1148 ****
    <para>
     The view <literal>domain_udt_usage</literal> identifies all columns
     that use data types owned by the current user. Note that in
!    PostgreSQL, built-in data types behave like user-defined types, so
!    they are included here as well.
    </para>
  
    <table>
--- 1146,1153 ----
    <para>
     The view <literal>domain_udt_usage</literal> identifies all columns
     that use data types owned by the current user. Note that in
!    <productname>PostgreSQL</productname>, built-in data types behave
!    like user-defined types, so they are included here as well.
    </para>
  
    <table>
***************
*** 1266,1272 ****
        <entry>
         If the domain has a character type, the maximum possible length
         in octets (bytes) of a datum (this should not be of concern to
!        PostgreSQL users); null for all other data types.
        </entry>
       </row>
  
--- 1271,1278 ----
        <entry>
         If the domain has a character type, the maximum possible length
         in octets (bytes) of a datum (this should not be of concern to
!        <productname>PostgreSQL</productname> users); null for all
!        other data types.
        </entry>
       </row>
  
***************
*** 2416,2426 ****
     The view <literal>role_usage_grants</literal> is meant to identify
     <literal>USAGE</literal> privileges granted on various kinds of
     objects to a group that the current user is a member of.  In
!    PostgreSQL, this currently only applies to domains, and since
!    domains do not have real privileges in PostgreSQL, this view is
!    empty.  Futher information can be found under
!    <literal>usage_privileges</literal>.  In the future, this view may
!    contain more useful information.
    </para>
  
    <table>
--- 2422,2432 ----
     The view <literal>role_usage_grants</literal> is meant to identify
     <literal>USAGE</literal> privileges granted on various kinds of
     objects to a group that the current user is a member of.  In
!    <productname>PostgreSQL</productname>, this currently only applies
!    to domains, and since domains do not have real privileges in
!    <productname>PostgreSQL</productname>, this view is empty.  Futher
!    information can be found under <literal>usage_privileges</literal>.
!    In the future, this view may contain more useful information.
    </para>
  
    <table>
***************
*** 2582,2589 ****
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of PostgreSQL will possibly prohibit having
!    users and groups with the same name.
    </para>
   </sect1>
  
--- 2588,2595 ----
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of <productname>PostgreSQL</productname>
!    will possibly prohibit having users and groups with the same name.
    </para>
   </sect1>
  
***************
*** 2874,2881 ****
         not the owner of the function).  (According to the SQL
         standard, this column is only applicable if
         <literal>routine_body</literal> is <literal>SQL</literal>, but
!        in PostgreSQL it will contain whatever source text was
!        specified when the function was created.)
        </entry>
       </row>
  
--- 2880,2888 ----
         not the owner of the function).  (According to the SQL
         standard, this column is only applicable if
         <literal>routine_body</literal> is <literal>SQL</literal>, but
!        in <productname>PostgreSQL</productname> it will contain
!        whatever source text was specified when the function was
!        created.)
        </entry>
       </row>
  
***************
*** 3082,3090 ****
    <para>
     The table <literal>sql_features</literal> contains information
     about which formal features defined in the SQL standard are
!    supported by PostgreSQL.  This is the same information that is
!    presented in <xref linkend="features">.  There you can also find
!    some additional background information.
    </para>
  
    <table>
--- 3089,3097 ----
    <para>
     The table <literal>sql_features</literal> contains information
     about which formal features defined in the SQL standard are
!    supported by <productname>PostgreSQL</productname>.  This is the
!    same information that is presented in <xref linkend="features">.
!    There you can also find some additional background information.
    </para>
  
    <table>
***************
*** 3226,3234 ****
  
    <para>
     The table <literal>sql_languages</literal> contains one row for
!    each SQL language binding that is supported by PostgreSQL.
!    PostgreSQL supports direct SQL and embedded SQL in C; that is all
!    you will learn from this table.
    </para>
  
    <table>
--- 3233,3242 ----
  
    <para>
     The table <literal>sql_languages</literal> contains one row for
!    each SQL language binding that is supported by
!    <productname>PostgreSQL</productname>.
!    <productname>PostgreSQL</productname> supports direct SQL and
!    embedded SQL in C; that is all you will learn from this table.
    </para>
  
    <table>
***************
*** 3313,3320 ****
    <para>
     The table <literal>sql_packages</literal> contains information
     about which features packages defined in the SQL standard are
!    supported by PostgreSQL.  Refer to <xref linkend="features"> for
!    background information on feature packages.
    </para>
  
    <table>
--- 3321,3328 ----
    <para>
     The table <literal>sql_packages</literal> contains information
     about which features packages defined in the SQL standard are
!    supported by <productname>PostgreSQL</productname>.  Refer to <xref
!    linkend="features"> for background information on feature packages.
    </para>
  
    <table>
***************
*** 3375,3386 ****
  
    <para>
     The table <literal>sql_sizing</literal> contains information about
!    various size limits and maximum values in PostgreSQL.  This
!    information is primarily intended for use in the context of the
!    ODBC interface; users of other interfaces will probably find this
!    information to be of little use.  For this reason, the individual
!    sizing items are not described here; you will find them in the
!    description of the ODBC interface.
    </para>
  
    <table>
--- 3383,3395 ----
  
    <para>
     The table <literal>sql_sizing</literal> contains information about
!    various size limits and maximum values in
!    <productname>PostgreSQL</productname>.  This information is
!    primarily intended for use in the context of the ODBC interface;
!    users of other interfaces will probably find this information to be
!    of little use.  For this reason, the individual sizing items are
!    not described here; you will find them in the description of the
!    ODBC interface.
    </para>
  
    <table>
***************
*** 3657,3664 ****
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of PostgreSQL will possibly prohibit having
!    users and groups with the same name.
    </para>
   </sect1>
  
--- 3666,3673 ----
     Note that the column <literal>grantee</literal> makes no
     distinction between users and groups.  If you have users and groups
     with the same name, there is unfortunately no way to distinguish
!    them.  A future version of <productname>PostgreSQL</productname>
!    will possibly prohibit having users and groups with the same name.
    </para>
   </sect1>
  
***************
*** 3875,3895 ****
    </table>
  
    <para>
!    Triggers in PostgreSQL have two incompatibilities with the SQL
!    standard that affect the representation in the information schema.
!    First, trigger names are local to the table in PostgreSQL, rather
     than independent schema objects.  Therefore there may be duplicate
     trigger names defined in one schema, as long as they belong to
     different tables.  (<literal>trigger_catalog</literal> and
     <literal>trigger_schema</literal> are really the values pertaining
     to the table that the trigger is defined on.)  Second, triggers can
!    be defined to fire on multiple events in PostgreSQL (e.g.,
!    <literal>ON INSERT OR UPDATE</literal>), whereas the SQL standard
!    only allows one.  If a trigger is defined to fire on multiple
!    events, it is represented as multiple rows in the information
!    schema, one for each type of event.  As a consequence of these two
!    issues, the primary key of the view <literal>triggers</literal> is
!    really <literal>(trigger_catalog, trigger_schema, trigger_name,
     event_object_name, event_manipulation)</literal> instead of
     <literal>(trigger_catalog, trigger_schema, trigger_name)</literal>,
     which is what the SQL standard specifies.  Nonetheless, if you
--- 3884,3906 ----
    </table>
  
    <para>
!    Triggers in <productname>PostgreSQL</productname> have two
!    incompatibilities with the SQL standard that affect the
!    representation in the information schema.  First, trigger names are
!    local to the table in <productname>PostgreSQL</productname>, rather
     than independent schema objects.  Therefore there may be duplicate
     trigger names defined in one schema, as long as they belong to
     different tables.  (<literal>trigger_catalog</literal> and
     <literal>trigger_schema</literal> are really the values pertaining
     to the table that the trigger is defined on.)  Second, triggers can
!    be defined to fire on multiple events in
!    <productname>PostgreSQL</productname> (e.g., <literal>ON INSERT OR
!    UPDATE</literal>), whereas the SQL standard only allows one.  If a
!    trigger is defined to fire on multiple events, it is represented as
!    multiple rows in the information schema, one for each type of
!    event.  As a consequence of these two issues, the primary key of
!    the view <literal>triggers</literal> is really
!    <literal>(trigger_catalog, trigger_schema, trigger_name,
     event_object_name, event_manipulation)</literal> instead of
     <literal>(trigger_catalog, trigger_schema, trigger_name)</literal>,
     which is what the SQL standard specifies.  Nonetheless, if you
***************
*** 3905,3913 ****
    <para>
     The view <literal>usage_privileges</literal> is meant to identify
     <literal>USAGE</literal> privileges granted on various kinds of
!    objects to the current user or by the current user.  In PostgreSQL,
!    this currently only applies to domains, and since domains do not
!    have real privileges in PostgreSQL, this view shows implicit
     <literal>USAGE</literal> privileges granted to
     <literal>PUBLIC</literal> for all domains.  In the future, this
     view may contain more useful information.
--- 3916,3925 ----
    <para>
     The view <literal>usage_privileges</literal> is meant to identify
     <literal>USAGE</literal> privileges granted on various kinds of
!    objects to the current user or by the current user.  In
!    <productname>PostgreSQL</productname>, this currently only applies
!    to domains, and since domains do not have real privileges in
!    <productname>PostgreSQL</productname>, this view shows implicit
     <literal>USAGE</literal> privileges granted to
     <literal>PUBLIC</literal> for all domains.  In the future, this
     view may contain more useful information.
Index: doc/src/sgml/installation.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/installation.sgml,v
retrieving revision 1.140
diff -c -r1.140 installation.sgml
*** doc/src/sgml/installation.sgml	1 Sep 2003 23:01:49 -0000	1.140
--- doc/src/sgml/installation.sgml	11 Sep 2003 21:10:45 -0000
***************
*** 406,418 ****
       To make the backup, you can use the <command>pg_dumpall</command>
       command from the version you are currently running.  For best
       results, however, try to use the <command>pg_dumpall</command>
!      command from PostgreSQL &version;, since this version contains
!      bug fixes and improvements over older versions.  While this
!      advice might seem idiosyncratic since you haven't installed the
!      new version yet, it is advisable to follow it if you plan to
!      install the new version in parallel with the old version.  In
!      that case you can complete the installation normally and transfer
!      the data later.  This will also decrease the downtime.
      </para>
     </step>
  
--- 406,419 ----
       To make the backup, you can use the <command>pg_dumpall</command>
       command from the version you are currently running.  For best
       results, however, try to use the <command>pg_dumpall</command>
!      command from <productname>PostgreSQL</productname> &version;,
!      since this version contains bug fixes and improvements over older
!      versions.  While this advice might seem idiosyncratic since you
!      haven't installed the new version yet, it is advisable to follow
!      it if you plan to install the new version in parallel with the
!      old version.  In that case you can complete the installation
!      normally and transfer the data later.  This will also decrease
!      the downtime.
      </para>
     </step>
  
Index: doc/src/sgml/intro.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/intro.sgml,v
retrieving revision 1.21
diff -c -r1.21 intro.sgml
*** doc/src/sgml/intro.sgml	8 Sep 2003 23:02:28 -0000	1.21
--- doc/src/sgml/intro.sgml	11 Sep 2003 21:11:59 -0000
***************
*** 6,23 ****
   <title>Preface</title>
  
   <para>
!   This book is the official documentation of PostgreSQL.  It is being
!   written by the PostgreSQL developers and other volunteers in
!   parallel to the development of the PostgreSQL software.  It
!   describes all the functionality that the current version of
!   PostgreSQL officially supports.
   </para>
  
   <para>
!   To make the large amount of information about PostgreSQL manageable,
!   this book has been organized in several parts.  Each part is
!   targeted at a different class of users, or at users in different
!   stages of their PostgreSQL experience:
  
    <itemizedlist>
     <listitem>
--- 6,26 ----
   <title>Preface</title>
  
   <para>
!   This book is the official documentation of
!   <productname>PostgreSQL</productname>.  It is being written by the
!   <productname>PostgreSQL</productname> developers and other
!   volunteers in parallel to the development of the
!   <productname>PostgreSQL</productname> software.  It describes all
!   the functionality that the current version of
!   <productname>PostgreSQL</productname> officially supports.
   </para>
  
   <para>
!   To make the large amount of information about
!   <productname>PostgreSQL</productname> manageable, this book has been
!   organized in several parts.  Each part is targeted at a different
!   class of users, or at users in different stages of their
!   <productname>PostgreSQL</productname> experience:
  
    <itemizedlist>
     <listitem>
***************
*** 38,53 ****
     <listitem>
      <para>
       <xref linkend="admin"> describes the installation and
!      administration of the server.  Everyone that runs a PostgreSQL
!      server, be it for private use or for others, should read this
!      part.
      </para>
     </listitem>
  
     <listitem>
      <para>
       <xref linkend="client-interfaces"> describes the programming
!      interfaces for PostgreSQL client programs.
      </para>
     </listitem>
  
--- 41,57 ----
     <listitem>
      <para>
       <xref linkend="admin"> describes the installation and
!      administration of the server.  Everyone that runs a
!      <productname>PostgreSQL</productname> server, be it for private
!      use or for others, should read this part.
      </para>
     </listitem>
  
     <listitem>
      <para>
       <xref linkend="client-interfaces"> describes the programming
!      interfaces for <productname>PostgreSQL</productname> client
!      programs.
      </para>
     </listitem>
  
***************
*** 111,118 ****
      </listitem>
     </itemizedlist>
  
!    Also, PostgreSQL can be extended by the user in many ways, for
!    example by adding new
  
     <itemizedlist spacing="compact">
      <listitem>
--- 115,122 ----
      </listitem>
     </itemizedlist>
  
!    Also, <productname>PostgreSQL</productname> can be extended by the
!    user in many ways, for example by adding new
  
     <itemizedlist spacing="compact">
      <listitem>
***************
*** 137,145 ****
    </para>
  
    <para>
!    And because of the liberal license, PostgreSQL can be used,
!    modified, and distributed by everyone free of charge for any
!    purpose, be it private, commercial, or academic.
    </para>
   </sect1>
  
--- 141,150 ----
    </para>
  
    <para>
!    And because of the liberal license,
!    <productname>PostgreSQL</productname> can be used, modified, and
!    distributed by everyone free of charge for any purpose, be it
!    private, commercial, or academic.
    </para>
   </sect1>
  
Index: doc/src/sgml/libpq.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/libpq.sgml,v
retrieving revision 1.135
diff -c -r1.135 libpq.sgml
*** doc/src/sgml/libpq.sgml	3 Sep 2003 22:05:01 -0000	1.135
--- doc/src/sgml/libpq.sgml	11 Sep 2003 21:12:45 -0000
***************
*** 2049,2059 ****
     <parameter>from</parameter> parameter binary string in memory
     allocated with <function>malloc()</>.  This memory must be freed
     using <function>PQfreemem()</> when the result is no longer needed.
!    The return string has all special characters replaced
!    so that they can be properly processed by the PostgreSQL string literal
!    parser, and the <type>bytea</type> input function. A terminating zero
!    byte is also added.  The single quotes that must surround
!    PostgreSQL string literals are not part of the result string.
    </para>
    </listitem>
    </varlistentry>
--- 2049,2061 ----
     <parameter>from</parameter> parameter binary string in memory
     allocated with <function>malloc()</>.  This memory must be freed
     using <function>PQfreemem()</> when the result is no longer needed.
!    The return string has all special characters replaced so that they
!    can be properly processed by the
!    <productname>PostgreSQL</productname> string literal parser, and
!    the <type>bytea</type> input function. A terminating zero byte is
!    also added.  The single quotes that must surround
!    <productname>PostgreSQL</productname> string literals are not part
!    of the result string.
    </para>
    </listitem>
    </varlistentry>
Index: doc/src/sgml/plpgsql.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/plpgsql.sgml,v
retrieving revision 1.24
diff -c -r1.24 plpgsql.sgml
*** doc/src/sgml/plpgsql.sgml	11 Sep 2003 18:30:38 -0000	1.24
--- doc/src/sgml/plpgsql.sgml	11 Sep 2003 21:13:41 -0000
***************
*** 2056,2064 ****
      (raise an error and abort the current transaction). Whether
      messages of a particular priority are reported to the client,
      written to the server log, or both is controlled by the
!     <option>log_min_messages</option> and
!     <option>client_min_messages</option> configuration variables. See
!     <xref linkend="runtime-config"> for more information.
     </para>
  
     <para>
--- 2056,2065 ----
      (raise an error and abort the current transaction). Whether
      messages of a particular priority are reported to the client,
      written to the server log, or both is controlled by the
!     <varname>log_min_messages</varname> and
!     <varname>client_min_messages</varname> configuration
!     variables. See <xref linkend="runtime-config"> for more
!     information.
     </para>
  
     <para>
***************
*** 2448,2454 ****
         <para>
          The <literal>RETURN</literal> key word in the function
          prototype (not the function body) becomes
!         <literal>RETURNS</literal> in PostgreSQL.
         </para>
        </listitem>
  
--- 2449,2456 ----
         <para>
          The <literal>RETURN</literal> key word in the function
          prototype (not the function body) becomes
!         <literal>RETURNS</literal> in
!         <productname>PostgreSQL</productname>.
         </para>
        </listitem>
  
***************
*** 2805,2811 ****
  
     <para>
      This section explains a few other things to watch for when porting
!     Oracle <application>PL/SQL</> functions to PostgreSQL.
     </para>
  
     <sect3>
--- 2807,2814 ----
  
     <para>
      This section explains a few other things to watch for when porting
!     Oracle <application>PL/SQL</> functions to
!     <productname>PostgreSQL</productname>.
     </para>
  
     <sect3>
Index: doc/src/sgml/protocol.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/protocol.sgml,v
retrieving revision 1.43
diff -c -r1.43 protocol.sgml
*** doc/src/sgml/protocol.sgml	3 Sep 2003 22:05:07 -0000	1.43
--- doc/src/sgml/protocol.sgml	11 Sep 2003 21:14:26 -0000
***************
*** 4,10 ****
   <title>Frontend/Backend Protocol</title>
  
   <para>
!   <application>PostgreSQL</application> uses a message-based protocol
    for communication between frontends and backends (clients and servers).
    The protocol is supported over <acronym>TCP/IP</acronym> and also over
    Unix-domain sockets.  Port number 5432 has been registered with IANA as
--- 4,10 ----
   <title>Frontend/Backend Protocol</title>
  
   <para>
!   <productname>PostgreSQL</productname> uses a message-based protocol
    for communication between frontends and backends (clients and servers).
    The protocol is supported over <acronym>TCP/IP</acronym> and also over
    Unix-domain sockets.  Port number 5432 has been registered with IANA as
***************
*** 14,20 ****
  
   <para>
    This document describes version 3.0 of the protocol, implemented in
!   <application>PostgreSQL</application> 7.4 and later.  For descriptions
    of the earlier protocol versions, see previous releases of the
    <productname>PostgreSQL</productname> documentation.  A single server
    can support multiple protocol versions.  The initial
--- 14,20 ----
  
   <para>
    This document describes version 3.0 of the protocol, implemented in
!   <productname>PostgreSQL</productname> 7.4 and later.  For descriptions
    of the earlier protocol versions, see previous releases of the
    <productname>PostgreSQL</productname> documentation.  A single server
    can support multiple protocol versions.  The initial
***************
*** 165,171 ****
  
     <para>
      Data of a particular datatype might be transmitted in any of several
!     different <firstterm>formats</>.  As of <application>PostgreSQL</> 7.4
      the only supported formats are <quote>text</> and <quote>binary</>,
      but the protocol makes provision for future extensions.  The desired
      format for any value is specified by a <firstterm>format code</>.
--- 165,171 ----
  
     <para>
      Data of a particular datatype might be transmitted in any of several
!     different <firstterm>formats</>.  As of <productname>PostgreSQL</> 7.4
      the only supported formats are <quote>text</> and <quote>binary</>,
      but the protocol makes provision for future extensions.  The desired
      format for any value is specified by a <firstterm>format code</>.
Index: doc/src/sgml/release.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/release.sgml,v
retrieving revision 1.206
diff -c -r1.206 release.sgml
*** doc/src/sgml/release.sgml	27 Aug 2003 03:35:35 -0000	1.206
--- doc/src/sgml/release.sgml	11 Sep 2003 21:21:41 -0000
***************
*** 10,17 ****
  
    <para>
     Below is a subset of the changes that have gone into the
!    development branch of PostgreSQL since version 7.3.  For a complete
!    list of changes, consult the CVS logs.
    </para>
  
  <!--
--- 10,17 ----
  
    <para>
     Below is a subset of the changes that have gone into the
!    development branch of <productname>PostgreSQL</productname> since
!    version 7.3.  For a complete list of changes, consult the CVS logs.
    </para>
  
  <!--
Index: doc/src/sgml/rules.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/rules.sgml,v
retrieving revision 1.29
diff -c -r1.29 rules.sgml
*** doc/src/sgml/rules.sgml	31 Aug 2003 17:32:19 -0000	1.29
--- doc/src/sgml/rules.sgml	11 Sep 2003 21:22:14 -0000
***************
*** 8,23 ****
   </indexterm>
  
  <Para>
!      This chapter discusses the rule system in PostgreSQL.
!      Production rule systems are conceptually simple, but
!      there are many subtle points involved in actually using
!      them.
  </Para>
  
  <Para>
       Some other database systems define active database rules, which
!      are usually stored procedures and triggers.  In PostgreSQL, these
!      can be implemented using functions and triggers as well.
  </Para>
  
  <Para>
--- 8,24 ----
   </indexterm>
  
  <Para>
!      This chapter discusses the rule system in
!      <productname>PostgreSQL</productname>.  Production rule systems
!      are conceptually simple, but there are many subtle points
!      involved in actually using them.
  </Para>
  
  <Para>
       Some other database systems define active database rules, which
!      are usually stored procedures and triggers.  In
!      <productname>PostgreSQL</productname>, these can be implemented
!      using functions and triggers as well.
  </Para>
  
  <Para>
Index: doc/src/sgml/runtime.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/runtime.sgml,v
retrieving revision 1.206
diff -c -r1.206 runtime.sgml
*** doc/src/sgml/runtime.sgml	11 Sep 2003 18:30:39 -0000	1.206
--- doc/src/sgml/runtime.sgml	11 Sep 2003 20:59:41 -0000
***************
*** 797,803 ****
          this much time, the server breaks the connection. This prevents
          hung clients from occupying a connection indefinitely. This
          option can only be set at server start or in the
!         <filename>postgresql.conf</filename> file.
         </para>
        </listitem>
       </varlistentry>
--- 797,803 ----
          this much time, the server breaks the connection. This prevents
          hung clients from occupying a connection indefinitely. This
          option can only be set at server start or in the
!         <filename>postgresql.conf</filename> file. The default is 60.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1028,1036 ****
         </para>
  
         <para>
!         PostgreSQL procedural language libraries may be preloaded in
!         this way, typically by using the syntax
!         <literal>'$libdir/plXXX:plXXX_init'</literal> where
          <literal>XXX</literal> is <literal>pgsql</>, <literal>perl</>,
          <literal>tcl</>, or <literal>python</>.
         </para>
--- 1028,1036 ----
         </para>
  
         <para>
!         <productname>PostgreSQL</productname> procedural language
!         libraries may be preloaded in this way, typically by using the
!         syntax <literal>'$libdir/plXXX:plXXX_init'</literal> where
          <literal>XXX</literal> is <literal>pgsql</>, <literal>perl</>,
          <literal>tcl</>, or <literal>python</>.
         </para>
***************
*** 1228,1238 ****
        <para>
         These configuration parameters provide a crude method for
         influencing the query plans chosen by the query optimizer. If
!        the default plan chosen by the optimizer is not optimal, a
!        temporary solution may be found by using one of these
!        configuration parameters to force the optimizer to choose a
!        better plan. Other ways to improve the quality of the plans
!        chosen by the optimizer include configuring the <xref
         linkend="runtime-config-query-constants"
         endterm="runtime-config-query-constants-title">, running
         <command>ANALYZE</command> more frequently, and increasing the
--- 1228,1238 ----
        <para>
         These configuration parameters provide a crude method for
         influencing the query plans chosen by the query optimizer. If
!        the default plan chosen by the optimizer for a particular query
!        is not optimal, a temporary solution may be found by using one
!        of these configuration parameters to force the optimizer to
!        choose a better plan. Other ways to improve the quality of the
!        plans chosen by the optimizer include configuring the <xref
         linkend="runtime-config-query-constants"
         endterm="runtime-config-query-constants-title">, running
         <command>ANALYZE</command> more frequently, and increasing the
***************
*** 1370,1376 ****
          disk cache (that is, the portion of the kernel's disk cache
          that will be used for <productname>PostgreSQL</productname>
          data files). This is measured in disk pages, which are
!         normally 8192 bytes each.
         </para>
        </listitem>
       </varlistentry>
--- 1370,1376 ----
          disk cache (that is, the portion of the kernel's disk cache
          that will be used for <productname>PostgreSQL</productname>
          data files). This is measured in disk pages, which are
!         normally 8192 bytes each. The default is 1000.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1382,1389 ****
          Sets the query planner's estimate of the cost of a
          nonsequentially fetched disk page. This is measured as a
          multiple of the cost of a sequential page fetch. A higher
!         value makes it more likely a sequential scan will be used,
!         a lower value makes it more likely an index scan will be used.
         </para>
        </listitem>
       </varlistentry>
--- 1382,1390 ----
          Sets the query planner's estimate of the cost of a
          nonsequentially fetched disk page. This is measured as a
          multiple of the cost of a sequential page fetch. A higher
!         value makes it more likely a sequential scan will be used, a
!         lower value makes it more likely an index scan will be
!         used. The default is four.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1394,1400 ****
         <para>
          Sets the query planner's estimate of the cost of processing
          each tuple during a query. This is measured as a fraction of
!         the cost of a sequential page fetch.
         </para>
        </listitem>
       </varlistentry>
--- 1395,1401 ----
         <para>
          Sets the query planner's estimate of the cost of processing
          each tuple during a query. This is measured as a fraction of
!         the cost of a sequential page fetch. The default is 0.01.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1405,1411 ****
         <para>
          Sets the query planner's estimate of the cost of processing
          each index tuple during an index scan. This is measured as a
!         fraction of the cost of a sequential page fetch.
         </para>
        </listitem>
       </varlistentry>
--- 1406,1413 ----
         <para>
          Sets the query planner's estimate of the cost of processing
          each index tuple during an index scan. This is measured as a
!         fraction of the cost of a sequential page fetch. The default
!         is 0.001.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1416,1422 ****
         <para>
          Sets the planner's estimate of the cost of processing each
          operator in a <literal>WHERE</> clause. This is measured as a fraction of
!         the cost of a sequential page fetch.
         </para>
        </listitem>
       </varlistentry>
--- 1418,1424 ----
         <para>
          Sets the planner's estimate of the cost of processing each
          operator in a <literal>WHERE</> clause. This is measured as a fraction of
!         the cost of a sequential page fetch. The default is 0.0025.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1502,1508 ****
          had a column-specific target set via <command>ALTER TABLE SET
          STATISTICS</>.  Larger values increase the time needed to do
          <command>ANALYZE</>, but may improve the quality of the planner's
!         estimates. The default value is 10.
         </para>
        </listitem>
       </varlistentry>
--- 1504,1510 ----
          had a column-specific target set via <command>ALTER TABLE SET
          STATISTICS</>.  Larger values increase the time needed to do
          <command>ANALYZE</>, but may improve the quality of the planner's
!         estimates. The default is 10.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1650,1657 ****
        <listitem>
         <para>
          Controls the amount of detail written in the server log for each
! 	message that is logged.  Valid values are <literal>terse</>,
! 	<literal>default</>, and <literal>verbose</>, each adding more
  	fields to displayed messages.
         </para>
        </listitem>
--- 1652,1659 ----
        <listitem>
         <para>
          Controls the amount of detail written in the server log for each
! 	message that is logged.  Valid values are <literal>TERSE</>,
! 	<literal>DEFAULT</>, and <literal>VERBOSE</>, each adding more
  	fields to displayed messages.
         </para>
        </listitem>
***************
*** 1813,1826 ****
        <term><varname>debug_pretty_print</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         These options enable various debugging output to be sent to the
!         client or server log. For each executed query, they print the resulting
!         parse tree, the query rewriter output, or the execution plan.
!         <option>DEBUG_PRETTY_PRINT</option> indents these displays to
!         produce a more readable but much longer output format.
!         <option>CLIENT_MIN_MESSAGES</option> or <option>LOG_MIN_MESSAGES</option>
!         must be <literal>DEBUG1</literal> or lower to send output to the client
!         or server logs.
         </para>
        </listitem>
       </varlistentry>
--- 1815,1829 ----
        <term><varname>debug_pretty_print</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         These options enable various debugging output to be sent to
!         the client or server log. For each executed query, they print
!         the resulting parse tree, the query rewriter output, or the
!         execution plan.  <varname>debug_pretty_print</varname> indents
!         these displays to produce a more readable but much longer
!         output format.  <varname>client_min_messages</varname> or
!         <varname>log_min_messages</varname> must be
!         <literal>DEBUG1</literal> or lower to send output to the
!         client or server logs. These options are off by default.
         </para>
        </listitem>
       </varlistentry>
***************
*** 1845,1851 ****
          Causes the duration of every completed statement to be logged.
          To use this option, enable <varname>log_statement</> and
          <varname>log_pid</> so you can link the statement to the
!         duration using the process ID.
          Only superusers can turn off this option if it is enabled by
          the administrator.
         </para>
--- 1848,1854 ----
          Causes the duration of every completed statement to be logged.
          To use this option, enable <varname>log_statement</> and
          <varname>log_pid</> so you can link the statement to the
!         duration using the process ID. The default is off.
          Only superusers can turn off this option if it is enabled by
          the administrator.
         </para>
***************
*** 1869,1875 ****
        <term><varname>log_statement</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         Causes each SQL statement to be logged.
          Only superusers can turn off this option if it is enabled by
          the administrator.
         </para>
--- 1872,1878 ----
        <term><varname>log_statement</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         Causes each SQL statement to be logged. The default is off.
          Only superusers can turn off this option if it is enabled by
          the administrator.
         </para>
***************
*** 1932,1940 ****
         <para>
          For each query, write performance statistics of the respective
          module to the server log. This is a crude profiling
!         instrument.
!         Only superusers can turn off this option if it is enabled by
!         the administrator.
         </para>
        </listitem>
       </varlistentry>
--- 1935,1943 ----
         <para>
          For each query, write performance statistics of the respective
          module to the server log. This is a crude profiling
!         instrument. All of these options are disabled by default.
!         Only superusers can turn off any of these options if they have
!         been enabled by the administrator.
         </para>
        </listitem>
       </varlistentry>
***************
*** 2127,2133 ****
        <listitem>
         <para>
          Aborts any statement that takes over the specified number of
!         milliseconds.  A value of zero turns off the timer.
         </para>
        </listitem>
       </varlistentry>
--- 2130,2137 ----
        <listitem>
         <para>
          Aborts any statement that takes over the specified number of
!         milliseconds.  A value of zero turns off the timer, which is
!         the default value.
         </para>
        </listitem>
       </varlistentry>
***************
*** 2300,2307 ****
        <term><varname>explain_pretty_print</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         Determines whether <command>EXPLAIN VERBOSE</> uses the indented
!         or non-indented format for displaying detailed query-tree dumps.
         </para>
        </listitem>
       </varlistentry>
--- 2304,2312 ----
        <term><varname>explain_pretty_print</varname> (<type>boolean</type>)</term>
        <listitem>
         <para>
!         Determines whether <command>EXPLAIN VERBOSE</> uses the
!         indented or non-indented format for displaying detailed
!         query-tree dumps. The default is on.
         </para>
        </listitem>
       </varlistentry>
***************
*** 2357,2365 ****
        <listitem>
         <para>
          Sets the maximum expression nesting depth of the parser. The
!         default value is high enough for any normal query, but you can
!         raise it if needed. (But if you raise it too high, you run
!         the risk of server crashes due to stack overflow.)
         </para>
        </listitem>
       </varlistentry>
--- 2362,2370 ----
        <listitem>
         <para>
          Sets the maximum expression nesting depth of the parser. The
!         default value of 10000 is high enough for any normal query,
!         but you can raise it if needed. (But if you raise it too high,
!         you run the risk of server crashes due to stack overflow.)
         </para>
        </listitem>
       </varlistentry>
***************
*** 2409,2415 ****
        <listitem>
         <para>
          The shared lock table is sized on the assumption that at most
!         <varname>max_locks_per_transaction</> *
          <varname>max_connections</varname> distinct objects will need to
          be locked at any one time. The default, 64, has historically
          proven sufficient, but you might need to raise this value if you
--- 2414,2420 ----
        <listitem>
         <para>
          The shared lock table is sized on the assumption that at most
!         <varname>max_locks_per_transaction</varname> *
          <varname>max_connections</varname> distinct objects will need to
          be locked at any one time. The default, 64, has historically
          proven sufficient, but you might need to raise this value if you
***************
*** 2453,2459 ****
         <para>
          The regular expression <quote>flavor</> can be set to
          <literal>advanced</>, <literal>extended</>, or <literal>basic</>.
!         The usual default is <literal>advanced</>.  The <literal>extended</>
          setting may be useful for exact backwards compatibility with
          pre-7.4 releases of <productname>PostgreSQL</>.
         </para>
--- 2458,2464 ----
         <para>
          The regular expression <quote>flavor</> can be set to
          <literal>advanced</>, <literal>extended</>, or <literal>basic</>.
!         The default is <literal>advanced</>.  The <literal>extended</>
          setting may be useful for exact backwards compatibility with
          pre-7.4 releases of <productname>PostgreSQL</>.
         </para>
***************
*** 2533,2545 ****
      <title>Developer Options</title>
  
      <para>
!      The following options are intended for work on the PostgreSQL source,
!      and in some cases to assist with recovery of
!      severely damaged databases.  There should be no reason to use them in
!      a production database setup.  As such, they have been excluded from the
!      sample <filename>postgresql.conf</> file.
!      Note that many of these options require special
!      source compilation flags to work at all.
      </para>
  
      <variablelist>
--- 2538,2550 ----
      <title>Developer Options</title>
  
      <para>
!      The following options are intended for work on the
!      <productname>PostgreSQL</productname> source, and in some cases
!      to assist with recovery of severely damaged databases.  There
!      should be no reason to use them in a production database setup.
!      As such, they have been excluded from the sample
!      <filename>postgresql.conf</> file.  Note that many of these
!      options require special source compilation flags to work at all.
      </para>
  
      <variablelist>
***************
*** 2580,2588 ****
         <para>
          Generates a great amount of debugging output for the
          <command>LISTEN</command> and <command>NOTIFY</command>
!         commands.
!         <option>CLIENT_MIN_MESSAGES</option> or <option>LOG_MIN_MESSAGES</option>
!         must be <literal>DEBUG1</literal> or lower to send this output to the
          client or server log, respectively.
         </para>
        </listitem>
--- 2585,2593 ----
         <para>
          Generates a great amount of debugging output for the
          <command>LISTEN</command> and <command>NOTIFY</command>
!         commands.  <varname>client_min_messages</varname> or
!         <varname>log_min_messages</varname> must be
!         <literal>DEBUG1</literal> or lower to send this output to the
          client or server log, respectively.
         </para>
        </listitem>
Index: doc/src/sgml/xfunc.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/xfunc.sgml,v
retrieving revision 1.73
diff -c -r1.73 xfunc.sgml
*** doc/src/sgml/xfunc.sgml	31 Aug 2003 17:32:20 -0000	1.73
--- doc/src/sgml/xfunc.sgml	11 Sep 2003 21:23:09 -0000
***************
*** 814,828 ****
  
      <para>
       To know how to write C-language functions, you need to know how
!      PostgreSQL internally represents base data types and how they can
!      be passed to and from functions.
!      Internally, <productname>PostgreSQL</productname> regards a
!      base type as a <quote>blob of memory</quote>.   The  user-defined  
!      functions that you define over a type in turn define the 
!      way  that  <productname>PostgreSQL</productname> can operate  
!      on  it.  That is, <productname>PostgreSQL</productname> will 
!      only store and retrieve the data from disk and use  your  
!      user-defined functions to input, process, and output the data.
      </para>
  
      <para>
--- 814,828 ----
  
      <para>
       To know how to write C-language functions, you need to know how
!      <productname>PostgreSQL</productname> internally represents base
!      data types and how they can be passed to and from functions.
!      Internally, <productname>PostgreSQL</productname> regards a base
!      type as a <quote>blob of memory</quote>.  The user-defined
!      functions that you define over a type in turn define the way that
!      <productname>PostgreSQL</productname> can operate on it.  That
!      is, <productname>PostgreSQL</productname> will only store and
!      retrieve the data from disk and use your user-defined functions
!      to input, process, and output the data.
      </para>
  
      <para>
***************
*** 1249,1261 ****
  
      <para>
       Here, <replaceable>DIRECTORY</replaceable> stands for the
!      directory of the shared library file (for instance the PostgreSQL
!      tutorial directory, which contains the code for the examples used
!      in this section).  (Better style would be to use just
!      <literal>'funcs'</> in the <literal>AS</> clause, after having
!      added <replaceable>DIRECTORY</replaceable> to the search path.
!      In any case, we may omit the system-specific extension for a
!      shared library, commonly <literal>.so</literal> or
       <literal>.sl</literal>.)
      </para>
  
--- 1249,1262 ----
  
      <para>
       Here, <replaceable>DIRECTORY</replaceable> stands for the
!      directory of the shared library file (for instance the
!      <productname>PostgreSQL</productname> tutorial directory, which
!      contains the code for the examples used in this section).
!      (Better style would be to use just <literal>'funcs'</> in the
!      <literal>AS</> clause, after having added
!      <replaceable>DIRECTORY</replaceable> to the search path.  In any
!      case, we may omit the system-specific extension for a shared
!      library, commonly <literal>.so</literal> or
       <literal>.sl</literal>.)
      </para>
  
***************
*** 1483,1497 ****
  
      <para>
       Before we turn to the more advanced topics, we should discuss
!      some coding rules for PostgreSQL C-language functions.  While it
!      may be possible to load functions written in languages other than
!      C into <productname>PostgreSQL</productname>, this is usually
!      difficult (when it is possible at all) because other languages,
!      such as C++, FORTRAN, or Pascal often do not follow the same
!      calling convention as C.  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 C-language functions
!      are actually written in C.
      </para>
  
      <para>
--- 1484,1499 ----
  
      <para>
       Before we turn to the more advanced topics, we should discuss
!      some coding rules for <productname>PostgreSQL</productname>
!      C-language functions.  While it may be possible to load functions
!      written in languages other than C into
!      <productname>PostgreSQL</productname>, this is usually difficult
!      (when it is possible at all) because other languages, such as
!      C++, FORTRAN, or Pascal often do not follow the same calling
!      convention as C.  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 C-language functions are
!      actually written in C.
      </para>
  
      <para>
Index: doc/src/sgml/ref/copy.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/copy.sgml,v
retrieving revision 1.49
diff -c -r1.49 copy.sgml
*** doc/src/sgml/ref/copy.sgml	9 Sep 2003 18:28:52 -0000	1.49
--- doc/src/sgml/ref/copy.sgml	11 Sep 2003 21:15:04 -0000
***************
*** 201,207 ****
      directly by the server, not by the client application. Therefore,
      they must reside on or be accessible to the database server machine,
      not the client. They must be accessible to and readable or writable
!     by the <application>PostgreSQL</application> user (the user ID the
      server runs as), not the client. <command>COPY</command> naming a
      file is only allowed to database superusers, since it allows reading
      or writing any file that the server has privileges to access.
--- 201,207 ----
      directly by the server, not by the client application. Therefore,
      they must reside on or be accessible to the database server machine,
      not the client. They must be accessible to and readable or writable
!     by the <productname>PostgreSQL</productname> user (the user ID the
      server runs as), not the client. <command>COPY</command> naming a
      file is only allowed to database superusers, since it allows reading
      or writing any file that the server has privileges to access.
***************
*** 367,373 ****
  
     <para>
      The file format used for <command>COPY BINARY</command> changed in
!     <application>PostgreSQL</application> 7.4. The new format consists
      of a file header, zero or more tuples containing the row data, and
      a file trailer. Headers and data are now in network byte order.
     </para>
--- 367,373 ----
  
     <para>
      The file format used for <command>COPY BINARY</command> changed in
!     <productname>PostgreSQL</productname> 7.4. The new format consists
      of a file header, zero or more tuples containing the row data, and
      a file trailer. Headers and data are now in network byte order.
     </para>
***************
*** 474,480 ****
  
      <para>
  To determine the appropriate binary format for the actual tuple data you
! should consult the <application>PostgreSQL</application> source, in
  particular the <function>*send</> and <function>*recv</> functions for
  the data type (typically found in the <filename>src/backend/utils/adt</filename>
  directory). The <application>contrib/binarycopy</application> module
--- 474,480 ----
  
      <para>
  To determine the appropriate binary format for the actual tuple data you
! should consult the <productname>PostgreSQL</productname> source, in
  particular the <function>*send</> and <function>*recv</> functions for
  the data type (typically found in the <filename>src/backend/utils/adt</filename>
  directory). The <application>contrib/binarycopy</application> module
Index: doc/src/sgml/ref/create_function.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/create_function.sgml,v
retrieving revision 1.51
diff -c -r1.51 create_function.sgml
*** doc/src/sgml/ref/create_function.sgml	10 Sep 2003 20:13:45 -0000	1.51
--- doc/src/sgml/ref/create_function.sgml	11 Sep 2003 21:21:03 -0000
***************
*** 382,388 ****
  
    <para>
     A <command>CREATE FUNCTION</command> command is defined in SQL99.
!    The <application>PostgreSQL</application> version is similar but
     not fully compatible.  The attributes are not portable, neither are the
     different available languages.
    </para>
--- 382,388 ----
  
    <para>
     A <command>CREATE FUNCTION</command> command is defined in SQL99.
!    The <productname>PostgreSQL</productname> version is similar but
     not fully compatible.  The attributes are not portable, neither are the
     different available languages.
    </para>
Index: doc/src/sgml/ref/create_index.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/create_index.sgml,v
retrieving revision 1.41
diff -c -r1.41 create_index.sgml
*** doc/src/sgml/ref/create_index.sgml	9 Sep 2003 18:28:52 -0000	1.41
--- doc/src/sgml/ref/create_index.sgml	11 Sep 2003 21:15:23 -0000
***************
*** 53,59 ****
    </para>
  
    <para>
!    <application>PostgreSQL</application> provides the index methods
     B-tree, R-tree, hash, and GiST. The B-tree index method is an
     implementation of Lehman-Yao high-concurrency B-trees. The R-tree
     index method implements standard R-trees using Guttman's quadratic
--- 53,59 ----
    </para>
  
    <para>
!    <productname>PostgreSQL</productname> provides the index methods
     B-tree, R-tree, hash, and GiST. The B-tree index method is an
     implementation of Lehman-Yao high-concurrency B-trees. The R-tree
     index method implements standard R-trees using Guttman's quadratic
***************
*** 198,204 ****
     Currently, only the B-tree and GiST index methods support
     multicolumn indexes. Up to 32 fields may be specified by default.
     (This limit can be altered when building
!    <application>PostgreSQL</application>.)  Only B-tree currently
     supports unique indexes.
    </para>
  
--- 198,204 ----
     Currently, only the B-tree and GiST index methods support
     multicolumn indexes. Up to 32 fields may be specified by default.
     (This limit can be altered when building
!    <productname>PostgreSQL</productname>.)  Only B-tree currently
     supports unique indexes.
    </para>
  
Index: doc/src/sgml/ref/declare.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/declare.sgml,v
retrieving revision 1.26
diff -c -r1.26 declare.sgml
*** doc/src/sgml/ref/declare.sgml	31 Aug 2003 17:32:22 -0000	1.26
--- doc/src/sgml/ref/declare.sgml	11 Sep 2003 21:15:43 -0000
***************
*** 105,113 ****
       <para>
        Indicates that data retrieved from the cursor should be
        unaffected by updates to the tables underlying the cursor while
!       the cursor exists.  In PostgreSQL, all cursors are insensitive;
!       this key word currently has no effect and is present for
!       compatibility with the SQL standard.
       </para>
      </listitem>
     </varlistentry>
--- 105,113 ----
       <para>
        Indicates that data retrieved from the cursor should be
        unaffected by updates to the tables underlying the cursor while
!       the cursor exists.  In <productname>PostgreSQL</productname>,
!       all cursors are insensitive; this key word currently has no
!       effect and is present for compatibility with the SQL standard.
       </para>
      </listitem>
     </varlistentry>
Index: doc/src/sgml/ref/end.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/end.sgml,v
retrieving revision 1.10
diff -c -r1.10 end.sgml
*** doc/src/sgml/ref/end.sgml	31 Aug 2003 17:32:23 -0000	1.10
--- doc/src/sgml/ref/end.sgml	11 Sep 2003 21:16:18 -0000
***************
*** 30,38 ****
    <para>
     <command>END</command> commits the current transaction. All changes
     made by the transaction become visible to others and are guaranteed
!    to be durable if a crash occurs.  It is a PostgreSQL extension that
!    is equivalent to <xref linkend="sql-commit"
!    endterm="sql-commit-title">.
    </para>
   </refsect1>
    
--- 30,38 ----
    <para>
     <command>END</command> commits the current transaction. All changes
     made by the transaction become visible to others and are guaranteed
!    to be durable if a crash occurs.  It is a
!    <productname>PostgreSQL</productname> extension that is equivalent
!    to <xref linkend="sql-commit" endterm="sql-commit-title">.
    </para>
   </refsect1>
    
Index: doc/src/sgml/ref/grant.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/grant.sgml,v
retrieving revision 1.34
diff -c -r1.34 grant.sgml
*** doc/src/sgml/ref/grant.sgml	31 Aug 2003 17:32:23 -0000	1.34
--- doc/src/sgml/ref/grant.sgml	11 Sep 2003 21:16:37 -0000
***************
*** 375,382 ****
  
     <para>
      The <literal>RULE</literal> privilege, and privileges on
!     databases, schemas, languages, and sequences are PostgreSQL
!     extensions.
     </para>
   </refsect1>
  
--- 375,382 ----
  
     <para>
      The <literal>RULE</literal> privilege, and privileges on
!     databases, schemas, languages, and sequences are
!     <productname>PostgreSQL</productname> extensions.
     </para>
   </refsect1>
  
Index: doc/src/sgml/ref/load.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/load.sgml,v
retrieving revision 1.18
diff -c -r1.18 load.sgml
*** doc/src/sgml/ref/load.sgml	31 Aug 2003 17:32:23 -0000	1.18
--- doc/src/sgml/ref/load.sgml	11 Sep 2003 21:16:58 -0000
***************
*** 50,56 ****
    <title>Compatibility</title>
  
    <para>
!    <command>LOAD</command> is a <application>PostgreSQL</application>
     extension.
    </para>
   </refsect1>
--- 50,56 ----
    <title>Compatibility</title>
  
    <para>
!    <command>LOAD</command> is a <productname>PostgreSQL</productname>
     extension.
    </para>
   </refsect1>
Index: doc/src/sgml/ref/lock.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/lock.sgml,v
retrieving revision 1.37
diff -c -r1.37 lock.sgml
*** doc/src/sgml/ref/lock.sgml	9 Sep 2003 18:28:53 -0000	1.37
--- doc/src/sgml/ref/lock.sgml	11 Sep 2003 21:16:01 -0000
***************
*** 201,207 ****
    <para>
     There is no <command>LOCK TABLE</command> in the SQL standard,
     which instead uses <command>SET TRANSACTION</command> to specify
!    concurrency levels on transactions.  PostgreSQL supports that too;
     see <xref linkend="SQL-SET-TRANSACTION"
     endterm="SQL-SET-TRANSACTION-TITLE"> for details.
    </para>
--- 201,207 ----
    <para>
     There is no <command>LOCK TABLE</command> in the SQL standard,
     which instead uses <command>SET TRANSACTION</command> to specify
!    concurrency levels on transactions.  <productname>PostgreSQL</productname> supports that too;
     see <xref linkend="SQL-SET-TRANSACTION"
     endterm="SQL-SET-TRANSACTION-TITLE"> for details.
    </para>
Index: doc/src/sgml/ref/pg_dump.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/pg_dump.sgml,v
retrieving revision 1.63
diff -c -r1.63 pg_dump.sgml
*** doc/src/sgml/ref/pg_dump.sgml	31 Aug 2003 17:32:23 -0000	1.63
--- doc/src/sgml/ref/pg_dump.sgml	11 Sep 2003 21:17:24 -0000
***************
*** 705,711 ****
     The <application>pg_dump</application> utility first appeared in
     <application>Postgres95</application> release 0.02.  The
     non-plain-text output formats were introduced in
!    <application>PostgreSQL</application> release 7.1.
    </para>
   </refsect1>
  
--- 705,711 ----
     The <application>pg_dump</application> utility first appeared in
     <application>Postgres95</application> release 0.02.  The
     non-plain-text output formats were introduced in
!    <productname>PostgreSQL</productname> release 7.1.
    </para>
   </refsect1>
  
Index: doc/src/sgml/ref/pg_restore.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/pg_restore.sgml,v
retrieving revision 1.41
diff -c -r1.41 pg_restore.sgml
*** doc/src/sgml/ref/pg_restore.sgml	31 Aug 2003 17:32:24 -0000	1.41
--- doc/src/sgml/ref/pg_restore.sgml	11 Sep 2003 21:17:46 -0000
***************
*** 659,665 ****
  
    <para>
     The <application>pg_restore</application> utility first appeared in
!    PostgreSQL 7.1.
    </para>
   </refsect1>
  
--- 659,665 ----
  
    <para>
     The <application>pg_restore</application> utility first appeared in
!    <productname>PostgreSQL</productname> 7.1.
    </para>
   </refsect1>
  
Index: doc/src/sgml/ref/reindex.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/reindex.sgml,v
retrieving revision 1.19
diff -c -r1.19 reindex.sgml
*** doc/src/sgml/ref/reindex.sgml	9 Sep 2003 18:28:53 -0000	1.19
--- doc/src/sgml/ref/reindex.sgml	11 Sep 2003 21:18:03 -0000
***************
*** 46,56 ****
      <listitem>
       <para>
        The index in question contains a lot of dead index pages that
!       are not being reclaimed. This can occur with B-tree indexes in PostgreSQL
!       under certain access patterns. <command>REINDEX</command>
!       provides a way to reduce the space consumption of the index by
!       writing a new version of the index without the dead pages. See
!       <xref linkend="routine-reindex"> for more information.
       </para>
      </listitem>
     </itemizedlist>
--- 46,57 ----
      <listitem>
       <para>
        The index in question contains a lot of dead index pages that
!       are not being reclaimed. This can occur with B-tree indexes in
!       <productname>PostgreSQL</productname> under certain access
!       patterns. <command>REINDEX</command> provides a way to reduce
!       the space consumption of the index by writing a new version of
!       the index without the dead pages. See <xref
!       linkend="routine-reindex"> for more information.
       </para>
      </listitem>
     </itemizedlist>
Index: doc/src/sgml/ref/select.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/select.sgml,v
retrieving revision 1.69
diff -c -r1.69 select.sgml
*** doc/src/sgml/ref/select.sgml	31 Aug 2003 17:32:24 -0000	1.69
--- doc/src/sgml/ref/select.sgml	11 Sep 2003 21:19:18 -0000
***************
*** 798,807 ****
  
     <para>
      <literal>FOR UPDATE</literal> may appear before
!     <literal>LIMIT</literal> for compatibility with PostgreSQL
!     versions before 7.3.  It effectively executes after
!     <literal>LIMIT</literal>, however, and so that is the recommended
!     place to write it.
     </para>
    </refsect2>
   </refsect1>
--- 798,807 ----
  
     <para>
      <literal>FOR UPDATE</literal> may appear before
!     <literal>LIMIT</literal> for compatibility with
!     <productname>PostgreSQL</productname> versions before 7.3.  It
!     effectively executes after <literal>LIMIT</literal>, however, and
!     so that is the recommended place to write it.
     </para>
    </refsect2>
   </refsect1>
***************
*** 1008,1018 ****
  SELECT distributors.* FROM distributors d, distributors distributors;
  </programlisting>
      that he will actually get.  To help detect this sort of mistake,
!     PostgreSQL will warn if the implicit-<literal>FROM</literal>
!     feature is used in a <command>SELECT</command> statement that also
!     contains an explicit <literal>FROM</literal> clause.  Also, it is
!     possible to disable the implicit-<literal>FROM</literal> feature
!     by setting the <varname>ADD_MISSING_FROM</> parameter to false.
     </para>
    </refsect2>
  
--- 1008,1019 ----
  SELECT distributors.* FROM distributors d, distributors distributors;
  </programlisting>
      that he will actually get.  To help detect this sort of mistake,
!     <productname>PostgreSQL</productname> will warn if the
!     implicit-<literal>FROM</literal> feature is used in a
!     <command>SELECT</command> statement that also contains an explicit
!     <literal>FROM</literal> clause.  Also, it is possible to disable
!     the implicit-<literal>FROM</literal> feature by setting the
!     <varname>ADD_MISSING_FROM</> parameter to false.
     </para>
    </refsect2>
  
Index: doc/src/sgml/ref/set_constraints.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/set_constraints.sgml,v
retrieving revision 1.7
diff -c -r1.7 set_constraints.sgml
*** doc/src/sgml/ref/set_constraints.sgml	31 Aug 2003 17:32:24 -0000	1.7
--- doc/src/sgml/ref/set_constraints.sgml	11 Sep 2003 21:19:55 -0000
***************
*** 77,84 ****
  
    <para>
     This command complies with the behavior defined in the SQL
!    standard, except for the limitation that, in PostgreSQL, it only
!    applies to foreign-key constraints.
    </para>
   </refsect1>
  </refentry>
--- 77,85 ----
  
    <para>
     This command complies with the behavior defined in the SQL
!    standard, except for the limitation that, in
!    <productname>PostgreSQL</productname>, it only applies to
!    foreign-key constraints.
    </para>
   </refsect1>
  </refentry>
Index: doc/src/sgml/ref/set_session_auth.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/set_session_auth.sgml,v
retrieving revision 1.10
diff -c -r1.10 set_session_auth.sgml
*** doc/src/sgml/ref/set_session_auth.sgml	31 Aug 2003 17:32:24 -0000	1.10
--- doc/src/sgml/ref/set_session_auth.sgml	11 Sep 2003 21:20:14 -0000
***************
*** 89,98 ****
    <para>
     The SQL standard allows some other expressions to appear in place
     of the literal <replaceable>username</replaceable> which are not
!    important in practice.  <application>PostgreSQL</application>
     allows identifier syntax (<literal>"username"</literal>), which SQL
     does not.  SQL does not allow this command during a transaction;
!    <application>PostgreSQL</application> does not make this
     restriction because there is no reason to.  The privileges
     necessary to execute this command are left implementation-defined
     by the standard.
--- 89,98 ----
    <para>
     The SQL standard allows some other expressions to appear in place
     of the literal <replaceable>username</replaceable> which are not
!    important in practice.  <productname>PostgreSQL</productname>
     allows identifier syntax (<literal>"username"</literal>), which SQL
     does not.  SQL does not allow this command during a transaction;
!    <productname>PostgreSQL</productname> does not make this
     restriction because there is no reason to.  The privileges
     necessary to execute this command are left implementation-defined
     by the standard.
Index: doc/src/sgml/ref/set_transaction.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/set_transaction.sgml,v
retrieving revision 1.16
diff -c -r1.16 set_transaction.sgml
*** doc/src/sgml/ref/set_transaction.sgml	9 Sep 2003 18:28:53 -0000	1.16
--- doc/src/sgml/ref/set_transaction.sgml	11 Sep 2003 21:18:29 -0000
***************
*** 122,128 ****
    <para>
     Both commands are defined in the <acronym>SQL</acronym> standard.
     <literal>SERIALIZABLE</literal> is the default transaction
!    isolation level in the standard; in PostgreSQL the default is
     ordinarily <literal>READ COMMITTED</literal>, but you can change it as
     described above.  <productname>PostgreSQL</productname> does not
     provide the isolation levels <literal>READ UNCOMMITTED</literal>
--- 122,128 ----
    <para>
     Both commands are defined in the <acronym>SQL</acronym> standard.
     <literal>SERIALIZABLE</literal> is the default transaction
!    isolation level in the standard; in <productname>PostgreSQL</productname> the default is
     ordinarily <literal>READ COMMITTED</literal>, but you can change it as
     described above.  <productname>PostgreSQL</productname> does not
     provide the isolation levels <literal>READ UNCOMMITTED</literal>
Index: doc/src/sgml/ref/update.sgml
===================================================================
RCS file: /var/lib/cvs/pgsql-server/doc/src/sgml/ref/update.sgml,v
retrieving revision 1.24
diff -c -r1.24 update.sgml
*** doc/src/sgml/ref/update.sgml	31 Aug 2003 17:32:24 -0000	1.24
--- doc/src/sgml/ref/update.sgml	11 Sep 2003 21:20:37 -0000
***************
*** 164,170 ****
  
    <para>
     This command conforms to the SQL standard.  The
!    <literal>FROM</literal> clause is a PostgreSQL extension.
    </para>
   </refsect1>
  </refentry>
--- 164,171 ----
  
    <para>
     This command conforms to the SQL standard.  The
!    <literal>FROM</literal> clause is a
!    <productname>PostgreSQL</productname> extension.
    </para>
   </refsect1>
  </refentry>
