Traduction des "informations d'optimisation pour les fonctions" (v12)

postgresql/xfunc.xml

@@ -3412,122 +3412,132 @@ void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
    </sect1>
 
   <sect1 id="xfunc-optimization">
-   <title>Function Optimization Information</title>
+   <title>Informations d'optimisation de fonction</title>
 
   <indexterm zone="xfunc-optimization">
-   <primary>optimization information</primary>
-   <secondary>for functions</secondary>
+   <primary>informations d'optimisation</primary>
+   <secondary>pour les functions</secondary>
   </indexterm>
 
    <para>
-    By default, a function is just a <quote>black box</quote> that the
-    database system knows very little about the behavior of.  However,
-    that means that queries using the function may be executed much less
-    efficiently than they could be.  It is possible to supply additional
-    knowledge that helps the planner optimize function calls.
+    Par défaut, une fonction est juste une <quote>boîte noire</quote>
+    dont la base de données connait très peu du comportement. De ce fait,
+    il peut arriver que les requêtes utilisant la fonction se trouvent
+    exécutées beaucoup moins efficacement qu'elles ne pourraient.
+    Il est possible de fournir une connaissance supplémentaire qui aide
+    le planificateur à optimiser les appels de fonctions.
    </para>
 
    <para>
-    Some basic facts can be supplied by declarative annotations provided in
-    the <xref linkend="sql-createfunction"/> command.  Most important of
-    these is the function's <link linkend="xfunc-volatility">volatility
-    category</link> (<literal>IMMUTABLE</literal>, <literal>STABLE</literal>,
-    or <literal>VOLATILE</literal>); one should always be careful to
-    specify this correctly when defining a function.
-    The parallel safety property (<literal>PARALLEL
-    UNSAFE</literal>, <literal>PARALLEL RESTRICTED</literal>, or
-    <literal>PARALLEL SAFE</literal>) must also be specified if you hope
-    to use the function in parallelized queries.
-    It can also be useful to specify the function's estimated execution
-    cost, and/or the number of rows a set-returning function is estimated
-    to return.  However, the declarative way of specifying those two
-    facts only allows specifying a constant value, which is often
-    inadequate.
+    Quelques indications basiques peuvent être données via les annotations
+    déclaratives présentes dans la commande <xref linkend="sql-createfunction"/>.
+    La plus importante de celles-ci est la <link linkend="xfunc-volatility">
+    catégorie de volatilité</link> (<literal>IMMUTABLE</literal>, <literal>STABLE</literal>,
+    or <literal>VOLATILE</literal>); on doit toujours être très soucieux
+    de la spécifier correctement lorsqu'on définit une fonction.
+    La propriété de sûreté face au parallélisme (<literal>PARALLEL
+    UNSAFE</literal>, <literal>PARALLEL RESTRICTED</literal>, ou
+    <literal>PARALLEL SAFE</literal>) doit également être spécifiée
+    pour espérer utiliser la fonction dans des requêtes parallélisées.
+    Il peut aussi être utile de spécifier le coût estimé de l'exécution
+    de la fonction, et le nombre de lignes qu'une fonction
+    renvoyant un ensemble d'enregistrement est estimée renvoyer.
+    Toutefois, la manière déclarative de spécifier ces deux informations
+    ne permet seulement que de donner une valeur constante, ce qui est
+    souvent inadéquat.
    </para>
 
    <para>
-    It is also possible to attach a <firstterm>planner support
-    function</firstterm> to a SQL-callable function (called
-    its <firstterm>target function</firstterm>), and thereby provide
-    knowledge about the target function that is too complex to be
-    represented declaratively.  Planner support functions have to be
-    written in C (although their target functions might not be), so this is
-    an advanced feature that relatively few people will use.
+    Il est aussi possible de rattacher une <firstterm>fonction
+    de support de planification</firstterm> à une fonction appelable
+    en SQL (appelée <firstterm>fonction cible</firstterm>), et
+    ainsi de fournir sur la fonction cible une connaissance
+    qui serait trop complexe à être représentée déclarativement.
+    Les fonctions de support de planification doivent être écrites en
+    C (alors que leurs fonctions cibles peuvent ne pas l'être), ce qui en
+    fait une fonctionnalité avancée que relativement peu de personnes
+    utiliseront.
    </para>
 
    <para>
-    A planner support function must have the SQL signature
+    Une fonction de support de planification doit avoir la signature SQL
 <programlisting>
 supportfn(internal) returns internal
 </programlisting>
-    It is attached to its target function by specifying
-    the <literal>SUPPORT</literal> clause when creating the target function.
+    Elle est rattachée à sa fonction cible en spécifiant la clause
+    <literal>SUPPORT</literal> dans la création de la fonction cible.
    </para>
 
    <para>
-    The details of the API for planner support functions can be found in
-    file <filename>src/include/nodes/supportnodes.h</filename> in the
-    <productname>PostgreSQL</productname> source code.  Here we provide
-    just an overview of what planner support functions can do.
-    The set of possible requests to a support function is extensible,
-    so more things might be possible in future versions.
+    Les détails de l'API des fonctions de support de planification
+    se trouvent dans le fichier
+    <filename>src/include/nodes/supportnodes.h</filename> dans le code
+    source de <productname>PostgreSQL</productname>. Ici on ne fournit
+    qu'une vue d'ensemble de ce que les fonctions de support de planification
+    peuvent faire.
+    L'ensemble des demandes possibles adressables à une fonction de support
+    est extensible, si bien que d'autres choses seront possibles dans
+    des versions ultérieures.
    </para>
 
    <para>
-    Some function calls can be simplified during planning based on
-    properties specific to the function.  For example,
-    <literal>int4mul(n, 1)</literal> could be simplified to
-    just <literal>n</literal>.  This type of transformation can be
-    performed by a planner support function, by having it implement
-    the <literal>SupportRequestSimplify</literal> request type.
-    The support function will be called for each instance of its target
-    function found in a query parse tree.  If it finds that the particular
-    call can be simplified into some other form, it can build and return a
-    parse tree representing that expression.  This will automatically work
-    for operators based on the function, too &mdash; in the example just
-    given, <literal>n * 1</literal> would also be simplified to
-    <literal>n</literal>.
-    (But note that this is just an example; this particular
-    optimization is not actually performed by
-    standard <productname>PostgreSQL</productname>.)
-    We make no guarantee that <productname>PostgreSQL</productname> will
-    never call the target function in cases that the support function could
-    simplify.  Ensure rigorous equivalence between the simplified
-    expression and an actual execution of the target function.
+    Certains appels de fonctions peuvent être simplifiés lors de la
+    planification en se basant sur les propriétés spécifiques de la fonction.
+    Par exemple, <literal>int4mul(n, 1)</literal> pourrait être simplifié par
+    <literal>n</literal>. Ce type de transformation peut être exécuté
+    par une fonction de support de planification, en lui faisant implémenter
+    le type de demande <literal>SupportRequestSimplify</literal>.
+    La fonction de support va être appelée pour chaque instance de la
+    fonction cible trouvée dans l'arbre d'analyse de la requête.
+    Si elle trouve qu'un appel particulier peut être simplifié en
+    une autre forme, elle est capable de construire et renvoyer
+    un arbre d'analyse représentant cette expression. Cela fonctionnera
+    automatiquement pour les opérateurs basés sur cette fonction,
+    également &mdash; dans l'exemple juste ci-dessus, <literal>n * 1</literal>
+    serait aussi simplifié en <literal>n</literal>.
+    (Mais notez que c'est juste un exemple; cette optimisation particulière
+    n'est pas réellement mise en oeuvre par <productname>PostgreSQL</productname>.)
+    Nous ne garantissons pas que <productname>PostgreSQL</productname> n'appelera
+    jamais la fonction cible dans les cas que la fonction de support pourrait
+    simplifier. Assurez-vous d'une équivalence rigoureuse entre l'expression
+    simplifiée et l'exécution réelle de la fonction cible.
    </para>
 
    <para>
-    For target functions that return boolean, it is often useful to estimate
-    the fraction of rows that will be selected by a WHERE clause using that
-    function.  This can be done by a support function that implements
-    the <literal>SupportRequestSelectivity</literal> request type.
+    Pour les fonctions cible qui renvoient un booléean, il est souvent utile
+    d'estimer la fraction des lignes qui vont être sélectionnées par une clause
+    WHERE utilisant cette fonction. Ceci réalisable avec une fonction de support
+    qui implémente le type de demande <literal>SupportRequestSelectivity</literal>.
    </para>
 
    <para>
-    If the target function's runtime is highly dependent on its inputs,
-    it may be useful to provide a non-constant cost estimate for it.
-    This can be done by a support function that implements
-    the <literal>SupportRequestCost</literal> request type.
+    Si le temps d'exécution d'une fonction cible est très dépendant
+    de ses entrées, il peut être utile de fournir un coût d'exécution
+    non constant pour celle-ci.
+    Ceci est réalisable avec une fonction de support implémentant
+    le type de demande <literal>SupportRequestCost</literal>.
    </para>
 
    <para>
-    For target functions that return sets, it is often useful to provide
-    a non-constant estimate for the number of rows that will be returned.
-    This can be done by a support function that implements
-    the <literal>SupportRequestRows</literal> request type.
+    Pour les fonctions cibles qui renvoient des ensembles de lignes,
+    il est souvent utile de fournir une estimation non constante du
+    nombre de lignes renvoyées.
+    Ceci est réalisable avec une fonction de support implémentant
+    le type de demande <literal>SupportRequestRows</literal>.
    </para>
 
    <para>
-    For target functions that return boolean, it may be possible to
-    convert a function call appearing in WHERE into an indexable operator
-    clause or clauses.  The converted clauses might be exactly equivalent
-    to the function's condition, or they could be somewhat weaker (that is,
-    they might accept some values that the function condition does not).
-    In the latter case the index condition is said to
-    be <firstterm>lossy</firstterm>; it can still be used to scan an index,
-    but the function call will have to be executed for each row returned by
-    the index to see if it really passes the WHERE condition or not.
-    To create such conditions, the support function must implement
-    the <literal>SupportRequestIndexCondition</literal> request type.
+    Pour les fonctions cibles qui renvoient un booléean, il est envisageable
+    de convertir un appel de fonction au niveau d'un WHERE vers une ou
+    plusieurs clauses d'un opérateur indexable. Ces clauses peuvent être
+    exactement équivalentes à la condition de la fonction, ou bien elle peuvent
+    être plus faibles (c'est-à-dire qu'elles peuvent accepter certaines
+    valeurs que la condition via la fonction n'accepte pas).
+    Dans ce dernier cas, la condition d'index est dite
+    <firstterm>avec perte</firstterm>; elle peut toujours être utilisée
+    pour un parcours d'index, mais la fonction devra être appelée pour chaque
+    ligne renvoyée par l'index pour vérifier qu'elle satisfait la condition WHERE.
+    Pour créer de telles conditions, la fonction de support doit implémenter
+    le type de demande <literal>SupportRequestIndexCondition</literal>.
    </para>
   </sect1>