Relecture orthographique des paragraphes 9.15 à 9.19 inclus

postgresql/func.xml

@@ -11054,7 +11054,7 @@ transformation-table2
     Il existe des variantes de ces opérateurs pour les types <type>json</type>
     et <type>jsonb</type>. Les opérateurs d'extraction de champ/élément/chemin
     renvoient le même type de données que l'élément à gauche (soit
-    <type>json</type> soit <type>jsonb</type>), sauf pour ceux indiquant
+    <type>json</type>, soit <type>jsonb</type>), sauf pour ceux indiquant
     renvoyer du <type>text</type>, qui forcera la conversion vers le type text.
     Les opérateurs d'extraction de champ/élément/chemin renvoient NULL, plutôt
     que d'échouer, si la valeur JSON en entrée n'a pas la structure correspondant
@@ -11076,7 +11076,7 @@ transformation-table2
    <type>jsonb</type>, comme indiqué dans <xref
    linkend="functions-jsonb-op-table"/>. Plusieurs de ces opérateurs peuvent
    être indexés par les classes d'opérateur <type>jsonb</type>. Pour une
-   description complète du contenant <type>jsonb</type> et des émantiques, voir
+   description complète du contenant <type>jsonb</type> et des sémantiques, voir
    <xref linkend="json-containment"/>. <xref linkend="json-indexing"/> décrit
    comment ces opérateurs peuvent être utilisés pour indexer efficacement les
    données de type <type>jsonb</type>.
@@ -11104,7 +11104,7 @@ transformation-table2
         <entry><literal>&lt;@</literal></entry>
         <entry><type>jsonb</type></entry>
         <entry>Les entrées clefs/valeurs de la valeur JSON sont-elles
-        contenus au premier niveau de la valeur JSON de droite&nbsp;?</entry>
+        contenues au premier niveau de la valeur JSON de droite&nbsp;?</entry>
         <entry><literal>'{"b":2}'::jsonb &lt;@ '{"a":1, "b":2}'::jsonb</literal></entry>
        </row>
        <row>
@@ -11125,7 +11125,7 @@ transformation-table2
         <entry><literal>?&amp;</literal></entry>
         <entry><type>text[]</type></entry>
         <entry>Est-ce que toutes les <emphasis>chaînes</emphasis>
-        du tableau existe comme clef de premier niveau&nbsp;?</entry>
+        du tableau existent comme clef de premier niveau&nbsp;?</entry>
         <entry><literal>'["a", "b"]'::jsonb ?&amp; array['a', 'b']</literal></entry>
        </row>
        <row>
@@ -11236,11 +11236,11 @@ transformation-table2
        </para></entry>
        <entry>
          Renvoie la valeur en tant que type <type>json</type> ou <type>jsonb</type>. Les tableaux et valeurs
-         compositent sont convertis (récursivement) en tableaux et objets.
+         composites sont convertis (récursivement) en tableaux et objets.
          Dans le cas contraire, s'il existe une conversion de ce type vers le
          type <type>json</type>, la fonction de conversion sera utilisée pour
          réaliser la conversion. Dans les autres cas, une valeur scalaire est
-         produit. Pour tout type scalaire autre qu'un nombre, un booléen ou
+         produite. Pour tout type scalaire autre qu'un nombre, un booléen ou
          une valeur NULL, la représentation textuelle sera utilisée,
          de telle manière que cela soit une valeur valide pour les types
          <type>json</type> ou <type>jsonb</type>.
@@ -11254,7 +11254,7 @@ transformation-table2
        </entry>
        <entry><type>json</type></entry>
        <entry>
-         Renvoie le tableau sous la forme d'un tableau JSON. Un tableau PostgreSQL multi-dimensionnel
+         Renvoie le tableau sous la forme d'un tableau JSON. Un tableau PostgreSQL multidimensionnel
          devient un tableau JSON de tableaux. Des retours à la ligne seront
          ajoutés entre les éléments de la première dimension si <parameter>pretty_bool</parameter>
          vaut true.
@@ -11281,7 +11281,7 @@ transformation-table2
        </para></entry>
       <entry><type>json</type></entry>
        <entry>
-         Construit un table JSON de type possiblement hétérogène à partir d'une
+         Construit un tableau JSON de type possiblement hétérogène à partir d'une
          liste d'arguments variables.
        </entry>
        <entry><literal>json_build_array(1,2,'3',4,5)</literal></entry>
@@ -11309,7 +11309,7 @@ transformation-table2
          doit avoir soit exactement une dimension avec un nombre pair de
          membres, auquel cas ils sont pros comme des paires clé/valeur en
          alternance, soit deux dimensions, de telle façon que chaque tableau
-         interne contient exactement deux éléments, qui sont pris sous la forme
+         interne contienne exactement deux éléments, qui sont pris sous la forme
          d'une paire clé/valeur.
        </entry>
        <entry><para><literal>json_object('{a, 1, b, "def", c, 3.5}')</literal></para>
@@ -11346,7 +11346,7 @@ transformation-table2
     <para>
      L'extension <xref linkend="hstore"/> dispose d'une conversion du type
      <type>hstore</type> vers le type <type>json</type>, pour que les valeurs
-     <type>hstore</type> converties via les fonctions de création JSON seront
+     <type>hstore</type> converties via les fonctions de création JSON soient
      représentées en tant qu'objets JSON et non pas en tant que les valeurs
      des chaînes de caractères habituelles.
     </para>
@@ -11525,7 +11525,7 @@ transformation-table2
                <entry><type>json</type></entry>
                <entry>
                 Renvoie l'objet JSON pointé par <replaceable>path_elems</replaceable>
-                (equivalent à l'opérateur <literal>#&gt;</literal>).
+                (équivalent à l'opérateur <literal>#&gt;</literal>).
                </entry>
                <entry><literal>json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4')</literal></entry>
                <entry><literal>{"f5":99,"f6":"foo"}</literal></entry>
@@ -11538,7 +11538,7 @@ transformation-table2
                <entry>
                 Renvoie l'objet JSON pointé par <replaceable>path_elems</replaceable>
                 as <type>text</type>
-                (equivalent à l'opérateur <literal>#&gt;&gt;</literal>).
+                (équivalent à l'opérateur <literal>#&gt;&gt;</literal>).
                </entry>
                <entry><literal>json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4', 'f6')</literal></entry>
                <entry><literal>foo</literal></entry>
@@ -11718,7 +11718,7 @@ transformation-table2
          Renvoie <replaceable>target</replaceable> avec la section dont
          le chemin est désigné par <replaceable>path</replaceable>
          remplacée par <replaceable>new_value</replaceable>,
-         ou avec <replaceable>new_value</replaceable> ajouté
+         ou avec <replaceable>new_value</replaceable> ajoutée
          si <replaceable>create_missing</replaceable> est true
          (ce qui est la valeur par défaut) et l'élément
          désigné par le chemin <replaceable>path</replaceable>
@@ -11743,15 +11743,15 @@ transformation-table2
        <entry><para><type>jsonb</type></para></entry>
        <entry>
          Renvoie <replaceable>target</replaceable> avec
-         <replaceable>new_value</replaceable> inséré. Si la section
+         <replaceable>new_value</replaceable> insérée. Si la section
          <replaceable>target</replaceable> désignée par
          <replaceable>path</replaceable> est dans un tableau JSONB,
          <replaceable>new_value</replaceable> sera insérée avant la cible ou
          après la cible si <replaceable>insert_after</replaceable> vaut true
          (la valeur par défaut est <literal>false</literal>). Si la section
          <replaceable>target</replaceable> désignée par
          <replaceable>path</replaceable> est dans un objet JSONB,
-         <replaceable>new_value</replaceable> sera inséré seulement si
+         <replaceable>new_value</replaceable> sera insérée seulement si
          <replaceable>target</replaceable> n'existe pas. Tout comme avec les
          opérateurs orientés chemin, les entiers négatifs qui apparaissent
          dans <replaceable>path</replaceable> sont décomptés à partir de la
@@ -11802,7 +11802,7 @@ transformation-table2
              Unicode en chaînes JSON avec le caractère approprié. Ce n'est pas un
              problème si la valeur en entrée est de type <type>jsonb</type> parce que
              la conversion est déjà faite. Par contre, pour une valeur de type
-             <type>json</type>, cela pourrait résulter par le renvoi d'une erreur comme
+             <type>json</type>, cela pourrait résulter par le renvoi d'une erreur, comme
              indiqué dans <xref linkend="datatype-json"/>.
             </para>
            </note>
@@ -11881,7 +11881,7 @@ transformation-table2
               noms de champs dupliqués dans les objets, le résultat pourrait
               être sémantiquement quelque peu différent, dépendant de
               l'ordre dans lequel ils apparaissent. Ce n'est pas un problème
-              pour <literal>jsonb_strip_nulls</literal> car les valeurs de type
+              pour <literal>jsonb_strip_nulls</literal>, car les valeurs de type
               <type>jsonb</type> n'ont jamais des noms de champs dupliqués.
             </para>
           </note>
@@ -11917,13 +11917,13 @@ transformation-table2
 
            <para>
             Cette section décrit les fonctions opérant sur les <firstterm>objets de
-             type séquence</firstterm>, aussi appelés générateurs de séquence ou tout
-            simplement séquences). Les séquences sont des tables spéciales, mono-lignes,
+             type séquence</firstterm>, aussi appelés générateurs de séquence (ou tout
+            simplement séquences). Les séquences sont des tables spéciales, monolignes,
             créées avec la commande <xref linkend="sql-createsequence"/>. Les séquences
             sont habituellement utilisées pour générer des identifiants uniques de
             lignes d'une table. Les fonctions de séquence, listées dans le <xref
             linkend="functions-sequence-table"/>, fournissent des méthodes simples, et
-            sûres en environnement multi-utilisateurs, d'obtention de valeurs
+            sûres en environnement multiutilisateurs, d'obtention de valeurs
             successives à partir d'objets séquence.
            </para>
 
@@ -11979,7 +11979,7 @@ transformation-table2
             La séquence à traiter par l'appel d'une fonction de traitement de séquences est
             identifiée par un argument <type>regclass</type>, qui n'est autre que l'OID de la
             séquence dans le catalogue système <structname>pg_class</structname>. Il
-            n'est toutefois pas nécessaire de se préoccuper de la recherche de cet OID car
+            n'est toutefois pas nécessaire de se préoccuper de la recherche de cet OID, car
             le convertisseur de saisie du type de données <type>regclass</type> s'en
             charge. Il suffit d'écrire le nom de la séquence entre guillemets simples, de
             façon à le faire ressembler à un libellé. Pour obtenir une
@@ -12060,9 +12060,9 @@ pour trouver <literal>foo</literal></lineannotation></programlisting>
     Pour éviter le blocage de transactions concurrentes qui obtiennent des
     nombres de la même séquence, une opération <function>nextval</function>
     n'est jamais annulée&nbsp;; c'est-à-dire qu'une fois la valeur
-    récupérée, elle est considérée utilisée et ne sera jamais renvoyée de
-    nouveau. Ceci est vrai même si la transaction appelante finit par demander
-    son annulation ou si la requête appelant finit par ne pas utiliser la
+    récupérée, elle est considérée comme utilisée et ne sera jamais renvoyée de
+    nouveau. Cela est vrai même si la transaction appelante finit par demander
+    son annulation ou si la requête appelante finit par ne pas utiliser la
     valeur. Par exemple, un <command>INSERT</command> doté d'une clause
     <literal>ON CONFLICT</literal> traitera la ligne à insérer, en incluant
     tout appel requis à <function>nextval</function> avant de détecter un
@@ -12161,7 +12161,7 @@ SELECT setval('foo', 42, false);    <lineannotation>Le <function>nextval</functi
     Pour éviter le blocage de transactions concurrentes qui obtiennent des
     nombres de la même séquence, une opération <function>nextval</function>
     n'est jamais annulée&nbsp;; c'est-à-dire qu'une fois la valeur
-    récupérée, elle est considérée utilisée, même si la transaction qui exécute
+    récupérée, elle est considérée comme utilisée, même si la transaction qui exécute
     <function>nextval</function> avorte par la suite. Cela signifie que les transactions
     annulées peuvent laisser des <quote>trous</quote> inutilisés dans la
     séquence des valeurs assignées. Les opérations <function>setval</function>
@@ -12402,7 +12402,7 @@ END</synopsis>
 
    <para>
     <function>GREATEST</function> et <function>LEAST</function> ne sont pas dans le
-    standard SQL mais sont des extensions habituelles. D'autres SGBD leur imposent
+    standard SQL, mais sont des extensions habituelles. D'autres SGBD leur imposent
     de retourner NULL si l'un quelconque des arguments est NULL, plutôt que
     lorsque tous les arguments sont NULL.
    </para>
@@ -12536,10 +12536,10 @@ END</synopsis>
          <para>
           Les comparaisons de tableaux comparent les contenus des tableaux élément par
           élément, en utilisant la fonction de comparaison par défaut du B-Tree pour
-          le type de données de l'élément. Dans les tableaux multi-dimensionnels,
+          le type de données de l'élément. Dans les tableaux multidimensionnels,
           les éléments sont visités dans l'ordre des colonnes (<quote>row-major
            order</quote>, le dernier indice varie le plus rapidement).
-          Si le contenu de deux tableaux est identique mais que les dimensions sont
+          Si le contenu de deux tableaux est identique, mais que les dimensions sont
           différentes, la première différence dans l'information de dimension
           détermine l'ordre de tri. (Ce fonctionnement diffère de celui des versions de
           <productname>PostgreSQL</productname> antérieures à la 8.2&nbsp;: les
@@ -12716,7 +12716,7 @@ END</synopsis>
         </entry>
         <entry><type>int</type></entry>
         <entry>renvoie la position dans le tableau de la première
-        occurrence du second argument, en débutant la recherche par le
+        occurrence du deuxième argument, en débutant la recherche par le
         troisième argument ou au premier élément (le tableau doit
         être à une dimension)</entry>
         <entry><literal>array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon')</literal></entry>
@@ -12755,7 +12755,7 @@ END</synopsis>
              </entry>
              <entry><type>anyarray</type></entry>
              <entry>supprime tous les éléments égaux à la valeur donnée à partir
-              du table (qui doit n'avoir qu'une seule dimension)</entry>
+              du tableau (qui doit n'avoir qu'une seule dimension)</entry>
              <entry><literal>array_remove(ARRAY[1,2,3,2], 2)</literal></entry>
              <entry><literal>{1,3}</literal></entry>
             </row>
@@ -12865,15 +12865,15 @@ END</synopsis>
     Dans la fonction <function>array_positions</function>,
     <literal>NULL</literal> est renvoyé uniquement si le tableau est
     <literal>NULL</literal>&nbsp;; si la valeur n'est pas trouvée, un tableau
-    vide est renvoyée à la place.
+    vide est renvoyé à la place.
    </para>
 
    <para>
           Dans <function>string_to_array</function>, si le délimiteur vaut NULL,
           chaque caractère de la chaîne en entrée deviendra un élément séparé dans
           le tableau résultant. Si le délimiteur est une chaîne vide, alors la
           chaîne entière est renvoyée dans un tableau à un élément. Dans les autres
-          cas, la chaîne en entrée est divisée à chaque occurence du délimiteur.
+          cas, la chaîne en entrée est divisée à chaque occurrence du délimiteur.
          </para>
 
          <para>
@@ -12897,7 +12897,7 @@ END</synopsis>
          </note>
 
          <para>
-          Voir aussi <xref linkend="functions-aggregate"/> à propose la fonction
+          Voir aussi <xref linkend="functions-aggregate"/> à propos de la fonction
           d'agrégat <function>array_agg</function> à utiliser avec les tableaux.
          </para>
         </sect1>
@@ -13064,19 +13064,19 @@ END</synopsis>
          </table>
 
          <para>
-          Les opérateurs de comparaison simples <literal>&lt;</literal>,
+          Les opérateurs simples de comparaison <literal>&lt;</literal>,
           <literal>&gt;</literal>, <literal>&lt;=</literal> et
           <literal>&gt;=</literal> comparent tout d'abord les limites basses. Si
           elles sont égales, elles comparent les limites hautes. Ces comparaisons
-          ne sont généralement par très utiles pour les données de type range mais
+          ne sont généralement par très utiles pour les données de type range, mais
           sont néanmoins fournies pour permettre la construction d'index B-tree sur
           les ranges.
          </para>
 
          <para>
           Les opérateurs à gauche de/à droite de/adjacent renvoient toujours
           false quand une donnée vide de type range est fournie. Cela signifie qu'un
-          intervalle vide est toujours considéré comme n'étant ni avant ni après tout
+          intervalle vide est toujours considéré comme n'étant ni avant, ni après tout
           autre intervalle.
          </para>