Traduction du fichier plpython.xml

postgresql/plpython.xml

@@ -86,8 +86,8 @@
       Le langage nommé <literal>plpythonu</literal> implémente PL/Python
       suivant la variante par défaut du langage Python, qui est actuellement
       Python 2. (Cette valeur par défaut est indépendante de ce que toute
-      installations locales de Python pourrait considérer comme la valeur
-      par <quote>défaut</quote>, par exemplece que pourrait être
+      installation locale de Python qui pourrait être considérée comme la valeur
+      par <quote>défaut</quote>, par exemple ce que pourrait être
       <filename>/usr/bin/python</filename>.) La valeur par défaut sera
       probablement changée avec Python 3 dans une prochaine version de
       PostgreSQL, suivant les progrès de la migration à Python 3 dans la
@@ -96,9 +96,9 @@
     </listitem>
    </itemizedlist>
 
-   This scheme is analogous to the recommendations in <ulink
-   url="http://www.python.org/dev/peps/pep-0394/">PEP 394</ulink> regarding the
-   naming and transitioning of the <command>python</command> command.
+   Cela est analogue aux recommendations de <ulink
+   url="http://www.python.org/dev/peps/pep-0394/">PEP 394</ulink> au
+   regard des nommages et transitions des commandes <command>python</command>.
   </para>
 
   <para>
@@ -892,47 +892,49 @@ $$ LANGUAGE plpythonu;
     <title>Fonctions d'accès à la base de données</title>
 
   <para>
-   The <literal>plpy</literal> module provides several functions to execute
-   database commands:
+   Le module <literal>plpy</literal> fournit plusieurs fonctions pour exécuter
+   des commandes sur la base de données&nbsp;:
   </para>
 
   <variablelist>
    <varlistentry>
     <term><literal>plpy.<function>execute</function>(<replaceable>query</replaceable> [, <replaceable>max-rows</replaceable>])</literal></term>
     <listitem>
      <para>
-      Calling <function>plpy.execute</function> with a query string and an
-      optional row limit argument causes that query to be run and the result to
-      be returned in a result object.
+      L'appel à <function>plpy.execute</function> avec une chaîne pour la requête
+      et une limite de ligne optionnelle permet d'exécuter la requête et de
+      retourner le résultat dans un objet résultant.
      </para>
 
      <para>
-      The result object emulates a list or dictionary object.  The result
-      object can be accessed by row number and column name.  For example:
+      L'objet resultant émule une liste ou un objet dictionnaire. L'objet
+      résultant peut être accédé par le numéro de ligne et le nom de colonne.
+      Par exemple&nbsp;:
  <programlisting>
  rv = plpy.execute("SELECT * FROM my_table", 5)
  </programlisting>
-      returns up to 5 rows from <literal>my_table</literal>.  If
-      <literal>my_table</literal> has a column
-      <literal>my_column</literal>, it would be accessed as:
+      retourne jusqu'à 5 lignes de <literal>my_table</literal>.
+      Si <literal>my_table</literal> possède une colonne <literal>my_column</literal>, 
+      elle pourra être accédée ainsi&nbsp;:
  <programlisting>
  foo = rv[i]["my_column"]
  </programlisting>
-      The number of rows returned can be obtained using the built-in
-      <function>len</function> function.
+      Le nombre de lignes retournées peut être obtenu en utilisant la
+      fonction intégrée <function>len</function>.
      </para>
 
      <para>
-      The result object has these additional methods:
+      L'objet résultant contient ces méthodes additionnelles&nbsp;:
       <variablelist>
        <varlistentry>
         <term><literal><function>nrows</function>()</literal></term>
         <listitem>
          <para>
-          Returns the number of rows processed by the command.  Note that this
-          is not necessarily the same as the number of rows returned.  For
-          example, an <command>UPDATE</command> command will set this value but
-          won't return any rows (unless <literal>RETURNING</literal> is used).
+          Retourne le nombre de lignes traitées par cette commande. Notez que
+          cela n'est pas nécessairement identique au nombre de lignes retournées.
+          Par exemple, une commande <command>UPDATE</command> fixera cette valeur
+          mais ne retournera aucune ligne (sauf si <literal>RETURNING</literal> 
+          est utilisé).
          </para>
         </listitem>
        </varlistentry>
@@ -941,7 +943,7 @@ $$ LANGUAGE plpythonu;
         <term><literal><function>status</function>()</literal></term>
         <listitem>
          <para>
-          The <function>SPI_execute()</function> return value.
+          La valeur retournée par <function>SPI_execute()</function>.
          </para>
         </listitem>
        </varlistentry>
@@ -952,33 +954,35 @@ $$ LANGUAGE plpythonu;
         <term><literal><function>coltypmods</function>()</literal></term>
         <listitem>
          <para>
-          Return a list of column names, list of column type OIDs, and list of
-          type-specific type modifiers for the columns, respectively.
+          Retourne respectivement une liste de noms de colonne, une liste de type OID
+          de colonne et une liste de type de modifieurs spécifiques à un type
+          pour les colonnes.
          </para>
 
          <para>
-          These methods raise an exception when called on a result object from
-          a command that did not produce a result set, e.g.,
-          <command>UPDATE</command> without <literal>RETURNING</literal>, or
-          <command>DROP TABLE</command>.  But it is OK to use these methods on
-          a result set containing zero rows.
+          Ces méthodes lèvent une exception quand elles sont appelées sur un
+          objet résultant d'une commande n'ayant pas produit d'ensemble de
+          résultat, par ex,
+          <command>UPDATE</command> sans <literal>RETURNING</literal>, ou
+          <command>DROP TABLE</command>. Il est cependant normal d'utiliser
+          ces méthodes sur un ensemble de résultat ne contenant aucune ligne.
          </para>
         </listitem>
        </varlistentry>
       </variablelist>
      </para>
 
      <para>
-      The result object can be modified.
+      L'objet résultant peut être modifié.
      </para>
 
      <para>
-      Note that calling <literal>plpy.execute</literal> will cause the entire
-      result set to be read into memory.  Only use that function when you are
-      sure that the result set will be relatively small.  If you don't want to
-      risk excessive memory usage when fetching large results,
-      use <literal>plpy.cursor</literal> rather
-      than <literal>plpy.execute</literal>.
+      Notez que l'appel à <literal>plpy.execute</literal> provoquera la lecture
+      de tout l'ensemble de résultat en mémoire. N'utilisez cette fonction que
+      lorsque vous êtes surs que l'ensemble de résultat sera relativement petit.
+      Si vous ne voulez pas risquer une utilisation excessive de mémoire pour
+      récupérer de gros ensembles, préférez <literal>plpy.cursor</literal> à
+      <literal>plpy.execute</literal>.
      </para>
     </listitem>
    </varlistentry>
@@ -988,52 +992,56 @@ $$ LANGUAGE plpythonu;
     <term><literal>plpy.<function>execute</function>(<replaceable>plan</replaceable> [, <replaceable>arguments</replaceable> [, <replaceable>max-rows</replaceable>]])</literal></term>
     <listitem>
      <para>
-      <indexterm><primary>preparing a query</primary><secondary>in PL/Python</secondary></indexterm>
-      <function>plpy.prepare</function> prepares the execution plan for a
-      query.  It is called with a query string and a list of parameter types,
-      if you have parameter references in the query.  For example:
+      <indexterm><primary>Préparer une requête</primary><secondary>en PL/Python</secondary></indexterm>
+      <function>plpy.prepare</function> prépare le plan d'exécution pour une requête.
+      Il faut l'appeler avec une chaîne contenant la requête et une liste de types
+      de paramètres, si vous avez des références à des paramètres dans cette requête.
+      Par exemple&nbsp;:
  <programlisting>
 plan = plpy.prepare("SELECT last_name FROM my_users WHERE first_name = $1", ["text"])
  </programlisting>
-      <literal>text</literal> is the type of the variable you will be passing
-      for <literal>$1</literal>.  The second argument is optional if you don't
-      want to pass any parameters to the query.
+      <literal>text</literal> est le type de variable qui sera passé à
+      <literal>$1</literal>.  Le second paramètre est optionel si vous
+      ne voulez pas fournir de paramètre à la requête.
      </para>
      <para>
-      After preparing a statement, you use a variant of the
-      function <function>plpy.execute</function> to run it:
+      Après avoir préparé une requête, il faut utiliser une variante
+      de la fonction <function>plpy.execute</function> pour l'exécuter&nbsp;:
  <programlisting>
 rv = plpy.execute(plan, ["name"], 5)
  </programlisting>
-      Pass the plan as the first argument (instead of the query string), and a
-      list of values to substitute into the query as the second argument.  The
-      second argument is optional if the query does not expect any parameters.
-      The third argument is the optional row limit as before.
+      Il faut fournir le plan comme premier argument (à la place de la chaîne),
+      et une liste de valeurs à substituer dans la requête comme second argument.
+      Le deuxième argument est optionnel si la requête n'attend pas de paramètre.
+      Le troisième argument est la limite de ligne optionnelle comme auparavant.
      </para>
 
      <para>
-      Query parameters and result row fields are converted between PostgreSQL
-      and Python data types as described in <xref linkend="plpython-data"/>.
-      The exception is that composite types are currently not supported: They
-      will be rejected as query parameters and are converted to strings when
-      appearing in a query result.  As a workaround for the latter problem, the
-      query can sometimes be rewritten so that the composite type result
-      appears as a result row rather than as a field of the result row.
-      Alternatively, the resulting string could be parsed apart by hand, but
-      this approach is not recommended because it is not future-proof.
+      Les paramètres de requête ainsi que les champs des lignes de résultat
+      sont converties entre les types de données de PostgreSQL et de Python
+      comme décrit dans  <xref linkend="plpython-data"/>.
+      Il y a une exception pour les types composites qui ne sont pour le
+      moment pas supportés&nbsp;: ils seront rejetés comme paramètre de requête
+      et convertis en chaînes de caractères s'ils apparaissent dans le
+      résultat d'une requête. Pour contourner le dernier problème, la
+      requête peut parfois être réécrite pour que le type composite résultant
+      apparaisse comme une ligne plutôt qu'un champ dans la ligne résultante.
+      Sinon, la chaîne résultante peut être analysée séparément à la main,
+      mais cette approche n'est pas recommendée car elle n'est pas à l'abri
+      d'un changement ultérieur.
      </para>
 
      <para>
-      When you prepare a plan using the PL/Python module it is automatically
-      saved.  Read the SPI documentation (<xref linkend="spi"/>) for a
-      description of what this means.  In order to make effective use of this
-      across function calls one needs to use one of the persistent storage
-      dictionaries <literal>SD</literal> or <literal>GD</literal> (see
-      <xref linkend="plpython-sharing"/>). For example:
+      Quand un plan est préparé en utilisant le module PL/Python, il est
+      automatiquement sauvegardé. Voir la documentation de SPI (<xref linkend="spi"/>)
+      pour une description de ce que cela signifie. Afin d'utiliser efficacement
+      ces appels de fonction, il faut utiliser un des dictionnaires de stockage
+      persistant <literal>SD</literal> ou <literal>GD</literal> (voir
+      <xref linkend="plpython-sharing"/>). Par exemple&nbsp;:
  <programlisting>
  CREATE FUNCTION usesavedplan() RETURNS trigger AS $$
     plan = SD.setdefault("plan", plpy.prepare("SELECT 1"))
-     # rest of function
+     # reste de la fonction
  $$ LANGUAGE plpythonu;
  </programlisting>
      </para>
@@ -1045,29 +1053,30 @@ rv = plpy.execute(plan, ["name"], 5)
     <term><literal>plpy.<function>cursor</function>(<replaceable>plan</replaceable> [, <replaceable>arguments</replaceable>])</literal></term>
     <listitem>
      <para>
-      The <literal>plpy.cursor</literal> function accepts the same arguments
-      as <literal>plpy.execute</literal> (except for the row limit) and returns
-      a cursor object, which allows you to process large result sets in smaller
-      chunks.  As with <literal>plpy.execute</literal>, either a query string
-      or a plan object along with a list of arguments can be used.
+      La fonction <literal>plpy.cursor</literal> accepte les mêmes arguments
+      que <literal>plpy.execute</literal> (à l'exception de la limite de lignes)
+      et retourne un objet curseur, qui permet de traiter de gros ensembles de
+      résultats en plus petits morceaux. Comme avec  <literal>plpy.execute</literal>,
+      une chaîne de caractère ou un objet plan accompagné d'une liste d'arguments
+      peuvent être utilisés.
      </para>
 
      <para>
-      The cursor object provides a <literal>fetch</literal> method that accepts
-      an integer parameter and returns a result object.  Each time you
-      call <literal>fetch</literal>, the returned object will contain the next
-      batch of rows, never larger than the parameter value.  Once all rows are
-      exhausted, <literal>fetch</literal> starts returning an empty result
-      object.  Cursor objects also provide an
-      <ulink url="http://docs.python.org/library/stdtypes.html#iterator-types">iterator
-      interface</ulink>, yielding one row at a time until all rows are
-      exhausted.  Data fetched that way is not returned as result objects, but
-      rather as dictionaries, each dictionary corresponding to a single result
-      row.
+      L'objet curseur fournit une méthode <literal>fetch</literal> qui requiert
+      en entrée un paramètre entier et retourne un objet résultat. À chaque appel
+      de <literal>fetch</literal>, l'objet retourné contiendra la prochaine
+      série de lignes, mais jamais plus que la valeur passée en paramètre.
+      Une fois que toutes les lignes ont été épuisées, <literal>fetch</literal>
+      se met à retourner des objets résultat vides. Les objets curseurs
+      fournissent également une <ulink url="http://docs.python.org/library/stdtypes.html#iterator-types">
+      interface d'itérateur</ulink>, fournissant les lignes une par une jusqu'à épuisement.
+      Les données récupérées de cette façon ne sont pas retournées dans des objets
+      résultat, mais plutôt dans des dictionnaires, chacun correspondant à une unique
+      ligne de résultat.
      </para>
 
      <para>
-      An example of two ways of processing data from a large table is:
+      Un exemple montrant deux façons de traiter des données dans une large table est:
 <programlisting>
 CREATE FUNCTION count_odd_iterator() RETURNS integer AS $$
 odd = 0
@@ -1101,18 +1110,19 @@ $$ LANGUAGE plpythonu;
      </para>
 
      <para>
-      Cursors are automatically disposed of.  But if you want to explicitly
-      release all resources held by a cursor, use the <literal>close</literal>
-      method.  Once closed, a cursor cannot be fetched from anymore.
+      Les curseurs sont automatiquement libérés. Mais si vous voulez
+      libérer explicitement toutes les ressources retenues par un curseur,
+      il faut utiliser la méthode <literal>close</literal>.
+      Une fois fermé, un curseur ne peut plus être utilisé pour retourner
+      des lignes.
      </para>
 
      <tip>
       <para>
-        Do not confuse objects created by <literal>plpy.cursor</literal> with
-        DB-API cursors as defined by
-        the <ulink url="http://www.python.org/dev/peps/pep-0249/">Python
-        Database API specification</ulink>.  They don't have anything in common
-        except for the name.
+        Il ne faut pas confondre les objets créés par <literal>plpy.cursor</literal>
+        avec les curseurs DB-API comme définis par <ulink url="http://www.python.org/dev/peps/pep-0249/">
+        la spécification Python Database API</ulink>. Ils n'ont rien en commun si
+        ce n'est le nom.
       </para>
      </tip>
     </listitem>

postgresql/ref/create_type.xml

@@ -290,10 +290,10 @@ CREATE TYPE <replaceable class="parameter">nom</replaceable>
    englobée dans une seule valeur entière positive pour son stockage dans les
    catalogues système.
    <replaceable class="parameter">type_modifier_input_function</replaceable>
-   se voit fourni le modifieur déclaré de la forme d'un tableau de
+   se voit fournir le modifieur déclaré de la forme d'un tableau de
    <type>cstring</type>. Il doit vérifier la validité des valeurs et renvoyer une
    erreur si elles sont invalides. Dans le cas contraire, il renvoie une valeur
-   entière postivequi sera stockée dans la colonne <quote>typmod</quote>. Les
+   entière postive qui sera stockée dans la colonne <quote>typmod</quote>. Les
    modifieurs de type seront rejetés si le type n'a pas de
    <replaceable class="parameter">type_modifier_input_function</replaceable>.
    <replaceable class="parameter">type_modifier_output_function</replaceable>