<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.17 $ -->
 <reference id="ref.pgsql">
  <title>PostgreSQL</title>
  <titleabbrev>PostgreSQL</titleabbrev>
  <partintro>
   <para>
    Postgres, initialement d&eacute;velopp&eacute; au d&eacute;partement de
    Science informatique, &agrave; UC Berkeley, mis en place la majorit&eacute;
    des concepts des bases relationnelles, actuellement disponibles sur le
    march&eacute;. PostgreSQL accepte le langage SQL92/SQL3, assure
    l'int&eacute;grit&eacute; transactionnelle, et l'extension de type.
    PostgreSQL est une &eacute;volution du code originale de Berkeley :
    il est Open Source et dans le domaine public.
   </para>
   <para>
    PostgreSQL est disponible sans frais. La version actuelle est disponible
    &agrave; (en anglais) : <ulink url="&url.pgsql;">www.PostgreSQL.org</ulink>.
   </para>
   <para>
    Depuis la version 6.3 (03/02/1998) PostgreSQL utilise les sockets UNIX, et
    une table est d&eacute;di&eacute;e &agrave; ces nouvelles capacit&eacute;s.
    La socket est situ&eacute;e dans le dossier
    <filename>/tmp/.s.PGSQL.5432</filename>. Cette option peut &ecirc;tre
    activ&eacute;e avec '-i' pass&eacute; au  <command>postmaster</command>
    et cela s'interpr&egrave;te: "&eacute;coute sur les sockets TCP/IP et sur
    les sockets Unix".
    <table>
     <title>Postmaster et PHP</title>
     <tgroup cols="3">
      <thead>
       <row>
	<entry>Postmaster</entry>
	<entry>PHP</entry>
	<entry>Statut</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry>postmaster &amp;</entry>
	<entry>pg_connect("dbname=MonDbName");</entry>
	<entry>OK</entry>
       </row>
       <row>
	<entry>postmaster -i &amp;</entry>
	<entry>pg_connect("dbname=MonDbName");</entry>
	<entry>OK</entry>
       </row>
       <row>
	<entry>postmaster &amp;</entry>
	<entry>pg_connect("host=localhost dbname=MonDbName");</entry>
	<entry>
	 Unable to connect to PostgreSQL server: connectDB() failed:
	 Impossible de se connecter au serveur PostgreSQL:
	 connectDB() a &eacute;chou&eacute;. Est ce que le postmaster fonctionne,
	 et accepte les TCP/IP (option -i) sur le port '5432'?
	</entry>
       </row>
       <row>
	<entry>postmaster -i &amp;</entry>
	<entry>pg_connect("host=localhost dbname=MonDbName");</entry>
	<entry>OK</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>
   <para>
    Il est possible de se connecter avec la commande suivante :
    <command>$conn = pg_Connect("host=monHote port=monPort tty=monTTY
    options=myOptions dbname=myDB user=myUser password=myPassword");
    </command>
   </para>
   <para>
    L'ancienne syntaxe :
    <command>
      $conn = pg_connect("host", "port", "options", "tty", "dbname")
    </command>
    est obsol&egrave;te.
   </para>
   <para>
     Pour utiliser l'interface des grands objets (large object (lo) interface),
     il est n&eacute;cessaire de les placer dans un bloc de transaction. Un bloc
     de transaction commence avec <command>begin</command> et si la transaction
     se termine avec un <command>commit</command> et <command>end</command>. Si
     la transaction &eacute;choue, elle doit &ecirc;tre conclue par un
     <command>abort</command> et <command>rollback</command>.
    <example>
     <title>Utilisation des objets de grande taille (Large Objects)</title>
     <programlisting role="php">
&lt;?php
  $database = pg_connect("", "", "", "", "jacarta");
  pg_exec($database, "begin");
  $oid = pg_locreate($database);
  echo "$oid\n";
  $handle = pg_loopen($database, $oid, "w");
  echo "$handle\n";
  pg_lowrite($handle, "gaga");
  pg_loclose($handle);
  pg_exec($database, "commit")
  pg_exec($database, "end")
?&gt;
     </programlisting>
    </example>
   </para>
  </partintro>
  <refentry id="function.pg-close">
   <refnamediv>
    <refname>pg_Close</refname>
    <refpurpose>Termine une connexion PostgreSQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_close</methodname>
      <methodparam><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_close</function> retourne &false; si
     l'index de connexion n'est pas valable, et &true; sinon.
     <function>pg_close</function> ferme la connexion au serveur PostgreSQL
     associ&eacute; &agrave; <parameter>connection</parameter>.
    </para>
    <note>
     <para>
      Il n'est g&eacute;n&eacute;ralement pas n&eacute;cessaire de fermer une
      connexion non persistante, car elles sont automatiquement ferm&eacute;es
      &agrave; la fin d'un script.
     </para>
    </note>
    <para>
     <function>pg_close</function> ne ferme pas les connexions persistantes
     ouvertes avec <function>pg_pconnect</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-cmdtuples">
   <refnamediv>
    <refname>pg_cmdTuples</refname>
    <refpurpose>Retourne le nombre de tuples affect&eacute;s.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_cmdtuples</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_cmdtuples</function> retourne le nombre de tuples (instances)
     affect&eacute;s par les requ&ecirc;tes INSERT, UPDATE, et DELETE. Si aucun
     tuple n'a &eacute;t&eacute; affect&eacute;, la fonction retournera 0.
     <example>
      <title>pg_cmdtuples</title>
      <programlisting role="php">
&lt;?php
$result = pg_exec($conn, "INSERT INTO verlag VALUES ('Auteur')");
$cmdtuples = pg_cmdtuples($result);
echo $cmdtuples . " &lt;- tuples modifi&eacute;s.";
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     Voir aussi
     <function>pg_numfields</function> et
     <function>pg_numrows</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-connect">
   <refnamediv>
    <refname>pg_connect</refname>
    <refpurpose>Ouvre une connexion.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>pg_connect</methodname>
      <methodparam><type>string</type><parameter>host</parameter></methodparam>
      <methodparam><type>string</type><parameter>port</parameter></methodparam>
      <methodparam><type>string</type><parameter>dbname</parameter></methodparam>
     </methodsynopsis>
     <methodsynopsis>
      <type>resource</type><methodname>pg_connect</methodname>
      <methodparam><type>string</type><parameter>host</parameter></methodparam>
      <methodparam><type>string</type><parameter>port</parameter></methodparam>
      <methodparam><type>string</type><parameter>options</parameter></methodparam>
      <methodparam><type>string</type><parameter>dbname</parameter></methodparam>
     </methodsynopsis>
     <methodsynopsis>
      <type>resource</type><methodname>pg_connect</methodname>
      <methodparam><type>string</type><parameter>host</parameter></methodparam>
      <methodparam><type>string</type><parameter>port</parameter></methodparam>
      <methodparam><type>string</type><parameter>options</parameter></methodparam>
      <methodparam><type>string</type><parameter>tty</parameter></methodparam>
      <methodparam><type>string</type><parameter>dbname</parameter></methodparam>
     </methodsynopsis>
     <methodsynopsis>
      <type>resource</type><methodname>pg_connect</methodname>
      <methodparam><type>string</type><parameter>conn_string</parameter></methodparam>
     </methodsynopsis>
    <para>
     <parameter>conn_string</parameter> retourne un index de
     connexion en cas de succ&egrave;s, et &false; sinon. Ouvre une connexion
     &agrave; un serveur PostgreSQL. Les arguments doivent &ecirc;tre plac&eacute;
     entre guillemets.
     <example>
     <title>Exemples avec <function>pg_connect</function></title>
      <programlisting role="php">
&lt;?php
  $dbconn = pg_connect("dbname=marie");
  //connexion &agrave; une base de donn&eacute;es nomm&eacute;e "marie"
  $dbconn2 = pg_connect("host=localhost port=5432 dbname=marie");
  //connexion &agrave; une base de donn&eacute;es nomm&eacute;e "marie" sur l'h&ocirc;te "localhost" sur le port "5432"
  $dbconn3 = pg_Connect ("host=sheep port=5432 dbname=marie user=mouton password=baaaa");
  //connexion &agrave; une base de donn&eacute;es nomm&eacute;e "marie" sur le serveur "mouton" avec
  // un nom d'utilisateur et le mot de passe associ&eacute;
?&gt;
      </programlisting>
     </example>
     Les arguments disponibles comptent notamment <parameter>dbname</parameter>
     <parameter>port</parameter>, <parameter>host</parameter>,
     <parameter>tty</parameter>, <parameter>options</parameter>,
     <parameter>user</parameter>, et <parameter>password</parameter>
    </para>
    <para>
     <function>pg_connect</function> retourne un index de connexion qui sera
     n&eacute;cessaire aux autres fonctions PostgreSQL. Vous pouvez ouvrir
     plusieurs connexions simultan&eacute;es.
    </para>
     <para>
     Si un deuxi&egrave;me appel &agrave; <function>pg_connect</function> est
     fait avec les m&ecirc;mes arguments, aucune nouvelle connexion ne sera
     &eacute;tablie, mais la connexion pr&eacute;c&eacute;dente sera
     retourn&eacute;e.
    </para>
    <para>
     L'ancienne syntaxe <command>
      $conn = pg_connect("host", "port", "options", "tty", "dbname")
     </command> est obsol&egrave;te.
    </para>
    <para>
     Voir aussi
     <function>pg_pconnect</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-dbname">
   <refnamediv>
    <refname>pg_DBname</refname>
    <refpurpose>Nom de la base de donn&eacute;es.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_dbname</methodname>
      <methodparam><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_dbname</function> retourne le nom de la base de donn&eacute;es
     PostgreSQL associ&eacute;e &agrave; l'index de connexion connection, ou
     &false; si connection n'est pas valide.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-end-copy">
   <refnamediv>
    <refname>pg_end_copy</refname>
    <refpurpose>Synchronise avec le serveur PostgreSQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_end_copy</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_end_copy</function> synchronise le client PostgreSQL (ici PHP)
     avec le serveur, apr&egrave;s une op&eacute;ration de copie. Il faut
     utiliser cette fonction, sous peine de recevoir une erreur "out of sync"
     (d&eacute;synchronis&eacute;). <function>pg_end_copy</function> retourne
     &true; en cas de succ&egrave;s, et &false; sinon.
    </para>
    <para>
     Pour plus de d&eacute;tails et un exemple voyez :
     <function>pg_put_line</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-errormessage">
   <refnamediv>
    <refname>pg_ErrorMessage</refname>
    <refpurpose>Message d'erreur.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_errormessage</methodname>
      <methodparam><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_errormessage</function> retourne une cha&icirc;ne contenant
     le dernier message d'erreur, ou &false;
     en cas d'&eacute;chec. Il sera impossible d'obtenir des d&eacute;tails sur
     l'erreur g&eacute;n&eacute;r&eacute;e, en utilisant la fonction
     <function>pg_errormessage</function> si une erreur est survenue dans
     la derni&egrave;re action pour laquelle une connexion valide existe.
     <function>pg_errormessage</function> retournera une cha&icirc;ne contenant
     le message d'erreur g&eacute;n&eacute;r&eacute; par le serveur final.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-exec">
   <refnamediv>
    <refname>pg_Exec</refname>
    <refpurpose>Ex&eacute;cute une requ&ecirc;te.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>pg_exec</methodname>
      <methodparam><type>resource</type><parameter>connection</parameter></methodparam>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_exec</function> retourne un index de r&eacute;sultat,
     si la requ&ecirc;te a &eacute;t&eacute; correctement
     ex&eacute;cut&eacute;e, et &false; en cas d'&eacute;chec, ou si
     la connexion connection n'&eacute;tait pas un index de connexion valide. En
     cas d'erreur, le message d'erreur peut &ecirc;tre obtenu gr&acirc;ce &agrave; la
     fonction <function>pg_errormessage</function>, si l'index de connexion
     &eacute;tait valide. Envoie une requ&ecirc;te &agrave; un serveur
     PostgreSQL identifi&eacute; gr&acirc;ce &agrave; l'index de connexion. La
     r&eacute;ponse retourn&eacute;e par cette fonction est un index de
     r&eacute;sultat qui devra &ecirc;tre utilis&eacute; pour acc&eacute;der
     aux lignes de r&eacute;sultat, gr&acirc;ce &agrave; d'autres
     fonctions PostgreSQL.
     <note>
      <simpara>
       PHP/FI retournait 1 lorsque la requ&ecirc;te n'attendait pas de
       donn&eacute;es en r&eacute;ponse (insertion, modifcations, par exemple),
       et retournait un nombre plus grand que 1, m&ecirc;me sur un select qui
       donnait un ensemble vide. Ce n'est plus le cas.
      </simpara>
     </note>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fetch-array">
   <refnamediv>
    <refname>pg_Fetch_Array</refname>
    <refpurpose>Lit une ligne dans un tableau.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>pg_fetch_array</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>result_type</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fetch_array</function> retourne un tableau qui contient
     &agrave; la ligne demand&eacute;e, dans le r&eacute;sultat identifi&eacute;e
     par <parameter>result</parameter>, et &false; , s'il ne
     reste plus de lignes.
    </para>
    <para>
     <function>pg_fetch_array</function> est une version &eacute;volu&eacute;e de
     <function>pg_fetch_row</function>. En plus de proposer un tableau &agrave;
     indice num&eacute;rique, elle peut aussi enregistrer les donn&eacute;es
     dans un tableau associatif, en utilisant les noms des champs comme
     cl&eacute;s.
    </para>
    <para>
     L'argument optionnel  <parameter>result_type</parameter> de
     <function>pg_fetch_array</function> est une constante, qui peut prendre les
     valeurs suivantes : PGSQL_ASSOC, PGSQL_NUM, et PGSQL_BOTH.
     <note>
      <para>
       <parameter>result_type</parameter> a &eacute;t&eacute; ajout&eacute;e en
       PHP 4.0.
      </para>
     </note>
    </para>
    <para>
     Il est important de noter que <function>pg_fetch_array</function> n'est pas
     significativement plus lent que <function>pg_fetch_row</function>, tandis
     qu'elle fournit un confort d'utilisation notable.
    </para>
    <para>
     Pour plus de d&eacute;tails, reportez-vous &agrave;
     <function>pg_fetch_row</function>.
   </para>
    <example>
     <title>PostgreSQL fetch array</title>
     <programlisting role="php">
&lt;?php
$conn = pg_pconnect("dbname=publisher");
if (!$conn) {
    echo "Erreur de connexion.\n";
    exit;
}
$result = pg_exec($conn, "SELECT * FROM authors");
if (!$result) {
    echo "Erreur durant la requete.\n";
    exit;
}
$arr = pg_fetch_array($result, 0);
echo $arr[0] . " &lt;- array\n";
$arr = pg_fetch_array($result, 1);
echo $arr["author"] . " &lt;- array\n";
?&gt;
     </programlisting>
    </example>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fetch-object">
   <refnamediv>
    <refname>pg_Fetch_Object</refname>
    <refpurpose>Lit une ligne dans un objet.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>object</type><methodname>pg_fetch_object</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>result_type</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fetch_object</function> retourne un objet dont les
     membres sont les champs de la ligne demand&eacute;e, ou
     &false; , si il n'y a plus de lignes.
    </para>
    <para>
     <function>pg_fetch_object</function> est similaire &agrave;
      <function>pg_fetch_array</function>, avec une diff&eacute;rence majeure :
      c'est un objet qui est retourn&eacute;, au lieu d'un tableau. Par
      cons&eacute;quent, cela signifie que vous ne pouvez acc&eacute;der aux
      membres qu'avec leur nom, et non plus leur offset
      (les nombres ne sont pas autoris&eacute;s comme nom de membre).
    </para>
    <para>
      L'argument optionnel <parameter>result_type</parameter> de
      <parameter>result_type</parameter> est une constante qui peut prendre les
      valeurs suivantes : PGSQL_ASSOC, PGSQL_NUM, et PGSQL_BOTH.
     <note>
      <para>
       <parameter>result_type</parameter> a &eacute;t&eacute; ajout&eacute; dans
       PHP 4.0.
      </para>
     </note>
    </para>
    <para>
     Au niveau vitesse, <function>pg_fetch_object</function> est aussi rapide que
     <function>pg_fetch_row</function> et presque aussi rapide que
     <function>pg_fetch_row</function> (la diff&eacute;rence est non significative).
    </para>
    <para>
     Voir aussi
     <function>pg_fetch_array</function> et
     <function>pg_fetch_row</function>.
     <example>
      <title>Lecture d'un objet Postgres</title>
      <programlisting role="php">
&lt;?php
$database = "verlag";
$db_conn = pg_connect("host=localhost port=5432 dbname=$database");
if (!$db_conn):
?&gt;
    &lt;H1&gt;Connexion impossible &agrave; la base postgres &lt;?php echo $database &gt;&lt;/H1&gt; &lt;?php
    exit;
endif;
$qu = pg_exec($db_conn, "SELECT * FROM verlag ORDER BY autor");
$row = 0; // postgres r&eacute;clame un compteur de ligne, d'autres bases ne le font pas.
while ($data = pg_fetch_object($qu, $row)):
    echo $data-&gt;autor." (";
    echo $data-&gt;jahr ."): ";
    echo $data-&gt;titel."&lt;BR&gt;";
    $row++;
endwhile;
?&gt;
&lt;PRE&gt;&lt;?php
$fields[] = array("autor", "Author");
$fields[] = array("jahr",  "  Year");
$fields[] = array("titel", " Title");
$row= 0; // Postgres r&eacute;clame un compteur de ligne, d'autres bases ne le font pas.
while ($data = pg_fetch_object($qu, $row)):
    echo "----------\n";
    reset($fields);
    while (list(,$item) = each($fields)):
        echo $item[1].": ".$data-&gt;$item[0]."\n";
    endwhile;
    $row++;
endwhile;
echo "----------\n";
?&gt;
&lt;/PRE&gt;
&lt;?php
pg_freeresult($qu);
pg_close($db_conn);
?&gt;
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fetch-row">
   <refnamediv>
    <refname>pg_Fetch_Row</refname>
    <refpurpose>Lit une ligne dans un tableau.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>pg_fetch_row</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fetch_row</function> retourne un tableau qui contient
     les donn&eacute;es de la ligne demand&eacute;e, ou
     &false; , si il ne reste plus de lignes.
    </para>
    <para>
     <function>pg_fetch_row</function> lit une ligne dans le r&eacute;sultat
     associ&eacute; &agrave; l'index <parameter>result</parameter>. La ligne est
     retourn&eacute;e sous la forme d'un tableau. La ligne est retourn&eacute;e
     sous la forme d'un tableau, qui commence &agrave; l'index 0.
    </para>
    <para>
     Les appels ult&eacute;rieurs &agrave; <function>pg_fetch_row</function>
     retourneront la ligne d'apr&egrave;s, ou bien &false;,
     lorsqu'il n'y aura plus de lignes.
    </para>
    <para>
     Voir aussi
     <function>pg_fetch_array</function>,
     <function>pg_fetch_object</function> et 
     <function>pg_result</function>.
     <example>
      <title>Postgres retourne une ligne</title>
      <programlisting role="php">
&lt;?php
$conn = pg_pconnect("dbname=publisher");
if (!$conn) {
    echo "Une erreur est survenue.\n";
    exit;
}
$result = pg_exec($conn, "SELECT * FROM authors");
if (!$result) {
    echo "Une erreur est survenue.\n";
    exit;
}
$num = pg_numrows($result);
for ($i=0; $i&lt;$num; $i++) {
  $r = pg_fetch_row($result, $i);
  for ($j=0; $j&lt;count($r); $j++) {
    echo "$r[$j]&amp;nbsp;";
  }
  echo "&lt;br&gt;";
}
?&gt;
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldisnull">
   <refnamediv>
    <refname>pg_FieldIsNull</refname>
    <refpurpose>Teste si un champs est &agrave; &null;.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_fieldisnull</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>field</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldisnull</function> teste si un champs est &agrave;
     &null;. <function>pg_fieldisnull</function> retourne 0 si le champs n'est
     pas &null;. <function>pg_fieldisnull</function> retourne 1 si le champs est
     &agrave; &null;. Le champs peut &ecirc;tre identifi&eacute; avec son nom ou
     son index num&eacute;rique (commencant &agrave; 0).
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldname">
   <refnamediv>
    <refname>pg_FieldName</refname>
    <refpurpose>Retourne le nom d'un champs.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_fieldname</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_number</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldname</function> va retourne le nom du champs qui occupe la
     colonne num&eacute;ro <parameter>field_number</parameter> dans le
     r&eacute;sultat <parameter>result_id</parameter>. La num&eacute;rotation
     des champs commence &agrave; 0.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldnum">
   <refnamediv>
    <refname>pg_FieldNum</refname>
    <refpurpose>Retourne le num&eacute;ro d'une colonne.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_fieldnum</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>string</type><parameter>field_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldnum</function> retourne le num&eacute;ro de la colonne,
     dont le nom est <parameter>field_name</parameter>, dans le r&eacute;sultat
     <parameter>result_id</parameter>. La num&eacute;rotation des champs commence
     &agrave; 0. Cette fonction retournera -1 en cas d'erreur.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldprtlen">
   <refnamediv>
    <refname>pg_FieldPrtLen</refname>
    <refpurpose>Retourne la taille imprim&eacute;e.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_fieldprtlen</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>row_number</parameter></methodparam>
      <methodparam><type>string</type><parameter>field_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldprtlen</function> retourne la taille imprim&eacute;e
     (nombre de caract&egrave;res) d'une valeur donn&eacute;e dans un
     r&eacute;sultat PostgreSQL. La num&eacute;rotation des lignes commence
     &agrave; 0. Cette fonction retourne -1 en cas d'erreur.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldsize">
   <refnamediv>
    <refname>pg_FieldSize</refname>
    <refpurpose>
     Retourne la taille interne de stockage d'un champs donn&eacute;.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_fieldsize</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_number</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldsize</function> retourne la taille interne de stockage
     d'un champs donn&eacute;, en octets. <function>pg_fieldsize</function>
     retourne -1 si la taille est variable. <function>pg_fieldsize</function>
     retourne <literal>FALSE</literal> en cas d'erreur. La num&eacute;rotation
     des colonnes commence &agrave; 0.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-fieldtype">
   <refnamediv>
    <refname>pg_FieldType</refname>
    <refpurpose>
     Retourne le type d'un champs donn&eacute; par index.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_fieldtype</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_number</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_fieldtype</function> retourne une cha&icirc;ne contenant
     le type du champs donn&eacute; par son index field_number . La
     num&eacute;rotation des champs commence &agrave; 0.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-freeresult">
   <refnamediv>
    <refname>pg_FreeResult</refname>
    <refpurpose>Lib&egrave;re la m&eacute;moire</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_freeresult</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_freeresult</function> n'est vraiment utile que si vous risquez
     d'utiliser trop de m&eacute;moire durant votre script. La m&eacute;moire
     occup&eacute;e par les r&eacute;sultats est automatiquement
     lib&eacute;r&eacute;e &agrave; la fin du script. Mais, si vous &ecirc;tes
     s&ucirc;r de ne pas avoir besoin du r&eacute;sultat ult&eacute;rieurement,
     vous pouvez appeler <function>pg_freeresult</function> avec l'index de
     r&eacute;sultat comme argument, et la m&eacute;moire sera lib&eacute;r&eacute;e.
     </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-getlastoid">
   <refnamediv>
    <refname>pg_GetLastOid</refname>
    <refpurpose>Retourne le dernier identifiant d'objet.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>pg_getlastoid</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_getlastoid</function> sert &agrave; lire l'Oid assign&eacute;
     &agrave; un tuple ins&eacute;r&eacute;, si l'index de r&eacute;sultat a
     &eacute;t&eacute; obtenu avec la fonction <function>pg_exec</function>,
     dont la requ&ecirc;te &eacute;tait exclusivement SQL INSERT. Cette fonction
     retourne un entier positif si un Oid valide a &eacute;t&eacute; trouv&eacute;.
     Elle retournera -1 si une erreur est survenue, ou si la derni&egrave;re
     commande n'&eacute;tait pas un INSERT.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-host">
   <refnamediv>
    <refname>pg_Host</refname>
    <refpurpose>Retourne le nom d'h&ocirc;te.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_host</methodname>
      <methodparam><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_host</function> retourne le nom d'h&ocirc;te associ&eacute;
     &agrave; l'index de connexion PostgreSQL.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loclose">
   <refnamediv>
    <refname>pg_loclose</refname>
    <refpurpose>Ferme un objet de grande taille.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>void</type><methodname>pg_loclose</methodname>
      <methodparam><type>resource</type><parameter>fd</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_loclose</function> ferme un objet de type Inversion Large Object.
     <parameter>fd</parameter> est un descripteur de fichier, obtenu avec
     <function>pg_loopen</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-locreate">
   <refnamediv>
    <refname>pg_locreate</refname>
    <refpurpose>Cr&eacute;e un objet de grande taille.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>pg_loimport</methodname>
      <methodparam><type>resource</type><parameter>conn</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_locreate</function> cr&eacute;e un objet de type Inversion
     Large Object et retourne son Oid.  <parameter>conn</parameter> doit &ecirc;tre
     une connexion valide avec une base de donn&eacute;es PostgreSQL. Les modes
     d'acc&egrave;s PostgreSQL INV_READ, INV_WRITE, et INV_ARCHIVE ne sont pas
     support&eacute;s : l'objet peut toujours &ecirc;tre cr&eacute;&eacute;, avec
     des droits d'acc&egrave;s en lecture et &eacute;criture. Le mode INV_ARCHIVE
     a &eacute;t&eacute; supprim&eacute; des bases PostgreSQL (version 6.3 et
     ult&eacute;rieur).
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loexport">
   <refnamediv>
    <refname>pg_loexport</refname>
    <refpurpose>Exporte un objet de grande taille vers un fichier</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_loexport</methodname>
      <methodparam><type>resource</type><parameter>oid</parameter></methodparam>
      <methodparam><type>int</type><parameter>file</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_loexport</function> exporte un objet de grande taille
     dans un fichier. <parameter>oid</parameter> est un identifiant d'objet de
     grande taille qui sera export&eacute; dans le fichier
     <parameter>filename</parameter>,
     qui sp&eacute;cifie son chemin. RetourneFALSEsi une erreur survient,
     et &true; en cas de succ&egrave;s.
     N'oubliez pas que la manipulation d'un objet de  grande taille
     dans PostgreSQL doit intervenir dans une transaction.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loimport">
   <refnamediv>
    <refname>pg_loimport</refname>
    <refpurpose>Importe un objet de grande taille depuis un fichier</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>pg_loimport</methodname>
      <methodparam><type>int</type><parameter>file</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <parameter>filename</parameter> est le chemin jusqu'&agrave; un fichier
     qui servira de source pour cr&eacute;er un objet de grande taille.
     La fonction retourne <literal>FALSE</literal> en cas d'erreur, et sinon
     un identifiant d'objet, cr&eacute;&eacute; directement &agrave; la bonne taille.
     N'oubliez pas que la manipulation d'un objet de  grande taille
     dans PostgreSQL doit intervenir dans une transaction.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loopen">
   <refnamediv>
    <refname>pg_loopen</refname>
    <refpurpose>Ouvre un objet de grande taille.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_loopen</methodname>
      <methodparam><type>resource</type><parameter>conn</parameter></methodparam>
      <methodparam><type>resource</type><parameter>objoid</parameter></methodparam>
      <methodparam><type>string</type><parameter>mode</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_loopen</function> ouvre un objet de type Inversion Large Object
     et retourne un descripteur de fichier pour cet objet. Le descripteur de fichier
     contient les informations de connexion. Ne refermez pas la connexion avant
     d'avoir ferm&eacute; l'objet. <parameter>objoid</parameter> est un Oid valide de
     Large Object, et <parameter>mode</parameter> peut prendre es valeurs suivantes
     : "r", "w", ou "rw".
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loread">
   <refnamediv>
    <refname>pg_loread</refname>
    <refpurpose>Lit un objet de grande taille.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_loread</methodname>
      <methodparam><type>resource</type><parameter>loid</parameter></methodparam>
      <methodparam><type>int</type><parameter>len</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_loread</function> lit au plus <parameter>len</parameter> octets
     d'un objet de grande taille, et retourne les donn&eacute;es sous la forme
     d'une cha&icirc;ne. <parameter>loid</parameter> est un identifiant valide
     d'objet de grande taille, et <parameter>len</parameter> indique la taille
     maximale de m&eacute;moire allou&eacute; &agrave; l'objet de grande taille.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-loreadall">
   <refnamediv>
    <refname>pg_loreadall</refname>
    <refpurpose>Lit un objet de grande taille en totalit&eacute;.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>void</type><methodname>pg_loreadall</methodname>
      <methodparam><type>resource</type><parameter>fd</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_loreadall</function> lit un objet de grande taille en
     totalit&eacute; et le passe directement au client, apr&egrave;s les
     en-t&ecirc;tes ad&eacute;quates. Cette fonction est pr&eacute;vue
     pour transmettre des sons ou des images.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-lounlink">
   <refnamediv>
    <refname>pg_lounlink</refname>
    <refpurpose>Efface un objet de grande taille </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>void</type><methodname>pg_lounlink</methodname>
      <methodparam><type>resource</type><parameter>conn</parameter></methodparam>
      <methodparam><type>resource</type><parameter>lobjid</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_lounlink</function> efface l'objet de grande taille dont
     l'identifiant est <parameter>lobjid</parameter>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-lowrite">
   <refnamediv>
    <refname>pg_lowrite</refname>
    <refpurpose>Ecrit un objet de grande taille </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_lowrite</methodname>
      <methodparam><type>resource</type><parameter>fd</parameter></methodparam>
      <methodparam><type>string</type><parameter>buf</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_lowrite</function> &eacute;crit dans l'objet de grande
     taille autant de donn&eacute;es possible, issues de la variable
     <parameter>buf</parameter> et retourne le nombre d'octets
     r&eacute;ellement &eacute;crits, ou <literal>FALSE</literal> en cas d'erreur.
     <parameter>fd</parameter> est un descripteut d'objet de grande taille,
     obtenu avec <function>pg_loopen</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-numfields">
   <refnamediv>
    <refname>pg_NumFields</refname>
    <refpurpose>Retourne le nombre de champs</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_numfields</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_numfields</function> retourne le nombre de champs ou
     (colonnes) d'un r&eacute;sultat PostgreSQL. L'argument doit &ecirc;tre
     un identifiant de r&eacute;sultat valide retourn&eacute; par
     <function>pg_exec</function>. Cette fonction retournera -1 en cas  d'erreur.
    </para>
    <para>
     Voir aussi 
     <function>pg_numrows</function> et
     <function>pg_cmdtuples</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-numrows">
   <refnamediv>
    <refname>pg_NumRows</refname>
    <refpurpose>Retourne le nombre de lignes.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_numrows</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_numrows</function> retourne le nombre de lignes
     d'un r&eacute;sultat PostgreSQL. L'argument doit &ecirc;tre un
     identifiant de r&eacute;sultat valide retourn&eacute; par
     <function>pg_exec</function>. Cette fonction retournera -1 en cas d'erreur.
    </para>
    <para>
     Voir aussi
     <function>pg_numfields</function> et
     <function>pg_cmdtuples</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-options">
   <refnamediv>
    <refname>pg_Options</refname>
    <refpurpose>Retourne les options.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_options</methodname>
      <methodparam><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_options</function> retourne une cha&icirc;ne contenant
     les options de la connexion PostgreSQL.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-pconnect">
   <refnamediv>
    <refname>pg_pConnect</refname>
    <refpurpose>
     Etablit une connexion persistante.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_pconnect</methodname>
      <methodparam><type>string</type><parameter>conn_string</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_pconnect</function> retourne un index de connexion
     en cas de succ&egrave;s, ou &false; en cas d'erreur.
     <function>pg_pconnect</function> ouvre une connexion permanente &agrave;
     une base PostgreSQL. Les arguments doivent &ecirc;tre ins&eacute;r&eacute;s
     dans une cha&icirc;ne &agrave; guillemets. Ils incluent :
     <parameter>host</parameter>,
     <parameter>port</parameter>, <parameter>tty</parameter>,
     <parameter>options</parameter>, <parameter>dbname</parameter>,
     <parameter>user</parameter> et <parameter>password</parameter>.
    </para>
    <para>
     <function>pg_pconnect</function> retourne un indentifiant de
     connexion qui sera utilis&eacute;es par les autres fonctions PostgreSQL.
     Vous pouvez ouvrir plusieurs connexions en m&ecirc;me temps.
    </para>
    <para>
     L'ancienne syntaxe
     <command>$conn = pg_pconnect("host", "port", "options", "tty", "dbname")</command>
     est obsol&egrave;te.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-port">
   <refnamediv>
    <refname>pg_Port</refname>
    <refpurpose>Retourne le num&eacute;ro de port.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_port</methodname>
      <methodparam><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_port</function> retourne le num&eacute;ro de port de
     la connexion identifi&eacute;e <parameter>connection_id</parameter>.
    </para>
   </refsect1>
  </refentry>
    <refentry id="function.pg-put-line">
   <refnamediv>
    <refname>pg_put_line</refname>
    <refpurpose>Envoie une cha&icirc;ne au serveur PostgreSQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_put_line</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>connection_id</parameter></methodparam>
      <methodparam><type>string</type><parameter>data</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_put_line</function> envoie une cha&icirc;ne (termin&eacute;e
     par &null;) au serveur PostgreSQL. Ceci est pratique pour effectuer
     des insertions tr&egrave;s rapides dans une table, initi&eacute;e par une
     op&eacute;ration de copie PostgreSQL copy-operation. Le caract&egrave;re
     final &null; est automatiquement ajout&eacute;.
     <function>pg_put_line</function>  retourne &true; en cas de succ&egrave;s,
     et &false;.
    </para>
    <note>
     <para>
      Notez que l'application doit explicitement ajouter les deux caract&egrave;res
      "\." &agrave; la fin de la cha&icirc;ne pour indiquer au serveur qu'elle a finit
      d'envoyer des donn&eacute;es.
     </para>
    </note>
    <para>
     Voir aussi 
     <function>pg_end_copy</function>.
     <example>
      <title>Insertion &agrave; grande vitesse dans une table</title>
      <programlisting role="php">
&lt;?php
    $conn = pg_pconnect("dbname=foo");
    pg_exec($conn, "create table bar (a int4, b char(16), d float8)");
    pg_exec($conn, "copy bar from stdin");
    pg_put_line($conn, "3\tBonjour le monde\t4.5\n");
    pg_put_line($conn, "4\tAu revoir le monde\t7.11\n");
    pg_put_line($conn, "\\.\n");
    pg_end_copy($conn);
?&gt;
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-result">
   <refnamediv>
    <refname>pg_Result</refname>
    <refpurpose>Retourne les valeurs d'un identifiant de r&eacute;sultat.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>mixed</type><methodname>pg_result</methodname>
      <methodparam><type>resource</type><parameter>result_id</parameter></methodparam>
      <methodparam><type>int</type><parameter>row_number</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>fieldname</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_result</function> retourne les valeurs d'un identifiant de
     r&eacute;sultat, produit par <function>pg_exec</function>. Les arguments
     <parameter>row_number</parameter> et <parameter>fieldname</parameter>
     pr&eacute;cisent la cellule qui sera retourn&eacute;e. La num&eacute;rotation
     des lignes commence &agrave; 0. Au lieu d'utiliser le nom du champs, vous
     pouvez utiliser son index, sous la forme d'un nombre sans guillemets. La
     num&eacute;rotation des champs commence &agrave; 0.
    </para>
    <para>
     PostgreSQL dispose de nombreux types, et seuls, les types basiques sont
     support&eacute;s ici. Toutes les formes d'entier, bool&eacute;en et Oid
     sont retourn&eacute;s sous la forme d'entiers. Toutes les formes de nombre
     &agrave; virgule flottante et types r&eacute;els sont retourn&eacute;s sous
     la forme d'une valeur de type double. Tous les autres types, y compris les
     tableaux, sont retourn&eacute;s sous la forme de cha&icirc;nes format&eacute;es,
     au format par d&eacute;faut de PostgreSQL.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-set-client-encoding">
   <refnamediv>
    <refname>pg_set_client_encoding</refname>
    <refpurpose>
     Choisit l'encodage du client
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>pg_set_client_encoding</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>connection</parameter></methodparam>
      <methodparam><type>string</type><parameter>encoding</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_set_client_encoding</function> fixe l'encodage du client.
     Elle retourne 0 en cas de succ&egrave;s, et -1 sinon.
    </para>
    <para>
     <parameter>encoding</parameter> est l'encodage du client, et peut &ecirc;tre
     SQL_ASCII, EUC_JP, EUC_CN, EUC_KR, EUC_TW, UNICODE,
     MULE_INTERNAL, LATINX (X=1...9), KOI8, WIN, ALT,
     SJIS, BIG5, WIN1250.
    </para>
    <note>
     <para>
      Cette fonction requiert PHP-4.0.2 ou plus r&eacute;cent et PostgreSQL-7.0 ou
      plus r&eacute;cent.
     </para>
     <para>
      Jadis, <function>pg_set_client_encoding</function> s'appelait
      pg_setclientencoding().
     </para>
    </note>
    <para>
     Voir aussi 
     <function>pg_client_encoding</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-client-encoding">
   <refnamediv>
    <refname>pg_client_encoding</refname>
    <refpurpose>
     Lit l'encodage du client
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>pg_client_encoding</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_client_encoding</function> retourne l'encodage du client.
     Elle retourne une des valeurs suivantes :
     SQL_ASCII, EUC_JP, EUC_CN, EUC_KR, EUC_TW, UNICODE,
     MULE_INTERNAL, LATINX (X=1...9), KOI8, WIN, ALT,
     SJIS, BIG5, WIN1250.
    </para>
    <note>
     <para>
      Cette fonction requiert PHP-4.0.2 ou plus r&eacute;cent et PostgreSQL-7.0 ou
      plus r&eacute;cent.
     </para>
     <para>
      Jadis, <function>pg_client_encoding</function> s'appelait
      pg_clientencoding().
     </para>
    </note>
    <para>
     Voir aussi
     <function>pg_set_client_encoding</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-trace">
   <refnamediv>
    <refname>pg_trace</refname>
    <refpurpose>Active le suivi d'une connexion PostgreSQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_trace</methodname>
      <methodparam><type>string</type><parameter>filename</parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>mode</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_trace</function> active le suivi des communications entre PHP et
     le serveur PostgreSQL. Cet historique sera enregistr&eacute; dans un fichier.
     Pour comprendre ces lignes, il faut &ecirc;tre familier avec le protocole
     de communication interne &agrave; PostgreSQL. Pour ceux qui le ne sont pas,
     elles peuvent &ecirc;tre utiles pour suivre les requ&ecirc;tes et les erreurs :
     avec la commande <command>grep '^To backend' trace.log</command>, vous
     pourrez voir les requ&ecirc;tes r&eacute;ellement envoy&eacute;es au serveur PostgreSQL.
    </para>
    <para>
     <parameter>filename</parameter> et <parameter>mode</parameter>
     sont les m&ecirc;mes arguments que pour la fonction <function>fopen</function>
     (<parameter>mode</parameter> par d&eacute;faut &agrave; 'w'),
     <parameter>connection</parameter> indique la connexion &agrave; suivre.
     Par d&eacute;faut, c'est la derni&egrave;re ouverte.
    </para>
    <para>
     <function>pg_trace</function> retourne &true; si
     <parameter>filename</parameter> a pu &ecirc;tre ouvert en
     &eacute;criture, etFALSEsinon.
    </para>
    <para>
     Voir aussi
     <function>fopen</function> et
     <function>pg_untrace</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-tty">
   <refnamediv>
    <refname>pg_tty</refname>
    <refpurpose>Retourne le nom de tty.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
     <type>string</type><methodname>pg_tty</methodname>
     <methodparam><type>resource</type><parameter>connection_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_tty</function> retourne le nom de tty de la connexion
     associ&eacute;e &agrave; <parameter>connection_id</parameter>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.pg-untrace">
   <refnamediv>
    <refname>pg_untrace</refname>
    <refpurpose>Termine le suivi d'une connexion PostgreSQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>pg_untrace</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>connection</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>pg_untrace</function> termine le suivi d'une connexion
     PostgreSQL, initi&eacute;e avec <function>pg_trace</function>.
     <parameter>connection</parameter> indique la connexion &agrave;
     suivre. Par d&eacute;faut, c'est la derni&egrave;re ouverte.
    </para>
    <para>
     <function>pg_untrace</function> retourne toujours &true;.
    </para>
    <para>
     Voir aussi
     <function>pg_trace</function>.
    </para>
   </refsect1>
  </refentry>
 </reference>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->