Changeset 18

Timestamp:

10/03/05 22:57:36 (4 years ago)

Author:

gleu

Message:

Relecture de Stéphane Schildknecht.

Location:

traduc/branches/bv747/sgml

Files:

• problems.sgml (modified) (22 diffs)
• queries.sgml (modified) (64 diffs)

traduc/branches/bv747/sgml/problems.sgml

@@ -8 +8 @@
  <para>
   Lorsque vous trouvez un bogue dans <productname>PostgreSQL</productname>,
-  nous voulons en entendre parler. Vos rapports de bogues jouent un rôle
-  important pour rendre <productname>PostgreSQL</productname> plus fiable car
-  même avec la plus grande attention, nous ne pouvons pas garantir que chaque
-  partie de <productname>PostgreSQL</productname> fonctionnera sur toutes les
-  plates-formes et dans toutes les circonstances.
+  il faut que nous le sachions. Vos rapports de bogues sont essentiels pour
+  rendre <productname>PostgreSQL</productname> plus fiable. En effet
+  même la plus grande attention ne pas garantir que chaque
+  partie de <productname>PostgreSQL</productname> fonctionnera sur toute
+  plates-forme en toute circonstance.
  </para>
 
  <para>
   Les suggestions suivantes ont pour but de vous former à la saisie d'un
-  rapport de bogue qui pourra ensuite être gérée de façon efficace. Il n'est
-  pas requis de les suivre mais ce serait à l'avantage de tous.
+  rapport de bogue qui pourra ensuite être géré de façon efficace. Il n'est
+  pas obligatoire de les suivre mais tout le monde en tirera profit.
  </para>
 
  <para>
-  Nous ne pouvons pas promettre de corriger tous les bogues immédiatement. Si
+  Nous ne promettons pas de corriger tous les bogues immédiatement. Si
   le bogue est évident, critique ou affecte un grand nombre d'utilisateurs, il
   y a de grandes chances pour que quelqu'un s'en charge. Il peut aussi arriver
-  que nous vous demandons d'utiliser une version plus récente pour voir si le
-  bogue est toujours présent. Ou nous pourrions décider que le bogue ne peut
-  être corrigé avant qu'une réécriture massive, que nous avions planifiée, ne
-  soit faite. Ou peut-être est-il trop difficile et que des choses plus
-  importantes nous attendent. Si vous avez besoin d'aide immédiatement,
-  considérez l'obtention d'un contrat de support commercial.
+  que nous vous demandions d'utiliser une version plus récente pour voir si le
+  bogue est toujours présent. Nous pourrions aussi décider que le bogue ne peut
+  être corrigé avant qu'une réécriture massive, que nous planifierions, ne
+  soit réalisée. Peut-être encore cette correction est-elle trop difficile et
+  des choses plus importantes sont prévues. Si vous avez un besoin d'aide immédiat,
+  il vous faudra considérer la souscription d'un contrat de support commercial.
  </para>
 
@@ -38 +38 @@
   <para>
    Avant de rapporter un bogue, merci de lire et re-lire la documentation pour
-   vérifier que vous pouvez réellement faire ce que vous essayez de faire. Si
-   ce n'est pas clair, rapportez-le aussi&nbsp;; c'est un bogue dans la
-   documentation. S'il s'avère que le programme fait différemment de ce
-   qu'indique la documentation, c'est un bogue. Ceci peut inclure les
-   circonstances suivantes, sans s'y limiter&nbsp;:
+   vérifier que ce que vous essayez de faire est réellement prévu. Si
+   la documentation n'est pas claire sur ce point, faites également remonter cette
+   information&nbsp;; c'est un bogue dans la documentation. S'il s'avère que le
+   programme se déroule différemment de ce qu'indique la documentation, c'est un bogue.
+   Ceci peut inclure les circonstances suivantes, sans s'y limiter&nbsp;:
 
    <itemizedlist>
     <listitem>
      <para>
-      Un programme se terminant avec un signal fatal ou un message d'erreur du
-      système d'exploitation qui indiquerait un problème avec le programme.
+      Un programme se termine avec un signal fatal ou un message d'erreur du
+      système d'exploitation indiquant un problème dans le programme.
       (Un contre-exemple pourrait être le message <quote>disk full</quote>,
       disque plein, car vous devez le régler vous-même.)
@@ -56 +56 @@
     <listitem>
      <para>
-      Un programme produit une mauvaise sortie pour une entrée donnée.
+      Un programme produit une sortie erronnée pour une entrée donnée.
      </para>
     </listitem>
@@ -70 +70 @@
      <para>
       Un programme accepte une entrée invalide sans information ou message
-      d'erreur. Mais gardez en tête que votre idée d'entrée invalide pourrait
-      être notre idée d'une extension ou d'une compatibilité avec les
+      d'erreur. Il est toutefois possible que ce que vous estimez être une entrée
+      invalide soit en fait notre idée d'une extension ou d'une compatibilité avec les
       pratiques traditionnelles.
      </para>
@@ -85 +85 @@
    </itemizedlist>
 
-   Ici, <quote>programme</quote> fait référence à un exécutable, pas au moteur
-   du serveur.
+   Ici, <quote>programme</quote> fait référence à un exécutable, pas uniquement
+   au moteur du serveur.
   </para>
 
@@ -92 +92 @@
    Une lenteur ou une accaparation des ressources n'est pas nécessairement un
    bogue. Lisez la documentation ou demandez sur une des listes de discussion
-   pour de l'aide concernant l'optimisation de vos applications. Ne pas se
+   de l'aide pour optimiser vos applications. Ne pas se
    conformer au standard <acronym>SQL</acronym> n'est pas nécessairement un
    bogue sauf si une telle conformité est indiquée explicitement.
@@ -98 +98 @@
 
   <para>
-   Avant de continuer, vérifiez sur la liste des choses à faire ainsi que dans
-   la FAQ pour voir si votre bogue n'est pas déjà connu. Si vous n'arrivez pas à
-   décoder les informations sur la liste des choses à faire, écrivez un rapport.
+   Avant de continuer, vérifiez sur la liste des tâches, ainsi que dans
+   la FAQ, pour voir si votre bogue n'est pas déjà connu. Si vous n'arrivez pas à
+   décoder les informations sur la liste des tâches, écrivez un rapport.
    Le minimum que nous puissions faire est de rendre cette liste plus claire.
   </para>
@@ -107 +107 @@
  <sect2>
   <title>Que rapporter&nbsp;?</title>
-
-  <para>
-   Le point le plus important à se rappeler avec les rapports de bogues est de
-   donner tous les faits et seulement les faits. Ne spéculez pas sur ce que vous
-   pensez qui ne va pas, sur ce qu'<quote>il semble faire</quote> ou sur quelle
-   partie le programme a une erreur. Si vous n'êtes pas familier avec
+  <para>
+   Le point le plus important lors d'un rapport de bogues est de se souvenir de
+   rapporter tous les faits et seulement les faits. Ne spéculez pas sur ce que vous
+   pensez être le dysfonctionnement, sur ce qu'<quote>il semblait faire</quote> ou
+   sur la partie du programme qui contient une erreur. Si vous n'êtes pas familier de
    l'implémentation, vous vous tromperez probablement et vous ne nous aiderez
-   pas. Et même si vous avez raison, des explications complètes sont un bon
-   supplément mais elles ne doivent pas se substituer aux faits. Si nous pensons
+   pas. Même si vous aviez raison, des explications complètes sont un bon
+   complément mais elles ne doivent pas se substituer aux faits. Si nous décidons de
    corriger le bogue, nous devons toujours le reproduire nous-même. Rapporter
-   les faits stricts est relativement simple (vous pouvez probablement
+   les faits stricts est relativement simple (vous pouvez probablement les
    copier/coller à partir de l'écran) mais, trop souvent, des détails importants
    sont oubliés parce que quelqu'un a pensé qu'ils n'avaient pas d'importance ou
@@ -131 +130 @@
      <para>
       La séquence exacte des étapes nécessaires pour reproduire le problème
-      <emphasis>à partir du lancement du programme</emphasis>. Ceci devrait se
-      suffire&nbsp;; il n'est pas suffisant d'envoyer une simple instruction
+      <emphasis>à partir du lancement du programme</emphasis>. Ceci doit se
+      suffire&nbsp;; si la sortie doit dépendre des données contenues dans
+      les tables, il n'est pas suffisant d'envoyer une simple instruction
       <command>SELECT</command> sans les commandes
       <command>CREATE TABLE</command> et <command>INSERT</command>
-      qui ont précédé, si la sortie devrait dépendre des données contenues dans
-      les tables. Nous n'avons pas le temps de comprendre le schéma de votre
-      base de données. Si nous sommes supposés créer nos propres données, nous
-      allons probablement ne pas voir le problème.
-     </para>
-
-     <para>
-      Le meilleur format pour un test suite à un problème relatif à SQL est un
+      qui ont précédé. Nous n'avons pas le temps de comprendre le schéma de votre
+      base de données et si nous sommes supposés créer nos propres données, nous
+      allons probablement passer à côté du problème.
+     </para>
+
+     <para>
+      Le meilleur format de jeu de test pour les problèmes relatif au SQL est un
       fichier qui peut être lancé via l'interface
       <application>psql</application> et qui montrera le problème.
       (Assurez-vous de ne rien avoir dans votre fichier de lancement
-      <filename>~/.psqlrc</filename>.) Un début facile pour ce fichier est
+      <filename>~/.psqlrc</filename>.) Un bon début pour ce fichier est
       d'utiliser <application>pg_dump</application> pour récupérer les
       déclarations des tables ainsi que les données nécessaires pour mettre en
@@ -157 +156 @@
      <para>
       Si votre application utilise une autre interface client, telle que
-      <application>PHP</>, alors essayez d'isoler le problème aux requêtes
-      erronées. Nous n'allons certainement pas mettre en place un serveur web
-      pour reproduire votre problème. Dans tous les cas, rappelez-vous
-      d'apporter les fichiers d'entrée exacts&nbsp;; n'essayez pas de deviner
+      <application>PHP</>, essayez alors d'isoler les requêtes
+      posant problème. Nous n'allons certainement pas mettre en place un serveur web
+      pour reproduire votre problème. Dans tous les cas, n'oubliez pas de fournir
+      les fichiers d'entrée exacts&nbsp;; n'essayez pas de deviner
       que le problème se pose pour les <quote>gros fichiers</quote> ou pour les
       <quote>bases de données de moyenne taille</quote>, etc. car cette
-      information est trop inexacte, subjective pour être utile.
+      information est trop inexacte, voire subjective, pour être utile.
      </para>
     </listitem>
@@ -171 +170 @@
       La sortie que vous obtenez. Merci de ne pas dire que cela <quote>ne
       fonctionne pas</quote> ou s'est <quote>arrêté brutalement</quote>. S'il
-      existe un message d'erreur, montrez-le même si vous ne le comprenez pas.
+      existe un message d'erreur, montrez-le, même si vous ne le comprenez pas.
       Si le programme se termine avec une erreur du système d'exploitation,
       dites-le. Même si le résultat de votre test est un arrêt brutal du
       programme ou un autre soucis évident, il pourrait ne pas survenir sur
       notre plateforme. Le plus simple est de copier directement la sortie du
-      terminal, si possible.
+      terminal quand cela est possible.
      </para>
      <note>
       <para>
        Si vous rapportez un message d'erreur, merci d'obtenir la forme la plus
-       verbeuse de ce message. Avec <application>psql</>, exécutez <literal>\set
-       VERBOSITY verbose</> avant tout. Si vous récupérez le message des traces
-       du serveur, initialisez la variable d'exécution
-       <varname>log_error_verbosity</> avec <literal>verbose</> pour que tous les
+       verbeuse de ce message. Avec <application>psql</>, exécutez avant tout <literal>\set
+       VERBOSITY verbose</>. Si vous récupérez le message des traces
+       du serveur, positionnez la variable d'exécution
+       <varname>log_error_verbosity</> à <literal>verbose</> pour que tous les
        détails soient tracés.
       </para>
@@ -193 +192 @@
        pourrait ne pas contenir toutes les informations disponibles. Jetez aussi un
        &oelig;il aux traces du serveur de la base de données. Si vous ne
-       conservez pas les traces de votre serveur, c'est le bon moment pour
+       conservez pas les traces de votre serveur, c'est peut-être le bon moment pour
        commencer à le faire.
       </para>
@@ -207 +206 @@
       est correct car cela correspond exactement à ce que nous attendions. Nous
       ne devrions pas avoir à passer du temps pour décoder la sémantique exacte
-      de vos commandes. Tout spécialement, ne vous contentez pas de dire que
+      de vos commandes. En particulier, ne vous contentez pas de dire que
       <quote>Ce n'est pas ce que SQL spécifie/Oracle fait.</quote> Rechercher le
       comportement correct à partir de <acronym>SQL</acronym> n'est pas
@@ -220 +219 @@
       Toutes les options en ligne de commande ainsi que les autres options de
       lancement incluant les variables d'environnement ou les fichiers de
-      configuration que vous avez modifié. Encore une fois, soyez exact. Si
-      vous utilisez une distribution pré-packagée qui lance le serveur au
+      configuration que vous avez modifié. Encore une fois, soyez précis. Si
+      vous utilisez une distribution pré-empaquetée qui lance le serveur au
       démarrage, vous devriez essayer de retrouver ce que cette distribution
       fait.
@@ -229 +228 @@
     <listitem>
      <para>
-      Tout ce que vous avez fait de différent à partir des instructions d'installation.
+      Tout ce que vous avez fait différement des instructions d'installation.
      </para>
     </listitem>
@@ -240 +239 @@
       aussi d'une option <option>--version</option>&nbsp;;
       <literal>postmaster --version</literal> et <literal>psql --version</literal>
-      devraient au moins fonctionner.
+      au moins devraient fonctionner.
       Si la fonction ou les options n'existent pas, alors votre version est bien
-      trop ancienne et vous devez mettre à jour. Si vous avez lancé une version
-      préparée sous forme de paquets, tel que les RPM, dites-le en incluant la
-      sous-version que le paquet pourrait avoir. Si vous êtes sur une version
-      CVS, mentionnez-le en indiquant la date et l'heure.
+      trop ancienne et vous devez la mettre à jour. Si vous avez lancé une version
+      préparée sous forme de paquets, tels que des RPM, dites-le en incluant la
+      sous-version que le paquet aurait éventuellement. Si vous travaillez avec
+      une version CVS, mentionnez-le en indiquant la date et l'heure de la capture CVS.
      </para>
 
      <para>
       Si votre version est antérieure à &version;, nous allons certainement
-      vous demander de mettre à jour. Il existe des tonnes de corrections à
+      vous demander de la mettre à jour. Il existe des tonnes de corrections à
       chaque mise à jour, ce qui explique pourquoi nous faisons de nouvelles
       versions.
@@ -265 +264 @@
       tout le monde sait ce que <quote>Debian</quote> contient ou que tout le
       monde utilise des Pentiums. Si vous avez des problèmes à l'installation,
-      des informations sur le compilateurs, make, etc. sont aussi nécessaires.
+      les informations concernant le compilateurs, make, etc. seront aussi nécessaires.
      </para>
     </listitem>
    </itemizedlist>
 
-   N'ayez pas peur si votre rapport de bogue devient assez long. C'est un fait.
-   Il est mieux de tout rapporter la première fois plutôt que nous ayons à vous
-   demander tous les faits. D'un autre côté, si vos fichiers d'entrée sont trop
+   Ne vous inquiétez pas si votre rapport de bogue devient assez long. C'est un fait.
+   Il est préférable de tout rapporter la première fois plutôt que de nous obliger à vous
+   demander tous les faits. D'un autre côté, si vos fichiers en entrée sont trop
    gros, il est préférable de demander si quelqu'un souhaite s'y plonger.
   </para>
 
   <para>
-   Ne passez pas tout votre temps à vous demander quelles modifications apportées
-   pour que le problème s'en aille. Ceci ne nous aidera probablement pas à le
-   résoudre. S'il arrive que le bogue ne peut pas être corrigé immédiatement,
-   vous aurez toujours l'opportunité de chercher ceci et de partager vos trouvailles.
-   De même, encore une fois, ne perdez pas votre temps à deviner pourquoi le
-   bogue existe. Nous le trouverons assez rapidement.
+   Ne passez pas tout votre temps à vous demander quelles modifications apporter
+   aux données en entrée pour faire disparaître le problème. Ceci ne nous aidera
+   probablement pas à le résoudre. S'il se trouve que le bogue ne puisse pas être
+   corrigé instantanément, vous aurez toujours le temps de chercher et de partager vos trouvailles.
+   Encore une fois, ne perdez pas votre temps à deviner pourquoi le
+   bogue existe. Nous trouverons cela assez rapidement.
   </para>
 
   <para>
    Lors de la rédaction d'un rapport de bogue, merci de choisir une terminologie
-   qui ne laisse pas place aux confusions. Le paquet logiciel en totalité est
-   appelé <quote>PostgreSQL</quote>, quelque fois <quote>Postgres</quote> en court.
+   qui ne laisse pas de place à l'ambiguité. Le paquet logiciel dans sa totalité est
+   appelé <quote>PostgreSQL</quote>, parfois <quote>Postgres</quote> en abrégé.
    Si vous parlez spécifiquement du serveur, mentionnez-le mais ne dites pas
    seulement <quote>PostgreSQL a planté</quote>. Un arrêt brutal d'un seul processus
    serveur est assez différent de l'arrêt brutal du
    <quote>postmaster</> père&nbsp;; merci de ne pas dire que <quote>le postmaster
-   a planté</> lorsque vous voulez dire qu'un seul processus s'est arrêté, et non
-   pas vice versa. De plus, les programmes clients tels que l'interface interactive
+   a planté</> lorsque vous voulez dire qu'un seul processus s'est arrêté, et
+   vice versa. De plus, les programmes clients tels que l'interface interactive
    <quote><application>psql</application></quote> sont complètement séparés du
    moteur. Essayez d'être précis sur la provenance du problème&nbsp;: client ou
@@ -306 +305 @@
   <para>
    En général, envoyez vos rapports de bogue à la liste de discussion des
-   rapports de bogue (<email>pgsql-bogues@postgresql.org</email>).
-   Nous vous demandons d'utiliser un sujet descriptif pour votre courrier
-   électronique, par exemple une partie du message d'erreur.
+   rapports de bogue (<email>pgsql-bugs@postgresql.org</email>).
+   Il est recommandé d'utiliser un sujet descriptif pour votre courriel, pourquoi
+   pas une partie du message d'erreur.
   </para>
 
@@ -315 +314 @@
    site web du projet
    <ulink url="http://www.postgresql.org/">http://www.postgresql.org/</ulink>.
-   Saisir un rapport de bogue de cette façon fait que celui-ci est envoyé à la
-   liste de discussion <email>pgsql-bogues@postgresql.org</email>.
+   Saisir un rapport de bogue de cette façon implique son envoi à la
+   liste de discussion <email>pgsql-bugs@postgresql.org</email>.
   </para>
 
@@ -323 +322 @@
    préfériez qu'il ne soit pas immédiatement visible dans les archives
    publiques, ne l'envoyez pas sur <literal>pgsql-bugs</literal>. Les problèmes
-   de sécurité peuvent être rapportés de façon privé sur
+   de sécurité peuvent être rapportés en privé sur
    <email>security@postgresql.org</email>.
   </para>
 
   <para>
-   N'envoyez pas de rapports de bogue aux listes de discussion des utilisateurs,
+   N'envoyez pas de rapports de bogue aux listes de discussion d'utilisateurs,
    comme <email>pgsql-sql@postgresql.org</email> ou
    <email>pgsql-general@postgresql.org</email>.
    Ces listes de discussion servent à répondre aux questions des utilisateurs et
-   les abonnés ne souhaitent pas recevoir de rapports de bogues. Plus important,
-   ils ont peu de chance de les corriger.
+   les abonnés ne souhaitent pas, en général, recevoir de rapports de bogues. Plus important,
+   il y a peu de chance qu'ils les corrigent.
   </para>
 
@@ -341 +340 @@
    Cette liste sert aux discussions concernant le développement de
    <productname>PostgreSQL</productname> et il serait bon de conserver les
-   rapports de bogue séparément. Nous pourrions choisir de discuter de votre
+   rapports de bogue séparément. Nous pouvons toujours décider de discuter de votre
    rapport de bogue sur <literal>pgsql-hackers</literal> si le problème
-   nécessite que plus de personnes s'en occupent.
+   nécessite plus de personnes pour s'en occuper.
   </para>
 
@@ -362 +361 @@
   <note>
    <para>
-    Dû, malheureusement, au grand nombre de pourriels (spam), toutes les
+    Du fait du grand nombre de pourriels (spam) qui circulent, toutes les
     adresses de courrier électronique ci-dessus appartiennent à des listes
     de discussion fermées. C'est-à-dire que vous devez être abonné pour être
-    autorisé à y envoyer un courrier. Néanmoins, vous n'avez pas besoin de vous
+    autorisé à y envoyer un courriel. Néanmoins, vous n'avez pas besoin de vous
     abonner pour utiliser le formulaire web de rapports de bogue. Si vous
-    souhaitez envoyer des courriers mais ne pas recevoir le trafic de la liste,
+    souhaitez envoyer des courriels mais ne pas recevoir le trafic de la liste,
     vous pouvez vous abonner et configurer l'option <literal>nomail</>.
-    Pour plus d'information, envoyez un courrier à
+    Pour plus d'information, envoyez un courriel à
     <email>majordomo@postgresql.org</email>
     avec le seul mot <literal>help</> dans le corps du message.

traduc/branches/bv747/sgml/queries.sgml

@@ -13 +13 @@
 
  <para>
-  Les précédents chapitres ont expliqué comme créer des tables, comment 
+  Les précédents chapitres expliquaient comme créer des tables, comment
   les remplir avec des données et comment manipuler ces données.
-  Maintenant, nous discutons enfin de la façon de récupérer ces données
+  Il est temps d'aborder maintenant la façon de récupérer ces données
   depuis la base de données.
  </para>
@@ -24 +24 @@
 
   <para>
-   Le processus et la commande de récupération des données sont appelés une
+   Le processus de récupération des données et la commande elle-même sont appelés
    <firstterm>requête</firstterm>. En SQL, la commande
-   <command>SELECT</command> est utilisé pour spécifier des requêtes. La
+   <command>SELECT</command> est utilisée pour spécifier des requêtes. La
    syntaxe générale de la commande <command>SELECT</command> est <synopsis>
-SELECT <replaceable>liste_select</replaceable> FROM
-<replaceable>expression_table</replaceable>
-<optional><replaceable>_specification_tri</replaceable></optional>
-</synopsis>
-   Les sections suivantes décrivent le détail de la liste de sélection,
-   l'expression des tables et la spécification du tri.
+SELECT <replaceable>liste_select</replaceable> FROM <replaceable>expression_table</replaceable> <optional><replaceable>specification_tri</replaceable></optional>
+</synopsis>
+   Les sections suivantes décrivent en détails la liste de sélection,
+   l'expression de tables et la spécification du tri.
   </para>
 
@@ -44 +42 @@
   commande récupérera toutes les lignes et toutes les colonnes de
   <literal>table1</literal>. (La méthode de récupération dépend de l'application
-  cliente. Par exemple, le programme <application>psql</application> affichera
-une table, façon art ASCII, alors que les bibliothèques du client offriront 
-des fonctions d'extraction de valeurs individuelles à partir du résultat de
-la requête.) <literal>*</literal> comme liste de sélection signifie que toutes
-les colonnes de l'expression de table seront récupérées. Une liste de sélection
-peut aussi être un sous-ensemble des colonnes disponibles ou effectuer 
-un calcul en utilisant les colonnes. Par exemple, si <literal>table1</literal>
-dispose des colonnes nommées <literal>a</>, <literal>b</> et <literal>c</> (et
-peut-être d'autres), vous pouvez lancer la requête suivante&nbsp;:
+  client. Par exemple, le programme <application>psql</application> affichera
+  une table, façon art ASCII, alors que les bibliothèques client offriront
+  des fonctions d'extraction de valeurs individuelles à partir du résultat de
+  la requête.) <literal>*</literal> utilisé comme liste de sélection désigne toutes
+  les colonnes que l'expression de la table fournie. Une liste de sélection
+  peut aussi sélectionner un sous-ensemble des colonnes disponibles ou effectuer
+  un calcul en utilisant les colonnes. Par exemple, si <literal>table1</literal>
+  dispose des colonnes nommées <literal>a</>, <literal>b</> et <literal>c</> (et
+  peut-être d'autres), la requête suivante peut être effectuée&nbsp;:
 <programlisting>
 SELECT a, b + c FROM table1;
@@ -62 +60 @@
  <para>
   <literal>FROM table1</literal> est un type très simple d'expression de
-tables&nbsp;: il lit une seule table. En général, les expressions de tables
-sont des constructions complexes de tables de base, de jointures et de
-sous-requêtes. Mais vous pouvez aussi entièrement omettre l'expression de table
-et utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
+  tables&nbsp;: il lit une seule table. En général, les expressions de tables
+  sont des constructions complexes de tables de base, de jointures et de
+  sous-requêtes. Il est également possible d'omettre l'expression de table
+  et d'utiliser la commande <command>SELECT</command> comme une calculatrice&nbsp;:
 <programlisting>
 SELECT 3 * 4;
 </programlisting>
   Ceci est plus utile si les expressions de la liste de sélection renvoient des
-  résultats variants. Par exemple, vous pouvez appeler une fonction de cette
+  résultats variables. Il est, par exemple, possible d'appeler une fonction de cette
   façon&nbsp;:
 <programlisting>
@@ -90 +88 @@
    L'expression de table contient une clause <literal>FROM</> qui peut être
    suivie des clauses <literal>WHERE</>, <literal>GROUP BY</> et
-   <literal>HAVING</>. Les expressions de table triviales réfèrent simplement à
-   une table sur le disque, une table de base, mais des expressions plus
+   <literal>HAVING</>. Les expressions de table triviales font simplement référence à
+   une table sur le disque, appelée table de base, mais des expressions plus
    complexes peuvent être utilisées pour modifier ou combiner des tables de base
-   de différentes façon.
+   de différentes façons.
   </para>
 
   <para>
    Les clauses optionnelles <literal>WHERE</>, <literal>GROUP BY</> et
-   <literal>HAVING</> dans l'expression de table spécifient un tube de
+   <literal>HAVING</> dans l'expression de table spécifient un enchaînement de
    transformations successives réalisées sur la table dérivée de la
    clause <literal>FROM</>. Toutes ces transformations produisent une table
    virtuelle fournissant les lignes à passer à la liste de sélection qui
-   choisira les lignes à afficher de la requête.
+   choisira les lignes à afficher en sortie de la requête.
   </para>
         
@@ -110 +108 @@
    <para>
     La clause <literal>FROM</> dérive une table à partir d'une ou plusieurs
-    tables données dans une liste de référence dont les tables sont séparées par
-    des virgules.
+    tables, spécifiées dans une liste de référence dont le séparateur est une virgule.
 <synopsis>
 FROM <replaceable>reference_table</replaceable> <optional>,
@@ -117 +114 @@
 </synopsis>
 
-    Une référence de table pourrait être un nom de table (avec en option
-    le nom du schéma) ou une table dérivée comme une sous-requête, une table
-    jointe ou une combinaison complexe de celles-ci. Si plus d'une référence de
-    tables est listé dans la clause <literal>FROM</>, elle sont jointes pour
-    former une table virtuelle intermédiaire qui pourrait être le sujet des
-    transformations des clauses <literal>WHERE</>, <literal>GROUP BY</>,
-    et <literal>HAVING</> et est finalement le résultat des expressions de
-    table.
+    Une référence de table peut être un nom de table (optionnellement préfixé par
+    le nom du schéma) ou une table dérivée. Une table dérivée peut-être une sous-requête,
+    une jointure de tables ou toute combinaison complexe de celles-ci. Si plusieurs
+    références de tables sont listées dans la clause <literal>FROM</>, elles sont
+    jointes (voir plus bas) pour former la table virtuelle intermédiaire, sujet possible de
+    transformations par les clauses <literal>WHERE</>, <literal>GROUP BY</> et
+    <literal>HAVING</>. et qui est finalement le résultat de l'expression des tables globale.
    </para>
 
@@ -132 +128 @@
 
    <para>
-    Lorsqu'une référence de table nomme une table qui est la table parent d'une
-    table suivant la hiérarchie de l'héritage, la référence de table produit les
+    Lorsqu'une référence de table fait référence à une table supertable d'une
+    hiérarchie d'héritage, la référence de table produit les
     lignes non seulement de la table mais aussi des successeurs de cette table
-    sauf si le mot clé <literal>ONLY</> précède le nom de la table. Néanmoins,
+    sauf si le mot clé <literal>ONLY</> précède le nom de la table. Toutefois,
     la référence produit seulement les colonnes qui apparaissent dans la table
-    nommée... toute colonne ajoutée dans une sous-table est ignorée.
+    nommée --- toute colonne ajoutée dans une sous-table est ignorée.
    </para>
 
@@ -175 +171 @@
 
       <indexterm>
-       <primary>crossed joind</primary>
+       <primary>cross join</primary>
       </indexterm>
 
@@ -185 +181 @@
        <para>
         Pour chaque combinaison de lignes provenant de
-        <replaceable>T1</replaceable> et <replaceable>T2</replaceable>, la
-        table dérivée contiendra une ligne consistant de toutes les colonnes de
+        <replaceable>T1</replaceable> et de <replaceable>T2</replaceable>, la
+        table dérivée contiendra une ligne constituée de toutes les colonnes de
         <replaceable>T1</replaceable> suivies de toutes les colonnes de
         <replaceable>T2</replaceable>. Si les tables ont respectivement N et M
@@ -196 +192 @@
         <replaceable>T2</replaceable></literal> est équivalent à
         <literal>FROM <replaceable>T1</replaceable>,
-        <replaceable>T2</replaceable></literal>.  C'est aussi équivalent à
+        <replaceable>T2</replaceable></literal>. C'est aussi équivalent à
         <literal>FROM <replaceable>T1</replaceable> INNER JOIN
         <replaceable>T2</replaceable> ON TRUE</literal> (voir ci-dessous).
@@ -233 +229 @@
        <para>
         Les mots <literal>INNER</literal> et
-        <literal>OUTER</literal> sont optionnelles dans toutes les formes.
+        <literal>OUTER</literal> sont optionnels dans toutes les formes.
         <literal>INNER</literal> est la valeur par défaut&nbsp;;
         <literal>LEFT</literal>, <literal>RIGHT</literal> et
@@ -240 +236 @@
 
        <para>
-        La <firstterm>condition de la jointure</firstterm> est spécifiée dans
-        la clause <literal>ON</> ou <literal>USING</> ou implicitement par le
+        La <firstterm>condition de jointure</firstterm> est spécifiée dans
+        la clause <literal>ON</> ou <literal>USING</>, ou implicitement par le
         mot <literal>NATURAL</>. La condition de jointure détermine les lignes
-        des deux tables source considérées comme <quote>correspondante</quote>,
+        des deux tables sources <quote>correspondantes</quote>,
         comme l'explique le paragraphe ci-dessous.
        </para>
@@ -249 +245 @@
        <para>
         La clause <literal>ON</> est le type le plus général de condition de 
-        jointure&nbsp;: il prend une expression booléenne du même genre que
-        celui utilisée dans une clause <literal>WHERE</>. Une paires de lignes
+        jointure&nbsp;: elle prend une expression booléenne du même genre que
+        celle utilisée dans une clause <literal>WHERE</>. Une paire de lignes
         de <replaceable>T1</> et <replaceable>T2</> correspondent si
         l'expression <literal>ON</> est évaluée à vraie (true) pour ces deux
@@ -257 +253 @@
 
        <para>
-        <literal>USING</> est la notation raccourcie&nbsp;: elle prend une
-        liste de noms de colonnes séparées par des virgules, que les tables
-        jointes ont en commun, et forme une condition de jointure spécifiant
+        <literal>USING</> est une notation raccourcie&nbsp;: elle prend une
+        liste de noms de colonnes, séparés par des virgules, que les tables
+        jointes doivent avoir en commun, et forme une condition de jointure spécifiant
         l'égalité de chacune de ces paires de colonnes. De plus, la sortie de
-        <literal>JOIN USING</> a une colonne pour chaque paires égales des
-        colonnes en entrée, suivies par toutes les autres colonnes de chaque
-        table. Du coup, <literal>USING (a, b, c)</literal> est équivalent à
-        <literal>ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c)</literal> avec
-        l'exception que si <literal>ON</> est utilisé, il y aura deux colonnes
+        <literal>JOIN USING</> a une colonne pour chaque paire égalée de
+        colonnes en entrée. Ces colonnes sont suivies par toutes les autres colonnes de chaque
+        table. De ce fait, <literal>USING (a, b, c)</literal> est équivalent à
+        <literal>ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c)</literal> à
+        la différence que si <literal>ON</> est utilisé, il y a deux colonnes
         <literal>a</>, <literal>b</>, puis <literal>c</> dans le résultat, alors
-        qu'avec <literal>USING</>, il n'y en aurait eu qu'une de chaque.
+        qu'avec <literal>USING</>, il n'y en aura qu'une de chaque.
        </para>
 
@@ -287 +283 @@
         Enfin, <literal>NATURAL</> est un format raccourci de
         <literal>USING</>&nbsp;: il forme une liste <literal>USING</>
-        consistant exactement des noms de colonnes apparaissant à la fois dans
-        deux tables en entrée. Comme avec <literal>USING</>, ces colonnes
-        apparaissent seulement une fois dans la table de sortie.
+        constituée exactement des noms des colonnes apparaissant à la fois dans
+        les deux tables en entrée. Comme avec <literal>USING</>, ces colonnes
+        n'apparaissent qu'une fois dans la table de sortie.
        </para>
 
@@ -301 +297 @@
          <listitem>
           <para>
-           Pour chaque ligne R1 de T1, la table jointe a une ligne pour chaque
-           ligne de T2 satisfaisant la condition de jointure avec R1.
+           Pour chaque ligne L1 de T1, la table jointe a une ligne pour chaque
+           ligne de T2 satisfaisant la condition de jointure avec L1.
           </para>
          </listitem>
@@ -330 +326 @@
          <listitem>
           <para>
-           Tout d'abord, une jointure interne est réalisée. Puis, pour chaque
-           ligne de T1 qui ne satisfont pas la condition de jointure avec toutes
-           les lignes de T2, une ligne jointe est ajoutée avec des valeurs
+           En premier lieu, une jointure interne est réalisée. Puis, pour chaque
+           ligne de T1 qui ne satisfait à la condition de jointure avec aucune
+           des lignes de T2, une ligne jointe est ajoutée avec des valeurs
            nulles dans les colonnes de T2. Du coup, la table jointe a au moins
-           une ligne pour chaque ligne de T1 quelque soient les conditions.
+           une ligne pour chaque ligne de T1 quelques soient les conditions.
           </para>
          </listitem>
@@ -362 +358 @@
          <listitem>
           <para>
-           Tout d'abord, une jointure interne est réalisée. Puis, pour chaque
-           ligne de T2 qui ne satisfait pas la condition de jointure avec une
-           ligne de T1, une ligne jointe est ajoutée avec des valeurs nulles
+           En premier lieu, une jointure interne est réalisée. Puis, pour chaque
+           ligne de T2 qui ne satisfait à la condition de jointure avec aucune
+           des lignes de T1, une ligne jointe est ajoutée avec des valeurs nulles
            dans les colonnes de T1. C'est l'inverse d'une jointure gauche&nbsp;:
-           la table résultante aura une ligne pour chaque ligne de T2 quelque
+           la table résultante aura une ligne pour chaque ligne de T2 quelques
            soient les conditions.
           </para>
@@ -377 +373 @@
          <listitem>
           <para>
-           Tout d'abord, une jointure interne est réalisée. Puis, pour chaque
-           ligne de T1 qui ne satisfait pas la condition de jointure avec une
-           ligne de T2, une ligne jointe est ajouté avec des valeurs nulles dans
-           les colonnes de T2. De plus, pour chaque ligne de T2 qui ne satisfait
-           pas la condition de jointure avec les lignes de T1, une ligne jointe
+           En premier lieu, une jointure interne est réalisée. Puis, pour chaque
+           ligne de T1 qui ne satisfait à la condition de jointure avec aucune
+           des lignes de T2, une ligne jointe est ajoutée avec des valeurs nulles dans
+           les colonnes de T2. Enfin, pour chaque ligne de T2 qui ne satisfait
+           à la condition de jointure avec aucune des lignes de T1, une ligne jointe
            est ajoutée avec des valeurs nulles dans les colonnes de T1.
           </para>
@@ -393 +389 @@
 
     <para>
-     Les jointures de tous les types peuvent être chaînées ensemble ou
-     imbriquées&nbsp;: soit les deux soit une des deux, parmi
-     <replaceable>T1</replaceable> et <replaceable>T2</replaceable>, pourraient
-     être des tables. Les parenthèses peuvent être utilisées autour des clauses
+     Des jointures de tout type peuvent être chaînées ou imbriquées&nbsp;:
+     <replaceable>T1</replaceable> et <replaceable>T2</replaceable> peuvent
+     être des tables jointes (l'une, l'autre ou les deux).
+     Des parenthèses peuvent être utilisées autour des clauses
      <literal>JOIN</> pour contrôler l'ordre de jointure. En l'absence de
-     parenthèses, les clauses <literal>JOIN</> sont imbriquées de gauche à
+     parenthèses, les clauses <literal>JOIN</> s'imbriquent de gauche à
      droite.
     </para>
 
     <para>
-     Pour rassembler tout ceci, supposons que nous avons une table
+     Pour résumer, supposons que nous ayons une table
      <literal>t1</literal>
 <programlisting>
- num | name
+ num | nom
 -----+------
    1 | a
@@ -414 +410 @@
      et une table <literal>t2</literal>
 <programlisting>
- num | value
+ num | valeur
 -----+-------
    1 | xxx
@@ -420 +416 @@
    5 | zzz
 </programlisting>
-     nous obtenons les résultats suivants des différentes jointures&nbsp;:
+     nous obtenons les résultats suivants pour les différentes jointures&nbsp;:
 <screen>
 <prompt>=></> <userinput>SELECT * FROM t1 CROSS JOIN t2;</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   1 | a    |   3 | yyy
-   1 | a    |   5 | zzz
-   2 | b    |   1 | xxx
-   2 | b    |   3 | yyy
-   2 | b    |   5 | zzz
-   3 | c    |   1 | xxx
-   3 | c    |   3 | yyy
-   3 | c    |   5 | zzz
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   1 | a   |   3 | yyy
+   1 | a   |   5 | zzz
+   2 | b   |   1 | xxx
+   2 | b   |   3 | yyy
+   2 | b   |   5 | zzz
+   3 | c   |   1 | xxx
+   3 | c   |   3 | yyy
+   3 | c   |   5 | zzz
 (9 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num;</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   3 | c    |   3 | yyy
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   3 | c   |   3 | yyy
 (2 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 INNER JOIN t2 USING (num);</>
- num | name | value
------+------+-------
-   1 | a    | xxx
-   3 | c    | yyy
+ num | nom | valeur
+-----+-----+-------
+   1 | a   | xxx
+   3 | c   | yyy
 (2 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 NATURAL INNER JOIN t2;</>
- num | name | value
------+------+-------
-   1 | a    | xxx
-   3 | c    | yyy
+ num | nom | valeur
+-----+-----+-------
+   1 | a   | xxx
+   3 | c   | yyy
 (2 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num;</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   2 | b    |     |
-   3 | c    |   3 | yyy
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   2 | b   |     |
+   3 | c   |   3 | yyy
 (3 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 LEFT JOIN t2 USING (num);</>
- num | name | value
------+------+-------
-   1 | a    | xxx
-   2 | b    |
-   3 | c    | yyy
+ num | nom | valeur
+-----+-----+-------
+   1 | a   | xxx
+   2 | b   |
+   3 | c   | yyy
 (3 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num;</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   3 | c    |   3 | yyy
-     |      |   5 | zzz
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   3 | c   |   3 | yyy
+     |     |   5 | zzz
 (3 rows)
 
 <prompt>=></> <userinput>SELECT * FROM t1 FULL JOIN t2 ON t1.num = t2.num;</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   2 | b    |     |
-   3 | c    |   3 | yyy
-     |      |   5 | zzz
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   2 | b   |     |
+   3 | c   |   3 | yyy
+     |     |   5 | zzz
 (4 rows)
 </screen>
@@ -494 +490 @@
     <para>
      La condition de jointure spécifiée avec <literal>ON</> peut aussi contenir
-     des conditions sans relation directe avec la jointure. Ceci peut prouver
-     son utilité pour quelques requêtes mais son utilisation doit avoir été
-     réfléchie. Par exemple&nbsp;:
+     des conditions sans relation directe avec la jointure. Par exemple&nbsp;:
 <screen>
 <prompt>=></> <userinput>SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num AND t2.value = 'xxx';</>
- num | name | num | value
------+------+-----+-------
-   1 | a    |   1 | xxx
-   2 | b    |     |
-   3 | c    |     |
+ num | nom | num | valeur
+-----+-----+-----+-------
+   1 | a   |   1 | xxx
+   2 | b   |     |
+   3 | c   |     |
 (3 rows)
 </screen>
@@ -524 +518 @@
     <para>
      Un nom temporaire peut être donné aux tables et aux références de tables
-     complexe, qui sera ensuite utilisé pour référencer la table dérivée dans la
-     suite de l'exécution. Cela s'appelle un <firstterm>alias de
-     table</firstterm>.
-    </para>
-
-    <para>
-     Pour créer un alias de table, écrivez
-<synopsis>
-FROM <replaceable>reference_table</replaceable> AS
-<replaceable>alias</replaceable>
-</synopsis>
-     or
+     complexes. Celui-ci sera ensuite utilisé pour faire référence à la table dérivée dans la
+     suite de l'exécution. On appelle cela un <firstterm>alias de table</firstterm>.
+    </para>
+
+    <para>
+     Pour créer un alias de table, il suffit d'écrire
+<synopsis>
+FROM <replaceable>reference_table</replaceable> AS <replaceable>alias</replaceable>
+</synopsis>
+     ou
 <synopsis>
 FROM <replaceable>reference_table</replaceable> <replaceable>alias</replaceable>
 </synopsis>
-     Le mot clé <literal>AS</literal> est du bruit.
-     <replaceable>alias</replaceable> peut être tout identifiant.
+     Le mot clé <literal>AS</literal> n'est pas nécessaire.
+     <replaceable>alias</replaceable> peut être n'importe quel identifiant.
     </para>
 
     <para>
      Une application typique des alias de table est l'affectation d'identifiants
-     cours pour les noms de tables longs, ce qui permet de garder des clauses de
+     courts pour les noms de table longs, ce qui permet de garder des clauses de
      jointures lisibles. Par exemple&nbsp;:
 <programlisting>
-SELECT * FROM nom_de_table_tres_tres_long s JOIN un_autre_nom_trs_long a ON
-s.id = a.num;
+SELECT * FROM nom_de_table_tres_long n JOIN un_autre_nom_assez_long u ON n.id = u.num;
 </programlisting>
     </para>
@@ -560 +551 @@
 SELECT * FROM ma_table AS m WHERE ma_table.a > 5;
 </programlisting>
-     n'est pas valide pour une syntaxe SQL. Ce qui va réellement se passer
-     (c'est une extension de <productname>PostgreSQL</productname> au standard)
-     est qu'une référence de table implicite est ajoutée à la clause
-     <literal>FROM</literal>, de façon à ce que la requête soit exécutée comme
-     si elle était écrite ainsi
+     n'est pas une syntaxe SQL valide. En réalité, (c'est une extension du standard
+     proposée par <productname>PostgreSQL</productname>) une référence de table
+     implicite est ajoutée à la clause <literal>FROM</literal>, de façon à ce
+     que la requête soit exécutée comme si elle était écrite ainsi
 <programlisting>
 SELECT * FROM ma_table AS m, ma_table AS ma_table WHERE ma_table.a > 5;
 </programlisting>
-     ce qui résultera en une jointure croisée, ce qui n'est habituellement pas
-     ce que vous voulez.
-    </para>
-
-    <para>
-     Les alias de table sont disponibles principalement pour aider à l'écriture
-     de requête mais ils deviennent nécessaires pour joindre une table avec
+     ce qui aboutira à une jointure croisée. Et ce n'est habituellement pas
+     ce qui est attendu.
+    </para>
+
+    <para>
+     Les alias de table sont essentiellement disponibles pour faciliter l'écriture
+     de requêtes mais ils apparaissent nécessaires pour joindre une table avec
      elle-même, par exemple
 <programlisting>
 SELECT * FROM ma_table AS a CROSS JOIN ma_table AS b ...
 </programlisting>
-     De plus, un alias est requis si la référence de la table est une
+     De plus, un alias est requis si la référence de table est une
      sous-requête (voir <xref linkend="queries-subqueries">).
     </para>
 
     <para>
-     Les parenthèses sont utilisées pour résoudre les ambiguités. L'instruction
-     suivante affectera l'alias <literal>b</literal> au résultat de la jointure
-     contrairement à l'exemple précédente&nbsp;:
+     Les parenthèses sont utilisées pour lever les ambiguités. L'instruction
+     suivante affectera le résultat de la jointure à l'alias <literal>b</literal>,
+     contrairement à l'exemple précédent&nbsp;:
 <programlisting>
 SELECT * FROM (ma_table AS a CROSS JOIN ma_table) AS b ...
@@ -596 +586 @@
      des tables&nbsp;:
 <synopsis>
-FROM <replaceable>reference_table</replaceable> <optional>AS</optional>
-<replaceable>alias</replaceable> ( <replaceable>colonne1</replaceable>
-<optional>, <replaceable>colonne2</replaceable> <optional>,
-...</optional></optional> )
-</synopsis>
-     Si le nombre d'alias de colonnes spécifié est plus petit que le nombre
-     de colonnes dont dispose la table réelle, les colonnes suivantes ne sont
-     pas renommées. Cette syntaxe est particulièrement utile dans le cas de
-     jointure de même table ou dans le cas de sous-requêtes.
-    </para>
-
-    <para>
-     Quand un alias est appliqué à la sortie d'une clause <literal>JOIN</> en
-utilisant n'importe laquelle de ces formes, l'alias cache le nom original à
-l'intérieur du <literal>JOIN</>. Par exemple,
+FROM <replaceable>reference_table</replaceable> <optional>AS</optional> <replaceable>alias</replaceable> ( <replaceable>colonne1</replaceable> <optional>, <replaceable>colonne2</replaceable> <optional>,...</optional></optional> )
+</synopsis>
+     Si le nombre d'alias de colonnes spécifiés est plus petit que le nombre
+     de colonnes dont dispose la table réelle, les colonnes résiduelles ne sont
+     pas renommées. Cette syntaxe est particulièrement utile dans le cas
+     d'auto-jointures ou dans le cas de sous-requêtes.
+    </para>
+
+    <para>
+     Quand un alias est appliqué à la sortie d'une clause <literal>JOIN</>,
+     quelqu'en soit la forme, l'alias cache le nom original à l'intérieur du
+     <literal>JOIN</>. Par exemple,
 <programlisting>
 SELECT a.* FROM ma_table AS a JOIN ta_table AS b ON ...
 </programlisting>
-     is valid SQL, but
+     est du SQL valide, mais
 <programlisting>
 SELECT a.* FROM (ma_table AS a JOIN ta_table AS b ON ...) AS c
@@ -631 +618 @@
 
     <para>
-     Une sous-requête spécifiant une table dérivée doit être enfermée 
-     dans des parenthèses et <emphasis>doit</emphasis> se voir affecté un alias 
+     Une sous-requête spécifiant une table dérivée doit être écrite entre
+     parenthèses et <emphasis>doit</emphasis> se voir affecter un alias
      de table. (Voir <xref linkend="queries-table-aliases">.) Par exemple&nbsp;:
 <programlisting>
@@ -640 +627 @@
 
     <para>
-     Cette exemple est équivalent à <literal>FROM table1 AS
-     nom_alias</literal>. Des cas plus intéressants, qui ne peuvent pas être
-     réduit à une jointure pleine, arrivent quand la sous-requête implique un
-     groupement ou une agrégat.
+     Cet exemple est équivalent à <literal>FROM table1 AS nom_alias</literal>.
+     Des cas plus intéressants, qui ne peuvent pas être réduits à une jointure
+     pleine, surviennent quand la sous-requête implique un groupement ou un agrégat.
     </para>
    </sect3>
@@ -659 +645 @@
     <para>
      Les fonctions de table sont des fonctions produisant un ensemble de
-     lignes composées de types de données de base (types scalaires) ou de types
-     de données composés (lignes de table). Elles sont utilisées comme une
-     table, une vue ou une sous-requête de la clause <literal>FROM</> d'une
-     requête. Les colonnes renvoyées par les fonctions de table peuvent être
+     lignes composées de types de données basiques (types scalaires) ou de types
+     de données composites (lignes de table). Elles sont utilisées de la même façon
+     qu'une table, une vue ou une sous-requête de la clause <literal>FROM</> d'une
+     requête. Les colonnes retournées par les fonctions de table peuvent être
      incluses dans une clause <literal>SELECT</>, <literal>JOIN</> ou
      <literal>WHERE</> de la même manière qu'une colonne de table, vue ou
@@ -669 +655 @@
 
     <para>
-     Si une fonction de table renvoie un type de données de base, la colonne
+     Si une fonction de table renvoie un type de données basique, la colonne
      de résultat est nommée comme la fonction. Si la fonction renvoie un type
-     composite, les colonnes résultants ont le même nom que les attributs
+     composite, les colonnes résultantes ont le même nom que les attributs
      individuels du type.
     </para>
 
     <para>
-     Une fonction de table pourrait avoir un alias dans la clause
-     <literal>FROM</> mais elle pourrait être laissée sans alias. Si une
-     fonction est utilisée dans la clause <literal>FROM</> sans alias, le nom de
-     la fonction est utilisé comme nom de table résultante.
+     Une fonction de table peut avoir un alias dans la clause <literal>FROM</>.
+     Dans le cas contraire, le nom de la fonction est utilisé comme nom de table résultante.
     </para>
 
@@ -687 +671 @@
 CREATE TABLE truc (trucid int, trucsousid int, trucnom text);
 
-CREATE FUNCTION recuptruc(int) RETURNS SETOF foo AS '
+CREATE FUNCTION recuptruc(int) RETURNS SETOF truc AS '
     SELECT * FROM truc WHERE trucid = $1;
 ' LANGUAGE SQL;
@@ -703 +687 @@
 
     <para>
-     Dans certains cas, il est utile de définir des fonctions de table pouvant
-     renvoyer des ensembles de colonnes différentes suivant la façon dont elles
-     sont appelées. Pour supporter ceci, la fonction de table est déclarée comme
+     Dans certains cas, il est utile de définir des fonctions de table qui
+     renvoient des ensembles de colonnes différents suivant la façon dont elles
+     sont appelées. Pour ce faire, la fonction de table est déclarée comme
      renvoyant le pseudotype <type>record</>. Quand une telle fonction est
      utilisée dans une requête, la structure de ligne attendue doit être
-     spécifiée dans la requête elle-même, de façon à ce que le système sache
-     comment analyser et planifier la requête. Considérez cet exemple&nbsp;:
+     spécifiée dans la requête elle-même. De cette façon, le système saura
+     comment analyser et planifier la requête. Par exemple&nbsp;:
 <programlisting>
 SELECT *
@@ -717 +701 @@
 </programlisting>
      La fonction <literal>dblink</> exécute une requête distante (voir
-     <filename>contrib/dblink</>). Elle déclare renvoyer le type
-     <type>record</> car elle pourrait être utilisée pour tout type de requête.
-     L'ensemble de colonnes réelles doit être spécifié dans la requête appelant
-     de façon à ce que l'analyseur sache, par exemple, ce que comment
-     étendre <literal>*</>.
+     <filename>contrib/dblink</>). Elle a été déclarée avec un type de retour
+     <type>record</>, puisqu'elle peut être utilisée pour tout type de requête.
+     L'ensemble de colonnes réelles doit être spécifié dans la requête appelante
+     de sorte que l'analyseur sache, par exemple, comment étendre <literal>*</>.
     </para>
    </sect3>
@@ -738 +721 @@
 WHERE <replaceable>condition_recherche</replaceable>
 </synopsis>
-    où <replaceable>condition_recherche</replaceable> est toute expression de
-    valeur définie dans <xref linkend="sql-expressions"> et renvoyant une valeur
-    de type <type>boolean</type>.
-   </para>
-
-   <para>
-    Après la réalisation de la clause <literal>FROM</>, chaque ligne de la
-    table virtuelle dérivée est vérifiée avec la condition de recherche. Si le
-    résultat de la vérification est positive (true), la ligne est conservée dans
-    la table de sortie, sinon (c'est-à-dire si le résultat est faux ou nul, la
-    ligne est abandonnée. La condition de recherche référence typiquement au
-    moins quelques colonnes de la table générée dans la clause
-    <literal>FROM</>&nbsp;; ceci n'est pas requis mais, dans le cas contraire,
-    la clause <literal>WHERE</> n'aurait aucune utilité.
+    où <replaceable>condition_recherche</replaceable> est une expression de
+    valeur, telle que définie dans <xref linkend="sql-expressions">, qui retourne
+    une valeur de type <type>boolean</type>.
+   </para>
+
+   <para>
+    Après le traitement de la clause <literal>FROM</>, chaque ligne de la
+    table virtuelle dérivée est confrontée à la condition de recherche. Si le
+    résultat de la vérification est positif (true), la ligne est conservée dans
+    la table de sortie, sinon (c'est-à-dire si le résultat est faux ou nul) la
+    ligne est abandonnée. La condition de recherche fait, en général, référence
+    à une colonne de la table engendrée dans la clause <literal>FROM</>&nbsp;;
+    ceci n'est pas impératif mais, dans le cas contraire, la clause <literal>WHERE</>
+    s'avère inutile.
    </para>
 
@@ -758 +741 @@
      Avant l'implémentation de la syntaxe <literal>JOIN</>, il était nécessaire
      de placer la condition de jointure d'une jointure interne dans la clause
-     <literal>WHERE</>. Par exemple, ces expressions de tables sont
-     équivalentes&nbsp;:
+     <literal>WHERE</>. Les expressions de tables suivantes sont équivalentes&nbsp;:
 <programlisting>
 FROM a, b WHERE a.id = b.id AND b.val &gt; 5
@@ -767 +749 @@
 FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val &gt; 5
 </programlisting>
-     ou même peut-être
+     ou même
 <programlisting>
 FROM a NATURAL JOIN b WHERE b.val &gt; 5
 </programlisting>
-     Laquelle vous utilisez est plutôt une affaire de style. La syntaxe
-     <literal>JOIN</> dans la clause <literal>FROM</> n'est probablement pas
-     aussi portable vers les autres systèmes de gestion de bases de données SQL.
-     Pour les jointures externes, il n'y a pas d'autres choix&nbsp;: elles
-     doivent être faites dans la clause <literal>FROM</> clause. Une clause
+     L'utilisation de l'une par rapport à l'autre est affaire de style. La syntaxe
+     <literal>JOIN</> dans la clause <literal>FROM</> n'est pas forcément très
+     portable vers les autres systèmes de gestion de bases de données SQL.
+     Pour les jointures externes, il n'y qu'une seule possibilité&nbsp;: elles
+     doivent être faites dans la clause <literal>FROM</>. Une clause
      <literal>ON</>/<literal>USING</> d'une jointure externe n'est
      <emphasis>pas</> équivalente à une condition <literal>WHERE</> parce
-     qu'elle détermine l'ajout de lignes (pour les lignes qui ne correspondent
-     pas en entrée) ainsi que pour la suppression de lignes dans le résultat
-     final.
+     qu'elle détermine l'ajout de lignes (pour les lignes en entrée sans
+     correspondance) ainsi que la suppression de lignes dans le résultat final.
     </para>
    </note>
@@ -802 +783 @@
     <literal>FROM</>. Les lignes qui ne correspondent pas à la condition de la
     recherche de la clause <literal>WHERE</> sont éliminées de la table
-    <literal>fdt</literal>. Notez l'utilisation de sous-requêtes scalaires en
-    tant qu'expressions de valeurs. Comme n'importe quelle autre requête, les
-    sous-requêtes peuvent employer des expressions de tables complexes. Notez
-    aussi comment <literal>fdt</literal> est référencée dans les sous-requêtes.
-    Qualifier <literal>c1</> comme <literal>fdt.c1</> est seulement nécessaire
-    si <literal>c1</> est aussi le nom d'une colonne dans la table d'entrée
-    dérivée de la sous-requête. Mais qualifier le nom de colonne ajoute à la
-    clarté même lorsque cela n'est pas nécessaire. Cet exemple montre comment
-    le nom de colonne d'une requête externe est étendue dans les requêtes
-    internes.
+    <literal>fdt</literal>. On peut noter l'utilisation de sous-requêtes scalaires
+    comme expressions de valeurs. A l'instar de n'importe quelle autre requête, les
+    sous-requêtes peuvent employer des expressions de tables complexes. On peut
+    également noter la façon dont <literal>fdt</literal> est référencée dans les
+    sous-requêtes. Qualifier <literal>c1</> sous la forme <literal>fdt.c1</> n'est
+    nécessaire que si <literal>c1</> est aussi le nom d'une colonne dans la table
+    dérivée en entrée de la sous-requête. Mais qualifier le nom de colonne, même lorsque cela
+    n'est pas nécessaire, ajoute à la clarté. Cet exemple montre comment le nommage
+    de colonne d'une requête externe est étendu dans les requêtes internes.
    </para>
   </sect2>
@@ -830 +810 @@
    <para>
     Après avoir passé le filtre <literal>WHERE</>, la table d'entrée dérivée
-    peut être sujette à un regroupement en utilisant la clause <literal>GROUP
-    BY</> et à une élimination de groupe de lignes avec la clause
+    peut faire l'objet d'un regroupement par l'utilisation de la clause
+    <literal>GROUP BY</> et d'une élimination de lignes groupées par la clause
     <literal>HAVING</>.
    </para>
@@ -839 +819 @@
     FROM ...
     <optional>WHERE ...</optional>
-    GROUP BY <replaceable>reference_colonne_regroupement</replaceable>
-<optional>,
-<replaceable>reference_colonne_regroupement</replaceable></optional>...
-</synopsis>
-
-   <para>
-    La clause <literal>GROUP BY</> est utilisée pour regrouper des lignes d'une
-    table partageant les mêmes valeurs dans toutes les colonnes précisées.
+    GROUP BY <replaceable>reference_colonne_regroupement</replaceable> <optional>, <replaceable>reference_colonne_regroupement</replaceable></optional>...
+</synopsis>
+
+   <para>
+    La clause <literal>GROUP BY</> est utilisée pour regrouper les lignes d'une
+    table qui partagent les mêmes valeurs pour toutes les colonnes précisées.
     L'ordre dans lequel ces colonnes sont indiquées importe peu. Le but est de
-    réduire chaque groupe de lignes partageant des valeurs communes en un seul
-    groupe de ligne représentant toutes les lignes du groupe. Ceci se fait en
-    éliminant les redondances dans la sortie et/ou pour calculer les agrégats
+    réduire chaque groupe de lignes partageant des valeurs communes en une seule
+    ligne de groupe représentative de toutes les lignes du groupe. Ceci est fait
+    pour éliminer les redondances dans la sortie et/ou pour calculer les agrégats
     s'appliquant à ces groupes. Par exemple&nbsp;:
 <screen>
@@ -873 +851 @@
           
    <para>
-    Dans la seconde requête, nous n'aurions pas pu écrire <literal>SELECT *
-    FROM test1 GROUP BY x</literal> parce qu'il n'existe pas une seule valeur
-    pour la colonne <literal>y</> pouvant être associé avec chaque autre groupe.
+    Dans la seconde requête, il n'est pas possible d'écrire <literal>SELECT *
+    FROM test1 GROUP BY x</literal> parce qu'il n'existe pas de valeur unique
+    pour la colonne <literal>y</> pouvant être associée avec chaque autre groupe.
     Les colonnes de regroupement peuvent être référencées dans la liste de
     sélection car elles ont une valeur constante connue par groupe.
@@ -881 +859 @@
 
    <para>
-    En général, si une table est groupée, les colonnes qui ne sont pas
-    utilisées dans le regroupement ne peuvent pas être référencées sauf dans les
+    En général, si une table est groupée, il ne peut pas être fait référence aux
+    colonnes qui ne sont pas utilisées dans le regroupement sinon dans les
     expressions d'agrégats. Voici un exemple d'expressions d'agrégat&nbsp;:
 <screen>
@@ -893 +871 @@
 (3 rows)
 </screen>
-    Ici, <literal>sum</literal> est la fonction d'agrégat qui calcule une seule
-    valeur pour le groupe entier. Plus d'informations sur les fonctions
-    d'agrégats disponibles sont proposées dans <xref
-    linkend="functions-aggregate">.
+    Ici, <literal>sum</literal> est une fonction d'agrégat qui calcule une
+    valeur unique pour tout le groupe. On pourra touver plus d'informations sur
+    les fonctions d'agrégats disponibles dans <xref linkend="functions-aggregate">.
    </para>
 
    <tip>
     <para>
-     Le regroupement sans expressions d'agrégats calcule effectivement
-     l'ensemble les valeurs distinctes d'une colonne. Ceci peut aussi se faire
-     en utilisant la clause <literal>DISTINCT</> (voir <xref
-     linkend="queries-distinct">).
+     Le regroupement sans expression d'agrégats calcule effectivement
+     l'ensemble des valeurs distinctes d'une colonne. Le même résultat peut être obtenu
+     à l'aide de la clause <literal>DISTINCT</> (voir <xref linkend="queries-distinct">).
     </para>
    </tip>
 
    <para>
-    Voici un autre exemple&nbsp;: il calcule les vantes totales pour chaque
-    produit (plutôt que le total des ventes sur tous les produits).
+    L'exemple suivant calcule les ventes totales pour chaque produit (plutôt que
+    le total des ventes sur tous les produits).
 <programlisting>
 SELECT produit_id, p.nom, (sum(v.unite) * p.prix) AS ventes
@@ -917 +893 @@
 </programlisting>
     Dans cet exemple, les colonnes <literal>produit_id</literal>,
-    <literal>p.nom</literal> et <literal>p.prix</literal> doivent être dans la
+    <literal>p.nom</literal> et <literal>p.prix</literal> doivent se trouver dans la
     clause <literal>GROUP BY</> car elles sont référencées dans la liste de
     sélection de la requête. (Suivant la façon dont est conçue la table
-    produits, le nom et le prix pourraient être totalement dépendants de l'ID du
-    produit, donc des regroupements supplémentaires pourraient théoriquement
-    être inutiles mais ceci n'est pas encore implémenté.) La colonne
+    produits, le nom et le prix peuvent être totalement dépendants de l'ID du
+    produit et de ce fait, les regroupements supplémentaires ne sont théoriquement pas
+    nécessaires. Mais ceci n'est pas encore implémenté.) La colonne
     <literal>s.unite</> n'a pas besoin d'être dans la liste <literal>GROUP
-    BY</> car elle est seulement utilisée dans l'expression de l'agrégat
+    BY</> car elle est utilisée uniquement dans l'expression de l'agrégat
     (<literal>sum(...)</literal>) représentant les ventes d'un produit. Pour
     chaque produit, la requête renvoie une ligne de résumé sur les ventes de ce
@@ -931 +907 @@
 
    <para>
-    En SQL strict, <literal>GROUP BY</> peut seulement grouper les colonnes de
-    la table source mais <productname>PostgreSQL</productname> étend ceci en
-    autorisant <literal>GROUP BY</> à grouper aussi les colonnes de la liste de
-    sélection. Grouper par expressions de valeurs au lieu de simples noms de
-    colonnes est aussi permis.
+    La norme SQL standard ne définit pour <literal>GROUP BY</> que le groupement
+    par colonnes de la table source. <productname>PostgreSQL</productname> autorise
+    également <literal>GROUP BY</> à grouper par colonnes de la liste de
+    sélection. Grouper par expressions de valeurs plutôt que par simples noms de
+    colonne est également autorisé.
    </para>
 
@@ -943 +919 @@
 
    <para>
-    Si une table a été groupée en utilisant la clause <literal>GROUP
-    BY</literal> mais que seul certains groupes sont intéressants, la clause
-    <literal>HAVING</literal> peut être utilisée, plus comme une clause
-    <literal>WHERE</>, pour éliminer les groupes d'une table groupée. Voici la
-    syntaxe&nbsp;:
-<synopsis>
-SELECT <replaceable>liste_selection</replaceable> FROM ... <optional>WHERE
-...</optional> GROUP BY ... HAVING
-<replaceable>expression_booléenne</replaceable>
-</synopsis>
-    Les expressions de la clause <literal>HAVING</> peuvent référer à la fois
-    aux expressions groupées et aux expressions non groupées (ce qui impliquent
+    Si une table a été groupée en utilisant la clause <literal>GROUP BY</literal>
+    mais que seuls certains groupes ont un intérêt, la clause
+    <literal>HAVING</literal> peut être utilisée, à l'instar d'une clause
+    <literal>WHERE</>, pour éliminer les groupes d'une table groupée. La syntaxe
+    est la suivante&nbsp;:
+<synopsis>
+SELECT <replaceable>liste_selection</replaceable> FROM ... <optional>WHERE ...</optional> GROUP BY ... HAVING <replaceable>expression_booléenne</replaceable>
+</synopsis>
+    Les expressions de la clause <literal>HAVING</> peuvent faire référence autant
+    à des expressions groupées qu'à des expressions non groupées (impliquant
     nécessairement une fonction d'agrégat).
    </para>
@@ -978 +952 @@
 
    <para>
-    De nouveau, un exemple plus réaliste&nbsp;:
+    L'exemple suivant est plus réaliste&nbsp;:
 <programlisting>
 SELECT produit_id, p.nom, (sum(v.unite) * (p.prix - p.cout)) AS profit
@@ -984 +958 @@
     WHERE v.date > CURRENT_DATE - INTERVAL '4 weeks'
     GROUP BY produit_id, p.nom, p.prix, p.cout
-    HAVING sum(p.prix * s.unite) > 5000;
+    HAVING sum(p.prix * v.unite) > 5000;
 </programlisting>
     Dans l'exemple ci-dessus, la clause <literal>WHERE</> sélectionne les
-    lignes par une colonne qui n'est pas groupée (l'expression est vraie
+    lignes à partir d'une colonne qui n'est pas groupée (l'expression est vraie
     seulement pour les ventes des quatre dernières semaines) alors que la
     clause <literal>HAVING</> restreint la sortie aux groupes dont le total des
     ventes dépasse 5000. Notez que les expressions d'agrégats n'ont pas besoin
-    d'être identiques dans toutes les parties d'une requête.
+    d'être les mêmes dans toutes les parties d'une requête.
    </para>
   </sect2>
@@ -1006 +980 @@
 
   <para>
-   Comme montré dans la section précédente, l'expression de table pour la
-commande <command>SELECT</command> construit une table virtuelle intermédiaire
-en combinant les tables, vues, en éliminant les lignes, en groupant, etc. Cette
-table est finalement passée à la réalisation de la <firstterm>liste de
-sélection</firstterm>. Cette liste détermine les <emphasis>colonnes</emphasis>
-de la table intermédiaire à afficher.
+   Comme cela a été vu dans la section précédente, l'expression de table
+   pour la commande <command>SELECT</command> construit une table virtuelle
+   intermédiaire en combinant les tables et les vues, en éliminant des lignes, en
+   réalisant des groupements, etc. Cette table est finalement transmise pour
+   traitement à la <firstterm>liste de sélection</firstterm>.
+   Cette liste détermine les <emphasis>colonnes</emphasis> de la table intermédiaire
+   à afficher.
   </para>
 
@@ -1025 +1000 @@
     émet toutes les colonnes que l'expression de table produit. Sinon, une liste
     de sélection est une liste d'expressions de valeurs séparées par des
-    virgules (comme défini dans <xref linkend="sql-expressions">). Par exemple,
-    cela pourrait être une liste des noms de colonnes&nbsp;:
+    virgules (comme défini dans <xref linkend="sql-expressions">). Cela peut, par
+    exemple, être une liste de noms de colonnes&nbsp;:
 <programlisting>
 SELECT a, b, c FROM ...
 </programlisting>
-     Les noms de colonnes <literal>a</>, <literal>b</> et <literal>c</> sont
+     Les noms de colonnes <literal>a</>, <literal>b</> et <literal>c</> sont,
      soit les noms actuels des colonnes des tables référencées dans la clause
-     <literal>FROM</> soit les alias qui leur ont été donnés (voir l'explication
+     <literal>FROM</>, soit les alias qui leur ont été donnés (voir l'explication
      dans <xref linkend="queries-table-aliases">). L'espace de nom disponible
      dans la liste de sélection est le même que dans la clause <literal>WHERE</>
-     sauf si le regroupement est utilisé, auquel cas c'est le même que dans la
+     sauf si un regroupement est utilisé, auquel cas c'est le même que dans la
      clause <literal>HAVING</>.
    </para>
 
    <para>
-    Si plus d'une table a une colonne du même nom, le nom de la table doit
-aussi être donné comme dans
+    Si plusieurs tables ont une colonne du même nom, le nom de la table doit aussi
+    être donné, comme dans
 <programlisting>
 SELECT tbl1.a, tbl2.a, tbl1.b FROM ...
 </programlisting>
-    En travaillant avec plusieurs tables, il est aussi utile de demander toutes
-    les colonnes d'une table particulière&nbsp;:
+    En travaillant avec plusieurs tables, il peut aussi être utile de demander
+    toutes les colonnes d'une table particulière&nbsp;:
 <programlisting>
 SELECT tbl1.*, tbl2.a FROM ...
@@ -1055 +1030 @@
    <para>
     Si une expression de valeur arbitraire est utilisée dans la liste de
-    sélection, il ajoute conceptuellement une nouvelle colonne virtuelle dans la
+    sélection, cela ajoute conceptuellement une nouvelle colonne virtuelle à la
     table renvoyée. L'expression de valeur est évaluée une fois pour chaque
-    ligne avec une substitution des valeurs de lignes avec les références de
+    ligne, les valeurs de lignes étant substituées pour chaque référence de
     colonnes. Mais les expressions de la liste de sélection n'ont pas à
-    référencer les colonnes dans l'expression de la table de la clause
-    <literal>FROM</>&nbsp;; elles pourrait être des expressions arithmétiques
-    constantes, par exemple.
+    faire référence aux colonnes de l'expression de table issue de la clause
+    <literal>FROM</>&nbsp;; elles pourraient, par exemple, aussi bien être des
+    expressions arithmétiques constantes.
    </para>
   </sect2>
@@ -1075 +1050 @@
    <para>
     Les entrées dans la liste de sélection peuvent se voir affecter des noms
-    pour la suite de l'exécution. La <quote>suite de l'exécution</quote> dans ce
-    cas est une spécification optionnelle du tri et l'application client
-    (c'est-à-dire les en-têtes de colonne pour l'affichage). Par exemple&nbsp;:
+    pour la suite du traitement. La <quote>suite du traitement</quote> dans le
+    cas présent est une spécification optionnelle du tri et l'application client
+    (les en-têtes de colonne pour l'affichage, par exemple). Ainsi&nbsp;:
 <programlisting>
 SELECT a AS value, b + c AS sum FROM ...
@@ -1084 +1059 @@
 
    <para>
-    Si aucun nom de colonne en sortie n'est spécifié en utilisant
-    <literal>AS</>, le système affecte un nom par défaut. Pour les références de
-    colonne simple, c'est le nom de la colonne référencée. Pour les appels de
+    Si aucun nom de colonne en sortie n'est spécifié par l'utilisation de <literal>AS</>,
+    le système affecte un nom par défaut. Pour les références de colonne simple,
+    c'est le nom de la colonne référencée. Pour les appels de
     fonction, il s'agit du nom de la fonction. Pour les expressions complexes,
-    le système générera un nom générique.
+    le système engendrera un nom générique.
    </para>
 
    <note>
     <para>
-     Le nom des colonnes en sortie est différent ici de ce qui est fait dans la
+     Le nommage des colonnes en sortie est ici différent de celui qui est fait dans la
      clause <literal>FROM</> (voir <xref linkend="queries-table-aliases">). Ce
-     tube vous permettra en fait de renommer deux fois la même colonne mais le
-     nom choisi dans la liste de sélection est celui qui sera passé.
+     tube vous permettra en fait de renommer deux fois la même colonne, mais le
+     nom choisi dans la liste de sélection est celui qui sera retenu.
     </para>
    </note>
@@ -1113 +1088 @@
 
    <para>
-    Après la réalisation de la liste de sélection, la table résultant pourrait
-    être optionnellement sujet à l'élimination des duplications. Le mot clé
+    Après le traitement de la liste de sélection, la table résultante peut
+    faire optionnellement l'objet de l'élimination des duplicats. Le mot clé
     <literal>DISTINCT</literal> est écrit directement après
-    <literal>SELECT</literal> pour activer ceci&nbsp;:
+    <literal>SELECT</literal> pour activer cela&nbsp;:
 <synopsis>
 SELECT DISTINCT <replaceable>liste_selection</replaceable> ...
 </synopsis>
-    (Au lieu de <literal>DISTINCT</>, le mot <literal>ALL</literal> peut être
+    (A la place de <literal>DISTINCT</>, le mot <literal>ALL</literal> peut être
     utilisé pour sélectionner le comportement par défaut, la récupération de
     toutes les lignes.)
@@ -1126 +1101 @@
 
    <para>
-    <indexterm><primary>valeur nulle</><secondary sortas="DISTINCT">dans
+    <indexterm><primary>valeur nulle</><secondary sortas="DISTINCT">avec
     DISTINCT</></indexterm>
     Évidemment, les deux lignes sont considérées distinctes si elles diffèrent
-    dans au moins une valeur de colonne. Les valeurs nulles sont considérées
+    par au moins une valeur de colonne. Les valeurs nulles sont considérées
     égales dans cette comparaison.
    </para>
 
    <para>
-    Alternativement, une expression arbitraire peut déterminer quelles lignes
-    doivent être considérées distinctes&nbsp;:
-<synopsis>
-SELECT DISTINCT ON (<replaceable>expression</replaceable> <optional>,
-<replaceable>expression</replaceable> ...</optional>)
-<replaceable>liste_selection</replaceable> ...
+    Alternativement, une expression arbitraire peut permettre de déterminer les
+    lignes à considérer distinctes&nbsp;:
+<synopsis>
+SELECT DISTINCT ON (<replaceable>expression</replaceable> <optional>, <replaceable>expression</replaceable> ...</optional>) <replaceable>liste_selection</replaceable> ...
 </synopsis>
     Ici, <replaceable>expression</replaceable> est une expression de valeur
     arbitraire, évaluée pour toutes les lignes. Les lignes dont toutes les
-    expressions sont égales sont considérées comme dupliquées et seule la
-    première ligne de cet ensemble est conservée dans la sortie. Notez que la
-    <quote>première ligne</quote> d'un ensemble est non prévisible sauf si la
+    expressions sont égales sont considérées dupliquées et seule la
+    première ligne de cet ensemble est conservée dans la sortie. Il est notable
+    que la <quote>première ligne</quote> d'un ensemble est imprévisible sauf si la
     requête est triée sur assez de colonnes pour garantir une ordre unique des
-    colonnes arrivant dans le filtre <literal>DISTINCT</>. (Le traitement de
-    <literal>DISTINCT ON</> parvient après le tri de <literal>ORDER BY</>.)
-   </para>
-
-   <para>
-    La clause <literal>DISTINCT ON</> ne fait pas partie du standard SQL et est
-    quelque fois considéré comme étant un mauvais style à cause de la nature
-    potentiellement indéterminée de ses résultats. Avec l'utilisation judicieuse
-    de <literal>GROUP BY</> et de sous-requêtes dans <literal>FROM</>, la
-    construction peut être évitée mais elle représente souvent l'alternative la
-    plus agréable.
+    colonnes arrivant dans le filtre <literal>DISTINCT</>. (Le traitement par
+    <literal>DISTINCT ON</> survient après le tri par <literal>ORDER BY</>.)
+   </para>
+
+   <para>
+    La clause <literal>DISTINCT ON</> ne fait pas partie du standard SQL. Elle est
+    souvent considérée comme de mauvais style du fait de la nature
+    potentiellement indéterminée de ses résultats. L'utilisation judicieuse
+    de <literal>GROUP BY</> et de sous-requêtes dans la clause <literal>FROM</>
+    permet d'éviter cette construction, mais elle représente souvent l'alternative la
+    plus pratique.
    </para>
   </sect2>
@@ -1190 +1163 @@
   <para>
    Les résultats de deux requêtes peuvent être combinés en utilisant les 
-   opérations d'ensemble&nbsp;: union, intersection et différence. La syntaxe
+   opérations ensemblistes&nbsp;: union, intersection et différence. La syntaxe
    est
 <synopsis>
@@ -1201 +1174 @@
 </synopsis>
    <replaceable>requete1</replaceable> et
-   <replaceable>requete2</replaceable> sont les requêtes pouvant utiliser
-   toutes les fonctionnalités discutées ici. Les opérations d'ensemble peuvent
-   aussi être combinées et chaînées, par exemple
-<synopsis>
-<replaceable>requete1</replaceable> UNION <replaceable>requete2</replaceable>
-UNION <replaceable>requete3</replaceable>
-</synopsis>
-   signifie réellement
-<synopsis>
-(<replaceable>requete1</replaceable> UNION <replaceable>requete2</replaceable>)
-UNION <replaceable>requete3</replaceable>
-</synopsis>
-  </para>
-
-  <para>
-   <literal>UNION</> ajoute effectivement le résultat de
+   <replaceable>requete2</replaceable> sont des requêtes pouvant utiliser
+   toutes les fonctionnalités discutées jusqu'ici. Les opérations ensemblistes peuvent
+   également être combinées et chaînées. Ainsi
+<synopsis>
+<replaceable>requete1</replaceable> UNION <replaceable>requete2</replaceable> UNION <replaceable>requete3</replaceable>
+</synopsis>
+   qui signifie réellement
+<synopsis>
+(<replaceable>requete1</replaceable> UNION <replaceable>requete2</replaceable>) UNION <replaceable>requete3</replaceable>
+</synopsis>
+  </para>
+
+  <para>
+   <literal>UNION</> ajoute simplement le résultat de
    <replaceable>requete2</replaceable> au résultat de
-   <replaceable>requete1</replaceable> (bien qu'il n'y ait pas de garantie
-   qu'il s'agit de l'ordre dans lequel les lignes sont réellement renvoyées). De
-   plus, il élimine toutes les lignes dupliquées, dans le sens de
-   <literal>DISTINCT</>, sauf si <literal>UNION ALL</> est utilisée.
+   <replaceable>requete1</replaceable> (il n'y a cependant aucune garantie
+   sur l'ordre effectif de retour des lignes). De plus, toutes les lignes dupliquées
+   sont éliminées, au sens de <literal>DISTINCT</>, à moins que <literal>UNION ALL</>
+   ne soit utilisé.
   </para>
 
@@ -1227 +1198 @@
    <literal>INTERSECT</> renvoie toutes les lignes qui sont à la fois dans le
    résultat de <replaceable>requete1</replaceable> et dans le résultat de
-   <replaceable>requete2</replaceable>. Les lignes dupliquées sont éliminées
+   <replaceable>requete2</replaceable>. Les lignes dupliquées sont éliminées,
    sauf si <literal>INTERSECT ALL</> est utilisé.
   </para>
@@ -1233 +1204 @@
   <para>
    <literal>EXCEPT</> renvoie toutes les lignes qui sont dans le résultat de
-   <replaceable>requete1</replaceable> mais pas dans le résultat de
-   <replaceable>requete2</replaceable>. (Ceci est quelque fois appelé la
-   <firstterm>différence</> entre deux requêtes.) De nouveau, les lignes
-   dupliquées sont éliminées sauf si <literal>EXCEPT ALL</> est utilisé.
-  </para>
-
-  <para>
-   Pour calculer l'union, l'intersection ou la différence de deux requêtes, les
-   deux requêtes doivent être <quote>compatibles pour une union</quote>, ce qui
-   signifie qu'elles doivent renvoyer le même nombre de colonnes et que les
+   <replaceable>requete1</replaceable> mais pas dans celui de
+   <replaceable>requete2</replaceable>. (On parle parfois de
+   <firstterm>différence</> entre deux requêtes.) Là aussi, les lignes
+   dupliquées sont éliminées, sauf si <literal>EXCEPT ALL</> est utilisé.
+  </para>
+
+  <para>
+   Pour calculer l'union, l'intersection ou la différence de deux requêtes, il est
+   impératif que les deux requêtes soient <quote>compatibles pour une union</quote>.
+   Cela signifie qu'elles doivent renvoyer le même nombre de colonnes et que les
    colonnes correspondantes doivent avoir des types de données compatibles,
-   comme décrit dans <xref linkend="typeconv-union-case">.
+   comme cela est décrit dans <xref linkend="typeconv-union-case">.
   </para>
  </sect1>
@@ -1261 +1232 @@
            
   <para>
-   Après qu'une requête ait produit une table en sortie (après que la liste de
-   sélection ait été traitée), elle peut être optionnellement triée. Si le tri
-   n'a pas été choisi, les lignes sont renvoyées dans un ordre aléatoire.
-   L'ordre réel dans ce cas dépendra des types de plan de parcours et de
-   jointure et de l'ordre sur le disque mais vous ne devez pas vous y fier. Un
-   tri particulier en sortie peut seulement être garantie si l'étape de tri est
-   choisie explicitement.
+   Après qu'une table de sortie ait été produite par une requête (après que la liste de
+   sélection ait été traitée), elle peut être optionnellement triée. Dans le cas
+   contraire, les lignes sont renvoyées dans un ordre aléatoire.
+   L'ordre réel, dans ce cas, dépendra des types de plan de parcours et de
+   jointure et de l'ordre des données sur le disque, mais on ne peut s'y fier.
+   Seul le tri explicite permet de garantir un ordre particulier en sortie.
   </para>
 
@@ -1275 +1245 @@
 SELECT <replaceable>liste_selection</replaceable>
     FROM <replaceable>expression_table</replaceable>
-    ORDER BY <replaceable>colonne1</replaceable> <optional>ASC | DESC</optional>
-<optional>, <replaceable>colonne2</replaceable> <optional>ASC | DESC</optional>
-...</optional>
-</synopsis>
-   <replaceable>colonne1</replaceable>, etc. réfèrent les colonnes de la liste
-   de sélection. Ceci peut soit être le nom de sortie d'une colonne (voir
-   <xref linkend="queries-column-labels">) ou le numéro d'une colonne. Voici
-   quelques exemples&nbsp;:
+    ORDER BY <replaceable>colonne1</replaceable> <optional>ASC | DESC</optional> <optional>, <replaceable>colonne2</replaceable> <optional>ASC | DESC</optional>...</optional>
+</synopsis>
+   <replaceable>colonne1</replaceable>, etc. font référence aux colonnes de la liste
+   de sélection. Il peut s'agir du nom de sortie d'une colonne (voir
+   <xref linkend="queries-column-labels">) ou du numéro d'une colonne. Quelques exemples&nbsp;:
 <programlisting>
 SELECT a, b FROM table1 ORDER BY a;
@@ -1291 +1258 @@
 
   <para>
-   Comme une extension du standard SQL, <productname>PostgreSQL</productname>
-   autorise aussi l'ordre des expressions arbitraires&nbsp;:
+   En extension au standard SQL, <productname>PostgreSQL</productname>
+   autorise aussi le tri par des expressions arbitraires&nbsp;:
 <programlisting>
 SELECT a, b FROM table1 ORDER BY a + b;
 </programlisting>
-   Les références des noms de colonnes dans la clause <literal>FROM</>,
-   renommées dans la liste de sélection, sont aussi autorisées&nbsp;:
+   Sont également autorisées les références aux noms de colonnes de la clause
+   <literal>FROM</> qui sont renommées dans la liste de sélection&nbsp;:
 <programlisting>
 SELECT a AS b FROM table1 ORDER BY a;
 </programlisting>
    Mais ces extensions ne fonctionnent pas dans les requêtes impliquant
-   <literal>UNION</>, <literal>INTERSECT</> ou <literal>EXCEPT</> et ne sont
-   pas portables dans les autres bases de données SQL.
-  </para>
-
-  <para>
-   Chaque spécification de colonne pourrait être suivie d'un
-   <literal>ASC</> ou <literal>DESC</> optionnelle pour initialiser la
-   direction du tri (ascendant ou descendant). L'ordre <literal>ASC</> est la
-   valeur par défaut. L'ordre ascendant place les plus petites valeurs en
-   premier où <quote>plus petit</quote> est défini en terme de l'opérateur
-   <literal>&lt;</literal>. De façon similaire, l'ordre descendant est
-   déterminé avec l'opérateur <literal>&gt;</literal>.
+   <literal>UNION</>, <literal>INTERSECT</> ou <literal>EXCEPT</>. Elles ne sont,
+   de plus, pas portables vers les autres bases de données SQL.
+  </para>
+
+  <para>
+   Chaque spécification de colonne peut être suivie d'un drapeau optionnel
+   <literal>ASC</> ou <literal>DESC</> permettant de préciser la direction du tri
+   (ascendant ou descendant). L'ordre <literal>ASC</> est la valeur par défaut.
+   L'ordre ascendant place les plus petites valeurs en premier. <quote>Plus petit</quote>
+   est défini conformément à l'opérateur <literal>&lt;</literal>. De façon similaire,
+   l'ordre descendant est déterminé avec l'opérateur <literal>&gt;</literal>.
     <footnote>
      <para>
       En fait, <productname>PostgreSQL</> utilise la <firstterm>classe
-      d'opérateur B-tree par défaut</> pour le type de données de la colonne 
-      pour déterminer l'ordre de tri avec <literal>ASC</> et <literal>DESC</>.
-      De façon conventionnelle, les types de données seront initialisés de
-      façon à ce que les opérateurs <literal>&lt;</literal> et
-      <literal>&gt;</literal> correspondent à cet ordre de tri mais un
-      concepteur des types de données définis par l'utilisateur pourrait choisir
-      de faire quelque chose de différent.
+      d'opérateur par défaut, B-tree</> pour le type de données de la colonne.
+      Cette classe permet de déterminer l'ordre de tri utilisé par <literal>ASC</>
+      et <literal>DESC</>. Par convention, les types de données sont
+      initialisés pour que les opérateurs <literal>&lt;</literal> et
+      <literal>&gt;</literal> correspondent à cet ordre de tri. Il est cependant
+      possible qu'un concepteur de types de données utilisateur choisisse
+      de procéder différement.
      </para>
     </footnote>
@@ -1329 +1295 @@
 
   <para>
-   Si plus d'une colonne de tri est spécifiée, les entrées suivantes sont
-   utilisées pour trier les lignes qui sont égales sous l'ordre imposé par les
-   colonnes de tri précédent.
+   Si plusieurs colonnes de tri sont spécifiées, les dernières entrées seront
+   utilisées pour trier les lignes qui seraient égales selon l'ordre imposé par
+   les premières colonnes de tri.
   </para>
  </sect1>
@@ -1348 +1314 @@
 
   <para>
-   <literal>LIMIT</> et <literal>OFFSET</> vous permet de retrouver seulement 
-   une portion des lignes générées par le reste de la requête&nbsp;:
+   <literal>LIMIT</> et <literal>OFFSET</> permettent de ne récupérer qu'une partie
+   des lignes engendrées par le reste de la requête&nbsp;:
 <synopsis>
 SELECT <replaceable>liste_selection</replaceable>
     FROM <replaceable>expression_table</replaceable>
-    <optional>LIMIT { <replaceable>numero</replaceable> | ALL }</optional>
-<optional>OFFSET <replaceable>numero</replaceable></optional>
-</synopsis>
-  </para>
-
-  <para>
-   Si un nombre limite est donné, pas plus que ce nombre de lignes sera renvoyé
-   (mais peut-être moins si la requête récupère moins de lignes). <literal>LIMIT
-   ALL</> est indique à ne pas spécifier la clause <literal>LIMIT</>.
-  </para>
-
-  <para>
-   <literal>OFFSET</> indique de passer ce nombre de lignes avant de renvoyer 
-   les lignes restantes. <literal>OFFSET 0</> est identique à oublier la clause
-   <literal>OFFSET</>. Si à la fois <literal>OFFSET</> et <literal>LIMIT</>
-   apparaissent, alors les <literal>OFFSET</> lignes sont laissés avant de
-   commencer le renvoi des <literal>LIMIT</> lignes.
-  </para>
-
-  <para>
-   Lors de l'utilisation de <literal>LIMIT</>, il est important d'utiliser une
+    <optional>LIMIT { <replaceable>numero</replaceable> | ALL }</optional> <optional>OFFSET <replaceable>numero</replaceable></optional>
+</synopsis>
+  </para>
+
+  <para>
+   Si une limite de comptage est donnée, il ne sera pas retourné plus de lignes
+   que ce nombre (peut-être moins si la requête complète retourne moins
+   de lignes). <literal>LIMIT ALL</> revient à ne pas spécifier la clause <literal>LIMIT</>.
+  </para>
+
+  <para>
+   <literal>OFFSET</> indique un nombre de lignes à ignorer avant de commencer à
+   retourner des lignes. <literal>OFFSET 0</> revient à oublier la clause
+   <literal>OFFSET</>. Si <literal>OFFSET</> et <literal>LIMIT</> sont utilisés ensemble,
+   <literal>OFFSET</> lignes sont ignorées avant de retourner <literal>LIMIT</> lignes.
+  </para>
+
+  <para>
+   Lors de l'utilisation de <literal>LIMIT</>, il est nécessaire d'utiliser une
    clause <literal>ORDER BY</> contraignant les lignes résultantes dans un ordre
-   unique. Sinon, vous obtiendrez un sous-ensemble non prévisible de lignes de
-   la requête. Vous pourriez demander des lignes 10 à 20 mais dans quel
-   ordre&nbsp;? L'ordre est inconnu si vous ne spécifiez pas <literal>ORDER
-   BY</>.
-  </para>
-
-  <para>
-   L'optimiseur de requêtes prend <literal>LIMIT</> en compte lors de la
-   génération d'un plan de requêtes, de façon à ce que vous obtenez
-   différents plans (avec différents ordres de lignes) suivant ce que vous
-   donnez à <literal>LIMIT</> et <literal>OFFSET</>. Du coup, utiliser des
-   valeurs <literal>LIMIT</>/<literal>OFFSET</> différentes pour sélectionner
-   des sous-ensembles différents d'un résultat de requête <emphasis>donnera des
-   résultats inconsistants</emphasis> sauf si vous forcez un ordre de
-   résultat prévisible avec <literal>ORDER BY</>. Ceci n'est pas un bogue&nbsp;;
-   c'est une conséquence inhérente du fait que le SQL ne promette par de
-   délivrer les résultats d'une requête dans un ordre particulier sauf si
-   <literal>ORDER BY</> est utilisé pour contraindre l'ordre.
+   unique. Dans le cas contraire, il est impossible de prévoir le sous-ensemble
+   de lignes qui sera retourné.
+  </para>
+
+  <para>
+   L'optimiseur de requêtes tient compte de <literal>LIMIT</> lors de la
+   génération d'un plan de requêtes. Ainsi, en fonction des valeurs précisées pour
+   <literal>LIMIT</> et <literal>OFFSET</>, différents plans seront obtenus impliquant
+   différents ordres de lignes. Sans l'utilisation de la clause <literal>ORDER BY</>
+   pour forcer l'ordre des résultats, l'emploi de valeurs <literal>LIMIT</>/<literal>OFFSET</>
+   différentes pour sélectionner des sous-ensembles différents du résultat d'une
+   requête <emphasis>donnera des résultats incohérents</emphasis>.
+   Ceci n'est pas un bogue, le SQL ne promettant pas de délivrer les résultats
+   d'une requête dans un ordre particulier en l'absence de spécifications de tri.
   </para>
  </sect1>