Traductions pendant un déplacement... :)

postgresql/datatype.xml

@@ -3282,10 +3282,11 @@ SELECT personne.nom, vacances.nombre_de_semaines FROM personne, vacances
     </indexterm>
 
     <para>
-     Lines are represented by the linear
-     equation <replaceable>A</replaceable>x + <replaceable>B</replaceable>y + <replaceable>C</replaceable> = 0,
-     where <replaceable>A</replaceable> and <replaceable>B</replaceable> are not both zero.  Values
-     of type <type>line</type> are input and output in the following form:
+     Les lignes sont représentées par l'équation linéraire
+     <replaceable>A</replaceable>x + <replaceable>B</replaceable>y + <replaceable>C</replaceable> = 0,
+     où <replaceable>A</replaceable> et <replaceable>B</replaceable> ne valent
+     pas zéro tous les deux. Les valeurs de type <type>line</type> sont fournies
+     et récupérées sous la forme suivante&nbsp::
 <synopsis>
 { <replaceable>A</replaceable>, <replaceable>B</replaceable>, <replaceable>C</replaceable> }
 </synopsis>
@@ -3320,9 +3321,9 @@ SELECT personne.nom, vacances.nombre_de_semaines FROM personne, vacances
     </indexterm>
 
     <para>
-     Line segments are represented by pairs of points that are the endpoints
-     of the segment.  Values of type <type>lseg</type> are specified using any
-     of the following syntaxes:
+     Les segments de ligne sont représentés par des paires de points qui sont
+     les points finaux du segment. Les valeurs de type <type>lseg</type> sont
+     précisées en utilisant une des syntaxes suivantes&nbsp;:
 
 <synopsis>[ ( <replaceable>x1</replaceable> , <replaceable>y1</replaceable> ) , ( <replaceable>x2</replaceable> , <replaceable>y2</replaceable> ) ]
 ( ( <replaceable>x1</replaceable> , <replaceable>y1</replaceable> ) , ( <replaceable>x2</replaceable> , <replaceable>y2</replaceable> ) )

postgresql/libpq.xml

@@ -133,11 +133,11 @@ PGconn *PQconnectdbParams(const char * const *keywords,
       <para>
        Quand <literal>expand_dbname</literal> est différent de zéro, la valeur
        du mot-clé <parameter>dbname</parameter> peut être reconnue comme une
-       chaîne de connexion. Only the first occurrence of
-       <parameter>dbname</parameter> is expanded this way, any subsequent
-       <parameter>dbname</parameter> value is processed as plain database name. More
-       details on the possible connection string formats appear in
-       <xref linkend="libpq-connstring"/>.
+       chaîne de connexion. Seule la première occurrence de
+       <parameter>dbname</parameter> est étendue de cette façon, toute valeur
+       <parameter>dbname</parameter> suivante est traitée comme un nom de base
+       de données. <xref linkend="libpq-connstring"/> fournit plus de détails
+       sur les formats possibles de la chaîne de connexion.
       </para>
 
       <para>

postgresql/plpgsql.xml

@@ -1083,25 +1083,26 @@ END;
     </para>
 
     <para>
-     For <command>INSERT</command>/<command>UPDATE</command>/<command>DELETE</command> with
-     <literal>RETURNING</literal>, <application>PL/pgSQL</application> reports
-     an error for more than one returned row, even when
-     <literal>STRICT</literal> is not specified.  This is because there
-     is no option such as <literal>ORDER BY</literal> with which to determine
-     which affected row should be returned.
+     Pour les commandes <command>INSERT</command> /
+     <command>UPDATE</command> / <command>DELETE</command> utilisées avec la
+     clause <literal>RETURNING</literal>, <application>PL/pgSQL</application>
+     renvoie une erreur si plus d'une ligne est renvoyée, même si la clause
+     <literal>STRICT</literal> n'est pas indiquée. Ceci est dû au fait qu'il
+     n'existe pas d'option <literal>ORDER BY</literal> qui permettrait de
+     déterminer la ligne affectée à renvoyer.
     </para>
 
     <para>
      Si <literal>print_strict_params</literal> est activé pour cette fonction,
-     then when an error is thrown because the requirements
-     of <literal>STRICT</literal> are not met, the <literal>DETAIL</literal> part of
-     the error message will include information about the parameters
-     passed to the query.
-     You can change the <literal>print_strict_params</literal>
-     setting for all functions by setting
-     <varname>plpgsql.print_strict_params</varname>, bien que seules les
-     compilations suivantes des fonctions seront affectées. Vous pouvez aussi
-     l'activer fonction par fonction en utilisant une option du compilateur, par exemple&nbsp;:
+     alors, quand une erreur est renvoyée parce que les conditions de
+     <literal>STRICT</literal> ne sont pas rencontrées, la partie
+     <literal>DETAIL</literal> du message d'erreur incluera les informations
+     sur les paramètres passés à la requête. Vous pouvez modifier la
+     configuration de <literal>print_strict_params</literal> pour toutes les
+     fonctions en configurant <varname>plpgsql.print_strict_params</varname>,
+     bien que seules les compilations suivantes des fonctions seront affectées.
+     Vous pouvez aussi l'activer fonction par fonction en utilisant une option
+     du compilateur, par exemple&nbsp;:
 <programlisting>
 CREATE FUNCTION get_userid(username text) RETURNS int
 AS $$
@@ -1115,7 +1116,8 @@ BEGIN
 END
 $$ LANGUAGE plpgsql;
 </programlisting>
-     On failure, this function might produce an error message such as
+     En cas d'échec, cette fonction pourrait renvoyer un message d'erreur tel
+     que&nbsp;:
 <programlisting>
 ERROR:  query returned no rows
 DETAIL:  parameters: $1 = 'nosuchuser'
@@ -2774,54 +2776,55 @@ END;
   </sect2>
 
   <sect2 id="plpgsql-get-diagnostics-context">
-   <title>Obtaining Current Execution Information</title>
+   <title>Obtenir des informations sur l'exécution en cours</title>
 
    <para>
-    The <command>GET <optional> CURRENT </optional> DIAGNOSTICS</command>
-    command retrieves information about current execution state (whereas
-   the <command>GET STACKED DIAGNOSTICS</command> command discussed above
-    reports information about the execution state as of a previous error).
-    This command has the form:
+    La commande <command>GET <optional> CURRENT </optional> DIAGNOSTICS</command>
+    récupère des informations sur l'état d'exécution actuel (alors que la
+    commande <command>GET STACKED DIAGNOSTICS</command> discuté ci-dessus
+    renvoie des informations sur l'état d'exécution depuis la dernière erreur).
+    Cette commande a la forme&nbsp;:
    </para>
 
 <synopsis>
-GET <optional> CURRENT </optional> DIAGNOSTICS <replaceable>variable</replaceable> { = | := } <replaceable>item</replaceable> <optional> , ... </optional>;
+GET <optional> CURRENT </optional> DIAGNOSTICS <replaceable>variable</replaceable> { = | := } <replaceable>élément</replaceable> <optional> , ... </optional>;
 </synopsis>
 
 
    <para>
-    Currently only one information item is supported.  Status
-    item <literal>PG_CONTEXT</literal> will return a text string with line(s) of
-    text describing the call stack.  The first line refers to the
-    current function and currently executing <command>GET DIAGNOSTICS</command>
-    command.  The second and any subsequent lines refer to calling functions
-    further up the call stack.  For example:
+    Actuellement seul un élément d'information est accepté. L'élément de
+    statut <literal>PG_CONTEXT</literal> renverra une chaîne de texte avec
+    une ou plusieurs lignes décrivant la pile d'appel. La première ligne fait
+    référence à la fonction actuelle et à la commande <command>GET
+    DIAGNOSTICS</command> en cours d'exécution. La seconde ligne et toutes les
+    lignes suivantes font référence aux fonctions appelantes dans la pile
+    d'appel. Par exemple&nbsp;:
 
 <programlisting>
-CREATE OR REPLACE FUNCTION outer_func() RETURNS integer AS $$BEGIN
-  RETURN inner_func();
+CREATE OR REPLACE FUNCTION fonction_externe() RETURNS integer AS $$BEGIN
+  RETURN fonction_interne();
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION inner_func() RETURNS integer AS $$
+CREATE OR REPLACE FUNCTION fonction_interne() RETURNS integer AS $$
 DECLARE
   stack text;
 BEGIN
   GET DIAGNOSTICS stack = PG_CONTEXT;
-  RAISE NOTICE E'--- Call Stack ---\n%', stack;
+  RAISE NOTICE E'--- Pile d''appel ---\n%', stack;
   RETURN 1;
 END;
 $$ LANGUAGE plpgsql;
 
-SELECT outer_func();
+SELECT fonction_externe();
 
 NOTICE:  --- Call Stack ---
-PL/pgSQL function inner_func() line 5 at GET DIAGNOSTICS
-PL/pgSQL function outer_func() line 3 at RETURN
-CONTEXT:  PL/pgSQL function outer_func() line 3 at RETURN
- outer_func
- ------------
-           1
+PL/pgSQL function fonction_interne() line 5 at GET DIAGNOSTICS
+PL/pgSQL function fonction_externe() line 3 at RETURN
+CONTEXT:  PL/pgSQL function fonction_externe() line 3 at RETURN
+ fonction_externe
+ -----------------
+                1
 (1 row)
 </programlisting>
 

postgresql/queries.xml

@@ -160,16 +160,16 @@ et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
      dérivées) suivant les règles du type de jointure particulier. Les
      jointures internes (inner), externes (outer) et croisées (cross) sont
      disponibles.
-     The general syntax of a joined table is
+     La syntaxe générale d'une table jointe est&nbsp;:
 <synopsis>
-<replaceable>T1</replaceable> <replaceable>join_type</replaceable> <replaceable>T2</replaceable> <optional> <replaceable>join_condition</replaceable> </optional>
+<replaceable>T1</replaceable> <replaceable>type_jointure</replaceable> <replaceable>T2</replaceable> <optional> <replaceable>condition_jointure</replaceable> </optional>
 </synopsis>
-     Joins of all types can be chained together, or nested: either or
-     both <replaceable>T1</replaceable> and
-     <replaceable>T2</replaceable> can be joined tables.  Parentheses
-     can be used around <literal>JOIN</literal> clauses to control the join
-     order.  In the absence of parentheses, <literal>JOIN</literal> clauses
-     nest left-to-right.
+     Des jointures de tous types peuvent être chaînées ensemble ou
+     imbriquées&nbsp;: une des deux tables ou les deux tables peuvent être
+     des tablees jointes. Des parenthèses peuvent être utilisées autour des
+     clauses <literal>JOIN</literal> pour contrôler l'ordre de jointure. Dans
+     l'absence des parenthèses, les clauses <literal>JOIN</literal> s'imbriquent
+     de gauche à droite.
     </para>
 
     <variablelist>
@@ -215,24 +215,24 @@ et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
         <replaceable>T2</replaceable></literal> est équivalent à
         <literal>FROM <replaceable>T1</replaceable> INNER JOIN
         <replaceable>T2</replaceable> ON TRUE</literal> (voir ci-dessous).
-        It is also equivalent to
+        C'est aussi équivalent à&nbsp;:
         <literal>FROM <replaceable>T1</replaceable>,
         <replaceable>T2</replaceable></literal>.
         <note>
         <para>
-         This latter equivalence does not hold exactly when more than two
-         tables appear, because <literal>JOIN</literal> binds more tightly than
-         comma.  For example
+         Cette dernière équivalence ne convient pas exactement quand plusieurs
+         tables apparaissent car <literal>JOIN</literal> lie de façon plus
+         profonde que la virgule. Par exemple
          <literal>FROM <replaceable>T1</replaceable> CROSS JOIN
          <replaceable>T2</replaceable> INNER JOIN <replaceable>T3</replaceable>
          ON <replaceable>condition</replaceable></literal>
-         is not the same as
+         n'est pas identique à
          <literal>FROM <replaceable>T1</replaceable>,
          <replaceable>T2</replaceable> INNER JOIN <replaceable>T3</replaceable>
          ON <replaceable>condition</replaceable></literal>
-         because the <replaceable>condition</replaceable> can
-         reference <replaceable>T1</replaceable> in the first case but not
-         the second.
+         car <replaceable>condition</replaceable> peut faire référence à
+         <replaceable>T1</replaceable> dans le premier cas mais pas dans le
+         second.
         </para>
         </note>
        </para>
@@ -379,35 +379,38 @@ et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
        </variablelist>
        </para>
        <para>
-        The <literal>ON</literal> clause is the most general kind of join
-        condition: it takes a Boolean value expression of the same
-        kind as is used in a <literal>WHERE</literal> clause.  A pair of rows
-        from <replaceable>T1</replaceable> and <replaceable>T2</replaceable> match if the
-        <literal>ON</literal> expression evaluates to true.
+        La clause <literal>ON</literal> est le type de condition de jointure le
+        plus utilisé&nbsp;: elle prend une valeur booléenne du même type que
+        celle utilisée dans une clause <literal>WHERE</literal>. Une paire de
+        lignes provenant de <replaceable>T1</replaceable> et de
+        <replaceable>T2</replaceable> correspondent si l'expression de la clause
+        <literal>ON</literal> vaut true.
        </para>
 
        <para>
-        The <literal>USING</literal> clause is a shorthand that allows you to take
-        advantage of the specific situation where both sides of the join use
-        the same name for the joining column(s).  It takes a
-        comma-separated list of the shared column names
-        and forms a join condition that includes an equality comparison
-        for each one.  For example, joining <replaceable>T1</replaceable>
-        and <replaceable>T2</replaceable> with <literal>USING (a, b)</literal> produces
-        the join condition <literal>ON <replaceable>T1</replaceable>.a
+        La clause <literal>USING</literal> est un raccourci qui vous permet de
+        prendre avantage d'une situation spécifique où les deux côtés de la
+        jointure utilisent le même nom pour la colonne jointe. Elle prend
+        une liste de noms de colonnes partagées, en séparant les noms par des
+        virgules et forme une condition de jointure qui inclut une comparaison
+        d'égalité entre chaque. Par exemple, joindre <replaceable>T1</replaceable>
+        et <replaceable>T2</replaceable> avec <literal>USING (a, b)</literal>
+        produit la même condition de jointure que la condition
+        <literal>ON <replaceable>T1</replaceable>.a
         = <replaceable>T2</replaceable>.a AND <replaceable>T1</replaceable>.b
         = <replaceable>T2</replaceable>.b</literal>.
        </para>
 
        <para>
-        Furthermore, the output of <literal>JOIN USING</literal> suppresses
-        redundant columns: there is no need to print both of the matched
-        columns, since they must have equal values.  While <literal>JOIN
-        ON</literal> produces all columns from <replaceable>T1</replaceable> followed by all
-        columns from <replaceable>T2</replaceable>, <literal>JOIN USING</literal> produces one
-        output column for each of the listed column pairs (in the listed
-        order), followed by any remaining columns from <replaceable>T1</replaceable>,
-        followed by any remaining columns from <replaceable>T2</replaceable>.
+        De plus, la sortie de <literal>JOIN USING</literal> supprime les
+        colonnes redondantes&nbsp;: il n'est pas nécessaire d'imprimer
+        les colonnes de correspondance, puisqu'elles doivent avoir des
+        valeurs identiques. Alors que <literal>JOIN ON</literal> produit
+        toutes les colonnes de <replaceable>T2</replaceable>, <literal>JOIN
+        USING</literal> produces produit une seule colonne pour chaque paire
+        de colonnes listées (dans l'ordre listé), suivi par chaque colonne
+        restante provenant de <replaceable>T1</replaceable>, suivi par chaque
+        colonne restante provenant de <replaceable>T2</replaceable>.
        </para>
 
        <para>
@@ -418,23 +421,24 @@ et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
         <indexterm>
          <primary>natural join</primary>
         </indexterm>
-        Finally, <literal>NATURAL</literal> is a shorthand form of
-        <literal>USING</literal>: it forms a <literal>USING</literal> list
-        consisting of all column names that appear in both
-        input tables.  As with <literal>USING</literal>, these columns appear
-        only once in the output table.  If there are no common
-        column names, <literal>NATURAL</literal> behaves like
+        Enfin, <literal>NATURAL</literal> est un raccourci de
+        <literal>USING</literal>&nbsp;: il forme une liste
+        <literal>USING</literal> consistant de tous les noms de colonnes
+        apparaissant dans les deux tables en entrée. Comme avec
+        <literal>USING</literal>, ces colonnes apparaissent seulement dans la
+        table en sortie. S'il n'existe aucun nom commun de colonne,
+        <literal>NATURAL</literal> se comporte comme
         <literal>CROSS JOIN</literal>.
        </para>
 
        <note>
         <para>
-         <literal>USING</literal> is reasonably safe from column changes
-         in the joined relations since only the listed columns
-         are combined.  <literal>NATURAL</literal> is considerably more risky since
-         any schema changes to either relation that cause a new matching
-         column name to be present will cause the join to combine that new
-         column as well.
+         <literal>USING</literal> est raisonnablement protégé contre les
+         changements de colonnes dans les relations jointes car seuls les noms
+         de colonnes listés sont combinés. <literal>NATURAL</literal> est
+         considéré comme plus risqué car toute modification de schéma causant
+         l'apparition d'un nouveau nom de colonne correspondant fera en sorte
+         de joindre la nouelle colonne.
         </para>
        </note>
       </listitem>
@@ -550,8 +554,8 @@ et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
      <literal>ON</literal> est traitée <emphasis>avant</emphasis> la jointure
      alors qu'une restriction placée dans la clause <literal>WHERE</literal>
      est traitée <emphasis>après</emphasis> la jointure.
-     That does not matter with inner joins, but it matters a lot with outer
-     joins.
+     Ceci n'a pas d'importance avec les jointures internes, mais en a une grande
+     avec les jointures externes.
     </para>
    </sect3>
 
@@ -1096,16 +1100,16 @@ SELECT ... FROM fdt WHERE EXISTS (SELECT c1 FROM t2 WHERE c2 &gt; fdt.c1)</progr
     produit.
    </para>
 
-   <indexterm><primary>functional dependency</primary></indexterm>
+   <indexterm><primary>dépendance fonctionnel</primary></indexterm>
 
    <para>
-    If the products table is set up so that, say,
-    <literal>product_id</literal> is the primary key, then it would be
-    enough to group by <literal>product_id</literal> in the above example,
-    since name and price would be <firstterm>functionally
-    dependent</firstterm> on the product ID, and so there would be no
-    ambiguity about which name and price value to return for each product
-    ID group.
+    Si la table produits est configuré de façon à ce que
+    <literal>id_produit</literal> soit la clé primaire, alors il serait suffisant
+    de grouper par la colonne <literal>id_produit</literal> dans l'exemple
+    ci-dessus, car le nom et le prix seraient <firstterm>dépendants
+    fonctionnellement</firstterm> de l'identifiant du produit, et donc il n'y
+    aurait pas d'ambiguité sur le nom et le prix à renvoyer pour chaque groupe
+    d'identifiant de produit.
    </para>
 
    <para>