Mise à jour de la traduction de libpq

postgresql/libpq.xml

@@ -2337,10 +2337,10 @@ suivantes :
           <term><literal>PGRES_SINGLE_TUPLE</literal></term>
           <listitem>
            <para>
-            The <structname>PGresult</structname> contains a single result tuple
-            from the current command.  This status occurs only when
-            single-row mode has been selected for the query
-            (see <xref linkend="libpq-single-row-mode"/>).
+            La structure <structname>PGresult</structname> contient une seule
+            ligne de résultat provenant de la commande courante. Ce statut
+            n'intervient que lorsque le mode simple ligne a été sélectionné
+            pour cette requête (voir <xref linkend="libpq-single-row-mode"/>).
            </para>
           </listitem>
          </varlistentry>
@@ -3517,10 +3517,11 @@ plusieurs commandes <acronym>SQL</acronym>, toutes les structures
 
     <listitem>
      <para>
-      <function>PQexec</function> always collects the command's entire result,
-      buffering it in a single <structname>PGresult</structname>.  While
-      this simplifies error-handling logic for the application, it can be
-      impractical for results containing many rows.
+      <function>PQexec</function> récupère toujours le résultat entier de la
+      commande, le mettant en cache dans une seule structure
+      <structname>PGresult</structname>. Bien que cela simplifie la logique
+      de la gestion des erreurs pour l'application, cela peut ne pas se
+      révéler pratique pour les résultats contenant de nombreuses lignes.
      </para>
     </listitem>
 </itemizedlist>
@@ -3738,10 +3739,10 @@ chaîne de commandes).
   </para>
 
   <para>
-   Another frequently-desired feature that can be obtained with
-   <function>PQsendQuery</function> and <function>PQgetResult</function>
-   is retrieving large query results a row at a time.  This is discussed
-   in <xref linkend="libpq-single-row-mode"/>.
+   Une autre fonctionnalité fréquemment demandée, pouvant être obtenu avec
+   <function>PQsendQuery</function> et <function>PQgetResult</function> est
+   la récupération d'un gros résultat une ligne à la fois. Ceci est discuté
+   dans <xref linkend="libpq-single-row-mode"/>.
   </para>
 
   <para>
@@ -3913,43 +3914,46 @@ décrit ci-dessus.
 </sect1>
 
  <sect1 id="libpq-single-row-mode">
-  <title>Retrieving Query Results Row-By-Row</title>
+  <title>Récupérer le résultats des requêtes ligne par ligne</title>
 
   <indexterm zone="libpq-single-row-mode">
    <primary>libpq</primary>
-   <secondary>single-row mode</secondary>
+   <secondary>mode simple ligne</secondary>
   </indexterm>
 
   <para>
-   Ordinarily, <application>libpq</application> collects a SQL command's
-   entire result and returns it to the application as a single
-   <structname>PGresult</structname>.  This can be unworkable for commands
-   that return a large number of rows.  For such cases, applications can use
-   <function>PQsendQuery</function> and <function>PQgetResult</function> in
-   <firstterm>single-row mode</firstterm>.  In this mode, the result row(s) are
-   returned to the application one at a time, as they are received from the
-   server.
+   D'habitude, <application>libpq</application> récupère le résultat complet
+   d'une commande SQL et la renvoie à l'application sous la forme d'une seule
+   structure <structname>PGresult</structname>. Ce comportement peut être un
+   problème pour les commandes qui renvoient un grand nombre de lignes. Dans
+   de tels cas, les applications peuvent utiliser
+   <function>PQsendQuery</function> et <function>PQgetResult</function> dans
+   le <firstterm>mode simple ligne</firstterm>. Dans ce mode, les lignes du
+   résultat sont renvoyées à l'application une par une, au fur et à mesure
+   qu'elles sont reçues du serveur.
   </para>
 
   <para>
-   To enter single-row mode, call <function>PQsetSingleRowMode</function>
-   immediately after a successful call of <function>PQsendQuery</function>
-   (or a sibling function).  This mode selection is effective only for the
-   currently executing query.  Then call <function>PQgetResult</function>
-   repeatedly, until it returns null, as documented in <xref
-   linkend="libpq-async"/>.  If the query returns any rows, they are returned
-   as individual <structname>PGresult</structname> objects, which look like
-   normal query results except for having status code
-   <literal>PGRES_SINGLE_TUPLE</literal> instead of
-   <literal>PGRES_TUPLES_OK</literal>.  After the last row, or immediately if
-   the query returns zero rows, a zero-row object with status
-   <literal>PGRES_TUPLES_OK</literal> is returned; this is the signal that no
-   more rows will arrive.  (But note that it is still necessary to continue
-   calling <function>PQgetResult</function> until it returns null.)  All of
-   these <structname>PGresult</structname> objects will contain the same row
-   description data (column names, types, etc) that an ordinary
-   <structname>PGresult</structname> object for the query would have.
-   Each object should be freed with <function>PQclear</function> as usual.
+   Pour entrer dans le mode simple ligne, appelez
+   <function>PQsetSingleRowMode</function> immédiatement après un appel
+   réussi à <function>PQsendQuery</function> (ou une fonction similaire).
+   Cette sélection de mode ne fonctionne que pour la requête en cours
+   d'exécution. Puis appelez <function>PQgetResult</function> de façon répétée,
+   jusqu'à ce qu'elle renvoit null, comme documenté dans <xref
+   linkend="libpq-async"/>. Si la requête renvoit des lignes, ils sont renvoyées
+   en tant qu'objet <structname>PGresult</structname> individuel, qui ressemble
+   à des résultats de requêtes standards en dehors du fait qu'elles ont le code
+   de statut <literal>PGRES_SINGLE_TUPLE</literal> au lieu de
+   <literal>PGRES_TUPLES_OK</literal>. Après la dernière ligne ou immédiatement
+   si la requête ne renvoit aucune ligne, un objet de zéro ligne avec le statut
+   <literal>PGRES_TUPLES_OK</literal> est renvoyé&nbsp;; c'est le signal
+   qu'aucune autre ligne ne va arriver. (Notez cependant qu'il est toujours
+   nécessaire de continuer à appeler <function>PQgetResult</function> jusqu'à
+   ce qu'elle renvoit null.) Tous les objets <structname>PGresult</structname>
+   contiendront les mêmes données de description de lignes (noms de colonnes,
+   types, etc) qu'un objet <structname>PGresult</structname> standard aurait
+   pour cette requête. Chaque objet doit être libéré avec la fonction
+   <function>PQclear</function> comme d'ordinaire.
   </para>
 
   <para>
@@ -3964,23 +3968,23 @@ décrit ci-dessus.
 
      <listitem>
       <para>
-       Select single-row mode for the currently-executing query.
+       Sélectionne le mode ligne simple pour la requête en cours d'exécution.
 
 <synopsis>
 int PQsetSingleRowMode(PGconn *conn);
 </synopsis>
       </para>
 
       <para>
-       This function can only be called immediately after
-       <function>PQsendQuery</function> or one of its sibling functions,
-       before any other operation on the connection such as
-       <function>PQconsumeInput</function> or
-       <function>PQgetResult</function>.  If called at the correct time,
-       the function activates single-row mode for the current query and
-       returns 1.  Otherwise the mode stays unchanged and the function
-       returns 0.  In any case, the mode reverts to normal after
-       completion of the current query.
+       Cette fonction peut seulement être appelée immédiatement après
+       <function>PQsendQuery</function> ou une de ses fonctions sœurs, avant
+       toute autre opération sur la connexion comme
+       <function>PQconsumeInput</function> ou
+       <function>PQgetResult</function>. Si elle est appelée au bon moment,
+       la fonction active le mode simple ligne pour la requête en cours et
+       renvoit 1. Sinon, le mode reste inchangé et la fonction renvoit 0. Dans
+       tous les cas, le mode retourne à la normale après la fin de la requête
+       en cours.
       </para>
      </listitem>
     </varlistentry>
@@ -3989,16 +3993,16 @@ int PQsetSingleRowMode(PGconn *conn);
 
   <caution>
    <para>
-    While processing a query, the server may return some rows and then
-    encounter an error, causing the query to be aborted.  Ordinarily,
-    <application>libpq</application> discards any such rows and reports only the
-    error.  But in single-row mode, those rows will have already been
-    returned to the application.  Hence, the application will see some
-    <literal>PGRES_SINGLE_TUPLE</literal> <structname>PGresult</structname>
-    objects followed by a <literal>PGRES_FATAL_ERROR</literal> object.  For
-    proper transactional behavior, the application must be designed to
-    discard or undo whatever has been done with the previously-processed
-    rows, if the query ultimately fails.
+    Lors du traitement d'une requête, le serveur pourrait renvoyer quelques
+    lignes puis rencontrer une erreur, causant l'annulation de la requête.
+    D'ordinaire, la bibliothèque partagée <application>libpq</application>
+    annule ces lignes et renvoit une erreur. Avec le mode simple ligne,
+    des lignes ont déjà pu être envoyées à l'application. Du coup, l'application
+    verra quelques objets <structname>PGresult</structname> de statut
+    <literal>PGRES_SINGLE_TUPLE</literal> suivi par un objet de statut
+    <literal>PGRES_FATAL_ERROR</literal>. Pour un bon comportement transactionnel,
+    l'application doit être conçue pour invalider ou annuler tout ce qui a été
+    fait avec les lignes précédemment traitées si la requête finit par échouer.
    </para>
   </caution>