func.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- Dernière modification
     le       $Date$
     par      $Author$
     révision $Revision$ -->

 <chapter id="functions">
  <title>Fonctions et opérateurs</title>

  <indexterm zone="functions">
   <primary>fonction</primary>
  </indexterm>

  <indexterm zone="functions">
   <primary>opérateur</primary>
  </indexterm>

  <para>
   <productname>PostgreSQL</productname> fournit un grand nombre de fonctions
   et d'opérateurs pour les types de données intégrés. Les utilisateurs peuvent
   aussi définir leurs propres fonctions et opérateurs comme décrit dans
   la <xref linkend="server-programming"/>.
  </para>
  <para>
   Les commandes <command>\df</command> et
   <command>\do</command> de <application>psql</application> sont utilisées
   pour afficher respectivement la liste des fonctions et des
   opérateurs.
  </para>

  <para>
   Du point de vue de la portabilité, il faut savoir que la
   plupart des fonctions et opérateurs décrits dans ce chapitre, à l'exception des opérateurs
   arithmétiques et logiques les plus triviaux et de quelques fonctions
   spécifiquement indiquées, ne font pas partie du standard
   <acronym>SQL</acronym>. Quelques fonctionnalités étendues sont
   présentes dans d'autres systèmes de gestion de bases de données
   <acronym>SQL</acronym> et dans la plupart des cas, ces fonctionnalités sont
   compatibles et cohérentes à de nombreuses implantations. Ce chapitre n'est
   pas exhaustif&nbsp;; des fonctions supplémentaires apparaissent dans les
   sections adéquates du manuel.
  </para>


  <sect1 id="functions-logical">
   <title>Opérateurs logiques</title>

   <indexterm zone="functions-logical">
    <primary>opérateur</primary>
    <secondary>logique</secondary>
   </indexterm>

   <indexterm>
    <primary>booléen</primary>
    <secondary>opérateurs</secondary>
    <see>opérateurs, logique</see>
   </indexterm>

   <para>
    Opérateurs logiques habituels&nbsp;:

    <indexterm>
     <primary>AND (opérateur)</primary>
    </indexterm>

    <indexterm>
     <primary>OR (opérateur)</primary>
    </indexterm>

    <indexterm>
     <primary>NOT (opérateur)</primary>
    </indexterm>

    <indexterm>
     <primary>conjonction</primary>
    </indexterm>

    <indexterm>
     <primary>disjonction</primary>
    </indexterm>

    <indexterm>
     <primary>négation</primary>
    </indexterm>

    <simplelist>
     <member><literal>AND</literal></member>
     <member><literal>OR</literal></member>
     <member><literal>NOT</literal></member>
    </simplelist>

    <acronym>SQL</acronym> utilise une logique booléenne à trois valeurs dans
    laquelle la valeur NULL représente <quote>inconnu</quote>. Les tables de
     vérité à considérer sont les suivantes&nbsp;:

    <informaltable>
     <tgroup cols="4">
      <thead>
       <row>
        <entry><replaceable>a</replaceable></entry>
        <entry><replaceable>b</replaceable></entry>
        <entry><replaceable>a</replaceable> AND
<replaceable>b</replaceable></entry>
        <entry><replaceable>a</replaceable> OR
<replaceable>b</replaceable></entry>
       </row>
      </thead>

      <tbody>
       <row>
        <entry>TRUE</entry>
        <entry>TRUE</entry>
        <entry>TRUE</entry>
        <entry>TRUE</entry>
       </row>

       <row>
        <entry>TRUE</entry>
        <entry>FALSE</entry>
        <entry>FALSE</entry>
        <entry>TRUE</entry>
       </row>

       <row>
        <entry>TRUE</entry>
        <entry>NULL</entry>
        <entry>NULL</entry>
        <entry>TRUE</entry>
       </row>

       <row>
        <entry>FALSE</entry>
        <entry>FALSE</entry>
        <entry>FALSE</entry>
        <entry>FALSE</entry>
       </row>

       <row>
        <entry>FALSE</entry>
        <entry>NULL</entry>
        <entry>FALSE</entry>
        <entry>NULL</entry>
       </row>

       <row>
        <entry>NULL</entry>
        <entry>NULL</entry>
        <entry>NULL</entry>
        <entry>NULL</entry>
       </row>
      </tbody>
     </tgroup>
    </informaltable>

    <informaltable>
     <tgroup cols="2">
      <thead>
       <row>
        <entry><replaceable>a</replaceable></entry>
        <entry>NOT <replaceable>a</replaceable></entry>
       </row>
      </thead>

      <tbody>
       <row>
        <entry>TRUE</entry>
        <entry>FALSE</entry>
       </row>

       <row>
        <entry>FALSE</entry>
        <entry>TRUE</entry>
       </row>

       <row>
        <entry>NULL</entry>
        <entry>NULL</entry>
       </row>
      </tbody>
     </tgroup>
    </informaltable>
   </para>

   <para>
    Les opérateurs <literal>AND</literal> et <literal>OR</literal> sont
    commutatifs, la permutation des opérandes gauche et
    droit n'affecte pas le résultat. Voir la <xref
    linkend="syntax-express-eval"/> pour plus d'informations sur l'ordre
    d'évaluation des sous-expressions.
   </para>
  </sect1>

  <sect1 id="functions-comparison">
   <title>Opérateurs de comparaison</title>

   <indexterm zone="functions-comparison">
    <primary>comparaison</primary>
    <secondary>opérateurs</secondary>
   </indexterm>

   <para>
    Les opérateurs de comparaison habituels sont disponibles, comme l'indique
    le <xref linkend="functions-comparison-table"/>.
   </para>

   <table id="functions-comparison-table">
    <title>Opérateurs de comparaison</title>
    <tgroup cols="2">
     <thead>
      <row>
       <entry>Opérateur</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal>&lt;</literal> </entry>
       <entry>inférieur à</entry>
      </row>

      <row>
       <entry><literal>&gt;</literal> </entry>
       <entry>supérieur à</entry>
      </row>

      <row>
       <entry><literal>&lt;=</literal> </entry>
       <entry>inférieur ou égal à</entry>
      </row>

      <row>
       <entry><literal>&gt;=</literal> </entry>
       <entry>supérieur ou égal à</entry>
      </row>

      <row>
       <entry><literal>=</literal> </entry>
       <entry>égal à</entry>
      </row>

      <row>
       <entry><literal>&lt;&gt;</literal> ou <literal>!=</literal> </entry>
       <entry>différent de</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <note>
    <para>
     L'opérateur <literal>!=</literal> est converti en
     <literal>&lt;&gt;</literal> au moment de l'analyse. Il n'est pas possible
     d'implanter des opérateurs <literal>!=</literal> et
     <literal>&lt;&gt;</literal> réalisant des opérations différentes.
    </para>
   </note>

   <para>
    Les opérateurs de comparaison sont disponibles pour tous les types de
    données pour lesquels cela a du sens. Tous les opérateurs de comparaison sont des
    opérateurs binaires renvoyant des valeurs du type <type>boolean</type>&nbsp;;
    des expressions comme <literal>1 &lt; 2 &lt; 3</literal> ne sont pas valides
    (car il n'existe pas d'opérateur <literal>&lt;</literal> de comparaison d'une
    valeur booléenne avec <literal>3</literal>).
   </para>

   <para>
    <indexterm>
     <primary>BETWEEN</primary>
    </indexterm>
    En plus des opérateurs de comparaison, on trouve la construction spéciale
    <token>BETWEEN</token>.
<synopsis><replaceable>a</replaceable> BETWEEN <replaceable>x</replaceable> AND <replaceable>y</replaceable></synopsis>
    est équivalent à
<synopsis><replaceable>a</replaceable> &gt;= <replaceable>x</replaceable> AND <replaceable>a</replaceable> &lt;= <replaceable>y</replaceable></synopsis>
    Notez que <token>BETWEEN</token> traite le point final comme inclut dans
    l'échelle des valeurs. <literal>NOT BETWEEN</literal> fait la comparaison
    inverse&nbsp;:
<synopsis><replaceable>a</replaceable> NOT BETWEEN <replaceable>x</replaceable> AND <replaceable>y</replaceable></synopsis>
    est équivalent à
<synopsis><replaceable>a</replaceable> &lt; <replaceable>x</replaceable> OR <replaceable>a</replaceable> &gt; <replaceable>y</replaceable></synopsis>
    <indexterm>
     <primary>BETWEEN SYMMETRIC</primary>
    </indexterm>
    <literal>BETWEEN SYMMETRIC</literal> est identique à <literal>BETWEEN</literal> sauf qu'il
    n'est pas nécessaire que l'argument à gauche de <literal>AND</literal> soit plus
    petit ou égal à l'argument à droite. SI ce n'est pas le cas, ces deux arguments sont
    automatiquement inversés, pour qu'une échelle non vide soit toujours supposée.
   </para>

   <para>
   <indexterm>
     <primary>IS NULL</primary>
   </indexterm>
   <indexterm>
     <primary>IS NOT NULL</primary>
   </indexterm>
   <indexterm>
     <primary>ISNULL</primary>
   </indexterm>
   <indexterm>
     <primary>NOTNULL</primary>
   </indexterm>
    Pour vérifier si une valeur est NULL ou non, on utilise les constructions
<synopsis><replaceable>expression</replaceable> IS NULL
<replaceable>expression</replaceable> IS NOT NULL</synopsis>
    ou la construction équivalente, non standard,
<synopsis><replaceable>expression</replaceable> ISNULL
<replaceable>expression</replaceable> NOTNULL</synopsis>
    <indexterm><primary>valeur NULL</primary><secondary>comparaison</secondary></indexterm>
   </para>

   <para>
    On <emphasis>ne</emphasis> peut <emphasis>pas</emphasis> écrire
    <literal><replaceable>expression</replaceable> = NULL</literal>
    parce que <literal>NULL</literal> n'est pas <quote>égal à</quote>
    <literal>NULL</literal>. (La valeur NULL représente une valeur inconnue
    et il est impossible de dire si deux valeurs inconnues sont égales.) Ce
    comportement est conforme au standard SQL.
   </para>

   <tip>
   <para>
    Il se peut que des applications s'attendent à voir 
    <literal><replaceable>expression</replaceable> = NULL</literal>
    évaluée à vrai (<foreignphrase>true</foreignphrase>) si <replaceable>expression</replaceable> s'évalue comme
    la valeur NULL. Il est chaudement recommandé que ces applications
    soient modifiées pour se conformer au standard SQL. Néanmoins, si cela
    n'est pas possible, le paramètre de configuration <xref
    linkend="guc-transform-null-equals"/> peut être utilisé. S'il est activé,
    <productname>PostgreSQL</productname> convertit les clauses <literal>x =
    NULL</literal> en <literal>x IS NULL</literal>.
   </para>
   </tip>

<!-- SAS 20080716 : quid si la ligne n'est pas nulle, mais que certains champs,
seulement le sont ? -->
  <note>
   <para>
    Si l'<replaceable>expression</replaceable> est une valeur de ligne, alors
    <literal>IS NULL</literal> est vrai quand l'expression même de la ligne est
    NULL ou quand tous les champs de la ligne sont NULL alors que
    <literal>IS NOT NULL</literal> est vrai quand l'expression même de la ligne
    est non NULL et que tous les champs de la ligne sont non NULL. À cause de
    ce comportement, <literal>IS NULL</literal> et <literal>IS NOT NULL</literal>
    ne renvoient pas toujours des résultats inversés pour les expressions de
    lignes, c'est-à-dire une expression de ligne qui contient à la fois des
    valeurs NULL et des valeurs non NULL retournera faux pour les deux tests.
    Cette définition, conforme au standard SQL, est une modification du
    comportement incohérent des versions de <productname>PostgreSQL</productname>
    antérieures à la 8.2.
   </para>
  </note>

   <para>
   <indexterm>
     <primary>IS DISTINCT FROM</primary>
   </indexterm>
   <indexterm>
     <primary>IS NOT DISTINCT FROM</primary>
   </indexterm>
    L'opérateur standard de comparaison renvoie NULL (ce qui signifie
    <quote>inconnu</quote>) si l'une des entrées est NULL, ni true ni false,
    c'est-à-dire <literal>7 = NULL</literal> renvoie NULL. Quand ce comportement
    n'est pas convenable, utilisez la syntaxe <literal>IS
    <optional>NOT</optional> DISTINCT FROM</literal>&nbsp;:
<synopsis>
<replaceable>expression</replaceable> IS DISTINCT FROM <replaceable>expression</replaceable>
<replaceable>expression</replaceable> IS NOT DISTINCT FROM <replaceable>expression</replaceable>
</synopsis>
    Pour des entrées non NULL, <literal>IS DISTINCT FROM</literal> est
    identique à l'opérateur <literal>&lt;&gt;</literal>. Cependant, si les deux entrées
    sont NULL, alors cela retourne faux et si une des deux entrées est NULL,
    alors cela retourne vrai. De la même façon, <literal>IS NOT DISTINCT
    FROM</literal> est identique à <literal>=</literal> pour les entrées non NULL
    mais il renvoie true si les deux entrées sont NULL et false quand une seule
    est NULL. Dans ces constructions, NULL n'est plus considéré comme
    un état inconnu mais comme une valeur.
   </para>

   <para>
   <indexterm>
     <primary>IS TRUE</primary>
   </indexterm>
   <indexterm>
     <primary>IS NOT TRUE</primary>
   </indexterm>
   <indexterm>
     <primary>IS FALSE</primary>
   </indexterm>
   <indexterm>
     <primary>IS NOT FALSE</primary>
   </indexterm>
   <indexterm>
     <primary>IS UNKNOWN</primary>
   </indexterm>
   <indexterm>
     <primary>IS NOT UNKNOWN</primary>
   </indexterm>
    Les valeurs booléennes peuvent aussi être testées en utilisant les
    constructions
<synopsis><replaceable>expression</replaceable> IS TRUE
<replaceable>expression</replaceable> IS NOT TRUE
<replaceable>expression</replaceable> IS FALSE
<replaceable>expression</replaceable> IS NOT FALSE
<replaceable>expression</replaceable> IS UNKNOWN
<replaceable>expression</replaceable> IS NOT UNKNOWN</synopsis>
    Elles retournent toujours true ou false, jamais une valeur NULL, même si
    l'opérande est NULL. Une entrée NULL est traitée comme la valeur logique
    <quote>inconnue</quote>. <literal>IS UNKNOWN</literal> et <literal>IS
    NOT UNKNOWN</literal> sont réellement identiques à <literal>IS NULL</literal> et
    <literal>IS NOT NULL</literal>, respectivement, sauf que l'expression en
    entrée doit être de type booléen.
   </para>
 
<!-- IS OF does not conform to the ISO SQL behavior, so it is undocumented here
   <para>
    <indexterm>
     <primary>IS OF</primary>
    </indexterm>
    <indexterm>
     <primary>IS NOT OF</primary>
    </indexterm>
    It is possible to check the data type of an expression using the
    constructs
<synopsis>
<replaceable>expression</replaceable> IS OF (typename, ...)
<replaceable>expression</replaceable> IS NOT OF (typename, ...)
</synopsis>
    They return a boolean value based on whether the expression's data
    type is one of the listed data types.
   </para>
-->

  </sect1>

  <sect1 id="functions-math">
   <title>Fonctions et opérateurs mathématiques</title>

   <para>
    Des opérateurs mathématiques sont fournis pour un grand nombre de types
    <productname>PostgreSQL</productname>. Pour les types sans conventions
    mathématiques standards (les types dates/time, par exemple), le
    comportement réel est décrit dans les sections appropriées.
   </para>

   <para>
    Le <xref linkend="functions-math-op-table"/> affiche les opérateurs
    mathématiques disponibles.
   </para>

   <table id="functions-math-op-table">
    <title>Opérateurs mathématiques</title>

    <tgroup cols="4">
     <colspec colnum="1" colwidth="1*"/>
     <colspec colnum="2" colwidth="2*"/>
     <colspec colnum="3" colwidth="1*"/>
     <colspec colnum="4" colwidth="1*"/>
     <thead>
      <row>
       <entry>Opérateur</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal>+</literal> </entry>
       <entry>addition</entry>
       <entry><literal>2 + 3</literal></entry>
       <entry><literal>5</literal></entry>
      </row>

      <row>
       <entry><literal>-</literal> </entry>
       <entry>soustraction</entry>
       <entry><literal>2 - 3</literal></entry>
       <entry><literal>-1</literal></entry>
      </row>

      <row>
       <entry><literal>*</literal> </entry>
       <entry>multiplication</entry>
       <entry><literal>2 * 3</literal></entry>
       <entry><literal>6</literal></entry>
      </row>

      <row>
       <entry><literal>/</literal> </entry>
       <entry>division (la division entière tronque les résultats)</entry>
       <entry><literal>4 / 2</literal></entry>
       <entry><literal>2</literal></entry>
      </row>

      <row>
       <entry><literal>%</literal> </entry>
       <entry>modulo (reste)</entry>
       <entry><literal>5 % 4</literal></entry>
       <entry><literal>1</literal></entry>
      </row>

      <row>
       <entry><literal>^</literal> </entry>
       <entry>exponentiel</entry>
       <entry><literal>2.0 ^ 3.0</literal></entry>
       <entry><literal>8</literal></entry>
      </row>

      <row>
       <entry><literal>|/</literal> </entry>
       <entry>racine carrée</entry>
       <entry><literal>|/ 25.0</literal></entry>
       <entry><literal>5</literal></entry>
      </row>

      <row>
       <entry><literal>||/</literal> </entry>
       <entry>racine cubique</entry>
       <entry><literal>||/ 27.0</literal></entry>
       <entry><literal>3</literal></entry>
      </row>

      <row>
       <entry><literal>!</literal> </entry>
       <entry>factoriel</entry>
       <entry><literal>5 !</literal></entry>
       <entry><literal>120</literal></entry>
      </row>

      <row>
       <entry><literal>!!</literal> </entry>
       <entry>factoriel (opérateur préfixe)</entry>
       <entry><literal>!! 5</literal></entry>
       <entry><literal>120</literal></entry>
      </row>

      <row>
       <entry><literal>@</literal> </entry>
       <entry>valeur absolue</entry>
       <entry><literal>@ -5.0</literal></entry>
       <entry><literal>5</literal></entry>
      </row>

      <row>
       <entry><literal>&amp;</literal> </entry>
       <entry>AND bit à bit</entry>
       <entry><literal>91 &amp; 15</literal></entry>
       <entry><literal>11</literal></entry>
      </row>

      <row>
       <entry><literal>|</literal> </entry>
       <entry>OR bit à bit</entry>
       <entry><literal>32 | 3</literal></entry>
       <entry><literal>35</literal></entry>
      </row>

      <row>
       <entry><literal>#</literal> </entry>
       <entry>XOR bit à bit</entry>
       <entry><literal>17 # 5</literal></entry>
       <entry><literal>20</literal></entry>
      </row>

      <row>
       <entry><literal>~</literal> </entry>
       <entry>NOT bit à bit</entry>
       <entry><literal>~1</literal></entry>
       <entry><literal>-2</literal></entry>
      </row>

      <row>
       <entry><literal>&lt;&lt;</literal> </entry>
       <entry>décalage gauche</entry>
       <entry><literal>1 &lt;&lt; 4</literal></entry>
       <entry><literal>16</literal></entry>
      </row>

      <row>
       <entry><literal>&gt;&gt;</literal> </entry>
       <entry>décalage droit</entry>
       <entry><literal>8 &gt;&gt; 2</literal></entry>
       <entry><literal>2</literal></entry>
      </row>

     </tbody>
    </tgroup>
   </table>

   <para>
    Les opérateurs bit à bit ne fonctionnent que sur les types de données
    entiers alors que les autres sont disponibles pour tous les types de
    données numériques. Les opérateurs bit à bit sont aussi disponibles pour
    les types de chaînes de bits <type>bit</type> et <type>bit varying</type>
    comme le montre le <xref linkend="functions-bit-string-op-table"/>.
   </para>

  <para>
   Le <xref linkend="functions-math-func-table"/> affiche les fonctions
   mathématiques disponibles. Dans ce tableau, <literal>dp</literal>
   signifie <type>double precision</type>. Beaucoup de ces fonctions sont
   fournies dans de nombreuses formes avec différents types d'argument.
   Sauf précision contraire, toute forme donnée d'une fonction renvoie le
   même type de données que son argument.
   Les fonctions utilisant des données de type <type>double
   precision</type> sont pour la plupart implantées avec la bibliothèque C du
   système hôte&nbsp;; la précision et le comportement dans les cas
   particuliers peuvent varier en fonction du système hôte.
  </para>

   <indexterm>
    <primary>abs</primary>
   </indexterm>
   <indexterm>
    <primary>cbrt</primary>
   </indexterm>
   <indexterm>
    <primary>ceiling</primary>
   </indexterm>
   <indexterm>
    <primary>degrees</primary>
   </indexterm>
   <indexterm>
    <primary>div</primary>
   </indexterm>
   <indexterm>
    <primary>exp</primary>
   </indexterm>
   <indexterm>
    <primary>floor</primary>
   </indexterm>
   <indexterm>
    <primary>ln</primary>
   </indexterm>
   <indexterm>
    <primary>log</primary>
   </indexterm>
   <indexterm>
    <primary>mod</primary>
   </indexterm>
   <indexterm>
    <primary>&pi;</primary>
   </indexterm>
   <indexterm>
    <primary>power</primary>
   </indexterm>
   <indexterm>
    <primary>radians</primary>
   </indexterm>
   <indexterm>
    <primary>random</primary>
   </indexterm>
   <indexterm>
    <primary>round</primary>
   </indexterm>
   <indexterm>
    <primary>setseed</primary>
   </indexterm>
   <indexterm>
    <primary>sign</primary>
   </indexterm>
   <indexterm>
    <primary>sqrt</primary>
   </indexterm>
   <indexterm>
    <primary>trunc</primary>
   </indexterm>
   <indexterm>
    <primary>width_bucket</primary>
   </indexterm>

   <table id="functions-math-func-table">
    <title>Fonctions mathématiques</title>
    <tgroup cols="5">
     <colspec colnum="1" colwidth="0.7*"/>
     <colspec colnum="2" colwidth="1*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1*"/>
     <colspec colnum="5" colwidth="1*"/>
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Type renvoyé</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>
      </row>
     </thead>

     <tbody>
      <row>
      
<entry><literal><function>abs</function>(<replaceable>x</replaceable>)</literal></entry>
       <entry>(identique à l'entrée)</entry>
       <entry>valeur absolue</entry>
       <entry><literal>abs(-17.4)</literal></entry>
       <entry><literal>17.4</literal></entry>
      </row>

      <row>
      
<entry><literal><function>cbrt</function>(<type>dp</type>)</literal></entry>
       <entry><type>dp</type></entry>
       <entry>racine cubique</entry>
       <entry><literal>cbrt(27.0)</literal></entry>
       <entry><literal>3</literal></entry>
      </row>

      <row>
       <entry><literal><function>ceil</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>plus petit entier supérieur à l'argument</entry>
       <entry><literal>ceil(-42.8)</literal></entry>
       <entry><literal>-42</literal></entry>
      </row>


      <row>
       <entry><literal><function>ceiling</function>(<type>dp</type> ou <type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>plus petit entier supérieur à l'argument (alias de
         <function>ceil</function>)</entry>
       <entry><literal>ceiling(-95.3)</literal></entry>
       <entry><literal>-95</literal></entry>
      </row>

      <row>
<entry><literal><function>degrees</function>(<type>dp</type>)</literal></entry>
       <entry><type>dp</type></entry>
       <entry>radians vers degrés</entry>
       <entry><literal>degrees(0.5)</literal></entry>
       <entry><literal>28.6478897565412</literal></entry>
      </row>

      <row>
       <entry><literal><function>div</function>(<parameter>y</parameter> <type>numeric</type>,
        <parameter>x</parameter> <type>numeric</type>)</literal></entry>
       <entry><type>numeric</type></entry>
       <entry>quotient entier de <parameter>y</parameter>/<parameter>x</parameter></entry>
       <entry><literal>div(9,4)</literal></entry>
       <entry><literal>2</literal></entry>
      </row>

      <row>
       <entry><literal><function>exp</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>exponentiel</entry>
       <entry><literal>exp(1.0)</literal></entry>
       <entry><literal>2.71828182845905</literal></entry>
      </row>

      <row>
       <entry><literal><function>floor</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>plus grand entier inférieur à l'argument</entry>
       <entry><literal>floor(-42.8)</literal></entry>
       <entry><literal>-43</literal></entry>
      </row>

      <row>
       <entry><literal><function>ln</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>logarithme</entry>
       <entry><literal>ln(2.0)</literal></entry>
       <entry><literal>0.693147180559945</literal></entry>
      </row>

      <row>
       <entry><literal><function>log</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>logarithme base 10</entry>
       <entry><literal>log(100.0)</literal></entry>
       <entry><literal>2</literal></entry>
      </row>

      <row>
       <entry><literal><function>log</function>(<parameter>b</parameter>
<type>numeric</type>,
        <parameter>x</parameter> <type>numeric</type>)</literal></entry>
       <entry><type>numeric</type></entry>
       <entry>logarithme en base <parameter>b</parameter></entry>
       <entry><literal>log(2.0, 64.0)</literal></entry>
       <entry><literal>6.0000000000</literal></entry>
      </row>

      <row>
       <entry><literal><function>mod</function>(<parameter>y</parameter>,
        <parameter>x</parameter>)</literal></entry>
       <entry>(identique au type des arguments)</entry>
       <entry>reste de
<parameter>y</parameter>/<parameter>x</parameter></entry>
       <entry><literal>mod(9,4)</literal></entry>
       <entry><literal>1</literal></entry>
      </row>

      <row>
       <entry><literal><function>pi</function>()</literal></entry>
       <entry><type>dp</type></entry>
       <entry>constante <quote>&pi;</quote></entry>
       <entry><literal>pi()</literal></entry>
       <entry><literal>3.14159265358979</literal></entry>
      </row>

      <row>
       <entry><literal><function>power</function>(<parameter>a</parameter>
<type>dp</type>,
        <parameter>b</parameter> <type>dp</type>)</literal></entry>
       <entry><type>dp</type></entry>
       <entry><parameter>a</parameter> élevé à la puissance
<parameter>b</parameter></entry>
       <entry><literal>power(9.0, 3.0)</literal></entry>
       <entry><literal>729</literal></entry>
      </row>

      <row>
       <entry><literal><function>power</function>(<parameter>a</parameter>
<type>numeric</type>,
        <parameter>b</parameter> <type>numeric</type>)</literal></entry>
       <entry><type>numeric</type></entry>
       <entry><parameter>a</parameter> élevé à la puissance
<parameter>b</parameter></entry>
       <entry><literal>power(9.0, 3.0)</literal></entry>
       <entry><literal>729</literal></entry>
      </row>

      <row>
      
<entry><literal><function>radians</function>(<type>dp</type>)</literal></entry>
       <entry><type>dp</type></entry>
       <entry>degrés vers radians</entry>
       <entry><literal>radians(45.0)</literal></entry>
       <entry><literal>0.785398163397448</literal></entry>
      </row>

      <row>
       <entry><literal><function>random</function>()</literal></entry>
       <entry><type>dp</type></entry>
       <entry>valeur au hasard entre 0.0 (compris) et 1.0 (non compris)</entry>
       <entry><literal>random()</literal></entry>
       <entry></entry>
      </row>

      <row>
       <entry><literal><function>round</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>arrondi à l'entier le plus proche</entry>
       <entry><literal>round(42.4)</literal></entry>
       <entry><literal>42</literal></entry>
      </row>

      <row>
       <entry><literal><function>round</function>(<parameter>v</parameter>
<type>numeric</type>, <parameter>s</parameter>
<type>int</type>)</literal></entry>
       <entry><type>numeric</type></entry>
       <entry>arrondi pour <parameter>s</parameter> décimales</entry>
       <entry><literal>round(42.4382, 2)</literal></entry>
       <entry><literal>42.44</literal></entry>
      </row>

<!-- random seed : nombre servant à initialiser une séquence aléatoire -->
      <row>
       <entry><literal><function>setseed</function>(<type>dp</type>)</literal></entry>
       <entry><type>void</type></entry>
       <entry>initialise les appels à
       <literal>random()</literal> à suivre
        (valeur entre -1.0 et 1.0, inclusif)</entry>
       <entry><literal>setseed(0.54823)</literal></entry>
       <entry><literal></literal></entry>
      </row>

      <row>
       <entry><literal><function>sign</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>signe de l'argument (-1, 0, +1)</entry>
       <entry><literal>sign(-8.4)</literal></entry>
       <entry><literal>-1</literal></entry>
      </row>

      <row>
       <entry><literal><function>sqrt</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>racine carré</entry>
       <entry><literal>sqrt(2.0)</literal></entry>
       <entry><literal>1.4142135623731</literal></entry>
      </row>

      <row>
       <entry><literal><function>trunc</function>(<type>dp</type> ou
<type>numeric</type>)</literal></entry>
       <entry>(identique à l'argument)</entry>
       <entry>tronque vers zéro</entry>
       <entry><literal>trunc(42.8)</literal></entry>
       <entry><literal>42</literal></entry>
      </row>

      <row>
       <entry><literal><function>trunc</function>(<parameter>v</parameter>
<type>numeric</type>, <parameter>s</parameter>
<type>int</type>)</literal></entry>
       <entry><type>numeric</type></entry>
       <entry>tronque sur <parameter>s</parameter> décimales</entry>
       <entry><literal>trunc(42.4382, 2)</literal></entry>
       <entry><literal>42.43</literal></entry>
      </row>

<!-- bucket : compartiment (Région de la mémoire constituée de plusieurs
champs, adressable en tant qu'entité.) -->
      <row>
       <entry><literal><function>width_bucket</function>(<parameter>opérande</parameter> <type>numeric</type>,
        <parameter>b1</parameter> <type>numeric</type>, <parameter>b2</parameter> <type>numeric</type>,
	<parameter>nombre</parameter> <type>int</type>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>renvoie le compartiment auquel l'<parameter>opérande</parameter> est affecté dans
        un histogramme d'équidistance à <parameter>nombre</parameter>
	compartiments, les valeurs allant de <parameter>b1</parameter> à
        <parameter>b2</parameter></entry>
       <entry><literal>width_bucket(5.35, 0.024, 10.06, 5)</literal></entry>
       <entry><literal>3</literal></entry>
      </row>

<!-- SAS 20080722 : doublon
      <row>
       <entry><literal><function>width_bucket</function>(<parameter>op</parameter> <type>dp</type>, <parameter>b1</parameter> <type>dp</type>, <parameter>b2</parameter> <type>dp</type>, <parameter>count</parameter> <type>int</type>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>renvoie le jeton auquel est associé <parameter>op</parameter>
	dans un histogramme d'équidistance avec <parameter>count</parameter>
        jetons, les valeurs allant de <parameter>b1</parameter> à
	<parameter>b2</parameter></entry>
       <entry><literal>width_bucket(5.35, 0.024, 10.06, 5)</literal></entry>
       <entry><literal>3</literal></entry>
      </row>
-->
     </tbody>
    </tgroup>
   </table>

  <para>
   Pour finir, le <xref linkend="functions-math-trig-table"/> affiche les fonctions
   trigonométriques disponibles. Toutes les fonctions trigonométriques prennent
   des arguments et renvoient des valeurs de type <type>double precision</type>.
  </para>

   <indexterm>
    <primary>acos</primary>
   </indexterm>
   <indexterm>
    <primary>asin</primary>
   </indexterm>
   <indexterm>
    <primary>atan</primary>
   </indexterm>
   <indexterm>
    <primary>atan2</primary>
   </indexterm>
   <indexterm>
    <primary>cos</primary>
   </indexterm>
   <indexterm>
    <primary>cot</primary>
   </indexterm>
   <indexterm>
    <primary>sin</primary>
   </indexterm>
   <indexterm>
    <primary>tan</primary>
   </indexterm>

   <table id="functions-math-trig-table">
    <title>Fonctions trigonométriques</title>

    <tgroup cols="2">
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>

<entry><literal><function>acos</function>(<replaceable>x</replaceable>)</literal></entry>
       <entry>arccosinus</entry>
      </row>

      <row>

<entry><literal><function>asin</function>(<replaceable>x</replaceable>)</literal></entry>
       <entry>arcsinus</entry>
      </row>

      <row>

<entry><literal><function>atan</function>(<replaceable>x</replaceable>)</literal></entry>
       <entry>arctangente</entry>
      </row>

      <row>
       <entry><literal><function>atan2</function>(<replaceable>y</replaceable>,
        <replaceable>x</replaceable>)</literal></entry>
       <entry>
        arctangente de <literal><replaceable>y</replaceable>/<replaceable>x</replaceable></literal>
       </entry>
      </row>

      <row>
      
<entry><literal><function>cos</function>(<replaceable>x</replaceable>)</literal>
</entry>
       <entry>cosinus</entry>
      </row>

      <row>
      
<entry><literal><function>cot</function>(<replaceable>x</replaceable>)</literal>
</entry>
       <entry>cotangente</entry>
      </row>

      <row>
      
<entry><literal><function>sin</function>(<replaceable>x</replaceable>)</literal>
</entry>
       <entry>sinus</entry>
      </row>

      <row>
      
<entry><literal><function>tan</function>(<replaceable>x</replaceable>)</literal>
</entry>
       <entry>tangente</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

  </sect1>


  <sect1 id="functions-string">
   <title>Fonctions et opérateurs de chaînes</title>

   <para>
    Cette section décrit les fonctions et opérateurs d'examen et de
    mainpulation des valeurs de type chaîne de caractères. Dans ce contexte,
    les chaînes incluent les valeurs des types <type>character</type>,
    <type>character varying</type> et <type>text</type>. Sauf lorsque cela est
    précisé différement, toutes les fonctions listées ci-dessous fonctionnent
    sur tous ces types, mais une attention particulière doit être portée aux
    effets potentiels du remplissage automatique lors de l'utilisation du type
    <type>character</type>. Quelques fonctions existent aussi nativement pour
    le type chaîne bit à bit.
   </para>

   <para>
    <acronym>SQL</acronym> définit quelques fonctions de type chaîne qui
    utilisent des mots clés, à la place de la virgule, pour séparer les
    arguments. Des détails sont disponibles dans le
    <xref linkend="functions-string-sql"/>. <productname>PostgreSQL</productname>
    fournit aussi des versions de ces fonctions qui utilisent la syntaxe
    standard d'appel des fonctions
    (voir le <xref linkend="functions-string-other"/>).
   </para>

   <note>
    <para>
     Avant <productname>PostgreSQL</productname> 8.3, ces fonctions acceptent
     silencieusement des valeurs de types de données différents de
     chaînes de caractères. Cela parce qu'existent des transtypages implicites de
     ces types en <type>text</type>. Ces forçages ont été supprimés parce
     que leur comportement est souvent surprenant. Néanmoins, l'opérateur de
     concaténation de chaîne (<literal>||</literal>) accepte toujours des
     éléments qui ne sont pas du type chaîne de caractères, dès lors qu'au
     moins un des éléments est de type chaîne, comme montré dans <xref
     linkend="functions-string-sql"/>. Dans tous les autres cas, il faut
     insérer un transtypage explicite en <type>text</type> pour mimer
     le comportement précédent.
    </para>
   </note>

   <indexterm>
    <primary>bit_length</primary>
   </indexterm>
   <indexterm>
    <primary>char_length</primary>
   </indexterm>
   <indexterm>
    <primary>lower</primary>
   </indexterm>
   <indexterm>
    <primary>octet_length</primary>
   </indexterm>
   <indexterm>
    <primary>overlay</primary>
   </indexterm>
   <indexterm>
    <primary>position</primary>
   </indexterm>
   <indexterm>
    <primary>substring</primary>
   </indexterm>
   <indexterm>
    <primary>trim</primary>
   </indexterm>
   <indexterm>
    <primary>upper</primary>
   </indexterm>

   <table id="functions-string-sql">
    <title>Fonctions et opérateurs <acronym>SQL</acronym> pour le type chaîne</title>
    <tgroup cols="5">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1.2*"/>
     <colspec colnum="5" colwidth="0.8*"/>
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Type renvoyé</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>  
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal><parameter>chaîne</parameter> <literal>||</literal>
        <parameter>chaîne</parameter></literal></entry>
       <entry><type>text</type> </entry>
       <entry>
        Concaténation de chaînes
        <indexterm>
         <primary>chaîne de caractères</primary>
         <secondary>concaténation</secondary>
        </indexterm>
       </entry>
       <entry><literal>'Post' || 'greSQL'</literal></entry>
       <entry><literal>PostgreSQL</literal></entry>
      </row>

      <row>
       <entry>
        <literal><parameter>chaîne</parameter> <literal>||</literal>
        <parameter>autre-que-chaîne</parameter></literal>
        ou
        <literal><parameter>autre-que-chaîne</parameter> <literal>||</literal>
        <parameter>chaîne</parameter></literal>
       </entry>
       <entry> <type>text</type> </entry>
       <entry>
        Concaténation de chaînes avec un argument non-chaîne
       </entry>
       <entry><literal>'Value: ' || 42</literal></entry>
       <entry><literal>Value: 42</literal></entry>
      </row>

      <row>
       <entry><literal><function>bit_length</function>
(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Nombre de bits de la chaîne</entry>
       <entry><literal>bit_length('jose')</literal></entry>
       <entry><literal>32</literal></entry>
      </row>

      <row>
       <entry><literal><function>char_length</function>
(<parameter>chaîne</parameter>)</literal> ou
<literal><function>character_length</function>
(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>
        Nombre de caractères de la chaîne
        <indexterm>
         <primary>chaîne de caractères</primary>
         <secondary>longueur</secondary>
        </indexterm>
        <indexterm>
         <primary>longueur</primary>
         <secondary sortas="character string">d'une chaîne de
         caractères</secondary>
         <see>chaîne de caractères, longueur</see>
        </indexterm>
       </entry>
       <entry><literal>char_length('jose')</literal></entry>
       <entry><literal>4</literal></entry>
      </row>

      <row>
       <entry><literal><function>lower</function>
(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Convertit une chaîne en minuscule</entry>
       <entry><literal>lower('TOM')</literal></entry>
       <entry><literal>tom</literal></entry>
      </row>

      <row>
       <entry><literal><function>octet_length</function>(<parameter>chaîne</parameter>)
</literal></entry>
       <entry><type>int</type></entry>
       <entry>Nombre d'octets de la chaîne</entry>
       <entry><literal>octet_length('jose')</literal></entry>
       <entry><literal>4</literal></entry>
      </row>

      <row>
       <entry><literal><function>overlay</function>(<parameter>chaîne</parameter>
placing <parameter>chaîne</parameter> from <type>int</type> <optional>for
<type>int</type></optional>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Remplace la sous-chaîne
       </entry>
       <entry><literal>overlay('Txxxxas' placing 'hom' from 2 for
4)</literal></entry>
       <entry><literal>Thomas</literal></entry>
      </row>

      <row>
       <entry><literal><function>position</function>(<parameter>substring</parameter>
in <parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Emplacement de la sous-chaîne indiquée</entry>
       <entry><literal>position('om' in 'Thomas')</literal></entry>
       <entry><literal>3</literal></entry>
      </row>

      <row>
       <entry><literal><function>substring</function>(<parameter>chaîne</parameter>
<optional>from <type>int</type></optional> <optional>for
<type>int</type></optional>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Extrait une sous-chaîne
       </entry>
       <entry><literal>substring('Thomas' from 2 for 3)</literal></entry>
       <entry><literal>hom</literal></entry>
      </row>

      <row>
      
<entry><literal><function>substring</function>(<parameter>chaîne</parameter>
from <replaceable>modele</replaceable>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Extrait la sous-chaîne correspondant à l'expression rationnelle POSIX.
	Voir <xref linkend="functions-matching"/> pour plus d'informations sur
	la correspondance de modèles.
       </entry>
       <entry><literal>substring('Thomas' from '...$')</literal></entry>
       <entry><literal>mas</literal></entry>
      </row>

      <row>
      
<entry><literal><function>substring</function>(<parameter>chaîne</parameter>
from <replaceable>pattern</replaceable> for
<replaceable>escape</replaceable>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Extrait la sous-chaîne correspondant à l'expression rationnelle
        <acronym>SQL</acronym>.
	Voir <xref linkend="functions-matching"/> pour plus d'informations sur
	la correspondance de modèles.
       </entry>
       <entry><literal>substring('Thomas' from '%#"o_a#"_' for
'#')</literal></entry>
       <entry><literal>oma</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>trim</function>(<optional>leading | trailing |
both</optional>
        <optional><parameter>caractères</parameter></optional> from
        <parameter>chaîne</parameter>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Supprime la plus grande chaîne qui ne contient que les
        <parameter>caractères</parameter> (une espace par défaut) à partir du
        début, de la fin ou des deux extrémités (respectivement leading,
	trailing, both) de la <parameter>chaîne</parameter>.
       </entry>
       <entry><literal>trim(both 'x' from 'xTomxx')</literal></entry>
       <entry><literal>Tom</literal></entry>
      </row>

      <row>
      
<entry><literal><function>upper</function>
(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Convertit une chaîne en majuscule</entry>
       <entry><literal>upper('tom')</literal></entry>
       <entry><literal>TOM</literal></entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    D'autres fonctions de manipulation de chaînes sont disponibles et listées
    dans le <xref linkend="functions-string-other"/>. Certaines d'entre elles
    sont utilisées en interne pour implanter les fonctions de chaîne répondant
    au standard <acronym>SQL</acronym> listées dans le <xref
    linkend="functions-string-sql"/>.
   </para>

   <indexterm>
    <primary>ascii</primary>
   </indexterm>
   <indexterm>
    <primary>btrim</primary>
   </indexterm>
   <indexterm>
    <primary>chr</primary>
   </indexterm>
   <indexterm>
    <primary>convert</primary>
   </indexterm>
   <indexterm>
    <primary>convert_from</primary>
   </indexterm>
   <indexterm>
    <primary>convert_to</primary>
   </indexterm>
   <indexterm>
    <primary>decode</primary>
   </indexterm>
   <indexterm>
    <primary>encode</primary>
   </indexterm>
   <indexterm>
    <primary>initcap</primary>
   </indexterm>
   <indexterm>
    <primary>lpad</primary>
   </indexterm>
   <indexterm>
    <primary>ltrim</primary>
   </indexterm>
   <indexterm>
    <primary>md5</primary>
   </indexterm>
   <indexterm>
    <primary>pg_client_encoding</primary>
   </indexterm>
   <indexterm>
    <primary>quote_ident</primary>
   </indexterm>
   <indexterm>
    <primary>quote_literal</primary>
   </indexterm>
   <indexterm>
    <primary>quote_nullable</primary>
   </indexterm>
   <indexterm>
    <primary>repeat</primary>
   </indexterm>
   <indexterm>
    <primary>replace</primary>
   </indexterm>
   <indexterm>
    <primary>rpad</primary>
   </indexterm>
   <indexterm>
    <primary>rtrim</primary>
   </indexterm>
   <indexterm>
    <primary>split_part</primary>
   </indexterm>
   <indexterm>
    <primary>strpos</primary>
   </indexterm>
   <indexterm>
    <primary>substr</primary>
   </indexterm>
   <indexterm>
    <primary>to_ascii</primary>
   </indexterm>
   <indexterm>
    <primary>to_hex</primary>
   </indexterm>
   <indexterm>
    <primary>translate</primary>
   </indexterm>

   <table id="functions-string-other">
    <title>Autres fonctions de chaîne</title>
    <tgroup cols="5">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1.2*"/>
     <colspec colnum="5" colwidth="0.8*"/>
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Type renvoyé</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal><function>ascii</function>(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Code <acronym>ASCII</acronym> du premier octet de
        l'argument. Pour <acronym>UTF8</acronym>, renvoie le code Unicode du
	caractère. Pour les autres codages multi-octets, l'argument doit
	impérativement être un caractère <acronym>ASCII</acronym>.</entry>
       <entry><literal>ascii('x')</literal></entry>
       <entry><literal>120</literal></entry>
      </row>

      <row>
       <entry><literal><function>btrim</function>(<parameter>chaîne</parameter> <type>text</type>
       <optional>, <parameter>caractères</parameter> <type>text</type></optional>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Supprime la chaîne la plus longue constituée uniquement de caractères 
        issus de <parameter>caractères</parameter> (une espace par défaut)
	à partir du début et de la fin de <parameter>chaîne</parameter>.
       </entry>
       <entry><literal>btrim('xyxtrimyyx', 'xy')</literal></entry>
       <entry><literal>trim</literal></entry>
      </row>

      <row>
      
<entry><literal><function>chr</function>(<type>int</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Caractère correspondant au code donné. Pour <acronym>UTF8</acronym>,
	l'argument est traité comme un code Unicode. Pour les autres codages
	multi-octets, l'argument doit impérativement désigner un caractère
	<acronym>ASCII</acronym>. Le caractère NULL (0) n'est pas
	autorisé car les types de données texte ne peuvent pas stocker ce
	type d'octets.
       </entry>
       <entry><literal>chr(65)</literal></entry>
       <entry><literal>A</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>convert</function>(<parameter>chaine</parameter> <type>bytea</type>,
        <parameter>encodage_source</parameter> <type>name</type>,
        <parameter>encodage_destination</parameter> <type>name</type>)</literal>
       </entry>
       <entry><type>bytea</type></entry>
       <entry>
        Convertit la chaîne en encodage
	<parameter>encodage_destination</parameter>. L'encodage d'origine est
	indiqué par <parameter>encodage_source</parameter>. La
        <parameter>chaine</parameter> doit être valide pour cet encodage.
        Les conversions peuvent être définies avec <command>CREATE
	CONVERSION</command>. De plus, il existe quelques conversions
	pré-définies. Voir <xref linkend="conversion-names"/> pour les
	conversions disponibles.
       </entry>
       <entry><literal>convert( 'texte_en_utf8', 'UTF8', 'LATIN1')</literal></entry>
       <entry><literal>texte_en_utf8</literal> représenté dans le codage LATIN1</entry>
      </row>

      <row>
       <entry>
        <literal><function>convert_from</function>(<parameter>chaine</parameter> <type>bytea</type>,
        <parameter>encodage_source</parameter> <type>nom</type>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Convertit la chaîne dans l'encodage de la base. L'encodage original
	est indiqué par <parameter>encodage_source</parameter>. La
        <parameter>chaîne</parameter> doit être valide pour cet encodage.
       </entry>
       <entry><literal>convert_from( 'texte_en_utf8', 'UTF8')</literal></entry>
       <entry><literal>texte_en_utf8</literal> représenté dans le codage de la
        base en cours</entry>
      </row>

      <row>
       <entry>
        <literal><function>convert_to</function>(<parameter>chaine</parameter> <type>text</type>,
        <parameter>encodage_destination</parameter> <type>nom</type>)</literal>
       </entry>
       <entry><type>bytea</type></entry>
       <entry>
        Convertit une chaîne en encodage <parameter>encodage_destination</parameter>.
       </entry>
       <entry><literal>convert_to( 'un texte', 'UTF8')</literal></entry>
       <entry><literal>un texte</literal> représenté dans l'encodage UTF8</entry>
      </row>

      <row>
       <entry>
        <literal><function>decode</function>(<parameter>chaîne</parameter>
<type>text</type>,
        <parameter>type</parameter> <type>text</type>)</literal>
       </entry>
       <entry><type>bytea</type></entry>
       <entry>
        Décode les données binaires à partir de <parameter>chaîne</parameter>,
        codée préalablement avec <function>encode</function>. Le type de paramètre est le
        même que <function>encode</function>.
       </entry>
       <entry><literal>decode('MTIzAAE=', 'base64')</literal></entry>
       <entry><literal>123\000\001</literal></entry>
      </row>       

      <row>
       <entry>
        <literal><function>encode</function>(<parameter>données</parameter>
<type>bytea</type>,
        <parameter>type</parameter> <type>text</type>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Code les données binaires en une représentation différente. Les types
	supportés sont&nbsp;:
        <literal>base64</literal>, <literal>hex</literal>, <literal>escape</literal>.
        <literal>escape</literal> affiche simplement des octets nuls sous la
	forme <literal>\000</literal> et des antislashs.
       </entry>
       <entry><literal>encode( E'123\\000\\001', 'base64')</literal></entry>
       <entry><literal>MTIzAAE=</literal></entry>
      </row>       

      <row>
       <entry><literal><function>initcap</function>
	(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
	Convertit la première lettre de chaque mot en majuscule et le reste en
	minuscule. Les mots sont des séquences de caractères alphanumériques
	séparés par des caractères non alphanumériques.
       </entry>
       <entry><literal>initcap('bonjour THOMAS')</literal></entry>
       <entry><literal>Bonjour Thomas</literal></entry>
      </row>

      <row>
       <entry><literal><function>length</function>
         (<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>
       Nombre de caractères de <parameter>chaîne</parameter>
       </entry>
       <entry><literal>length('jose')</literal></entry>
       <entry><literal>4</literal></entry>
      </row>

      <row>
       <entry><literal><function>length</function>(<parameter>chaine</parameter><type>bytea</type>,
        <parameter>encodage</parameter> <type>nom</type> )</literal></entry>
       <entry><type>int</type></entry>
       <entry>
        Nombre de caractères de <parameter>chaine</parameter> dans
        l'<parameter>encodage</parameter> donné. La <parameter>chaine</parameter>
        doit être valide dans cet encodage.
       </entry>
       <entry><literal>length('jose', 'UTF8')</literal></entry>
       <entry><literal>4</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>lpad</function>(<parameter>chaîne</parameter>
<type>text</type>,
        <parameter>longueur</parameter> <type>int</type>
        <optional>, <parameter>remplissage</parameter>
<type>text</type></optional>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Complète <parameter>chaîne</parameter> à 
        <parameter>longueur</parameter> en ajoutant les caractères
        <parameter>remplissage</parameter> en début de chaîne (une espace par défaut). Si
        <parameter>chaîne</parameter> a une taille supérieure à
        <parameter>longueur</parameter>, alors elle est tronquée (sur la
        droite).
       </entry>
       <entry><literal>lpad('hi', 5, 'xy')</literal></entry>
       <entry><literal>xyxhi</literal></entry>
      </row>

      <row>
       <entry><literal><function>ltrim</function>(<parameter>chaîne</parameter>
       <type>text</type>
       <optional>, <parameter>caractères</parameter> <type>text</type></optional>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Supprime la chaîne la plus longue constituée uniquement de caractères
	issus de <parameter>caractères</parameter> (une espace par défaut) à partir du début de la chaîne.
       </entry>
       <entry><literal>ltrim('zzzytrim', 'xyz')</literal></entry>
       <entry><literal>trim</literal></entry>
      </row>

      <row>
       <entry><literal><function>md5</function>(<parameter>chaîne</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Calcule la clé MD5 de <parameter>chaîne</parameter> et retourne le résultat en
        hexadécimal.
       </entry>
       <entry><literal>md5('abc')</literal></entry>
       <entry><literal>900150983cd24fb0 d6963f7d28e17f72</literal></entry>
      </row>

      <row>
       <entry><literal><function>pg_client_encoding</function>()</literal></entry>
       <entry><type>name</type></entry>
       <entry>
        Nom de l'encodage client courant.
       </entry>
       <entry><literal>pg_client_encoding()</literal></entry>
       <entry><literal>SQL_ASCII</literal></entry>
      </row>

      <row>
       <entry><literal><function>quote_ident</function>(<parameter>chaîne</parameter> <type>text</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Renvoie la chaîne correctement placée entre guillemets pour
        utilisation comme identifiant dans une chaîne d'instruction
	<acronym>SQL</acronym>. Les guillemets ne sont ajoutés que s'ils sont
	nécessaires (c'est-à-dire si la chaîne contient des caractères autres
	que ceux de l'identifiant ou qu'il peut y avoir un problème de casse).
	Les guillemets compris dans la chaîne sont correctement doublés.
        Voir aussi <xref linkend="plpgsql-quote-literal-example"/>.
       </entry>
       <entry><literal>quote_ident('Foo bar')</literal></entry>
       <entry><literal>"Foo bar"</literal></entry>
      </row>

      <row>
       <entry><literal><function>quote_literal</function>(<parameter>chaîne</parameter> <type>text</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Renvoie la chaîne correctement placée entre guillemets pour être
        utilisée comme libellé dans un chaîne d'instruction
        <acronym>SQL</acronym>. Les guillemets simples compris dans la chaîne
        et les antislash sont correctement doublés.
        Notez que <function>quote_literal</function> renvoit NULL si son
	argument est NULL&nbsp;; si l'argument peut être NULL, la fonction
        <function>quote_nullable</function> convient mieux.
        Voir aussi <xref linkend="plpgsql-quote-literal-example"/>.
       </entry>
       <entry><literal>quote_literal( 'O\'Reilly')</literal></entry>
       <entry><literal>'O''Reilly'</literal></entry>
      </row>

      <row>
       <entry><literal><function>quote_literal</function>(<parameter>valeur</parameter> <type>anyelement</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Convertit la valeur donnée en texte, puis la place entre guillemets
	suivant la méthode appropriée pour une valeur litérale.
        Les guillemets simples et antislashs faisant partie de cette
	valeur sont doublés proprement.
       </entry>
       <entry><literal>quote_literal(42.5)</literal></entry>
       <entry><literal>'42.5'</literal></entry>
      </row>

      <row>
       <entry><literal><function>regexp_matches</function>(<parameter>chaine</parameter> <type>text</type>, <parameter>modele</parameter> <type>text</type> [, <parameter>options</parameter> <type>text</type>])</literal></entry>
       <entry><type>setof text[]</type></entry>
       <entry>
        Renvoie toutes les sous-chaînes capturées résultant d'une correspondance
	entre l'expression rationnelle POSIX et <parameter>chaine</parameter>.
        Voir <xref linkend="functions-posix-regexp"/> pour plus d'informations.
       </entry>
       <entry><literal>regexp_matches('foobarbequebaz', '(bar)(beque)')</literal></entry>
       <entry><literal>{bar,beque}</literal></entry>
      </row>

      <row>
       <entry><literal><function>quote_nullable</function>(<parameter>chaine</parameter> <type>text</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Renvoit la chaîne donnée convenablement mise entre guillemets pour
	être utilisée comme une chaîne litérale dans une instruction SQL&nbsp;;
	or si l'argument est NULL, elle renvoit <literal>NULL</literal>.
	Les guillemets simples et antislashs dans la chaîne sont doublés
	correctement. Voir aussi <xref
	linkend="plpgsql-quote-literal-example"/>.
       </entry>
       <entry><literal>quote_nullable(NULL)</literal></entry>
       <entry><literal>NULL</literal></entry>
      </row>

      <row>
       <entry><literal><function>quote_nullable</function>(<parameter>valeur</parameter> <type>anyelement</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Renvoit la valeur donnée en texte, puis la met entre guillemets comme un
	litéral&nbsp;; or, si l'argument est NULL, elle renvoit
	<literal>NULL</literal>.Les guillemets simples et antislashs dans la
	chaîne sont doublés correctement.
       </entry>
       <entry><literal>quote_nullable(42.5)</literal></entry>
       <entry><literal>'42.5'</literal></entry>
      </row>

      <row>
       <entry><literal><function>regexp_replace</function>(<parameter>chaîne</parameter> <type>text</type>, <parameter>modele</parameter> <type>text</type>, <parameter>remplacement</parameter> <type>text</type> [,<parameter>options</parameter> <type>text</type>])</literal></entry>
       <entry><type>text</type></entry>
       <entry>
        Remplace la sous-chaîne correspondant à l'expression rationnelle POSIX.
	Voir <xref linkend="functions-posix-regexp"/> pour plus d'informations.
       </entry>
       <entry><literal>regexp_replace('Thomas', '.[mN]a.', 'M')</literal></entry>
       <entry><literal>ThM</literal></entry>
      </row>

      <row>
       <entry><literal><function>regexp_split_to_array</function> (<parameter>chaine</parameter> <type>text</type>, <parameter>modele</parameter> <type>text</type> [, <parameter>options</parameter> <type>text</type> ])</literal></entry>
       <entry><type>text[]</type></entry>
       <entry>
        Divise une <parameter>chaine</parameter> en utilisant une expression
	rationnelle POSIX en tant que délimiteur. Voir <xref
	linkend="functions-posix-regexp"/> pour plus d'informations.
       </entry>
       <entry><literal>regexp_split_to_array('hello world', E'\\s+')</literal></entry>
       <entry><literal>{hello,world}</literal></entry>
      </row>

      <row>
       <entry><literal><function>regexp_split_to_table</function> (<parameter>chaine</parameter> <type>text</type>, <parameter>modele</parameter> <type>text</type> [, <parameter>options</parameter> <type>text</type>])</literal></entry>
       <entry><type>setof text</type></entry>
       <entry>
        Divise la <parameter>chaine</parameter> en utilisant une expression
	rationnelle POSIX comme délimiteur. Voir <xref linkend="functions-posix-regexp"/> pour plus d'informations.
       </entry>
       <entry><literal>regexp_split_to_table('hello world', E'\\s+')</literal></entry>
       <entry><literal>hello</literal><para><literal>world</literal></para> (2 rows)</entry>
      </row>

      <row>
       <entry><literal><function>repeat</function>(<parameter>chaîne</parameter> <type>text</type>,
        <parameter>nombre</parameter> <type>int</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Répète le texte <parameter>chaîne</parameter> <parameter>nombre</parameter> fois</entry>
       <entry><literal>repeat('Pg', 4)</literal></entry>
       <entry><literal>PgPgPgPg</literal></entry>
      </row>

      <row>
       <entry><literal><function>replace</function>(<parameter>chaîne</parameter> <type>text</type>,
       <parameter>àpartirde</parameter> <type>text</type>,
       <parameter>vers</parameter> <type>text</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Remplace dans <parameter>chaîne</parameter> toutes les
        occurrences de la sous-chaîne <parameter>àpartirde</parameter> par la
        sous-chaîne <parameter>vers</parameter>.
       </entry>
       <entry><literal>replace( 'abcdefabcdef', 'cd', 'XX')</literal></entry>
       <entry><literal>abXXefabXXef</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>rpad</function>(<parameter>chaîne</parameter>
<type>text</type>,
        <parameter>longueur</parameter> <type>int</type>
        <optional>, <parameter>remplissage</parameter>
<type>text</type></optional>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>
        Complète <parameter>chaîne</parameter> à 
        <parameter>longueur</parameter> caractères en ajoutant les caractères
        <parameter>remplissage</parameter> à la fin (une espace par défaut). Si la
        <parameter>chaîne</parameter> a une taille supérieure à
        <parameter>longueur</parameter>, elle est tronquée.
       </entry>
       <entry><literal>rpad('hi', 5, 'xy')</literal></entry>
       <entry><literal>hixyx</literal></entry>
      </row>

      <row>
       <entry><literal><function>rtrim</function>(<parameter>chaîne</parameter> <type>text</type>
       <optional>, <parameter>caractères</parameter> <type>text</type></optional>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>Supprime la chaîne la plus longue contenant uniquement les
        caractères provenant de <parameter>caractères</parameter> (une espace par
        défaut) depuis la fin de <parameter>chaîne</parameter>.
       </entry>
       <entry><literal>rtrim('trimxxxx', 'x')</literal></entry>
       <entry><literal>trim</literal></entry>
      </row>

      <row>
      
<entry><literal><function>split_part</function>(<parameter>chaîne</parameter>
<type>text</type>,
       <parameter>délimiteur</parameter> <type>text</type>,
       <parameter>champ</parameter> <type>int</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Divise <parameter>chaîne</parameter> par rapport au
        <parameter>délimiteur</parameter> et renvoie le champ donné (en
        comptant à partir de 1).
       </entry>
       <entry><literal>split_part( 'abc~@~def~@~ghi', '~@~',
2)</literal></entry>
       <entry><literal>def</literal></entry>
      </row>

      <row>
      
<entry><literal><function>strpos</function>(<parameter>chaîne</parameter>,
<parameter>sous-chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Emplacement de la sous-chaîne indiquée (identique à
        <literal>position(<parameter>sous-chaîne</parameter> in
         <parameter>sous-chaîne</parameter>)</literal>, mais avec les
	 arguments en ordre inverse).
       </entry>
       <entry><literal>strpos('high', 'ig')</literal></entry>
       <entry><literal>2</literal></entry>
      </row>

      <row>
      
<entry><literal><function>substr</function>(<parameter>chaîne</parameter>,
<parameter>from</parameter> <optional>,
<parameter>nombre</parameter></optional>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Extrait la sous-chaîne (identique à
        <literal>substring(<parameter>chaîne</parameter> from
<parameter>àpartirde</parameter> for <parameter>nombre</parameter>)</literal>)
       </entry>
       <entry><literal>substr('alphabet', 3, 2)</literal></entry>
       <entry><literal>ph</literal></entry>
      </row>

      <row>
       <entry><literal><function>to_ascii</function>(<parameter>chaîne</parameter> <type>text</type>
        <optional>, <parameter>encodage</parameter> <type>text</type></optional>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Convertit la <parameter>chaîne</parameter> en
        <acronym>ASCII</acronym> à partir de n'importe quelle autre
	encodage (ne supporte que les conversions à partir de <literal>LATIN1</literal>,
	<literal>LATIN2</literal>, <literal>LATIN9</literal> et
	<literal>WIN1250</literal>).</entry>
       <entry><literal>to_ascii('Karel')</literal></entry>
       <entry><literal>Karel</literal></entry>
      </row>

      <row>
       <entry><literal><function>to_hex</function>(<parameter>nombre</parameter>
<type>int</type>
       ou <type>bigint</type>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>Convertit <parameter>nombre</parameter> dans sa représentation
        hexadécimale équivalente.
       </entry>
       <entry><literal>to_hex(2147483647)</literal></entry>
       <entry><literal>7fffffff</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>translate</function>(<parameter>chaîne</parameter>
        <type>text</type>,
        <parameter>àpartirde</parameter> <type>text</type>,
        <parameter>vers</parameter> <type>text</type>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>Tout caractère de <parameter>chaîne</parameter> qui correspond
        à un caractère de l'ensemble <parameter>àpartirde</parameter> est
        remplacé par le caractère correspondant de l'ensemble
        <parameter>vers</parameter>.
       </entry>
       <entry><literal>translate('12345', '14', 'ax')</literal></entry>
       <entry><literal>a23x5</literal></entry>
      </row>

     </tbody>
    </tgroup>
   </table>

   <table id="conversion-names">
    <title>Conversions intégrées</title>
    <tgroup cols="3">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.9*"/>
     <colspec colnum="3" colwidth="0.8*"/>
     <thead>
      <row>
       <entry>Nom de la conversion
        <footnote>
         <para>
          Les noms des conversions suivent un schéma de nommage standard&nbsp;:
          le nom officiel de l'encodage source avec tous les caractères non
          alpha-numériques remplacés par des tirets bas suivi de
          <literal>_to_</literal> suivi du nom de l'encodage cible ayant
	  subit le même traitement que le nom de l'encodage source.
          Il est donc possible que les noms varient par rapport aux noms
	  d'encodage personnalisés.
         </para>
        </footnote>
       </entry>
       <entry>Codage source</entry>
       <entry>Codage destination</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal>ascii_to_mic</literal></entry>
       <entry><literal>SQL_ASCII</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>ascii_to_utf8</literal></entry>
       <entry><literal>SQL_ASCII</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>big5_to_euc_tw</literal></entry>
       <entry><literal>BIG5</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
      </row>

      <row>
       <entry><literal>big5_to_mic</literal></entry>
       <entry><literal>BIG5</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>big5_to_utf8</literal></entry>
       <entry><literal>BIG5</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>euc_cn_to_mic</literal></entry>
       <entry><literal>EUC_CN</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>euc_cn_to_utf8</literal></entry>
       <entry><literal>EUC_CN</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>euc_jp_to_mic</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>euc_jp_to_sjis</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
       <entry><literal>SJIS</literal></entry>
      </row>

      <row>
       <entry><literal>euc_jp_to_utf8</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>euc_kr_to_mic</literal></entry>
       <entry><literal>EUC_KR</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>euc_kr_to_utf8</literal></entry>
       <entry><literal>EUC_KR</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>euc_tw_to_big5</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
       <entry><literal>BIG5</literal></entry>
      </row>

      <row>
       <entry><literal>euc_tw_to_mic</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>euc_tw_to_utf8</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>gb18030_to_utf8</literal></entry>
       <entry><literal>GB18030</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>gbk_to_utf8</literal></entry>
       <entry><literal>GBK</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_10_to_utf8</literal></entry>
       <entry><literal>LATIN6</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_13_to_utf8</literal></entry>
       <entry><literal>LATIN7</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_14_to_utf8</literal></entry>
       <entry><literal>LATIN8</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_15_to_utf8</literal></entry>
       <entry><literal>LATIN9</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_16_to_utf8</literal></entry>
       <entry><literal>LATIN10</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_1_to_mic</literal></entry>
       <entry><literal>LATIN1</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_1_to_utf8</literal></entry>
       <entry><literal>LATIN1</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_2_to_mic</literal></entry>
       <entry><literal>LATIN2</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_2_to_utf8</literal></entry>
       <entry><literal>LATIN2</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_2_to_windows_1250</literal></entry>
       <entry><literal>LATIN2</literal></entry>
       <entry><literal>WIN1250</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_3_to_mic</literal></entry>
       <entry><literal>LATIN3</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_3_to_utf8</literal></entry>
       <entry><literal>LATIN3</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_4_to_mic</literal></entry>
       <entry><literal>LATIN4</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_4_to_utf8</literal></entry>
       <entry><literal>LATIN4</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_5_to_koi8_r</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
       <entry><literal>KOI8R</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_5_to_mic</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_5_to_utf8</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_5_to_windows_1251</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
       <entry><literal>WIN1251</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_5_to_windows_866</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
       <entry><literal>WIN866</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_6_to_utf8</literal></entry>
       <entry><literal>ISO_8859_6</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_7_to_utf8</literal></entry>
       <entry><literal>ISO_8859_7</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_8_to_utf8</literal></entry>
       <entry><literal>ISO_8859_8</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>iso_8859_9_to_utf8</literal></entry>
       <entry><literal>LATIN5</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>johab_to_utf8</literal></entry>
       <entry><literal>JOHAB</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_r_to_iso_8859_5</literal></entry>
       <entry><literal>KOI8R</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_r_to_mic</literal></entry>
       <entry><literal>KOI8R</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_r_to_utf8</literal></entry>
       <entry><literal>KOI8R</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_r_to_windows_1251</literal></entry>
       <entry><literal>KOI8R</literal></entry>
       <entry><literal>WIN1251</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_r_to_windows_866</literal></entry>
       <entry><literal>KOI8R</literal></entry>
       <entry><literal>WIN866</literal></entry>
      </row>

      <row>
       <entry><literal>koi8_u_to_utf8</literal></entry>
       <entry><literal>KOI8U</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_ascii</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>SQL_ASCII</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_big5</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>BIG5</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_euc_cn</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>EUC_CN</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_euc_jp</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_euc_kr</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>EUC_KR</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_euc_tw</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_iso_8859_1</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>LATIN1</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_iso_8859_2</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>LATIN2</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_iso_8859_3</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>LATIN3</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_iso_8859_4</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>LATIN4</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_iso_8859_5</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_koi8_r</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>KOI8R</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_sjis</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>SJIS</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_windows_1250</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>WIN1250</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_windows_1251</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>WIN1251</literal></entry>
      </row>

      <row>
       <entry><literal>mic_to_windows_866</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
       <entry><literal>WIN866</literal></entry>
      </row>

      <row>
       <entry><literal>sjis_to_euc_jp</literal></entry>
       <entry><literal>SJIS</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
      </row>

      <row>
       <entry><literal>sjis_to_mic</literal></entry>
       <entry><literal>SJIS</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>sjis_to_utf8</literal></entry>
       <entry><literal>SJIS</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>tcvn_to_utf8</literal></entry>
       <entry><literal>WIN1258</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>uhc_to_utf8</literal></entry>
       <entry><literal>UHC</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_ascii</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>SQL_ASCII</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_big5</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>BIG5</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_euc_cn</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>EUC_CN</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_euc_jp</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>EUC_JP</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_euc_kr</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>EUC_KR</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_euc_tw</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>EUC_TW</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_gb18030</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>GB18030</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_gbk</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>GBK</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_1</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN1</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_10</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN6</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_13</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN7</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_14</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN8</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_15</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN9</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_16</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN10</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_2</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN2</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_3</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN3</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_4</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN4</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_5</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_6</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>ISO_8859_6</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_7</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>ISO_8859_7</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_8</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>ISO_8859_8</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_iso_8859_9</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>LATIN5</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_johab</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>JOHAB</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_koi8_r</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>KOI8R</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_koi8_u</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>KOI8U</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_sjis</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>SJIS</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_tcvn</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1258</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_uhc</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>UHC</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1250</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1250</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1251</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1251</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1252</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1252</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1253</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1253</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1254</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1254</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1255</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1255</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1256</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1256</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_1257</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN1257</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_866</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN866</literal></entry>
      </row>

      <row>
       <entry><literal>utf8_to_windows_874</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>WIN874</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1250_to_iso_8859_2</literal></entry>
       <entry><literal>WIN1250</literal></entry>
       <entry><literal>LATIN2</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1250_to_mic</literal></entry>
       <entry><literal>WIN1250</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1250_to_utf8</literal></entry>
       <entry><literal>WIN1250</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1251_to_iso_8859_5</literal></entry>
       <entry><literal>WIN1251</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1251_to_koi8_r</literal></entry>
       <entry><literal>WIN1251</literal></entry>
       <entry><literal>KOI8R</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1251_to_mic</literal></entry>
       <entry><literal>WIN1251</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1251_to_utf8</literal></entry>
       <entry><literal>WIN1251</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1251_to_windows_866</literal></entry>
       <entry><literal>WIN1251</literal></entry>
       <entry><literal>WIN866</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1252_to_utf8</literal></entry>
       <entry><literal>WIN1252</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>windows_1256_to_utf8</literal></entry>
       <entry><literal>WIN1256</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>windows_866_to_iso_8859_5</literal></entry>
       <entry><literal>WIN866</literal></entry>
       <entry><literal>ISO_8859_5</literal></entry>
      </row>

      <row>
       <entry><literal>windows_866_to_koi8_r</literal></entry>
       <entry><literal>WIN866</literal></entry>
       <entry><literal>KOI8R</literal></entry>
      </row>

      <row>
       <entry><literal>windows_866_to_mic</literal></entry>
       <entry><literal>WIN866</literal></entry>
       <entry><literal>MULE_INTERNAL</literal></entry>
      </row>

      <row>
       <entry><literal>windows_866_to_utf8</literal></entry>
       <entry><literal>WIN866</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>windows_866_to_windows_1251</literal></entry>
       <entry><literal>WIN866</literal></entry>
       <entry><literal>WIN</literal></entry>
      </row>

      <row>
       <entry><literal>windows_874_to_utf8</literal></entry>
       <entry><literal>WIN874</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>euc_jis_2004_to_utf8</literal></entry>
       <entry><literal>EUC_JIS_2004</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>ut8_to_euc_jis_2004</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>EUC_JIS_2004</literal></entry>
      </row>

      <row>
       <entry><literal>shift_jis_2004_to_utf8</literal></entry>
       <entry><literal>SHIFT_JIS_2004</literal></entry>
       <entry><literal>UTF8</literal></entry>
      </row>

      <row>
       <entry><literal>ut8_to_shift_jis_2004</literal></entry>
       <entry><literal>UTF8</literal></entry>
       <entry><literal>SHIFT_JIS_2004</literal></entry>
      </row>

      <row>
       <entry><literal>euc_jis_2004_to_shift_jis_2004</literal></entry>
       <entry><literal>EUC_JIS_2004</literal></entry>
       <entry><literal>SHIFT_JIS_2004</literal></entry>
      </row>

      <row>
       <entry><literal>shift_jis_2004_to_euc_jis_2004</literal></entry>
       <entry><literal>SHIFT_JIS_2004</literal></entry>
       <entry><literal>EUC_JIS_2004</literal></entry>
      </row>

     </tbody>
    </tgroup>
   </table>

  </sect1>


  <sect1 id="functions-binarystring">
   <title>Fonctions et opérateurs de chaînes binaires</title>

   <indexterm zone="functions-binarystring">
    <primary>données binaires</primary>
    <secondary>fonctions</secondary>
   </indexterm>

   <para>
    Cette section décrit les fonctions et opérateurs d'examen et de
    manipulation des valeurs de type <type>bytea</type>.
   </para>

   <para>
    <acronym>SQL</acronym> définit quelques fonctions de chaînes qui utilise
    des mots clés qui sont employés à la place de
    virgules pour séparer les arguments. Les détails sont présentés dans
    <xref linkend="functions-binarystring-sql"/>. <productname>PostgreSQL</productname>
    fournit aussi des versions de ces fonctions qui utilisant la syntaxe standard
    de l'appel de fonction (voir le <xref linkend="functions-binarystring-other"/>).
   </para>

   <table id="functions-binarystring-sql">
    <title>Fonctions et opérateurs <acronym>SQL</acronym> pour chaînes
binaires</title>
    <tgroup cols="5">
     <colspec colnum="1" colwidth="1.0*"/>
     <colspec colnum="2" colwidth="0.7*"/>
     <colspec colnum="3" colwidth="1.0*"/>
     <colspec colnum="4" colwidth="1.4*"/>
     <colspec colnum="5" colwidth="0.9*"/>
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Type renvoyé</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>  
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal><parameter>chaîne</parameter> <literal>||</literal>
        <parameter>chaîne</parameter></literal></entry>
       <entry><type>bytea</type> </entry>
       <entry>
        Concaténation de chaîne
        <indexterm>
         <primary>chaîne binaire</primary>
         <secondary>concaténation</secondary>
        </indexterm>
       </entry>
       <entry><literal>E'\\\\Post'::bytea || E'\\047gres\\000'::bytea</literal></entry>
       <entry><literal>\\Post'gres\000</literal></entry>
      </row>

      <row>
       <entry><function>get_bit</function>(<parameter>chaîne</parameter>, <parameter>décalage</parameter>)</entry>
       <entry><type>int</type></entry>
       <entry>
        Extrait un bit d'une chaîne
        <indexterm>
         <primary>get_bit</primary>
        </indexterm>
       </entry>
       <entry><literal>get_bit(E'Th\\000omas'::bytea, 45)</literal></entry>
       <entry><literal>1</literal></entry>
      </row>

      <row>
       <entry><function>get_byte</function>(<parameter>chaîne</parameter>, <parameter>décalage</parameter>)</entry>
       <entry><type>int</type></entry>
       <entry>
        Extrait un octet d'une chaîne
        <indexterm>
         <primary>get_byte</primary>
        </indexterm>
       </entry>
       <entry><literal>get_byte(E'Th\\000omas'::bytea, 4)</literal></entry>
       <entry><literal>109</literal></entry>
      </row>

      <row>
       <entry><literal><function>octet_length</function>( <parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Nombre d'octets d'une chaîne binaire</entry>
       <entry><literal>octet_length( E'jo\\000se'::bytea)</literal></entry>
       <entry><literal>5</literal></entry>
      </row>

      <row>
       <entry><literal><function>position</function>( <parameter>sous-chaîne</parameter>
in <parameter>chaîne</parameter>)</literal></entry>
       <entry><type>int</type></entry>
       <entry>Emplacement de la sous-chaîne indiquée</entry>
      <entry><literal>position( E'\\000om'::bytea in E'Th\\000omas'::bytea)</literal></entry>
       <entry><literal>3</literal></entry>
      </row>

      <row>
       <entry><function>set_bit</function>(<parameter>chaîne</parameter>,
        <parameter>décalage</parameter>, <parameter>nouvelle_valeur</parameter>)</entry>
       <entry><type>bytea</type></entry>
       <entry>
        Positionne un bit de la chaîne
        <indexterm>
         <primary>set_bit</primary>
        </indexterm>
       </entry>
       <entry><literal>set_bit(E'Th\\000omas'::bytea, 45, 0)</literal></entry>
       <entry><literal>Th\000omAs</literal></entry>
      </row>

      <row>
       <entry><function>set_byte</function>(<parameter>chaîne</parameter>,
       <parameter>décalage</parameter>, <parameter>nouvelle_valeur</parameter>)</entry>
       <entry><type>bytea</type></entry>
       <entry>
        Positionne un octet de la chaîne
        <indexterm>
         <primary>set_byte</primary>
        </indexterm>
       </entry>
       <entry><literal>set_byte( E'Th\\000omas'::bytea, 4, 64)</literal></entry>
       <entry><literal>Th\000o@as</literal></entry>
      </row>

      <row>
       <entry><literal><function>substring</function>(<parameter>chaîne</parameter> <optional>from <type>int</type></optional> <optional>for <type>int</type></optional>)</literal></entry>
       <entry><type>bytea</type></entry>
       <entry>
        Extrait une sous-chaîne
        <indexterm>
         <primary>sous-chaîne</primary>
        </indexterm>
       </entry>
       <entry><literal>substring(E'Th\\000omas'::bytea from 2 for 3)</literal></entry>
       <entry><literal>h\000o</literal></entry>
      </row>

      <row>
       <entry>
        <literal><function>trim</function>(<optional>both</optional>
        <parameter>octets</parameter> from
        <parameter>chaîne</parameter>)</literal>
       </entry>
       <entry><type>bytea</type></entry>
       <entry>
        Supprime la plus longue chaîne composée uniquement d'octets de
        <parameter>octets</parameter> à partir du début et de la fin de
        <parameter>chaîne</parameter>
       </entry>
       <entry><literal>trim(E'\\000'::bytea from E'\\000Tom\\000'::bytea)</literal></entry>
       <entry><literal>Tom</literal></entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    Des fonctions supplémentaires de manipulations de chaînes binaires sont listées dans le <xref
    linkend="functions-binarystring-other"/>. Certaines sont utilisées en interne
    pour coder les fonctions de chaînes suivant le standard
    <acronym>SQL</acronym> et sont listées dans le <xref
    linkend="functions-binarystring-sql"/>.
   </para>

   <table id="functions-binarystring-other">
    <title>Autres fonctions sur les chaînes binaires</title>
    <tgroup cols="5">
     <colspec colnum="1" colwidth="1.0*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.0*"/>
     <colspec colnum="4" colwidth="1.6*"/>
     <colspec colnum="5" colwidth="1.0*"/>
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Type retourné</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><literal><function>btrim</function>(<parameter>chaîne</parameter>
        <type>bytea</type>, <parameter>octets</parameter>
        <type>bytea</type>)</literal></entry>
       <entry><type>bytea</type></entry>
       <entry>
        Supprime la plus longue chaîne constituée uniquement d'octets de
        <parameter>octets</parameter> à partir du début et de la fin de
        <parameter>chaîne</parameter>.
      </entry>
      <entry><literal>btrim( E'\\000trim\\000'::bytea, E'\\000'::bytea)</literal></entry>
      <entry><literal>trim</literal></entry>
     </row>

     <row>
      <entry>
       <literal><function>decode</function>(<parameter>chaîne</parameter> <type>text</type>,
              <parameter>type</parameter> <type>text</type>)</literal>
      </entry>
      <entry><type>bytea</type></entry>
      <entry>
       Décode la chaîne binaire <parameter>chaîne</parameter> auparavant codée 
       avec <function>encode</function>. Le type de paramètre est le même que
       dans <function>encode</function>.
      </entry>
      <entry><literal>decode(E'123\\000456', 'escape')</literal></entry>
      <entry><literal>123\000456</literal></entry>
     </row>

     <row>
      <entry>
       <literal><function>encode</function>(<parameter>chaîne</parameter> <type>bytea</type>,
              <parameter>type</parameter> <type>text</type>)</literal>
      </entry>
      <entry><type>text</type></entry>
      <entry>
       Code la chaîne binaire en sa représentation <acronym>ASCII</acronym>.
       Les types supportés sont <literal>base64</literal>,
       <literal>hex</literal>, <literal>escape</literal>.
      </entry>
      <entry><literal>encode(E'123\\000456'::bytea, 'escape')</literal></entry>
      <entry><literal>123\000456</literal></entry>
     </row>

     <row>
      <entry><literal><function>length</function>
(<parameter>chaîne</parameter>)</literal></entry>
      <entry><type>int</type></entry>
      <entry>
       Longueur de la chaîne binaire
       <indexterm>
        <primary>chaîne binaire</primary>
	<secondary>longueur</secondary>
       </indexterm>
       <indexterm>
        <primary>longueur</primary>
	<secondary sortas="binary string">d'une chaîne binaire</secondary>
	<see>chaîne binaire, longueur</see>
       </indexterm>
      </entry>
      <entry><literal>length(E'jo\\000se'::bytea)</literal></entry>
      <entry><literal>5</literal></entry>
     </row>

     <row>
      <entry><literal><function>md5</function>(<parameter>chaîne</parameter>)</literal></entry>
      <entry><type>text</type></entry>
      <entry>
       Calcule le hachage MD5 de la <parameter>chaîne</parameter> et retourne
       le résultat en hexadécimal
      </entry>
      <entry><literal>md5(E'Th\\000omas'::bytea)</literal></entry>
      <entry><literal>8ab2d3c9689aaf18 b4958c334c82d8b1</literal></entry>
     </row>

    </tbody>
   </tgroup>
  </table>

 </sect1>


 <sect1 id="functions-bitstring">
   <title>Fonctions et opérateurs sur les chaînes de bits</title>
   
   <indexterm zone="functions-bitstring">
     <primary>chaîne de bits</primary>
     <secondary>fonctions</secondary>
   </indexterm>
   
   <para>
     Cette section décrit les fonctions et opérateurs d'examen et de
     manipulation des chaînes de bits, c'est-à-dire des valeurs de types
     <type>bit</type> et <type>bit varying</type>. En dehors des opérateurs
     de comparaison habituels, les opérateurs présentés dans le <xref
     linkend="functions-bit-string-op-table"/> peuvent être utilisés. Les
     opérandes de chaînes de bits utilisés avec <literal>&amp;</literal>,
     <literal>|</literal> et <literal>#</literal> doivent être de même
     longueur. Lors d'un décalage de bits, la longueur originale de la chaîne
     est préservée comme le montrent les exemples.
   </para>
     
     <table id="functions-bit-string-op-table">
       <title>Opérateurs sur les chaînes de bits</title>
       
       <tgroup cols="4">
         <thead>
           <row>
             <entry>Opérateur</entry>
             <entry>Description</entry>
             <entry>Exemple</entry>
             <entry>Résultat</entry>
           </row>
         </thead>
         
         <tbody>
           <row>
             <entry><literal>||</literal> </entry>
             <entry>concaténation</entry>
             <entry><literal>B'10001' || B'011'</literal></entry>
             <entry><literal>10001011</literal></entry>
           </row>
           
           <row>
             <entry><literal>&amp;</literal> </entry>
             <entry>AND bit à bit</entry>
             <entry><literal>B'10001' &amp; B'01101'</literal></entry>
             <entry><literal>00001</literal></entry>
           </row>
           
           <row>
             <entry><literal>|</literal> </entry>
             <entry>OR bit à bit</entry>
             <entry><literal>B'10001' | B'01101'</literal></entry>
             <entry><literal>11101</literal></entry>
           </row>
           
           <row>
             <entry><literal>#</literal> </entry>
             <entry>XOR bit à bit</entry>
             <entry><literal>B'10001' # B'01101'</literal></entry>
             <entry><literal>11100</literal></entry>
           </row>
           
           <row>
             <entry><literal>~</literal> </entry>
             <entry>NOT bit à bit</entry>
             <entry><literal>~ B'10001'</literal></entry>
             <entry><literal>01110</literal></entry>
           </row>
           
           <row>
             <entry><literal>&lt;&lt;</literal> </entry>
             <entry>décalage gauche bit à bit</entry>
             <entry><literal>B'10001' &lt;&lt; 3</literal></entry>
             <entry><literal>01000</literal></entry>
           </row>
           
           <row>
             <entry><literal>&gt;&gt;</literal> </entry>
             <entry>décalage droit bit à bit</entry>
             <entry><literal>B'10001' &gt;&gt; 2</literal></entry>
             <entry><literal>00100</literal></entry>
           </row>
         </tbody>
       </tgroup>
     </table>
     
     <para>
       Les fonctions <acronym>SQL</acronym> suivantes fonctionnent sur les
       chaînes de bits ainsi que sur les chaînes de caractères&nbsp;:
       <literal><function>length</function></literal>,
       <literal><function>bit_length</function></literal>,
       <literal><function>octet_length</function></literal>,
       <literal><function>position</function></literal>,
       <literal><function>substring</function></literal>.
     </para>
     
     <para>
       De plus, il est possible de convertir des valeurs intégrales vers ou
       depuis le type <type>bit</type>.
       Quelques exemples&nbsp;:
<programlisting>44::bit(10)                    <lineannotation>0000101100</lineannotation>
44::bit(3)                     <lineannotation>100</lineannotation>
cast(-44 as bit(12))           <lineannotation>111111010100</lineannotation>
'1110'::bit(4)::integer        <lineannotation>14</lineannotation></programlisting>
       Le transtypage <quote>bit</quote> signifie transtyper en
       <literal>bit(1)</literal> et, de ce fait, seul le bit de poids faible
       de l'entier est rendu.
     </para>

     <note>
       <para>
         Avant <productname>PostgreSQL</productname> 8.0, la conversion d'un entier
         en <type>bit(n)</type> copiait les <literal>n</literal> bits les plus à
         gauche de l'entier. Désormais, ce sont les <literal>n</literal> bits les
	 plus à droite qui sont copiés. De plus, la conversion d'un entier
         en une chaîne de bits plus grande que l'entier lui-même
         étend l'entier, avec signature, vers la gauche.
       </para>
     </note>

</sect1>


 <sect1 id="functions-matching">
  <title>Correspondance de motif</title>

  <indexterm zone="functions-matching">
   <primary>correspondance de motif</primary>
  </indexterm>

   <para>
    <productname>PostgreSQL</productname> fournit trois approches différentes
    à la correspondance de motif&nbsp;: l'opérateur
    <acronym>SQL</acronym> traditionnel
    <function>LIKE</function>, le plus récent <function>SIMILAR TO</function>
    (ajouté dans <acronym>SQL:1999</acronym>) et les expressions rationnelles
    de type <acronym>POSIX</acronym>. En dehors des opérateurs basiques du style
    <quote>est-ce que cette chaîne correspond à ce modèle&nbsp;?</quote>, les
    fonctions sont disponibles pour extraire ou remplacer des sous-chaînes
    correspondantes ou pour diviser une chaîne aux emplacements correspondants.
   </para>

   <tip>
    <para>
     Si un besoin de correspondances de motif va au-delà, il
     faut considérer l'écriture d'une fonction en Perl ou Tcl.
    </para>
   </tip>

  <sect2 id="functions-like">
   <title><function>LIKE</function></title>

   <indexterm>
    <primary>LIKE</primary>
   </indexterm>

<synopsis><replaceable>chaîne</replaceable> LIKE <replaceable>motif</replaceable> <optional>ESCAPE <replaceable>caractère d'échappement</replaceable></optional>
<replaceable>chaîne</replaceable> NOT LIKE <replaceable>motif</replaceable> <optional>ESCAPE <replaceable>caractère d'échappement</replaceable></optional></synopsis>

    <para>
     L'expression <function>LIKE</function> renvoie true si la
     <replaceable>chaîne</replaceable> est contenue dans l'ensemble de chaînes
     représenté par le <replaceable>motif</replaceable>. (L'expression
     <function>NOT LIKE</function> renvoie false si
     <function>LIKE</function> renvoie true et vice versa. Une expression
     équivalente est <literal>NOT (<replaceable>chaîne</replaceable> LIKE
      <replaceable>motif</replaceable>)</literal>.)
    </para>

    <para>
     Si le <replaceable>motif</replaceable> ne contient ni signe
     pourcent ni tiret bas, alors il ne représente que la
     chaîne elle-même&nbsp;; dans ce cas, <function>LIKE</function> agit
     exactement comme l'opérateur d'égalité. Un tiret bas (<literal>_</literal>)
     dans <replaceable>motif</replaceable> correspond à un seul
     caractère, un signe pourcent (<literal>%</literal>)
     à toutes les chaînes de zéro ou plusieurs caractères.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>'abc' LIKE 'abc'    <lineannotation>true</lineannotation>
'abc' LIKE 'a%'     <lineannotation>true</lineannotation>
'abc' LIKE '_b_'    <lineannotation>true</lineannotation>
'abc' LIKE 'c'      <lineannotation>false</lineannotation></programlisting>
   </para>
   
   <para>
    Le modèle <function>LIKE</function> correspond toujours à la chaîne
    entière. Du coup, pour faire correspondre une séquence à l'intérieur d'une chaîne, le
    motif doit donc commencer et finir avec un signe pourcent.
   </para>

   <para>
    Pour faire correspondre un vrai tiret bas ou un vrai signe de pourcentage
    sans correspondance avec d'autres caractères, le caractère correspondant dans
    <replaceable>motif</replaceable> doit être précédé du caractère
    d'échappement. Par défaut, il s'agit de l'antislash, mais un autre
    caractère peut être sélectionné en utilisant la clause
    <literal>ESCAPE</literal>. Pour un correspondance avec le caractère d'échappement
    lui-même, on écrit deux fois ce caractère.
   </para>

   <para>
    L'antislash a déjà une signification particulière dans les
    chaînes littérales. De ce fait, pour écrire un motif qui contient un
    antislash, il faut écrire deux antislashs dans l'instruction SQL (en
    supposant que la syntaxe d'échappement de chaînes soit utilisée, voir
    <xref linkend="sql-syntax-strings"/>). Ainsi, pour écrire un motif
    qui corresponde effectivement à un antislash littéral nécessite l'écriture
    de quatre antislash dans l'instruction. Tout cela peut être évité en
    sélectionnant un autre caractère d'échappement avec
    <literal>ESCAPE</literal>&nbsp;; un antislash n'est alors plus spécial
    au regard de <function>LIKE</function> (mais il est toujours spécial pour
    l'analyseur de chaînes littérales, et nécessite toujours d'être doublé
    pour correspondre à un antislash).
   </para>

   <para>
    Il est aussi possible de ne sélectionner aucun caractère d'échappement en
    écrivant <literal>ESCAPE ''</literal>. Ceci désactive complètement le
    mécanisme d'échappement, ce qui rend impossible la désactivation de la
    signification particulière du tiret bas et du signe de pourcentage dans le
    motif.
   </para>

   <para>
    Le mot clé <token>ILIKE</token> est utilisé à la place de
    <token>LIKE</token> pour faire des correspondances sans tenir compte de la
    casse mais en tenant compte de la locale active. Ceci ne fait pas partie du
    standard <acronym>SQL</acronym> mais est une extension
<productname>PostgreSQL</productname>.
   </para>

   <para>
    L'opérateur <literal>~~</literal> est équivalent à
    <function>LIKE</function> alors que <literal>~~*</literal> correspond à
    <function>ILIKE</function>. Il existe aussi les opérateurs
    <literal>!~~</literal> et <literal>!~~*</literal> représentant
    respectivement <function>NOT LIKE</function> et <function>NOT
    ILIKE</function>. Tous ces opérateurs sont spécifiques à
    <productname>PostgreSQL</productname>.
   </para>
  </sect2>


  <sect2 id="functions-similarto-regexp">
   <title>Expressions rationnelles <function>SIMILAR TO</function></title>

   <indexterm>
    <primary>expression rationnelle</primary>
    <!-- <seealso>pattern matching</seealso> breaks index build -->
   </indexterm>

   <indexterm>
    <primary>SIMILAR TO</primary>
   </indexterm>
   <indexterm>
    <primary>substring</primary>
   </indexterm>

<synopsis><replaceable>chaîne</replaceable> SIMILAR TO <replaceable>motif</replaceable> <optional>ESCAPE <replaceable>caractère d'échappement</replaceable></optional>
<replaceable>chaîne</replaceable> NOT SIMILAR TO <replaceable>motif</replaceable> <optional>ESCAPE <replaceable>caractère d'échappement</replaceable></optional></synopsis>

    <para>
     L'opérateur <function>SIMILAR TO</function> renvoie true ou false
     selon que le motif correspond ou non à la chaîne donnée.
     Il se rapproche de <function>LIKE</function> à la différence qu'il interprète le
     motif en utilisant la définition SQL d'une expression rationnelle. Les
     expressions rationnelles SQL sont un curieux mélange de la notation
     <function>LIKE</function> et de la notation habituelle des
     expressions rationnelles.
    </para>

    <para>
     À l'instar de <function>LIKE</function>, l'opérateur <function>SIMILAR
     TO</function> ne réussit que si son motif correspond à la chaîne
     entière&nbsp;; ceci en désaccord avec les pratiques habituelles des
     expressions rationnelles où le modèle peut se situer n'importe où dans la
     chaîne. Tout comme <function>LIKE</function>, <function>SIMILAR
     TO</function> utilise <literal>_</literal> et <literal>%</literal> comme caractères
     joker représentant respectivement tout caractère unique et toute chaîne (ils sont
     comparables à <literal>.</literal> et <literal>.*</literal> des expressions
     rationnelles compatibles POSIX).
    </para>

    <para>
     En plus de ces fonctionnalités empruntées à <function>LIKE</function>,
     <function>SIMILAR TO</function> supporte trois méta-caractères de
     correspondance de motif empruntés aux expressions rationnelles de
     POSIX&nbsp;:

    <itemizedlist>
     <listitem>
      <para>
       <literal>|</literal> représente une alternative (une des deux
       alternatives)&nbsp;;
      </para>
     </listitem>
     <listitem>
      <para>
       <literal>*</literal> représente la répétition des éléments précédents, 0 ou
       plusieurs fois&nbsp;;
      </para>
     </listitem>
     <listitem>
      <para>
       <literal>+</literal> représente la répétition des éléments précédents, une
       ou plusieurs fois&nbsp;;
      </para>
     </listitem>
     <listitem>
      <para>
       les parenthèses <literal>()</literal> peuvent être utilisées pour grouper des
       éléments en un seul élément logique&nbsp;;
      </para>
     </listitem>
     <listitem>
      <para>
       une expression entre crochets <literal>[...]</literal> spécifie une
       classe de caractères, comme dans les expressions rationnelles POSIX.
      </para>
     </listitem>
    </itemizedlist>

     Les opérateurs de répétitions encadrées (<literal>?</literal> et <literal>{...}</literal>) ne sont
     pas permises bien qu'elles existent en POSIX. De même, le point
     (<literal>.</literal>) n'est pas un méta-caractère.
    </para>

    <para>
     Comme avec <function>LIKE</function>, un antislash désactive la signification
     spéciale de tous les méta-caractères&nbsp;; un autre caractère
     d'échappement peut être indiqué avec <literal>ESCAPE</literal>.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>'abc' SIMILAR TO 'abc'      <lineannotation>true</lineannotation>
'abc' SIMILAR TO 'a'        <lineannotation>false</lineannotation>
'abc' SIMILAR TO '%(b|d)%'  <lineannotation>true</lineannotation>
'abc' SIMILAR TO '(b|c)%'   <lineannotation>false</lineannotation></programlisting>
   </para>

    <para>
     La fonction <function>substring</function> avec trois paramètres,
     <function>substring(<replaceable>chaîne</replaceable> from
     <replaceable>motif</replaceable> for
     <replaceable>caractère d'échappement</replaceable>)</function>, fournit
     l'extraction d'une sous-chaîne correspondant à un
     motif d'expression rationnelle SQL. Comme avec
     <literal>SIMILAR TO</literal>, le motif fourni doit correspondre à la
     chaîne de données entière, sinon la fonction échoue et renvoie NULL. Pour
     indiquer la partie du motif à retourner en cas de succès,
     le motif doit contenir deux occurrences du caractère d'échappement suivi
     d'un guillemet double (<literal>"</literal>). Le texte correspondant à la portion
     du motif entre ces deux marqueurs est renvoyé.
    </para>

   <para>
    Quelques exemples, avec <literal>#"</literal> délimitant la chaîne en
    retour&nbsp;:
<programlisting>substring('foobar' from '%#"o_b#"%' for '#')  
<lineannotation>oob</lineannotation>
substring('foobar' from '#"o_b#"%' for '#')   
<lineannotation>NULL</lineannotation></programlisting>
   </para>
  </sect2>

  <sect2 id="functions-posix-regexp">
   <title>Expressions rationnelles <acronym>POSIX</acronym></title>

   <indexterm zone="functions-posix-regexp">
    <primary>expression rationnelle</primary>
    <seealso>correspondance de modèle</seealso>
   </indexterm>
   <indexterm>
    <primary>substring</primary>
   </indexterm>
   <indexterm>
    <primary>regexp_replace</primary>
   </indexterm>
   <indexterm>
    <primary>regexp_matches</primary>
   </indexterm>
   <indexterm>
    <primary>regexp_split_to_table</primary>
   </indexterm>
   <indexterm>
    <primary>regexp_split_to_array</primary>
   </indexterm>

   <para>
    Le <xref linkend="functions-posix-table"/> liste les opérateurs disponibles
    pour la correspondance de motifs à partir d'expressions rationnelles
    POSIX.
   </para>

   <table id="functions-posix-table">
    <title>Opérateurs de correspondance des expressions rationnelles</title>

    <tgroup cols="3">
     <colspec colnum="1" colwidth="0.3*"/>
     <colspec colnum="2" colwidth="1.7*"/>
     <colspec colnum="3" colwidth="1*"/>
     <thead>
      <row>
       <entry>Opérateur</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
      </row>
     </thead>

      <tbody>
       <row>
        <entry><literal>~</literal> </entry>
        <entry>Correspondance d'expression rationnelle, en tenant compte
         de la casse</entry>
        <entry><literal>'thomas' ~ '.*thomas.*'</literal></entry>
       </row>

       <row>
        <entry><literal>~*</literal> </entry>
        <entry>Correspondance d'expression rationnelle, sans tenir compte
         de la casse</entry>
        <entry><literal>'thomas' ~* '.*Thomas.*'</literal></entry>
       </row>

       <row>
        <entry><literal>!~</literal> </entry>
        <entry>Non-correspondance d'expression rationnelle, en tenant compte
         de la casse</entry>
        <entry><literal>'thomas' !~ '.*Thomas.*'</literal></entry>
       </row>

       <row>
        <entry><literal>!~*</literal> </entry>
        <entry>Non-correspondance d'expression rationnelle, sans tenir compte
         de la casse</entry>
        <entry><literal>'thomas' !~* '.*vadim.*'</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

    <para>
     Les expressions rationnelles <acronym>POSIX</acronym> sont un outil de
     correspondance de motifs plus puissant que les opérateurs
     <function>LIKE</function> et <function>SIMILAR TO</function>. Beaucoup d'outils
     Unix comme <command>egrep</command>, <command>sed</command> ou
     <command>awk</command> utilisent un langage de correspondance de modèles
     similaire à celui décrit ici.
    </para>

    <para>
     Une expression rationnelle est une séquence de caractères représentant une
     définition abrégée d'un ensemble de chaînes (un <firstterm>ensemble
     rationnel</firstterm>). Une chaîne est déclarée correspondre à une
     expression rationnelle si elle est membre de l'ensemble rationnel décrit
     par l'expression rationnelle. Comme avec <function>LIKE</function>, les
     caractères du motif correspondent exactement aux caractères de le chaîne sauf
     s'ils représentent des caractères spéciaux dans le langage des expressions
     rationnelles &mdash; mais les expressions rationnelles utilisent des caractères
     spéciaux différents de ceux utilisés par <function>LIKE</function>. Contrairement
     aux motifs de <function>LIKE</function>, une expression rationnelle peut
     avoir une correspondance en toute place de la chaîne, sauf si l'expression
     rationnelle est explicitement ancrée au début ou à la fin de la chaîne.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>'abc' ~ 'abc'    <lineannotation>true</lineannotation>
'abc' ~ '^a'     <lineannotation>true</lineannotation>
'abc' ~ '(b|d)'  <lineannotation>true</lineannotation>
'abc' ~ '^(b|c)' <lineannotation>false</lineannotation></programlisting>
   </para>

    <para>
     Le langage modèle <acronym>POSIX</acronym> est décrit avec plus de détail
     ci-dessous.
    </para>

    <para>
     La fonction <function>substring</function> avec deux paramètres,
     <function>substring(<replaceable>chaîne</replaceable> from
     <replaceable>motif</replaceable>)</function>, extrait une sous-chaîne qui
     correspond à un motif d'expression rationnelle
     POSIX. Elle renvoie NULL s'il n'y a pas de correspondance, la portion
     de texte correspondant au modèle dans le cas contraire. Mais si le motif
     contient des parenthèses, c'est la portion de texte qui correspond à la
     première sous-expression entre parenthèses (la première dont la parenthèse
     gauche apparaît) qui est renvoyée. Il est possible de placer toute
     l'expression entre parenthèses pour pouvoir utiliser des parenthèses à
     l'intérieur sans déclencher cette exception. 
     Si des parenthèses sont nécessaires dans le motif avant la sous-expression
     à extraire, il faut utiliser les propriétés des parenthèses
     non-capturantes décrites plus bas.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>substring('foubar' from 'o.b')     <lineannotation>oub</lineannotation>
substring('foubar' from 'o(.)b')   <lineannotation>u</lineannotation></programlisting>
   </para>

    <para>
     La fonction <function>regexp_replace</function> substitue un
     nouveau texte aux sous-chaînes correspondantes des motifs
     d'expressions rationnelles. Elle a la syntaxe
     <function>regexp_replace</function>(<replaceable>source</replaceable>,
     <replaceable>motif</replaceable>, <replaceable>remplacement</replaceable>
     <optional>, <replaceable>options</replaceable> </optional>). La chaîne
     <replaceable>source</replaceable> est renvoyée non modifiée s'il n'existe pas de
     correspondance avec <replaceable>motif</replaceable>. S'il existe une correspondance,
     la chaîne <replaceable>source</replaceable> est renvoyée avec la chaîne
     <replaceable>remplacement</replaceable> substituée à la sous-chaîne
     correspondante. La chaîne <replaceable>remplacement</replaceable> peut contenir
     <literal>\</literal><replaceable>n</replaceable>, avec <replaceable>n</replaceable> de
     <literal>1</literal> à <literal>9</literal>, pour indiquer que la <replaceable>n</replaceable>-ième
     sous-chaîne source correspondante doit être insérée. Elle peut aussi
     contenir <literal>\&amp;</literal> pour indiquer que la sous-chaîne
     qui correspond au motif entier doit être insérée. On écrit
     <literal>\\</literal> pou placer un antislash littéral dans
     le texte de remplacement (comme toujours, les
     antislashs doivent être doublés dans les libellés, si la syntaxe
     d'échappement de chaînes est utilisée).
     Le paramètre
     <replaceable>options</replaceable> est une chaîne optionnelle de drapeaux
     (0 ou plus) d'une lettre qui modifie le comportement de la fonction. Le
     drapeau <literal>i</literal> indique une
     recherche insensible à la casse, le drapeau <literal>g</literal>
     un remplacement de chaque sous-chaîne correspondante (pas uniquement la
     première). Les autres options supportées sont décrites dans
     <xref linkend="posix-embedded-options-table"/>.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>regexp_replace('foobarbaz', 'b..', 'X')
                                   <lineannotation>fooXbaz</lineannotation>
regexp_replace('foobarbaz', 'b..', 'X', 'g')
                                   <lineannotation>fooXX</lineannotation>
regexp_replace('foobarbaz', 'b(..)', E'X\\1Y', 'g')
                                   <lineannotation>fooXarYXazY</lineannotation></programlisting>
   </para>

    <para>
     La fonction <function>regexp_matches</function> renvoie toutes les
     sous-chaînes capturées résultant de la correspondance avec une
     expression rationnelle POSIX. Elle a la syntaxe&nbsp;:
     <function>regexp_matches</function>(<replaceable>chaine</replaceable>, <replaceable>modele</replaceable>
     <optional>, <replaceable>options</replaceable> </optional>).
     S'il n'y a pas de correspondance avec <replaceable>modele</replaceable>,
     la fonction ne renvoie aucune ligne. S'il y a une correspondance, la
     fonction renvoie un tableau de texte dont l'élément
     <replaceable>n</replaceable> est la sous-chaîne en correspondance avec la
     <replaceable>n</replaceable>-ième sous-expression entre parenthèses du
     modèle (sans compter les parenthèses <quote>non capturantes</quote>&nbsp;;
     voir ci-dessous pour les détails). Si le modèle ne contient aucune
     sous-expression entre parenthèses, le résultat est un tableau texte à un
     seul élément représentant la sous-chaîne correspondant au modèle complet.
     Le paramètre <replaceable>options</replaceable> est une chaîne optionnelle
     contenant zéro ou plus options d'une lettre, modifiant ainsi le
     comportement de la fonction. L'option <literal>g</literal> indique que la
     fonction trouve chaque correspondance dans la chaîne, pas seulement la
     première, et renvoie une ligne pour chaque correspondance. Les autres
     options supportées sont décrites dans <xref
     linkend="posix-embedded-options-table"/>.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>
SELECT regexp_matches('foobarbequebaz', '(bar)(beque)');
 regexp_matches 
----------------
 {bar,beque}
(1 row)

SELECT regexp_matches('foobarbequebazilbarfbonk', '(b[^b]+)(b[^b]+)', 'g');
 regexp_matches 
----------------
 {bar,beque}
 {bazil,barf}
(2 rows)

SELECT regexp_matches('foobarbequebaz', 'barbeque');
 regexp_matches 
----------------
 {barbeque}
(1 row)
</programlisting>
   </para>

    <para>
     La fonction <function>regexp_split_to_table</function> divise une chaîne
     en utilisant une expression rationnelle POSIX comme délimiteur. Elle a la
     syntaxe suivante&nbsp;:
     <function>regexp_split_to_table</function>(<replaceable>chaine</replaceable>, <replaceable>modele</replaceable>
     <optional>, <replaceable>options</replaceable> </optional>).
     S'il n'y a pas de correspondance avec le <replaceable>modele</replaceable>,
     la fonction renvoie la <replaceable>chaine</replaceable>. S'il y a au
     moins une correspondance, pour chaque correspondance, elle renvoie le
     texte à partir de la fin de la dernière correspondance (ou le début de la
     chaîne) jusqu'au début de la correspondance. Quand il ne reste plus de
     correspondance, elle renvoie le texte depuis la fin de la dernière
     correspondance jusqu'à la fin de la chaîne. Le paramètre
     <replaceable>options</replaceable> est une chaîne optionelle contenant zéro
     ou plus options d'un caractère, modifiant ainsi le comportement de la
     fonction.
     <function>regexp_split_to_table</function> supporte les options décrites
     dans <xref linkend="posix-embedded-options-table"/>.
    </para>

    <para>
     La fonction <function>regexp_split_to_array</function> se comporte de la
     même façon que <function>regexp_split_to_table</function>, sauf que
     <function>regexp_split_to_array</function> renvoie son résultat en tant
     que tableau de <type>text</type>. Elle a comme syntaxe
     <function>regexp_split_to_array</function>(<replaceable>chaine</replaceable>, <replaceable>modele</replaceable>
     <optional>, <replaceable>options</replaceable> </optional>).
     Les paramètres sont les mêmes que pour
     <function>regexp_split_to_table</function>.
    </para>

   <para>
    Quelques exemples&nbsp;:
<programlisting>

<!-- SAS 20080723 : les exemples suivants fonctionnent avec E'\\\s+' ou
E'\\s+'. Quelle est la différence ? N'y en a-t-il simplement pas un de trop
dans le premier exemple ?-->
SELECT foo FROM regexp_split_to_table('the quick brown fox jumped over the lazy dog', E'\\s+') AS foo;
  foo   
--------
 the    
 quick  
 brown  
 fox    
 jumped 
 over   
 the    
 lazy   
 dog    
(9 rows)

SELECT regexp_split_to_array('the quick brown fox jumped over the lazy dog', E'\\s+');
              regexp_split_to_array             
------------------------------------------------
 {the,quick,brown,fox,jumped,over,the,lazy,dog}
(1 row)

SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
 foo 
-----
 t         
 h         
 e         
 q         
 u         
 i         
 c         
 k         
 b         
 r         
 o         
 w         
 n         
 f         
 o         
 x         
(16 rows)
</programlisting>
   </para>

   <para>
    Comme le montre le dernier exemple, les fonctions de division des expressions
    rationnelles ignorent les correspondances de longueur nulle qui surviennent
    au début ou à la fin de la chaîne ou immédiatement après une correspondance.
    C'est contraire à la définition stricte de la correspondance des
    expressions rationnelles implantée par
    <function>regexp_matches</function>, mais c'est habituellement le comportement
    le plus pratique. Les autres systèmes comme Perl utilisent des
    définitions similaires.
   </para>

<!-- derived from the re_syntax.n man page -->

   <sect3 id="posix-syntax-details">
    <title>Détails des expressions rationnelles</title>

   <para>
    Les expressions rationnelles de <productname>PostgreSQL</productname> sont
    implantées à l'aide d'un paquetage écrit par Henry Spencer. Une grande
    partie de la description des expressions rationnelles ci-dessous est une
    copie intégrale de son manuel.
   </para>

   <para>
    Les expressions rationnelles (<acronym>ER</acronym>s), telles que
    définies dans <acronym>POSIX</acronym> 1003.2, existent sous deux
    formes&nbsp;: les <acronym>ER</acronym> <firstterm>étendues</firstterm> ou
    <acronym>ERE</acronym> (en gros celles de <command>egrep</command>) et les
    <acronym>ER</acronym> <firstterm>basiques</firstterm> ou
    <acronym>ERB</acronym> (<acronym>BRE</acronym> en anglais)
    (en gros celles d'<command>ed</command>).
    <productname>PostgreSQL</productname> supporte les deux formes et
    y ajoute quelques extensions ne faisant pas partie du standard
    POSIX mais largement utilisées du fait de leur
    disponibilité dans les langages de programmation tels que Perl et Tcl.
    Les <acronym>ER</acronym> qui utilisent ces extensions non POSIX sont appelées
    des <acronym>ER</acronym> <firstterm>avancées</firstterm> ou
    <acronym>ERA</acronym> (<acronym>ARE</acronym> en anglais)
    dans cette documentation. Les ERA sont un surensemble exact des ERE alors
    que les ERB ont des incompatibilités de notation (sans parler du fait
    qu'elles sont bien plus limitées). En premier lieu sont décrits les formats
    ERA et ERE, en précisant les fonctionnalités qui ne s'appliquent qu'aux
    ERA. L'explication des différences des ERB vient ensuite.
   </para>

   <note>
    <para>
     La forme des expressions rationnelles acceptées par
     <productname>PostgreSQL</productname> peut être choisie à l'aide du
     paramètre d'exécution
     <xref linkend="guc-regex-flavor"/> (décrit dans le
     <xref linkend="runtime-config"/>). La configuration habituelle est
     <literal>advanced</literal> (NdT&nbsp;: pour avancées) mais il est possible
     de sélectionner <literal>extended</literal> (pour étendues) pour obtenir un
     maximum de compatibilité avec les versions antérieures à la version 7.4 de
     <productname>PostgreSQL</productname>.
    </para>
   </note>

   <para>
    Une expression rationnelle est définie par une ou plusieurs
    <firstterm>branches</firstterm> séparées par des caractères
    <literal>|</literal>. Elle établit une correspondance avec tout ce qui
    correspond à une des branches.
   </para>

   <para>
    Une branche contient des <firstterm>atomes quantifiés</firstterm>, ou
    <firstterm>contraintes</firstterm>, concaténés. Elle établit une correspondance
    pour le premier suivi d'une correspondance pour le second, etc&nbsp;; une
    branche vide établit une correspondance avec une chaîne vide.   
   </para>

   <para>
    Un atome quantifié est un <firstterm>atome</firstterm> éventuellement suivi d'un
    <firstterm>quantificateur</firstterm> unique. Sans quantificateur, il établit une
    correspondance avec l'atome. Avec un quantificateur, il peut établir un
    certain nombre de correspondances avec l'atome. Un <firstterm>atome</firstterm>
    est une des possibilités du <xref linkend="posix-atoms-table"/>.
    Les quantificateurs possibles et leurs significations sont disponibles dans le
    <xref linkend="posix-quantifiers-table"/>.
   </para>

<!-- SAS 20070719 : to match doit pouvoir se traduire différement de
correspondre. Cela engendre en effet des difficultés de compréhension, voire
une affaiblissement conceptuel du message original lors de sa traduction... -->
   <para>
    Une <firstterm>contrainte</firstterm> établit une correspondance avec une
    chaîne vide, mais cette correspondance n'est établie que lorsque des
    conditions spécifiques sont remplies.
    Une contrainte peut être utilisée là où un atome peut l'être et
    ne peut pas être suivie d'un quantificateur.
    Les contraintes simples sont affichées dans le <xref
    linkend="posix-constraints-table"/>&nbsp;; quelques contraintes
    supplémentaires sont décrites plus loin.
   </para>


   <table id="posix-atoms-table">
    <title>Atomes d'expressions rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Atome</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>(</literal><replaceable>re</replaceable><literal>)</literal> </entry>
       <entry>(où <replaceable>re</replaceable> est toute expression rationnelle)
        établit une correspondance avec <replaceable>re</replaceable>, la
        correspondance étant conservée en vue d'un éventuel report</entry>
       </row>

       <row>
       <entry><literal>(?:</literal><replaceable>re</replaceable><literal>)</literal> </entry>
       <entry>comme ci-dessus mais la correspondance n'est pas conservée pour
       report
       (un ensemble de parenthèses <quote>sans capture</quote>)
       (seulement pour les ERA) </entry>
       </row>

       <row>
       <entry><literal>.</literal> </entry>
       <entry>correpondance avec tout caractère unique</entry>
       </row>

       <row>
       <entry><literal>[</literal><replaceable>caractères</replaceable><literal>]</literal> </entry>
       <entry>une <firstterm>expression entre crochets</firstterm>, qui établit
       une correspondance avec tout caractère de <replaceable>caractères</replaceable> (voir la
       <xref linkend="posix-bracket-expressions"/> pour plus de détails) </entry>
       </row>

       <row>
       <entry><literal>\</literal><replaceable>k</replaceable> </entry>
       <entry>(où <replaceable>k</replaceable> n'est pas un caractère
       alpha-numérique) établit une correspondance avec ce caractère, considéré
       comme caractère ordinaire. Par exemple, <literal>\\</literal> établit
       une correspondance avec un caractère antislash </entry>
       </row>

       <row>
       <entry><literal>\</literal><replaceable>c</replaceable> </entry>
       <entry>avec <replaceable>c</replaceable> un caractère alphanumérique
       (éventuellement suivi d'autres caractères)
       est un <firstterm>échappement</firstterm>, voir la
       <xref linkend="posix-escape-sequences"/>
       (ERA seulement&nbsp;; pour les ERE et ERB, établit une correspondance
       avec <replaceable>c</replaceable>) </entry>
       </row>

       <row>
       <entry><literal>{</literal> </entry>
       <entry>lorsqu'il est suivi d'un caractère autre qu'un chiffre, établit
       une correspondance avec l'accolade ouvrante <literal>{</literal>&nbsp;;
       suivi d'un chiffre, c'est le début d'une
       <replaceable>limite</replaceable> (voir ci-dessous)</entry>
       </row>

       <row>
       <entry><replaceable>x</replaceable> </entry>
       <entry>où <replaceable>x</replaceable> est un caractère unique sans signification,
       établit une correspondance avec ce caractère</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Une ER ne peut pas se terminer par <literal>\</literal>.
   </para>

   <note>
    <para>
     L'antislash (<literal>\</literal>) a déjà une
     signification particulière dans les chaînes littérales
     <productname>PostgreSQL</productname>. Pour écrire un motif contenant un
     antislash, il faut écrire deux antislashs dans l'instruction, en supposant
     que la syntaxe de chaîne d'échappement est utilisée (voir <xref
     linkend="sql-syntax-strings"/>).
    </para>
   </note>

   <table id="posix-quantifiers-table">
    <title>quantificateur d'expressions rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>quantificateur</entry>
       <entry>Correspondance</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>*</literal> </entry>
       <entry>une séquence de 0 ou plus correspondance(s) de l'atome </entry>
       </row>

       <row>
       <entry><literal>+</literal> </entry>
       <entry>une séquence de 1 ou plus correspondance(s) de l'atome </entry>
       </row>

       <row>
       <entry><literal>?</literal> </entry>
       <entry>une séquence de 0 ou 1 correspondance de l'atome </entry>
       </row>

       <row>
       <entry><literal>{</literal><replaceable>m</replaceable><literal>}</literal> </entry>
       <entry>une séquence d'exactement <replaceable>m</replaceable>
       correspondances de l'atome
</entry>
       </row>

       <row>
       <entry><literal>{</literal><replaceable>m</replaceable><literal>,}</literal> </entry>
       <entry>une séquence de <replaceable>m</replaceable> ou plus
       correspondances de l'atome
</entry>
       </row>

       <row>
       <entry>
       <literal>{</literal><replaceable>m</replaceable><literal>,</literal><replaceable>n</replaceable><literal>}</literal>
</entry>
       <entry>une séquence de <replaceable>m</replaceable> à <replaceable>n</replaceable>
       (inclus) correspondances de l'atome&nbsp;; <replaceable>m</replaceable> ne doit pas
       être supérieur à <replaceable>n</replaceable> </entry>
       </row>

<!-- greedy : gourmande ? Que cela signifie-t-il ? -->
       <row>
       <entry><literal>*?</literal> </entry>
       <entry>version non gourmande de <literal>*</literal> </entry>
       </row>

       <row>
       <entry><literal>+?</literal> </entry>
       <entry>version non gourmande de <literal>+</literal> </entry>
       </row>

       <row>
       <entry><literal>??</literal> </entry>
       <entry>version non gourmande de <literal>?</literal> </entry>
       </row>

       <row>
       <entry><literal>{</literal><replaceable>m</replaceable><literal>}?</literal> </entry>
       <entry>version non gourmande de <literal>{</literal><replaceable>m</replaceable><literal>}</literal>
</entry>
       </row>

       <row>
       <entry><literal>{</literal><replaceable>m</replaceable><literal>,}?</literal> </entry>
       <entry>version non gourmande de
<literal>{</literal><replaceable>m</replaceable><literal>,}</literal> </entry>
       </row>

       <row>
       <entry>
      
<literal>{</literal><replaceable>m</replaceable><literal>,</literal><replaceable>n</replaceable><literal>}?</literal>
</entry>
       <entry>version non gourmande de
<literal>{</literal><replaceable>m</replaceable><literal>,</literal><replaceable>n</replaceable><literal>}</literal>
</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Les formes qui utilisent <literal>{</literal><replaceable>...</replaceable><literal>}</literal>
    sont appelées <firstterm>limite</firstterm>s.
    Les nombres <replaceable>m</replaceable> et <replaceable>n</replaceable> à l'intérieur d'une limite
    sont des entiers non signés dont les valeurs vont de 0 à 255 inclus.
   </para>

    <para>
     Les quantificateurs <firstterm>non gourmands</firstterm> (disponibles uniquement avec les ERA)
     correspondent aux même possibilités que leurs équivalents normaux
     (<firstterm>gourmand</firstterm>),
     mais préfèrent le plus petit nombre de correspondances au plus grand nombre.
     Voir la <xref linkend="posix-matching-rules"/> pour plus de détails.
   </para>

   <note>
    <para>
     Un quantificateur ne peut pas immédiatement suivre un autre quantificateur,
     autrement dit <literal>**</literal> est invalide.
     Il ne peut pas non plus débuter une expression ou sous-expression
     ni suivre <literal>^</literal> ou <literal>|</literal>.
    </para>
   </note>

   <table id="posix-constraints-table">
    <title>Contraintes des expressions rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Contrainte</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>^</literal></entry>
       <entry>correspondance de début de chaîne</entry>
       </row>

       <row>
       <entry><literal>$</literal></entry>
       <entry>correspondance de fin de chaîne</entry>
       </row>

       <row>
       <entry><literal>(?=</literal><replaceable>er</replaceable><literal>)</literal></entry>
       <entry><firstterm>positive lookahead</firstterm> (recherche positive) 
       établit une correspondance avec tout point où une
       sous-chaîne qui correspond à <replaceable>er</replaceable> débute
       (uniquement pour les ERA)</entry>
       </row>

       <row>
       <entry><literal>(?!</literal><replaceable>er</replaceable><literal>)</literal></entry>
       <entry><firstterm>negative lookahead</firstterm> (recherche négative)
       établit une correspondance avec tout point où aucune
       sous-chaîne qui correspond à <replaceable>re</replaceable> ne débute
       (uniquement pour les ERA)</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Les contraintes <quote>lookahead</quote> ne doivent pas contenir de
    <firstterm>références arrières</firstterm> (voir la <xref
    linkend="posix-escape-sequences"/>), et toutes les parenthèses contenues
    sont considérées comme non capturantes.
   </para>
   </sect3>

   <sect3 id="posix-bracket-expressions">
    <title>Expressions avec crochets</title>

   <para>
    Une <firstterm>expression entre crochets</firstterm> est une liste de
    caractères contenue dans <literal>[]</literal>. Une correspondance est
    habituellement établie avec tout caractère de la liste (voir cependant plus
    bas). Si la liste débute par <literal>^</literal>, la correspondance est
    établie avec tout caractère <emphasis>non</emphasis>
    compris dans la liste. Si deux caractères de la liste sont séparés par un
    tiret (<literal>-</literal>), il s'agit d'un raccourci pour représenter tous les caractères
    compris entre ces deux-là, c'est-à-dire qu'en <acronym>ASCII</acronym>,
    <literal>[0-9]</literal> correspond à tout chiffre. 
    Deux séquences ne peuvent pas partager une limite, par exemple 
    <literal>a-c-e</literal>. Les plages étant fortement liées à la séquence de
    tri (<foreignphrase>collate</foreignphrase>), il est recommandé de ne pas
    les utiliser dans les programmes portables.
   </para>

   <para>
    Un <literal>]</literal> peut être inclus dans la liste s'il en est le
    premier caractère (éventuellement précédé de 
    <literal>^</literal>). 
    Un <literal>-</literal> peut être inclus dans la liste s'il en est le
    premier ou le dernier caractère ou s'il est la deuxième borne d'une plage.
    Un <literal>-</literal> peut être utilisé comme première borne d'une plage
    s'il est entouré par <literal>[.</literal> et <literal>.]</literal> et
    devient de ce fait un élément d'interclassement (<foreignphrase>collating
    element</foreignphrase>).
    <!-- collating element ? Elément de cohésion ou collate dans le sens
    lc_collate, ordre de tri ? -->
    À l'exception de ces caractères, 
    des combinaisons utilisant <literal>[</literal> (voir les
    paragraphes suivants) et des échappements (uniquement pour les ERA), tous
    les autres caractères spéciaux perdent leur signification spéciale à
    l'intérieur d'une expression entre crochets. En particulier,
    <literal>\</literal> n'est pas spécial lorsqu'il suit les règles des ERE ou
    des ERB bien qu'il soit spécial (en tant qu'introduction d'un échappement)
    dans les ERA.
   </para>

<!-- Alors, là, on nage en pleine incompréhensibilité 
     La suite est à reprendre. Mais il me manque la compréhension du terme
     'collating' 
     en gros : collating : fusionnement
		collating sequence : sequence ou ordre d'interclassement
		collate : interclasser-->
   <para>
    Dans une expression entre crochets, un élément d'interclassement (un
    caractère, une séquence de caractères multiples qui s'interclasse comme un
    élément unique, ou le nom d'une séquence d'interclassement) entouré de
    <literal>[.</literal> et <literal>.]</literal> représente la séquence de
    caractères de cet élément d'interclassement. La séquence est un élément
    unique de la liste dans l'expression entre crochets. Une expression entre crochets
    contenant un élément d'interclassement multi-caractères peut donc correspondre
    à plusieurs caractères (par exemple, si la séquence d'interclassement inclut un 
    élément d'interclassement <literal>ch</literal>, alors l'ER
    <literal>[[.ch.]]*c</literal> établit une correspondance avec les cinq
    premiers caractères de <literal>chchcc</literal>.
   </para>

   <note>
    <para>
     <productname>PostgreSQL</productname> n'a pas, à ce jour, d'éléments
     d'interclassement multi-caractères. L'information portée ici décrit un
     éventuel comportement futur.
    </para>
   </note>

   <para>
    Dans une expression entre crochets, un élément d'interclassement
    écrit entre <literal>[=</literal> et <literal>=]</literal> est une classe
    d'équivalence qui représente les séquences de caractères de tous les
    éléments d'interclassement équivalents à celui-là, lui compris. (En
    l'absence d'élément d'interclassement équivalent, le traitement
    correspond à celui obtenu avec les délimiteurs <literal>[.</literal> et
    <literal>.]</literal>). Par exemple, si <literal>o</literal> et
    <literal>^</literal> sont les membres d'une classe d'équivalence, alors
    <literal>[[=o=]]</literal>, <literal>[[=^=]]</literal> et
    <literal>[o^]</literal> sont tous synonymes. Une classe d'équivalence
    ne peut pas être borne d'une plage.
   </para>

   <para>
    Dans une expression entre crochets, le nom d'une classe de
    caractères écrit entre <literal>[:</literal> et <literal>:]</literal>
    représente la liste de tous les caractères appartenant à cette classe.
    Les noms de classes de caractères standard sont <literal>alnum</literal>,
    <literal>alpha</literal>, <literal>blank</literal>,
    <literal>cntrl</literal>, <literal>digit</literal>,
    <literal>graph</literal>, <literal>lower</literal>,
    <literal>print</literal>, <literal>punct</literal>,
    <literal>space</literal>, <literal>upper</literal>,
    <literal>xdigit</literal>. Ils correspondent aux classes de caractères
    définies dans <citerefentry><refentrytitle>ctype</refentrytitle><manvolnum>3</manvolnum></citerefentry>.
    Une locale peut en fournir d'autres. Une classe de caractères ne peut pas
    être utilisée comme borne d'une plage.
   </para>

   <para>
    Il existe deux cas spéciaux d'expressions entre crochets&nbsp;: les
    expressions entre crochets <literal>[[:&lt;:]]</literal> et
    <literal>[[:&gt;:]]</literal> sont des contraintes, qui établissent une
    correspondance avec des chaînes
    vides respectivement au début et à la fin d'un mot. Un mot est défini comme
    une séquence de caractères de mot qui n'est ni précédée ni suivie de
    caractères de mot.
    Un caractère de mot est un caractère <literal>alnum</literal> (comme défini par
<citerefentry><refentrytitle>ctype</refentrytitle><manvolnum>3</manvolnum></citerefentry>)
    ou un tiret bas. C'est une extension, compatible avec, mais non spécifiée 
    dans <acronym>POSIX</acronym> 1003.2, et devant être utilisée avec
    précaution dans les logiciels conçus pour être portables sur d'autres
    systèmes. Les échappements de contraintes décrits ci-dessous sont
    généralement préférables (ils ne sont pas plus standard mais 
    certainement plus simples à saisir).
   </para>
   </sect3>

<!-- Jusque-là, a priori -->
   <sect3 id="posix-escape-sequences">
    <title>Échappement d'expressions rationnelles</title>

   <para>
    Les <firstterm>échappements</firstterm> sont des séquences spéciales
    débutant avec <literal>\</literal> suivi d'un caractère
    alphanumérique. Il existe plusieurs sortes d'échappements&nbsp;:
    entrée de caractère, raccourci de classe, échappement de contraintes et
    rétro-références. Un <literal>\</literal> suivi d'un caractère alphanumérique
    qui ne constitue pas un échappement valide est illégal dans une ERA.
    Pour les ERE, il n'y pas d'échappement&nbsp;: en dehors d'une expression
    entre crochets, un <literal>\</literal> suivi d'un caractère alphanumérique
    représente simplement ce caractère (comme ordinaire) et, à l'intérieur d'une
    expression entre crochets, <literal>\</literal> est un caractère ordinaire. 
    (C'est dans ce dernier cas que se situe réellement l'incompatibilité entre les ERE et les
    ERA.)
   </para>

   <para>
    Les <firstterm>échappements de caractère</firstterm>
    (<foreignphrase>character-entry escapes</foreignphrase>) permettent
    d'indiquer des caractères non affichables et donc indésirables dans
    les ER. Ils sont présentés dans le <xref linkend="posix-character-entry-escapes-table"/>.
   </para>

   <para>
    Les <firstterm>échappements de raccourci de classe</firstterm>
    (<foreignphrase>class-shorthand escapes</foreignphrase>) fournissent des
    raccourcis pour certaines classes de caractères communément utilisées. Ils sont
    présentés dans le <xref linkend="posix-class-shorthand-escapes-table"/>.
   </para>

   <para>
    Un <firstterm>échappement de contrainte</firstterm>
    (<foreignphrase>constraint escape</foreignphrase>) est une contrainte,
    qui correspond à la chaîne vide sous certaines conditions, écrite comme
    un échappement. Ces échappements sont
    présentés dans le <xref linkend="posix-constraint-escapes-table"/>.
   </para>

   <para>
    Une <firstterm>rétro-référence</firstterm> (<foreignphrase>back
    reference</foreignphrase>) (<literal>\</literal><replaceable>n</replaceable>)
    correspond à la même chaîne que la sous-expression entre parenthèses précédente
    indiquée par le nombre <replaceable>n</replaceable> (voir le <xref
    linkend="posix-constraint-backref-table"/>). Par exemple,
    <literal>([bc])\1</literal> peut correspondre à <literal>bb</literal> ou
    <literal>cc</literal>,
    mais ni à <literal>bc</literal> ni à <literal>cb</literal>. La sous-expression doit
    précéder complètement la référence dans l'ER. Les sous-expressions sont
    numérotées dans l'ordre des parenthèses ouvrantes. Les parenthèses non
    capturantes ne définissent pas de sous-expressions.
   </para>

   <note>
    <para>
     Le symbole <literal>\</literal> qui débute une séquence d'échappement doit être
     obligatoirement doublé pour saisir le motif comme une chaîne SQL constante. Par
     exemple&nbsp;:
<programlisting>'123' ~ E'^\\d{3}' <lineannotation>true</lineannotation></programlisting>
    </para>
   </note>

   <table id="posix-character-entry-escapes-table">
    <title>Échappements de caractère dans les expressions
rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Échappement</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>\a</literal> </entry>
       <entry>caractère alerte (cloche), comme en C </entry>
       </row>

       <row>
       <entry><literal>\b</literal> </entry>
       <entry>effacement (<foreignphrase>backspace</foreignphrase>), comme en C </entry>
       </row>

       <row>
       <entry><literal>\B</literal> </entry>
       <entry>synonyme de <literal>\</literal> pour éviter les doublements
       d'antislash </entry>
       </row>

       <row>
       <entry><literal>\c</literal><replaceable>X</replaceable> </entry>
       <entry>(où <replaceable>X</replaceable> est un caractère quelconque) le caractère
       dont les cinq bits de poids faible sont les mêmes que ceux de 
       <replaceable>X</replaceable> et dont tous les autres bits sont à zéro </entry>
       </row>

       <row>
       <entry><literal>\e</literal> </entry>
       <entry>le caractère dont le nom de séquence d'interclassement est
       <literal>ESC</literal>, ou le caractère de valeur octale
       033 </entry>
       </row>

       <row>
       <entry><literal>\f</literal> </entry>
       <entry>retour chariot (<foreignphrase>form feed</foreignphrase>), comme en C </entry>
       </row>

       <row>
       <entry><literal>\n</literal> </entry>
       <entry>retour à la ligne (<foreignphrase>newline</foreignphrase>), comme en C </entry>
       </row>

       <row>
       <entry><literal>\r</literal> </entry>
       <entry>retour chariot (<foreignphrase>carriage return</foreignphrase>), comme en C </entry>
       </row>

       <row>
       <entry><literal>\t</literal> </entry>
       <entry>tabulation horizontale, comme en C </entry>
       </row>

       <row>
       <entry><literal>\u</literal><replaceable>wxyz</replaceable> </entry>
       <entry>(où <replaceable>wxyz</replaceable> représente exactement quatre chiffres
       hexadécimaux) le caractère UTF16 (Unicode, 16 bits)
       <literal>U+</literal><replaceable>wxyz</replaceable>
       dans l'ordre local des octets</entry>
       </row>

       <row>
       <entry><literal>\U</literal><replaceable>stuvwxyz</replaceable> </entry>
       <entry>(où <replaceable>stuvwxyz</replaceable> représente exactement huit
       chiffres hexadécimaux) réservé pour une extension, hypothétique, de l'Unicode vers le 32
       bits
       </entry> 
       </row>

       <row>
       <entry><literal>\v</literal> </entry>
       <entry>tabulation verticale, comme en C </entry>
       </row>

       <row>
       <entry><literal>\x</literal><replaceable>hhh</replaceable> </entry>
       <entry>(où <replaceable>hhh</replaceable> représente toute séquence de chiffres
       hexadécimaux) le caractère dont la valeur hexadécimale est
       <literal>0x</literal><replaceable>hhh</replaceable>
       (un simple caractère, peu importe le nombre de chiffres hexadécimaux
       utilisés)
       </entry>
       </row>

       <row>
       <entry><literal>\0</literal> </entry>
       <entry>le caractère dont la valeur est <literal>0</literal> </entry>
       </row>

       <row>
       <entry><literal>\</literal><replaceable>xy</replaceable> </entry>
       <entry>(où <replaceable>xy</replaceable> représente exactement deux chiffres
       octaux et n'est pas une <firstterm>rétro-référence</firstterm>)
       le caractère dont la valeur octale est
       <literal>0</literal><replaceable>xy</replaceable> </entry>
       </row>

       <row>
       <entry><literal>\</literal><replaceable>xyz</replaceable> </entry>
       <entry>(où <replaceable>xyz</replaceable> représente exactement trois chiffres
       octaux et n'est pas une <firstterm>rétro-référence</firstterm>)
       le caractère dont la valeur octale est
       <literal>0</literal><replaceable>xyz</replaceable> </entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Les chiffres hexadécimaux sont <literal>0</literal>-<literal>9</literal>,
    <literal>a</literal>-<literal>f</literal> et <literal>A</literal>-<literal>F</literal>.
    Les chiffres octaux sont <literal>0</literal>-<literal>7</literal>.
   </para>

   <para>
    Les échappements de caractère sont toujours pris comme
    des caractères ordinaires. Par exemple, <literal>\135</literal> est <literal>]</literal>
    en ASCII mais <literal>\135</literal> ne termine pas une expression entre crochets.
   </para>

   <table id="posix-class-shorthand-escapes-table">
    <title>Échappement de raccourcis de classes dans les expressions
rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Échappement</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>\d</literal> </entry>
       <entry><literal>[[:digit:]]</literal> </entry>
       </row>

       <row>
       <entry><literal>\s</literal> </entry>
       <entry><literal>[[:space:]]</literal> </entry>
       </row>

       <row>
       <entry><literal>\w</literal> </entry>
       <entry><literal>[[:alnum:]_]</literal>
       (le tiret bas est inclus) </entry>
       </row>

       <row>
       <entry><literal>\D</literal> </entry>
       <entry><literal>[^[:digit:]]</literal> </entry>
       </row>

       <row>
       <entry><literal>\S</literal> </entry>
       <entry><literal>[^[:space:]]</literal> </entry>
       </row>

       <row>
       <entry><literal>\W</literal> </entry>
       <entry><literal>[^[:alnum:]_]</literal>
       (le tiret bas est inclus) </entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Dans les expressions entre crochets, <literal>\d</literal>, <literal>\s</literal>,
    et <literal>\w</literal> perdent leurs crochets externes et <literal>\D</literal>,
    <literal>\S</literal> et <literal>\W</literal> ne sont pas autorisés.
    (Ainsi, par exemple, <literal>[a-c\d]</literal> est équivalent à
    <literal>[a-c[:digit:]]</literal>. Mais 
    <literal>[a-c\D]</literal>, qui est équivalent à
    <literal>[a-c^[:digit:]]</literal>, est interdit.)
   </para>

   <table id="posix-constraint-escapes-table">
    <title>Échappements de contrainte dans les expressions rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Échappement</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>\A</literal> </entry>
       <entry>n'établit la correspondance qu'au début de la chaîne
       (voir la <xref linkend="posix-matching-rules"/> pour comprendre la
       différence avec <literal>^</literal>) </entry>
       </row>

       <row>
       <entry><literal>\m</literal> </entry>
       <entry>n'établit la correspondance qu'au début d'un mot </entry>
       </row>

       <row>
       <entry><literal>\M</literal> </entry>
       <entry>n'établit la correspondance qu'à la fin d'un mot </entry>
       </row>

       <row>
       <entry><literal>\y</literal> </entry>
       <entry>n'établit la correspondance qu'au début ou à la fin d'un mot </entry>
       </row>

       <row>
       <entry><literal>\Y</literal> </entry>
       <entry>n'établit la correspondance qu'en dehors du début et de la fin d'un mot </entry>
       </row>

       <row>
       <entry><literal>\Z</literal> </entry>
       <entry>n'établit la correspondance qu'à la fin d'une chaîne
       (voir la <xref linkend="posix-matching-rules"/> pour comprendre la
       différence avec <literal>$</literal>) </entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Un mot est défini selon suivant la spécification de <literal>[[:&lt;:]]</literal> et
    <literal>[[:&gt;:]]</literal> donnée ci-dessus. Les échappement de contrainte sont
    interdits dans les expressions entre crochets.
   </para>

   <table id="posix-constraint-backref-table">
    <title>Rétro-références dans les expressions rationnelles</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Échappement</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>\</literal><replaceable>m</replaceable> </entry>
       <entry>(où <replaceable>m</replaceable> est un chiffre différent de zéro)
       référence à la <replaceable>m</replaceable>-ième sous-expression </entry>
       </row>

       <row>
       <entry><literal>\</literal><replaceable>mnn</replaceable> </entry>
       <entry>(où <replaceable>m</replaceable> est un chiffre différent de zéro et
       <replaceable>nn</replaceable> quelques chiffres supplémentaires, et la valeur
       décimale <replaceable>mnn</replaceable> n'est pas plus grande que le nombre de
       parenthèses fermantes capturantes vues jusque là) référence 
       à la <replaceable>mnn</replaceable>-ième sous-expression </entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <note>
    <para>
     Une ambiguïté persiste entre les échappements
     de caractère octal et les rétro-références. Cette ambiguïté est résolue par
     les heuristiques suivantes, comme montré ci-dessus. Un zéro en début de chaîne indique
     toujours un échappement octal. Un caractère seul différent de zéro, qui
     n'est pas suivi d'un autre caractère, est toujours pris comme une rétro-référence. Une
     séquence à plusieurs chiffres qui ne débute pas par zéro est prise comme
     une référence si elle suit une sous-expression utilisable
     (c'est-à-dire que le nombre est dans la plage autorisée pour les
     rétro-références). Dans le cas contraire, il est pris comme nombre octal.
    </para>
   </note>
   </sect3>

   <sect3 id="posix-metasyntax">
    <title>Métasyntaxe des expressions rationnelles</title>

   <para>
    En plus de la syntaxe principale décrite ci-dessus, il existe quelques
    formes spéciales et autres possibilités syntaxiques.
   </para>

   <para>
    Normalement, le type d'ER considéré est déterminé par
    <varname>regex_flavor</varname>. Néanmoins, ce paramètre peut être surchargé par un préfixe
    <firstterm>directeur</firstterm>. Si une ER commence
    par <literal>***:</literal>, le reste de l'ER est considéré comme une ERA,
    quelque soit la valeur de <varname>regex_flavor</varname>.
    Si une ER commence par <literal>***=</literal>, le reste
    de l'ER est considéré comme une chaîne littérale, tous les caractères étant
    considérés ordinaires.
   </para>

   <para>
    Une ERA peut débuter par des <firstterm>options intégrées</firstterm>&nbsp;:
    une séquence <literal>(?</literal><replaceable>xyz</replaceable><literal>)</literal>
    (où <replaceable>xyz</replaceable> correspond à un ou plusieurs caractères
    alphabétiques) spécifie les options affectant le reste de l'ER. Ces options
    surchargent toutes les options précédemment déterminées (dont le type de
    l'ER et la sensibilité à la casse). Les lettres d'options disponibles sont
    indiquées dans le <xref linkend="posix-embedded-options-table"/>.
   </para>

   <table id="posix-embedded-options-table">
    <title>Lettres d'option intégrées à une ERA</title>

    <tgroup cols="2">
     <colspec colnum="1" colwidth="0.4*"/>
     <colspec colnum="2" colwidth="1.6*"/>
     <thead>
      <row>
       <entry>Option</entry>
       <entry>Description</entry>
      </row>
     </thead>

      <tbody>
       <row>
       <entry><literal>b</literal> </entry>
       <entry>le reste de l'ER est une ERB </entry>
       </row>

       <row>
       <entry><literal>c</literal> </entry>
       <entry>activation de la sensibilité à la casse (surcharge l'opérateur
       type) </entry>
       </row>

       <row>
       <entry><literal>e</literal> </entry>
       <entry>le reste de l'ER est une ERE </entry>
       </row>

       <row>
       <entry><literal>i</literal> </entry>
       <entry>désactivation de la sensibilité à la casse (voir la
       <xref linkend="posix-matching-rules"/>) (surcharge l'opérateur
       type)</entry>
       </row>

       <row>
       <entry><literal>m</literal> </entry>
       <entry>synonyme historique pour <literal>n</literal> </entry>
       </row>

       <row>
       <entry><literal>n</literal> </entry>
       <entry>activation de la sensibilité aux nouvelles lignes (voir la
       <xref linkend="posix-matching-rules"/>) </entry>
       </row>

       <row>
       <entry><literal>p</literal> </entry>
       <entry>activation de la sensibilité partielle aux nouvelles lignes (voir
       la <xref linkend="posix-matching-rules"/>) </entry>
       </row>

       <row>
       <entry><literal>q</literal> </entry>
       <entry>le reste de l'ER est une chaîne littérale (<quote>entre
       guillemets</quote>), composé uniquement de caractères ordinaires </entry>
       </row>

       <row>
       <entry><literal>s</literal> </entry>
       <entry>désactivation de la sensibilité aux nouvelles lignes (par défaut)
       </entry>
       </row>

       <row>
       <entry><literal>t</literal> </entry>
       <entry>syntaxe compacte (par défaut&nbsp;; voir ci-dessous) </entry>
       </row>

       <row>
       <entry><literal>w</literal> </entry>
       <entry>activation de la sensibilité partielle inverse aux nouvelles lignes
       (<quote>étrange</quote>)
       (voir la <xref linkend="posix-matching-rules"/>) </entry>
       </row>

       <row>
       <entry><literal>x</literal> </entry>
       <entry>syntaxe étendue (voir ci-dessous) </entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Les options intégrées prennent effet à la <literal>)</literal>
    qui termine la séquence. Elles ne peuvent apparaître qu'au début d'une
    ERA (après le directeur <literal>***:</literal> s'il y en a un).
   </para>

   <para>
    En plus de la syntaxe habituelle d'une ER (<firstterm>compacte</firstterm>), dans
    laquelle tous les caractères ont une signification, il existe une syntaxe
    <firstterm>étendue</firstterm>, accessible en signifiant l'option intégrée
    <literal>x</literal>. Avec la syntaxe étendue, les caractères espace dans
    l'ER sont ignorés comme le sont tous les caractères entre un <literal>#</literal> et
    le retour-chariot qui suit (ou la fin de l'ER). Ceci permet de mettre en
    paragraphe et de commenter une ER complexe. Il existe trois exceptions à
    cette règle de base&nbsp;:

    <itemizedlist>
     <listitem>
      <para>
       un caractère espace ou <literal>#</literal> suivi d'un <literal>\</literal> est
       retenu
      </para>
     </listitem>
     <listitem>
      <para>
       un caractère espace ou <literal>#</literal> à l'intérieur d'une expression
       entre crochets est retenu
      </para>
     </listitem>
     <listitem>
      <para>
       caractère espace et commentaires ne peuvent pas apparaître dans les
       symboles multi-caractères, tels que <literal>(?:</literal>
      </para>
     </listitem>
    </itemizedlist>

    Pour cela, les caractères espace sont
    l'espace, la tabulation, le retour chariot et tout caractère
    appartenant à la classe de caractère <replaceable>space</replaceable>.
   </para>

   <para>
    Enfin, dans une ERA, en dehors d'expressions entre crochets, la
    séquence <literal>(?#</literal><replaceable>ttt</replaceable><literal>)</literal>
    (où <replaceable>ttt</replaceable> est tout texte ne contenant pas <literal>)</literal>) est
    un commentaire, totalement ignoré. Là encore, cela n'est pas permis entre
    les caractères des symboles multi-caractères comme <literal>(?:</literal>. De tels
    commentaires sont plus un artefact historique qu'une fonctionnalité utile et
    leur utilisation est obsolète&nbsp;; on utilise plutôt la syntaxe étendue.
   </para>

   <para>
    <emphasis>Aucune</emphasis> de ces extensions métasyntaxique n'est disponible si un
    directeur initial <literal>***=</literal> indique que la saisie
    utilisateur doit être traitée comme une chaîne littérale plutôt que comme
    une ER.
   </para>
   </sect3>

   <sect3 id="posix-matching-rules">
    <title>Règles de correspondance des expressions rationnelles</title>

   <para>
    Dans l'hypothèse où une ER peut correspondre à plusieurs sous-chaînes
    d'une chaîne donnée, l'ER correspond à celle qui apparaît la première dans la
    chaîne. Si l'ER peut correspondre à plusieurs sous-chaînes à partir de ce
    point, c'est soit la correspondance la plus longue possible,
    soit la correspondance la plus courte possible, qui est retenue selon que l'ER
    est <firstterm>gourmande</firstterm> ou
    <firstterm>non-gourmande</firstterm>
    (<foreignphrase>greedy/non-greedy</foreignphrase>).
   </para>

<!-- SAS 20070731 : gourmandise est un terme sympathique, mais est-ce le
meilleur ?-->
   <para>
     La gourmandise d'une ER est déterminée par les règles
     suivantes&nbsp;:
     <itemizedlist>
       <listitem>
         <para>
           la plupart des atomes, et toutes les contraintes, n'ont pas
           d'attribut de gourmandise (parce qu'ils ne peuvent, en aucune façon, établir de
	   correspondance avec des quantités variables de texte)&nbsp;;
         </para>
       </listitem>
       <listitem>
         <para>
           l'ajout de parenthèses autour d'une ER ne change pas sa
	   gourmandise&nbsp;;
         </para>
       </listitem>
       <listitem>
         <para>
           un atome quantifié avec un quantificateur à répétition fixe
           (<literal>{</literal><replaceable>m</replaceable><literal>}</literal> ou
           <literal>{</literal><replaceable>m</replaceable><literal>}?</literal>) a la même gourmandise
           (éventuellement aucune) que l'atome lui-même&nbsp;;	
         </para>
       </listitem>
       <listitem>
         <para>
           un atome quantifié avec d'autres quantificateurs standard (dont
<literal>{</literal><replaceable>m</replaceable><literal>,</literal><replaceable>n</replaceable><literal>}</literal>
           avec <replaceable>m</replaceable> égal à <replaceable>n</replaceable>) est gourmand
           (préfère la plus grande correspondance)&nbsp;;
         </para>
       </listitem>
       <listitem>
         <para>
           un atome quantifié avec un quantificateur non gourmand (dont
    <literal>{</literal><replaceable>m</replaceable><literal>,</literal><replaceable>n</replaceable><literal>}?</literal>
           avec <replaceable>m</replaceable> égal à <replaceable>n</replaceable>) n'est pas gourmand
           (préfère la plus courte correspondance)&nbsp;;
         </para>
       </listitem>
       <listitem>
         <para>
           une branche &mdash; c'est-à-dire une ER dépourvue d'opérateur
           <literal>|</literal> au sommet &mdash; est aussi gourmande que le
           premier atome quantifié qu'elle contient qui possède un attribut de
	   gourmandise&nbsp;;
         </para>
       </listitem>
       <listitem>
         <para>
           une ER constituée au minimum de deux branches connectées par
           l'opérateur <literal>|</literal> est toujours gourmande.
         </para>
       </listitem>
     </itemizedlist>
   </para>

   <para>
     Les règles ci-dessus associent les attributs de gourmandise non seulement avec
     les atomes quantifiés individuels, mais aussi avec les branches et les
     ER complètes qui contiennent des atomes quantifiés. Cela signifie que la
     correspondance est établie de sorte que la branche, ou l'ER
     complète, corresponde à la sous-chaîne la plus longue ou la plus courte
     possible <emphasis>comme un tout</emphasis>.
     Une fois la longueur de la correspondance complète déterminée, la partie
     de cette correspondance qui établit une correspondance avec une
     sous-expression particulière est déterminée sur la base de l'attribut de
     gourmandise de cette sous-expression, priorité étant donnée aux sous-expressions commençant
     le plus tôt dans l'ER.
   </para>

   <para>
     Exemple de signification de tout cela&nbsp;:
<screen>SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
<lineannotation>Resultat : </lineannotation><computeroutput>123</computeroutput>
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
<lineannotation>Resultat : </lineannotation><computeroutput>1</computeroutput></screen>
     Dans le premier cas, l'ER dans son intégralité est gourmande parce que <literal>Y*</literal>
     est gourmand. Il peut établir une correspondance qui débute à <literal>Y</literal> et
     correspondre à la chaîne la plus longue à partir de là,
     soit <literal>Y123</literal>. La sortie reprend la partie entre parenthèses, soit
     <literal>123</literal>. Dans le second cas, l'ER dans son ensemble n'est
     pas gourmande
     car <literal>Y*?</literal> ne l'est pas. Il peut établir une
     correspondance qui débute à <literal>Y</literal> et correspond à la chaîne la plus courte
     à partir de là, soit <literal>Y1</literal>. La sous-expression 
     <literal>[0-9]{1,3}</literal> est gourmande mais elle ne peut pas changer la
     décision sur la longueur totale de la correspondance&nbsp;; elle ne peut
     donc correspondre qu'à <literal>1</literal>.
   </para>

   <para>
     En résumé, quand une ER contient à la fois des sous-expressions gourmandes
     et non gourmandes, la longueur de la correspondance totale est soit
     aussi longue que possible soit aussi courte que possible, en fonction de
     l'attribut affecté à l'ER complète. Les attributs assignés aux
     sous-expressions permettent uniquement de déterminer la partie de la
     correspondance qu'elles peuvent incorporer les unes par rapport aux autres.
   </para>

<!-- Je cherche un antonyme de gourmandise : raison, retenue, abstinence,
anorexie, modération :-) ? -->
   <para>
    Les quantificateurs <literal>{1,1}</literal> et <literal>{1,1}?</literal>
    peuvent être utilisés pour forcer, respectivement, la préférence la plus
    longue (gourmandise) ou la plus courte (retenue),
    sur une sous-expression ou une ER complète.
   </para>

<!-- match against : recherche de correspondance --> 
   <para>
    Les longueurs de correspondance sont mesurés en caractères, et non en
    éléments d'interclassement. Une chaîne vide est considérée plus grande que pas
    de correspondance du tout. Par exemple&nbsp;:
    <literal>bb*</literal> correspond aux trois caractères du milieu de
    <literal>abbbc</literal>&nbsp;;
    <literal>(week|wee)(night|knights)</literal> correspond aux dix caractères de
    <literal>weeknights</literal>&nbsp;;
    lorsque une correspondance est recherchée entre <literal>(.*).*</literal>
    et <literal>abc</literal>, la
    sous-expression entre parenthèses correspond aux trois caractères&nbsp;; et
    lorsqu'une correspondance est recherchée entre <literal>(a*)*</literal> et
    <literal>bc</literal>, à la fois l'ER et la
    sous-expression entre parenthèses correspondent à une chaîne vide.
   </para>

   <para>
    Lorsqu'il est précisé que la recherche de correspondance ne tient pas
    compte de la casse, cela revient à considérer 
    que toutes les distinctions de casse ont disparu de l'alphabet. Quand un
    caractère alphabétique, pour lequel existent différentes casses, apparaît comme un
    caractère ordinaire en dehors d'une expression entre crochets, il est
    en fait transformé en une expression entre crochets contenant les deux
    casses, c'est-à-dire que <literal>x</literal> devient <literal>[xX]</literal>. Quand il
    apparaît dans une expression entre crochets, toutes les transformations de
    casse sont ajoutées à l'expression entre crochets, c'est-à-dire que
    <literal>[x]</literal> devient <literal>[xX]</literal> et que
    <literal>[^x]</literal> devient <literal>[^xX]</literal>.
   </para>

   <para>
    Si la sensibilité aux retours chariots est précisée, <literal>.</literal> et les
    expressions entre crochets utilisant <literal>^</literal> n'établissent
    jamais de correspondance avec le caractère de
    retour à la ligne (de cette façon, les correspondances ne franchissent jamais
    les retours chariots sauf si l'ER l'explicite),
    et <literal>^</literal> et <literal>$</literal> établissent une
    correspondance avec la chaîne vide,
    respectivement après et avant un retour chariot, en plus d'établir une
    correspondance respectivement au début et à la fin de la chaîne. Mais les
    échappements d'ERA 
    <literal>\A</literal> et <literal>\Z</literal> n'établissent toujours de
    correspondance <emphasis>qu'</emphasis>au début ou à la fin de la chaîne.
   </para>

   <para>
    Si une sensibilité partielle aux retours chariot est indiquée, cela affecte
    <literal>.</literal> et les expressions entre crochets, comme avec la sensibilité
    aux retours chariot, mais pas <literal>^</literal> et <literal>$</literal>.
   </para>

   <para>
    Si une sensibilité partielle inverse aux retours chariot est indiquée, cela
    affecte <literal>^</literal> et <literal>$</literal>, comme avec la sensibilité
    aux retours chariot, mais pas <literal>.</literal> et les sous-expressions. Ceci
    n'est pas très utile mais est toutefois fourni pour des raisons de symétrie.
   </para>
   </sect3>

   <sect3 id="posix-limits-compatibility">
    <title>Limites et compatibilité</title>

   <para>
    Aucune limite particulière n'est imposée sur la longueur des ER dans cette
    implantation. Néanmoins, les programmes prévus pour être
    portables ne devraient pas employer d'ER de plus de 256 octets car
    une implantation POSIX peut refuser d'accepter de telles ER.
   </para>

   <para>
    La seule fonctionnalité des ERA qui soit incompatible avec les ERE POSIX est
    le maintien de la signification spéciale de <literal>\</literal> dans les
    expressions entre crochets. Toutes les autres fonctionnalités ERA utilisent
    une syntaxe interdite, à effets indéfinis ou non spécifiés
    dans les ERE POSIX&nbsp;; la syntaxe <literal>***</literal> des directeurs
    ne figure pas dans la syntaxe POSIX pour les ERB et les ERE.
   </para>

   <para>
    Un grand nombre d'extensions ERA sont empruntées à Perl mais certaines
    ont été modifiées et quelques extensions Perl ne sont pas
    présentes. Les incompatibilités incluent <literal>\b</literal>, <literal>\B</literal>,
    le manque de traitement spécial pour le retour à la ligne en fin de chaîne,
    l'ajout d'expressions entre crochets aux expressions affectées par les
    correspondances avec retour à la ligne, les restrictions sur les parenthèses
    et les références dans les contraintes et la sémantique de correspondance
    chaînes les plus longues/les plus courtes (au lieu de la première rencontrée).
   </para>

   <para>
    Deux incompatibilités importantes existent entre les syntaxes ERA et ERE
    reconnues par les versions antérieures à
    <productname>PostgreSQL</productname>&nbsp;7.4&nbsp;:

    <itemizedlist>
     <listitem>
      <para>
       dans les ERA, <literal>\</literal> suivi d'un caractère alphanumérique est soit
       un échappement soit une erreur alors que dans les versions précédentes,
       c'était simplement un autre moyen d'écrire un caractère alphanumérique.
       Ceci ne devrait pas poser trop de problèmes car il n'y avait aucune raison
       d'écrire une telle séquence dans les versions plus anciennes&nbsp;;
      </para>
     </listitem>
     <listitem>
      <para>
       dans les ERA, <literal>\</literal> reste un caractère spécial à
       l'intérieur de <literal>[]</literal>, donc un <literal>\</literal> à
       l'intérieur d'une expression entre crochets doit être écrit
       <literal>\\</literal>.
      </para>
     </listitem>
    </itemizedlist>

    Même si ces différences ne posent pas de problèmes pour la plupart
    des applications, il est possible de les éviter en initialisant
    <varname>regex_flavor</varname> à <literal>extended</literal>.
   </para>
   </sect3>

   <sect3 id="posix-basic-regexes">
    <title>Expressions rationnelles élémentaires</title>

   <para>
    Les ERB diffèrent des ERE par plusieurs aspects. Dans les BRE,
    <literal>|</literal>, <literal>+</literal> et <literal>?</literal> sont des caractères
    ordinaires et il n'existe pas d'équivalent pour leur fonctionnalité. Les
    délimiteurs de frontières sont <literal>\{</literal> et <literal>\}</literal>, avec <literal>{</literal> et
    <literal>}</literal> étant eux-même des caractères ordinaires. Les parenthèses
    pour les sous-expressions imbriquées sont <literal>\(</literal> et <literal>\)</literal>,
    <literal>(</literal> et <literal>)</literal> restent des caractères
    ordinaires. <literal>^</literal> est un caractère ordinaire sauf au début d'une ER
    ou au début d'une sous-expression entre parenthèses,
    <literal>$</literal> est un caractère ordinaire sauf à la fin d'une ER
    ou à la fin d'une sous-expression entre parenthèses et
    <literal>*</literal> est un caractère ordinaire s'il apparaît au début d'une ER ou
    au début d'une sous-expression entre parenthèses (après un possible
    <literal>^</literal>). Enfin, les rétro-références à un chiffre sont disponibles, et
    <literal>\&lt;</literal> et <literal>\&gt;</literal> sont des synonymes pour
    respectivement <literal>[[:&lt;:]]</literal> et <literal>[[:&gt;:]]</literal>&nbsp;;
    aucun autre échappement n'est disponible dans les BRE.
   </para>
   </sect3>

<!-- end re_syntax.n man page -->

  </sect2>
 </sect1>


  <sect1 id="functions-formatting">
   <title>Fonctions de formatage des types de données</title>

   <indexterm>
    <primary>formatage</primary>
   </indexterm>

   <indexterm>
    <primary>to_char</primary>
   </indexterm>
   <indexterm>
    <primary>to_date</primary>
   </indexterm>
   <indexterm>
    <primary>to_number</primary>
   </indexterm>
   <indexterm>
    <primary>to_timestamp</primary>
   </indexterm>

   <para>
    Les fonctions de formatage de <productname>PostgreSQL</productname>
    fournissent un ensemble d'outils puissants pour convertir différents types de
    données (date/heure, entier, nombre à virgule flottante, numérique) en
    chaînes formatées et pour convertir des chaînes formatées en types de
    données spécifiques. Le <xref linkend="functions-formatting-table"/> les liste.
    Ces fonctions suivent toutes une même convention d'appel&nbsp;: le
    premier argument est la valeur à formater et le second argument est un
    modèle définissant le format de sortie ou d'entrée.
   </para>

   <para>
    La fonction <function>to_timestamp</function> à un argument est aussi
    disponible&nbsp;; elle accepte un argument <type>double precision</type>
    unique pour convertir une valeur de type epoch Unix en <type>timestamp
    with time zone</type> (secondes depuis 1970-01-01 00:00:00+00) en
    <type>timestamp with time zone</type>.
    (Les types epoch Unix (<type>entier</type>) sont implicitement convertis en
    <type>double precision</type>.)
   </para>

    <table id="functions-formatting-table">
     <title>Fonctions de formatage</title>
     <tgroup cols="4">
      <colspec colnum="1" colwidth="0.9*"/>
      <colspec colnum="2" colwidth="0.8*"/>
      <colspec colnum="3" colwidth="1.0*"/>
      <colspec colnum="4" colwidth="1.3*"/>
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type en retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal><function>to_char</function>(<type>timestamp</type>,
<type>text</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>convertit un champ de type timestamp en chaîne</entry>
	<entry><literal>to_char(current_timestamp, 'HH12:MI:SS')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_char</function>(<type>interval</type>,
<type>text</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>convertit un champ de type interval en chaîne</entry>
	<entry><literal>to_char(interval '15h&nbsp;2m&nbsp;12s',
'HH24:MI:SS')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_char</function>(<type>int</type>,
<type>text</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>convertit un champ de type integer en chaîne</entry>
	<entry><literal>to_char(125, '999')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_char</function>(<type>double precision</type>,
        <type>text</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>convertit un champ de type real/double precision en chaîne</entry>
	<entry><literal>to_char(125.8::real, '999D9')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_char</function>(<type>numeric</type>,
<type>text</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>convertit un champ de type numeric en chaîne</entry>
	<entry><literal>to_char(-125.8, '999D99S')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_date</function>(<type>text</type>,
<type>text</type>)</literal></entry>
	<entry><type>date</type></entry>
	<entry>convertit une chaîne en date</entry>
	<entry><literal>to_date('05&nbsp;Dec&nbsp;2000',
'DD&nbsp;Mon&nbsp;YYYY')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_number</function>(<type>text</type>,
<type>text</type>)</literal></entry>
	<entry><type>numeric</type></entry>
	<entry>convertit une chaîne en champ de type numeric</entry>
	<entry><literal>to_number('12,454.8-', '99G999D9S')</literal></entry>
       </row>
       <row>
	<entry><literal><function>to_timestamp</function>(<type>text</type>,
<type>text</type>)</literal></entry>
	<entry><type>timestamp with time zone</type></entry>
	<entry>convertit une chaîne string en champ de type timestamp</entry>
	<entry><literal>to_timestamp('05&nbsp;Dec&nbsp;2000',
'DD&nbsp;Mon&nbsp;YYYY')</literal></entry>
       </row>
       <row>
        <entry><literal><function>to_timestamp</function>(<type>double precision</type>)</literal></entry>
        <entry><type>timestamp with time zone</type></entry>
        <entry>convertit une valeur de type epoch UNIX en valeur de type
	timestamp</entry>
        <entry><literal>to_timestamp(1284352323)</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Dans une chaîne de motif pour <function>to_char</function>, il existe
    certains motifs qui sont reconnus et remplacés avec des données
    correctement formatées basées sur la valeur. Tout texte qui n'est pas un
    motif est copié sans modification. De façon similaire, dans toute chaîne
    de motif en entrée (tout sauf <function>to_char</function>), les motifs
    identifient les valeurs à fournir à la chaîne de données en entrée.
   </para>

  <para>
   Le <xref linkend="functions-formatting-datetime-table"/> affiche les motifs
   disponibles pour formater les valeurs de types date et heure.
  </para>

    <table id="functions-formatting-datetime-table">
     <title>Modèles pour le formatage de champs de type date/heure</title>
     <tgroup cols="2">
      <colspec colnum="1" colwidth="0.4*"/>
      <colspec colnum="2" colwidth="1.6*"/>
      <thead>
       <row>
	<entry>Modèle</entry>
	<entry>Description</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal>HH</literal></entry>
	<entry>heure du jour (01-12)</entry>
       </row>
       <row>
	<entry><literal>HH12</literal></entry>
	<entry>heure du jour (01-12)</entry>
       </row>       
       <row>
	<entry><literal>HH24</literal></entry>
	<entry>heure du jour (00-23)</entry>
       </row>       
       <row>
	<entry><literal>MI</literal></entry>
	<entry>minute (00-59)</entry>
       </row>   
       <row>
	<entry><literal>SS</literal></entry>
	<entry>seconde (00-59)</entry>
       </row>
       <row>
	<entry><literal>MS</literal></entry>
	<entry>milliseconde (000-999)</entry>
       </row>
       <row>
	<entry><literal>US</literal></entry>
	<entry>microseconde (000000-999999)</entry>
       </row>
       <row>
	<entry><literal>SSSS</literal></entry>
	<entry>secondes écoulées depuis minuit (0-86399)</entry>
       </row>
       <row>
	<entry><literal>AM</literal> ou <literal>am</literal> ou
	<literal>PM</literal> ou <literal>pm</literal></entry>
	<entry>indicateur du méridien (sans point)</entry>
       </row>
       <row>
	<entry><literal>A.M.</literal> ou <literal>a.m.</literal> ou
	<literal>P.M.</literal> ou <literal>p.m.</literal></entry>
	<entry>indicateur du méridien (avec des points)</entry>
       </row>
       <row>
	<entry><literal>am</literal> ou <literal>a.m.</literal> ou
	<literal>pm</literal> ou <literal>p.m.</literal></entry>
	<entry>indicateur du méridien (en minuscules)</entry>
       </row>
       <row>
	<entry><literal>Y,YYY</literal></entry>
	<entry>année (quatre chiffres et plus) avec virgule</entry>
       </row>
       <row>
	<entry><literal>YYYY</literal></entry>
	<entry>année (quatre chiffres et plus)</entry>
       </row>
       <row>
	<entry><literal>YYY</literal></entry>
	<entry>trois derniers chiffres de l'année</entry>
       </row>
       <row>
	<entry><literal>YY</literal></entry>
	<entry>deux derniers chiffres de l'année</entry>
       </row>
       <row>
	<entry><literal>Y</literal></entry>
	<entry>dernier chiffre de l'année</entry>
       </row>
       <row>
        <entry><literal>IYYY</literal></entry>
        <entry>année ISO (quatre chiffres ou plus)</entry>
       </row>
       <row>
        <entry><literal>IYY</literal></entry>
        <entry>trois derniers chiffres de l'année ISO</entry>
       </row>
       <row>
        <entry><literal>IY</literal></entry>
	<entry>deux derniers chiffres de l'année ISO</entry>
       </row>
       <row>
        <entry><literal>I</literal></entry>
	<entry>dernier chiffre de l'année ISO</entry>
       </row>
       <row>
        <entry><literal>BC</literal>, <literal>bc</literal>,
        <literal>AD</literal> ou <literal>ad</literal></entry>
        <entry>indicateur de l'ère (sans point)</entry>
       </row>
       <row>
        <entry><literal>B.C.</literal>, <literal>b.c.</literal>,
        <literal>A.D.</literal> ou <literal>a.d.</literal></entry>
        <entry>indicateur de l'ère (avec des points)</entry>
       </row>
       <row>
	<entry><literal>MONTH</literal></entry>
	<!-- blank padded ? -->
	<entry>nom complet du mois en majuscules (espaces de complètement pour arriver à
         neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>Month</literal></entry>
	<entry>nom complet du mois en casse mixte (espaces de complètement pour arriver à
         neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>month</literal></entry>
	<entry>nom complet du mois en minuscules (espaces de complètement pour arriver à
         neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>MON</literal></entry>
	<entry>abréviation du nom du mois en majuscules (trois
         caractères en anglais, la longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>Mon</literal></entry>
	<entry>abréviation du nom du mois avec la première lettre en majuscule et
         les deux autres en minuscule (trois caractères en anglais, la
	     longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>mon</literal></entry>
	<entry>abréviation du nom du mois en minuscules (trois
         caractères en anglais, la longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>MM</literal></entry>
	<entry>numéro du mois (01-12)</entry>
       </row>
       <row>
	<entry><literal>DAY</literal></entry>
	<entry>nom complet du jour en majuscules (espaces de complètement pour
         arriver à neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>Day</literal></entry>
	<entry>nom complet du jour avec la première lettre en majuscule et les
         deux autres en minuscule (espaces de complètement pour
         arriver à neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>day</literal></entry>
	<entry>nom complet du jour en minuscules (espaces de complètement pour
         arriver à neuf caractères)</entry>
       </row>
       <row>
	<entry><literal>DY</literal></entry>
	<entry>abréviation du nom du jour en majuscules (trois caractères en
	 anglais, la longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>Dy</literal></entry>
	<entry>abréviation du nom du jour avec la première lettre en majuscule et
         les deux autres en minuscule (trois caractères en anglais, la
	     longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>dy</literal></entry>
	<entry>abréviation du nom du jour en minuscules (trois caractères en
	 anglais, la longueur des versions localisées peut varier)</entry>
       </row>
       <row>
	<entry><literal>DDD</literal></entry>
	<entry>jour de l'année (001-366)</entry>
       </row>
       <row>
        <entry><literal>IDDD</literal></entry>
        <entry>jour ISO de l'année (001-371&nbsp;; le jour 1 de l'année est
	 le lundi de la première semaine ISO.)</entry>
       </row>
       <row>
	<entry><literal>DD</literal></entry>
	<entry>jour du mois (01-31)</entry>
       </row>
       <row>
	<entry><literal>D</literal></entry>
	<entry>jour de la semaine du dimanche (<literal>1</literal>) au
	 samedi (<literal>7</literal>)</entry>
       </row>
       <row>
        <entry><literal>ID</literal></entry>
	<entry>jour ISO de la semaine du lundi (<literal>1</literal>) au
	 dimanche (<literal>7</literal>)</entry>
       </row>
       <row>
	<entry><literal>W</literal></entry>
	<entry>numéro de semaine du mois, de 1 à 5 (la première semaine
         commence le premier jour du mois)</entry>
       </row> 
       <row>
	<entry><literal>WW</literal></entry>
	<entry>numéro de la semaine dans l'année, de 1 à 53 (la première semaine
         commence le premier jour de l'année)</entry>
       </row>
       <row>
	<entry><literal>IW</literal></entry>
	<entry>numéro ISO de la semaine dans l'année (01 - 53&nbsp;; le premier
	 jeudi de la nouvelle année est dans la semaine 1)</entry>
       </row>
       <row>
	<entry><literal>CC</literal></entry>
	<entry>siècle (deux chiffres) (le 21è siècle commence le
	 1er janvier 2001)</entry>
       </row>
       <row>
	<entry><literal>J</literal></entry>
	<entry>Jour dans le calendrier Julien (nombre de jours depuis le 24
	 novembre -4714 à minuit)</entry>
       </row>
       <row>
	<entry><literal>Q</literal></entry>
	<entry>trimestre</entry>
       </row>
       <row>
	<entry><literal>RM</literal></entry>
	<entry>mois en majuscule en nombre romain (I-XII&nbsp;; I étant janvier) (en
         majuscules)</entry>
       </row>
       <row>
	<entry><literal>rm</literal></entry>
	<entry>mois en minuscule en nombre romain (i-xii; i étant janvier) (en
         minuscules)</entry>
       </row>
       <row>
	<entry><literal>TZ</literal></entry>
	<entry>nom en majuscule du fuseau horaire (en majuscules)</entry>
       </row>
       <row>
	<entry><literal>tz</literal></entry>
	<entry>nom en minuscule du fuseau horaire (en minuscules)</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Les modificateurs peuvent être appliqués à tous les motifs pour en changer
    le comportement. Par exemple, <literal>FMMonth</literal>
    est le motif <literal>Month</literal> avec le modificateur
    <literal>FM</literal>.
    Le <xref linkend="functions-formatting-datetimemod-table"/> affiche les
    modificateurs de motifs pour le formatage des dates/heures.
   </para>

    <table id="functions-formatting-datetimemod-table">
     <title>Modificateurs de motifs pour le formatage des dates/heures</title>
     <tgroup cols="3">
      <colspec colnum="1" colwidth="0.5*"/>
      <colspec colnum="2" colwidth="2.0*"/>
      <colspec colnum="3" colwidth="0.5*"/>
      <thead>
       <row>
	<entry>Modificateur</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
       <!-- SAS 20080730 : padding : complétion ou complément ? Complétement ne
       me paraît pas bon -->
	<entry>préfixe <literal>FM</literal></entry>
	<entry>mode remplissage (<foreignphrase>Fill Mode</foreignphrase>)
	(supprime les espaces et les zéros de complétion)</entry>
	<entry><literal>FMMonth</literal></entry>
       </row>
       <row>
	<entry>suffixe <literal>TH</literal></entry>
	<entry>suffixe du nombre ordinal en majuscules, c'est-à-dire
	 <literal>12TH</literal></entry>
	<entry><literal>DDTH</literal></entry>
       </row>	
       <row>
	<entry>suffixe <literal>th</literal></entry>
	<entry>suffixe du nombre ordinal en minuscules, c'est-à-dire
	 <literal>12th</literal></entry>
	<entry><literal>DDth</literal></entry>
       </row>
       <row>
	<entry>préfixe <literal>FX</literal></entry>
	<entry>option globale de format fixe (voir les notes
         d'utilisation)</entry>
	<entry><literal>FX&nbsp;Month&nbsp;DD&nbsp;Day</literal></entry>
       </row>
       <row>
        <entry>préfixe <literal>TM</literal></entry>
        <entry>mode de traduction (affiche les noms des jours et mois localisés
	 en fonction de <xref linkend="guc-lc-time"/>)</entry>
        <entry><literal>TMMonth</literal></entry>
       </row>
       <row>
	<entry>suffixe <literal>SP</literal></entry>
	<entry>mode épelé (<foreignphrase>Spell Mode</foreignphrase>) (non implanté)</entry>
	<entry><literal>DDSP</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Notes d'utilisation pour le formatage date/heure&nbsp;:

    <itemizedlist>
     <listitem>
      <para>
       <literal>FM</literal> supprime les zéros de début et les espaces de
       fin qui, autrement, sont ajoutés pour fixer la taille du motif de
       sortie&nbsp;;
      </para>
     </listitem>

<!-- trailing blanks, blank padded, leading zeros... -->
     <listitem>
      <para>
       <literal>TM</literal> n'inclut pas les espaces de compéltion en fin de chaîne&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       <function>to_timestamp</function> et <function>to_date</function>
       ignorent les espaces multiples de la chaîne en entrée si l'option
       <literal>FX</literal> n'est pas utilisée. Par exemple,
       <literal>to_timestamp('2000&nbsp;&nbsp;&nbsp;&nbsp;JUN', 'YYYY
MON')</literal> fonctionne mais
       <literal>to_timestamp('2000&nbsp;&nbsp;&nbsp;&nbsp;JUN', 'FXYYYY
MON')</literal> renvoie une erreur car <function>to_timestamp</function>
       n'attend qu'une seule espace&nbsp;;
       <literal>FX</literal> doit être indiqué comme premier élément du modèle.
      </para>
     </listitem>

     <listitem>
      <para>
       il est possible d'insérer du texte ordinaire dans les modèles
       <function>to_char</function>. il est alors littéralement remis en sortie.
       Une sous-chaîne peut être placée entre guillemets doubles pour
       forcer son interprétation en tant que libellé même si elle contient
       des mots clés de motif. Par exemple, dans
       <literal>'"Hello Year "YYYY'</literal>, les caractères
       <literal>YYYY</literal> sont remplacés par l'année mais
       l'<literal>Y</literal> isolé du mot <literal>Year</literal> ne l'est
       pas&nbsp;;
      </para>
     </listitem>

<!-- un slash, deux slashes ? Comme un match, deux matches ? -->
     <listitem>
      <para>
       pour afficher un guillemet double dans la sortie, il faut le faire
       précéder d'un antislash. <literal>E'\\"YYYY
       Month\\"'</literal>, par exemple. <!-- "" font-lock sanity :-) -->
       (Deux antislashs sont nécessaire parce que l'antislash a
       déjà une signification spéciale lors de l'utilisation de la syntaxe
       d'échappement des chaînes)&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       la conversion <literal>YYYY</literal> d'une chaîne en champ de type
       <type>timestamp</type> ou <type>date</type> comporte une restriction
       avec les années à plus de quatre chiffres. Il faut alors utiliser un
       modèle ou un caractère non-numérique après <literal>YYYY</literal>,
       sans quoi l'année est toujours interprétée sur
       quatre chiffres. Par exemple, pour l'année 20000&nbsp;:
       <literal>to_date('200001131', 'YYYYMMDD')</literal> est interprété
       comme une année à quatre chiffres&nbsp;; il faut alors utiliser un
       séparateur non décimal après l'année comme
       <literal>to_date('20000-1131', 'YYYY-MMDD')</literal> ou
       <literal>to_date('20000Nov31', 'YYYYMonDD')</literal>&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       dans les conversions de chaîne en <type>timestamp</type>
       ou <type>date</type>, le champ <literal>CC</literal> (siècle) est ignoré s'il y a
       un champ <literal>YYY</literal>, <literal>YYYY</literal> ou
       <literal>Y,YYY</literal>. Si <literal>CC</literal> est utilisé avec
       <literal>YY</literal> ou <literal>Y</literal>, alors l'année est calculée
       comme <literal>(CC-1)*100+YY</literal>&nbsp;;
     </para>
     </listitem>

     <listitem>
      <para>
       Une date de semaine ISO (distinct de la date grégorienne) peut être
       passée à <function>to_timestamp</function> et <function>to_date</function>
       de deux façons&nbsp;:
       <itemizedlist>
        <listitem>
         <para>
          Année, semaine et jour de la semaine. Par exemple,
	  <literal>to_date('2006-42-4', 'IYYY-IW-ID')</literal> renvoie la date
	  <literal>2006-10-19</literal>. En cas d'omission du jour de la semaine,
	  lundi est utilisé.
         </para>
        </listitem>
        <listitem>
         <para>
          Année et jour de l'année. Par exemple,
	  <literal>to_date('2006-291', 'IYYY-IDDD')</literal> renvoie aussi <literal>2006-10-19</literal>.
         </para>
        </listitem>
       </itemizedlist>
      </para>
      <para>
       Essayer de construire une date en utilisant un mix de champs de semaine
       ISO et de date grégorienne n'a pas de sens et renverra du coup une erreur.
       Dans le contexte d'une année ISO, le concept d'un <quote>mois</quote> ou
       du <quote>jour d'un mois</quote> n'a pas de signification. Dans le
       contexte d'une année grégorienne, la semaine ISO n'a pas de signification.
       Les utilisateurs doivent éviter de mixer les spécifications grégoriennes
       et les dates ISO.
      </para>
     </listitem>

     <listitem>
      <para>
       les valeurs en millisecondes (<literal>MS</literal>) et microsecondes
       (<literal>US</literal>) dans une conversion de chaîne en champ
       de type <type>timestamp</type> sont utilisées comme partie décimale
       des secondes. Par exemple,
       <literal>to_timestamp('12:3', 'SS:MS')</literal> n'est pas 3
       millisecondes mais 300 car la conversion le compte comme 12 + 0,3
       secondes. Cela signifie que pour le format <literal>SS:MS</literal>, les
       valeurs d'entrée <literal>12:3</literal>, <literal>12:30</literal> et
       <literal>12:300</literal> indiquent le même nombre de millisecondes.
       Pour obtenir trois millisecondes, il faut écrire
       <literal>12:003</literal> que la conversion compte comme
       12 + 0,003 = 12,003 secondes.
      </para>

      <para>
       Exemple plus complexe&nbsp;: 
       <literal>to_timestamp('15:12:02.020.001230', 'HH:MI:SS.MS.US')</literal>
       représente 15 heures, 12 minutes et (2 secondes + 20 millisecondes +
       1230 microsecondes =) 2,021230 secondes&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>la numérotation du jour de la semaine de
       <function>to_char(..., 'ID')</function> correspond à la fonction
       <function>extract(isodow from ...)</function> mais
       <function>to_char(..., 'D')</function> ne correspond pas à la numération
       des jours de <function>extract(dow from ...)</function>.
     </para>
     </listitem>

     <listitem>
      <para><function>to_char(interval)</function> formate <literal>HH</literal> et
        <literal>HH12</literal> comme les heures d'un seul jour alors que <literal>HH24</literal>
        peut afficher des heures dépassant un simple jour, c'est-à-dire &gt;24.
      </para>
     </listitem>

    </itemizedlist>
   </para>

  <para>
   Le <xref linkend="functions-formatting-numeric-table"/> affiche les motifs
   de modèle disponibles pour le formatage des valeurs numériques.
  </para>

    <table id="functions-formatting-numeric-table">
     <title>Motifs de modèle pour le formatage de valeurs numériques</title>
     <tgroup cols="2">
      <colspec colnum="1" colwidth="0.4*"/>
      <colspec colnum="2" colwidth="1.6*"/>
      <thead>
       <row>
	<entry>Motif</entry>
	<entry>Description</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal>9</literal></entry>
	<entry>valeur avec le nombre indiqué de chiffres</entry>
       </row>
       <row>
       <!-- SAS 20080730 : leading zeros ? zéros de remplissage, de début de
       chaîne ? -->
	<entry><literal>0</literal></entry>
	<entry>valeur avec des zéros de début de chaîne</entry>
       </row>
       <row>
	<entry><literal>.</literal> (point)</entry>
	<entry>point décimal</entry>
       </row>
       <row>
	<entry><literal>,</literal> (virgule)</entry>
	<entry>séparateur de groupe (milliers)</entry>
       </row>
       <row>
	<entry><literal>PR</literal></entry>
	<entry>valeur négative entre chevrons</entry>
       </row>
       <row>
	<entry><literal>S</literal></entry>
	<entry>signe accroché au nombre (utilise la locale)</entry>
       </row>
       <row>
	<entry><literal>L</literal></entry>
	<entry>symbole monétaire (utilise la locale)</entry>
       </row>
       <row>
	<entry><literal>D</literal></entry>
	<entry>point décimal (utilise la locale)</entry>
       </row>
       <row>
	<entry><literal>G</literal></entry>
	<entry>séparateur de groupe (utilise la locale)</entry>
       </row>
       <row>
	<entry><literal>MI</literal></entry>
	<entry>signe moins dans la position indiquée (si le nombre est
         inférieur à 0)</entry>
       </row>
       <row>
	<entry><literal>PL</literal></entry>
	<entry>signe plus dans la position indiquée (si le nombre est
         supérieur à 0)</entry>
       </row>
       <row>
	<entry><literal>SG</literal></entry>
	<entry>signe plus/moins dans la position indiquée</entry>
       </row>
       <row>
	<entry><literal>RN</literal></entry>
	<entry>numéro romain (saisie entre 1 et 3999)</entry>
       </row>
       <row>
	<entry><literal>TH</literal> ou <literal>th</literal></entry>
	<entry>suffixe du nombre ordinal</entry>
       </row>
       <row>
	<entry><literal>V</literal></entry>
	<entry>décalage du nombre indiqué de chiffres (voir les
         notes)</entry>
       </row>
       <row>
	<entry><literal>EEEE</literal></entry>
	<entry>notation scientifique (pas implantée)</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Notes d'utilisation pour le formatage des nombres&nbsp;:

    <itemizedlist>
     <listitem>
      <para>
       un signe formaté à l'aide de <literal>SG</literal>,
       <literal>PL</literal> ou <literal>MI</literal> n'est pas ancré au
       nombre&nbsp;; par exemple, <literal>to_char(-12, 'S9999')</literal>
       produit <literal>'&nbsp;&nbsp;-12'</literal> mais
       <literal>to_char(-12, 'MI9999')</literal> produit
       <literal>'-&nbsp;&nbsp;12'</literal>. L'implantation Oracle n'autorise
       pas l'utilisation de <literal>MI</literal> devant <literal>9</literal>,
       mais requiert plutôt que <literal>9</literal> précède
       <literal>MI</literal>&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       <literal>9</literal> est transformé en valeur avec le même nombre de
       chiffres qu'il y a de 9. Si un chiffre n'est pas disponible, il est
       remplacé par une espace&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       <literal>TH</literal> ne convertit pas les valeurs inférieures à zéro et
       ne convertit pas les nombres fractionnels&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       <literal>PL</literal>, <literal>SG</literal> et
       <literal>TH</literal> sont des extensions
       <productname>PostgreSQL</productname>&nbsp;;
      </para>
     </listitem>

     <listitem>
      <para>
       <literal>V</literal> multiplie effectivement les valeurs en entrée par
       <literal>10^<replaceable>n</replaceable></literal>, où
       <replaceable>n</replaceable> est le nombre de chiffres qui suit
       <literal>V</literal>. <function>to_char</function> ne supporte pas
       l'utilisation de <literal>V</literal> combiné avec un point décimal
       (donc <literal>99.9V99</literal> n'est pas autorisé).
      </para>
     </listitem>
    </itemizedlist>
   </para>   

   <para>
    Certains modificateurs peuvent être appliqués à un motif pour modifier
    son comportement. Par exemple, <literal>FM9999</literal> est le motif
    <literal>9999</literal> avec le modificateur <literal>FM</literal>.
    <xref linkend="functions-formatting-numericmod-table"/> affiche les
    motifs pour le formatage numérique.
   </para>

    <table id="functions-formatting-numericmod-table">
     <title>Modifications de motifs pour le formatage numérique</title>
     <tgroup cols="3">
      <thead>
       <row>
        <entry>Modificateur</entry>
        <entry>Description</entry>
        <entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>préfixe <literal>FM</literal></entry>
        <entry>mode de remplissuage (supprime les blancs et zéris avant et
	 après la chaîne)</entry>
        <entry><literal>FM9999</literal></entry>
       </row>
       <row>
        <entry>suffixe <literal>TH</literal></entry>
        <entry>suffixe d'un nombre ordinal en majuscule</entry>
        <entry><literal>999TH</literal></entry>
       </row>   
       <row>
        <entry>suffixe <literal>th</literal></entry>
        <entry>suffixe d'un nombre ordinal en minuscule</entry>
        <entry><literal>999th</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  <para>
   Le <xref linkend="functions-formatting-examples-table"/> affiche quelques
   exemples de l'utilisation de la fonction <function>to_char</function>.
  </para>

    <table id="functions-formatting-examples-table">
     <title>Exemples avec <function>to_char</function></title>
     <tgroup cols="2">
      <colspec colnum="1" colwidth="1.3*"/>
      <colspec colnum="2" colwidth="0.7*"/>
      <thead>
       <row>
	<entry>Expression</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><literal>to_char(current_timestamp,
'Day,&nbsp;DD&nbsp;&nbsp;HH12:MI:SS')</literal></entry>
       
<entry><literal>'Tuesday&nbsp;&nbsp;,&nbsp;06&nbsp;&nbsp;05:39:18'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(current_timestamp,
'FMDay,&nbsp;FMDD&nbsp;&nbsp;HH12:MI:SS')</literal></entry>
        <entry><literal>'Tuesday,&nbsp;6&nbsp;&nbsp;05:39:18'</literal></entry>
       </row>          
       <row>
        <entry><literal>to_char(-0.1, '99.99')</literal></entry>
        <entry><literal>'&nbsp;&nbsp;-.10'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(-0.1, 'FM9.99')</literal></entry>
        <entry><literal>'-.1'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(0.1, '0.9')</literal></entry>
        <entry><literal>'&nbsp;0.1'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(12, '9990999.9')</literal></entry>
        <entry><literal>'&nbsp;&nbsp;&nbsp;&nbsp;0012.0'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(12, 'FM9990999.9')</literal></entry>
        <entry><literal>'0012.'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(485, '999')</literal></entry>
        <entry><literal>'&nbsp;485'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(-485, '999')</literal></entry>
        <entry><literal>'-485'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(485, '9&nbsp;9&nbsp;9')</literal></entry>
        <entry><literal>'&nbsp;4&nbsp;8&nbsp;5'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(1485, '9,999')</literal></entry>
        <entry><literal>'&nbsp;1,485'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(1485, '9G999')</literal></entry>
        <entry><literal>'&nbsp;1&nbsp;485'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(148.5, '999.999')</literal></entry>
        <entry><literal>'&nbsp;148.500'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(148.5, 'FM999.999')</literal></entry>
        <entry><literal>'148.5'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(148.5, 'FM999.990')</literal></entry>
        <entry><literal>'148.500'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(148.5, '999D999')</literal></entry>
        <entry><literal>'&nbsp;148,500'</literal></entry>	 
       </row>
       <row>
        <entry><literal>to_char(3148.5, '9G999D999')</literal></entry>
        <entry><literal>'&nbsp;3&nbsp;148,500'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(-485, '999S')</literal></entry>
        <entry><literal>'485-'</literal></entry>
       </row>
       <row>		
        <entry><literal>to_char(-485, '999MI')</literal></entry>
        <entry><literal>'485-'</literal></entry>	
       </row>
       <row>
        <entry><literal>to_char(485, '999MI')</literal></entry>
        <entry><literal>'485&nbsp;'</literal></entry>		
       </row>
       <row>
        <entry><literal>to_char(485, 'FM999MI')</literal></entry>
        <entry><literal>'485'</literal></entry>		
       </row>
       <row>
        <entry><literal>to_char(485, 'PL999')</literal></entry>
        <entry><literal>'+485'</literal></entry>	
       </row>
       <row>		
        <entry><literal>to_char(485, 'SG999')</literal></entry>
        <entry><literal>'+485'</literal></entry>	
       </row>
       <row>
        <entry><literal>to_char(-485, 'SG999')</literal></entry>
        <entry><literal>'-485'</literal></entry>	
       </row>
       <row>
        <entry><literal>to_char(-485, '9SG99')</literal></entry>
        <entry><literal>'4-85'</literal></entry>	
       </row>
       <row>
        <entry><literal>to_char(-485, '999PR')</literal></entry>
        <entry><literal>'&lt;485&gt;'</literal></entry>		
       </row>
       <row>
        <entry><literal>to_char(485, 'L999')</literal></entry>
        <entry><literal>'DM&nbsp;485</literal></entry>	 
       </row>
       <row>
        <entry><literal>to_char(485, 'RN')</literal></entry>		
       
<entry><literal>'&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;CDLXXXV'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(485, 'FMRN')</literal></entry>	
        <entry><literal>'CDLXXXV'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(5.2, 'FMRN')</literal></entry>
        <entry><literal>'V'</literal></entry>		
       </row>
       <row>
        <entry><literal>to_char(482, '999th')</literal></entry>
        <entry><literal>'&nbsp;482nd'</literal></entry>				
       </row>
       <row>
        <entry><literal>to_char(485, '"Good&nbsp;number:"999')</literal></entry>
        <entry><literal>'Good&nbsp;number:&nbsp;485'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(485.8,
'"Pre:"999"&nbsp;Post:"&nbsp;.999')</literal></entry>
        <entry><literal>'Pre:&nbsp;485&nbsp;Post:&nbsp;.800'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(12, '99V999')</literal></entry>		
        <entry><literal>'&nbsp;12000'</literal></entry>
       </row>
       <row>
        <entry><literal>to_char(12.4, '99V999')</literal></entry>
        <entry><literal>'&nbsp;12400'</literal></entry>
       </row>
       <row>		
        <entry><literal>to_char(12.45, '99V9')</literal></entry>
        <entry><literal>'&nbsp;125'</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  </sect1>


  <sect1 id="functions-datetime">
   <title>Fonctions et opérateurs sur date/heure</title>

  <para>
   Le <xref linkend="functions-datetime-table"/> affiche les fonctions disponibles
   pour le traitement des valeurs date et heure. Les détails sont présentés
   dans les sous-sections qui suivent. Le <xref
   linkend="operators-datetime-table"/> illustre les comportements des
   opérateurs arithmétiques basiques (<literal>+</literal>,
   <literal>*</literal>, etc.).  Pour les fonctions de formatage, on peut se
   référer à la <xref linkend="functions-formatting"/>. Il est important d'être familier avec
   les informations de base concernant les types de données date/heure de la <xref
   linkend="datatype-datetime"/>.
  </para>

  <para>
   Toutes les fonctions et opérateurs décrits ci-dessous qui acceptent une entrée de
   type <type>time</type> ou <type>timestamp</type> acceptent deux
   variantes&nbsp;: une avec <type>time with time zone</type> ou
   <type>timestamp with time zone</type> et une autre avec <type>time without
   time zone</type> ou <type>timestamp without time zone</type>. 
   Ces variantes ne sont pas affichées séparément. De plus, les opérateurs
   <literal>+</literal> et <literal>*</literal> sont commutatifs (par exemple,
   date + integer et integer + date)&nbsp;; une seule possibilité est présentée
   ici.
  </para>

    <table id="operators-datetime-table">
     <title>Opérateurs date/heure</title>

     <tgroup cols="3">
      <colspec colnum="1" colwidth="0.4*"/>
      <colspec colnum="2" colwidth="1.3*"/>
      <colspec colnum="3" colwidth="1.3*"/>
      <thead>
       <row>
        <entry>Opérateur</entry>
        <entry>Exemple</entry>
        <entry>Résultat</entry>
       </row>
      </thead>

      <tbody>
       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>date '2001-09-28' + integer '7'</literal></entry>
        <entry><literal>date '2001-10-05'</literal></entry>
       </row>

       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>date '2001-09-28' + interval '1 hour'</literal></entry>
        <entry><literal>timestamp '2001-09-28 01:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>date '2001-09-28' + time '03:00'</literal></entry>
        <entry><literal>timestamp '2001-09-28 03:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>interval '1 day' + interval '1 hour'</literal></entry>
        <entry><literal>interval '1 day 01:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>timestamp '2001-09-28 01:00' + interval '23 hours'</literal></entry>
        <entry><literal>timestamp '2001-09-29 00:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>+</literal> </entry>
        <entry><literal>time '01:00' + interval '3 hours'</literal></entry>
        <entry><literal>time '04:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>- interval '23 hours'</literal></entry>
        <entry><literal>interval '-23:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>date '2001-10-01' - date '2001-09-28'</literal></entry>
        <entry><literal>integer '3'</literal> (jours)</entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>date '2001-10-01' - integer '7'</literal></entry>
        <entry><literal>date '2001-09-24'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>date '2001-09-28' - interval '1 hour'</literal></entry>
        <entry><literal>timestamp '2001-09-27 23:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>time '05:00' - time '03:00'</literal></entry>
        <entry><literal>interval '02:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>time '05:00' - interval '2 hours'</literal></entry>
        <entry><literal>time '03:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>timestamp '2001-09-28 23:00' - interval '23 hours'</literal></entry>
        <entry><literal>timestamp '2001-09-28 00:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>interval '1 day' - interval '1 hour'</literal></entry>
        <entry><literal>interval '1 day -01:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>-</literal> </entry>
        <entry><literal>timestamp '2001-09-29 03:00' - timestamp '2001-09-27 12:00'</literal></entry>
        <entry><literal>interval '1 day 15:00:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>*</literal> </entry>
        <entry><literal>900 * interval '1 second'</literal></entry>
        <entry><literal>interval '00:15:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>*</literal> </entry>
        <entry><literal>21 * interval '1 day'</literal></entry>
        <entry><literal>interval '21 days'</literal></entry>
       </row>

       <row>
        <entry> <literal>*</literal> </entry>
        <entry><literal>double precision '3.5' * interval '1 hour'</literal></entry>
        <entry><literal>interval '03:30:00'</literal></entry>
       </row>

       <row>
        <entry> <literal>/</literal> </entry>
        <entry><literal>interval '1 hour' / double precision '1.5'</literal></entry>
        <entry><literal>interval '00:40:00'</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <indexterm>
    <primary>age</primary>
   </indexterm>
   <indexterm>
    <primary>clock_timestamp</primary>
   </indexterm>
   <indexterm>
    <primary>current_date</primary>
   </indexterm>
   <indexterm>
    <primary>current_time</primary>
   </indexterm>
   <indexterm>
    <primary>current_timestamp</primary>
   </indexterm>
   <indexterm>
    <primary>date_part</primary>
   </indexterm>
   <indexterm>
    <primary>date_trunc</primary>
   </indexterm>
   <indexterm>
    <primary>extract</primary>
   </indexterm>
   <indexterm>
    <primary>isfinite</primary>
   </indexterm>
   <indexterm>
    <primary>justify_days</primary>
   </indexterm>
   <indexterm>
    <primary>justify_hours</primary>
   </indexterm>
   <indexterm>
    <primary>justify_interval</primary>
   </indexterm>
   <indexterm>
    <primary>localtime</primary>
   </indexterm>
   <indexterm>
    <primary>localtimestamp</primary>
   </indexterm>
   <indexterm>
    <primary>now</primary>
   </indexterm>
   <indexterm>
    <primary>statement_timestamp</primary>
   </indexterm>
   <indexterm>
    <primary>timeofday</primary>
   </indexterm>
   <indexterm>
    <primary>transaction_timestamp</primary>
   </indexterm>

    <table id="functions-datetime-table">
     <title>Fonctions date/heure</title>
     <tgroup cols="5">
     <colspec colnum="1" colwidth="2.0*"/>
     <colspec colnum="2" colwidth="0.5*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1.1*"/>
     <colspec colnum="5" colwidth="0.8*"/>
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Code de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>

      <tbody>
     <row>
       <entry><literal><function>age</function>(<type>timestamp</type>, <type>timestamp</type>)</literal></entry>
       <entry><type>interval</type></entry>
       <entry>Soustrait les arguments, ce qui produit un résultat <quote>symbolique</quote>
        en années, mois, jours</entry>
       <entry><literal>age(timestamp '2001-04-10', timestamp '1957-06-13')</literal></entry>
       <entry><literal>43 years 9 mons 27 days</literal></entry>
     </row>

     <row>
	<entry><literal><function>age</function>(<type>timestamp</type>)</literal></entry>
	<entry><type>interval</type></entry>
	<entry>Soustrait à la date courante (<function>current_date</function> à minuit)</entry>
	<entry><literal>age(timestamp '1957-06-13')</literal></entry>
	<entry><literal>43 years 8 mons 3 days</literal></entry>
      </row>

       <row>
        <entry><literal><function>clock_timestamp</function>()</literal></entry>
        <entry><type>timestamp with time zone</type></entry>
        <entry>Date et heure courantes (change pendant l'exécution de
	 l'instruction)&nbsp;;
         voir la <xref linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

       <row>
	       <entry><literal><function>current_date</function></literal></entry>
	       <entry><type>date</type></entry>
	       <entry>Date courante&nbsp;; voir la <xref linkend="functions-datetime-current"/>
	       </entry>
	       <entry></entry>
	       <entry><literal>1</literal></entry>
       </row>

       <row>
        <entry><literal><function>current_time</function></literal></entry>
        <entry><type>time with time zone</type></entry>
        <entry>Heure courante&nbsp;; voir la <xref
         linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

       <row>
	<entry><literal><function>current_timestamp</function></literal></entry>
	<entry><type>timestamp with time zone</type></entry>
	<entry>Date et heure courantes (début de la transaction en cours)&nbsp;;
	 voir la <xref linkend="functions-datetime-current"/>
	</entry>
	<entry></entry>
	<entry></entry>
       </row>

       <row>
	<entry><literal><function>date_part</function>(<type>text</type>,
<type>timestamp</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>Obtenir un sous-champ (équivalent à
	 <function>extract</function>)&nbsp;; voir la <xref
         linkend="functions-datetime-extract"/>
        </entry>
	<entry><literal>date_part('hour', timestamp '2001-02-16
20:38:40')</literal></entry>
	<entry><literal>20</literal></entry>
       </row>

       <row>
	<entry><literal><function>date_part</function>(<type>text</type>,
<type>interval</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>Obtenir un sous-champ (équivalent à
	 <function>extract</function>)&nbsp;; voir la <xref
         linkend="functions-datetime-extract"/>
        </entry>
	<entry><literal>date_part('month', interval '2 years 3
months')</literal></entry>
	<entry><literal>3</literal></entry>
       </row>

       <row>
	<entry><literal><function>date_trunc</function>(<type>text</type>,
<type>timestamp</type>)</literal></entry>
	<entry><type>timestamp</type></entry>
	<entry>Tronquer à la précision indiquée&nbsp;; voir aussi la <xref
         linkend="functions-datetime-trunc"/>
        </entry>
	<entry><literal>date_trunc('hour', timestamp '2001-02-16
20:38:40')</literal></entry>
	<entry><literal>2001-02-16 20:00:00</literal></entry>
       </row>

       <row>
	<entry><literal><function>extract</function>(<parameter>field</parameter> from
         <type>timestamp</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>Obtenir un sous-champ&nbsp;; voir la <xref
         linkend="functions-datetime-extract"/>
        </entry>
	<entry><literal>extract(hour from timestamp '2001-02-16
20:38:40')</literal></entry>
	<entry><literal>20</literal></entry>
       </row>

       <row>
	<entry><literal><function>extract</function>(<parameter>field</parameter> from
         <type>interval</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>Obtenir un sous-champ&nbsp;; voir la <xref
         linkend="functions-datetime-extract"/>
        </entry>
	<entry><literal>extract(month from interval '2 years 3
months')</literal></entry>
	<entry><literal>3</literal></entry>
       </row>

       <row>
        <entry><literal><function>isfinite</function>(<type>date</type>)</literal></entry>
        <entry><type>boolean</type></entry>
        <entry>Test si la date est finie (donc différent de +/-infinity)</entry>
        <entry><literal>isfinite(date '2001-02-16')</literal></entry>
        <entry><literal>true</literal></entry>
       </row>

       <row>
	<entry><literal><function>isfinite</function>(<type>timestamp</type>)</literal>
</entry>
	<entry><type>boolean</type></entry>
	<entry>Teste si l'estampille temporelle est finie (donc différent de +/-infinity)</entry>
	<entry><literal>isfinite(timestamp '2001-02-16 21:28:30')</literal></entry>
	<entry><literal>true</literal></entry>
       </row>

       <row>
	<entry><literal><function>isfinite</function>(<type>interval</type>)</literal></entry>
	<entry><type>boolean</type></entry>
	<entry>Teste si l'intervalle est fini</entry>
	<entry><literal>isfinite(interval '4 hours')</literal></entry>
	<entry><literal>true</literal></entry>
       </row>

       <row>
        <entry><literal><function>justify_days</function>(<type>interval</type>)</literal></entry>
        <entry><type>interval</type></entry>
        <entry>Ajuste l'intervalle pour que les périodes de 30 jours soient
	représentées comme des mois</entry>
        <entry><literal>justify_days(interval '35 days')</literal></entry>
        <entry><literal>1 mon 5 days</literal></entry>
       </row>

       <row>
        <entry><literal><function>justify_hours</function>(<type>interval</type>)</literal></entry>
        <entry><type>interval</type></entry>
        <entry>Ajuste l'intervalle pour que les périodes de 24 heures soient
	représentées comme des jours</entry>
        <entry><literal>justify_hours( interval '27 hours')</literal></entry>
        <entry><literal>1 day 03:00:00</literal></entry>
       </row>

       <row>
        <entry><literal><function>justify_interval</function>(<type>interval</type>)</literal></entry>
        <entry><type>interval</type></entry>
        <entry>Ajuste l'intervalle en utilisant <function>justify_days</function> et
	<function>justify_hours</function>, avec des signes supplémentaires
	d'ajustement</entry>
        <entry><literal>justify_interval(interval '1 mon -1 hour')</literal></entry>
        <entry><literal>29 days 23:00:00</literal></entry>
       </row>

       <row>
        <entry><literal><function>localtime</function></literal></entry>
        <entry><type>time</type></entry>
        <entry>Heure du jour courante&nbsp;; voir la <xref
         linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

       <row>
        <entry><literal><function>localtimestamp</function></literal></entry>
        <entry><type>timestamp</type></entry>
        <entry>Date et heure courantes (début de la transaction)&nbsp;; voir la <xref
         linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

       <row>
	<entry><literal><function>now</function>()</literal></entry>
	<entry><type>timestamp with time zone</type></entry>
	<entry>Date et heure courantes (début de la transaction)&nbsp;; voir la <xref
         linkend="functions-datetime-current"/>
	</entry>
	<entry></entry>
	<entry></entry>
       </row>

       <row>
        <entry><literal><function>statement_timestamp</function>()</literal></entry>
        <entry><type>timestamp with time zone</type></entry>
        <entry>Date et heure courantes (début de l'instruction en cours)&nbsp;;
         voir <xref linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

       <row>
	<entry><literal><function>timeofday</function>()</literal></entry>
	<entry><type>text</type></entry>
	<entry>Date et heure courantes (comme <function>clock_timestamp</function>
	 mais avec une chaîne de type <type>text</type>)&nbsp;; voir la <xref
         linkend="functions-datetime-current"/>
	</entry>
	<entry></entry>
	<entry></entry>
       </row>

       <row>
        <entry><literal><function>transaction_timestamp</function>()</literal></entry>
        <entry><type>timestamp with time zone</type></entry>
        <entry>Date et heure courantes (début de la transaction en cours)&nbsp;;
         voir <xref linkend="functions-datetime-current"/>
        </entry>
        <entry></entry>
        <entry></entry>
       </row>

      </tbody>
     </tgroup>
    </table>

   <para>
    En plus de ces fonctions, l'opérateur SQL <literal>OVERLAPS</literal> est
    supporté&nbsp;:
<synopsis>( <replaceable>début1</replaceable>, <replaceable>fin1</replaceable> ) OVERLAPS ( <replaceable>début2</replaceable>, <replaceable>fin2</replaceable> )
( <replaceable>début1</replaceable>, <replaceable>longueur1</replaceable> ) OVERLAPS ( <replaceable>début2</replaceable>, <replaceable>longueur2</replaceable> )</synopsis>
    Cette expression renvoie vrai (true) lorsque les deux périodes de temps 
    (définies par leurs extrémités) se chevauchent, et faux dans le cas
    contraire. Les limites peuvent être indiquées comme des paires de
    dates, d'heures ou de timestamps&nbsp;; ou comme une date, une heure ou un
    timestamp suivi d'un intervalle.
   </para>

<screen>SELECT (DATE '2001-02-16', DATE '2001-12-21') OVERLAPS
       (DATE '2001-10-30', DATE '2002-10-30');
<lineannotation>Résultat :
</lineannotation><computeroutput>true</computeroutput>
SELECT (DATE '2001-02-16', INTERVAL '100 days') OVERLAPS
       (DATE '2001-10-30', DATE '2002-10-30');
<lineannotation>Résultat :
</lineannotation><computeroutput>false</computeroutput></screen>

  <para>
   Lors de l'ajout (ou de la soustraction) d'une valeur de type
   <type>interval</type> à une valeur
   de type <type>timestamp with time zone</type>, le composant jours incrémente
   (ou décremente) la date du <type>timestamp with time zone</type> du nombre
   de jours indiqués. Avec les modifications occasionnées par les changements
   d'heure (avec un fuseau horaire de session qui reconnaît DST), cela
   signifie qu'un <literal>interval '1 day'</literal>  n'est pas forcément
   égal à un <literal>interval '24 hours'</literal>. Par exemple, avec un
   fuseau horaire configuré à <literal>CST7CDT</literal>,
   <literal>timestamp with time zone '2005-04-02 12:00-07' + interval '1 day'
   </literal> produit un <literal>timestamp with time zone '2005-04-03
   12:00-06'</literal> alors qu'ajouter <literal>interval '24
   hours'</literal> au <type>timestamp with time zone</type> initial
   produit un <literal>timestamp with time zone '2005-04-03
   13:00-06'</literal> parce qu'il y a un changement d'heure le <literal>2005-04-03
   02:00</literal> pour le fuseau horaire <literal>CST7CDT</literal>.
  </para>

  <para>
   Il peut y avoir une ambiguïté dans le nombre de 
   <literal>months</literal> retournés par <function>age</function> car les mois n'ont
   pas tous le même nombre de jours. L'approche de
   <productname>PostgreSQL</productname> utilise le mois de la date
   la plus ancienne lors du calcul de mois partiels. Par
   exemple, <literal>age('2004-06-01', '2004-04-30')</literal> utilise avril
   pour ramener <literal>1 mon 1 day</literal>, alors qu'utiliser mai aurait
   ramener <literal>1 mon 2 days</literal> car mai a 31 jours alors qu'avril
   n'en a que 30.
  </para>

  <sect2 id="functions-datetime-extract">
   <title><function>EXTRACT</function>, <function>date_part</function></title>

   <indexterm>
    <primary>date_part</primary>
   </indexterm>
   <indexterm>
    <primary>extract</primary>
   </indexterm>

<synopsis>EXTRACT (<replaceable>champ</replaceable> FROM <replaceable>source</replaceable>)</synopsis>

   <para>
    La fonction <function>extract</function> récupère des sous-champs de valeurs
    date/heure, tels que l'année ou l'heure.
    <replaceable>source</replaceable> est une expression de valeur de
    type <type>timestamp</type>, <type>time</type> ou <type>interval</type>.
    (Les expressions de type <type>date</type> sont
    converties en <type>timestamp</type> et peuvent aussi être utilisées.)
    <replaceable>champ</replaceable> est un identifiant ou une chaîne qui
    sélectionne le champ à extraire de la valeur source. La fonction
    <function>extract</function> renvoie des valeurs de type
    <type>double precision</type>. La liste qui suit présente les noms de champs
    valides&nbsp;:

    <!-- alphabetical -->
    <variablelist>
     <varlistentry>
      <term><literal>century</literal></term>
      <listitem>
       <para>
        Le siècle.
       </para>

<screen>SELECT EXTRACT(CENTURY FROM TIMESTAMP '2000-12-16 12:21:13');
<lineannotation>Résultat : </lineannotation><computeroutput>20</computeroutput>
SELECT EXTRACT(CENTURY FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>21</computeroutput></screen>

       <para>
         Le premier siècle commence le 1er janvier de l'an 1 (0001-01-01
         00:00:00 AD) bien qu'ils ne le savaient pas à cette époque. Cette
         définition s'applique à tous les pays qui utilisent le calendrier Grégorien.
         Le siècle 0 n'existe pas. On passe de -1 siècle à 1 siècle.
         En cas de désaccord, adresser une plainte à&nbsp;:
         Sa Sainteté le Pape, Cathédrale Saint-Pierre de Rome, Vatican.
       </para>

       <para>
	Les versions de <productname>PostgreSQL</productname> antérieures à
	la 8.0 ne suivaient pas la numérotation conventionnelle des siècles
	mais renvoyaient uniquement le champ année divisée par 100.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>day</literal></term>
      <listitem>
       <para>
        Le champ jour (du mois) : de 1 à 31.
       </para>

<screen>SELECT EXTRACT(DAY FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>16</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>decade</literal></term>
      <listitem>
       <para>
        Le champ année divisé par 10.
       </para>

<screen>SELECT EXTRACT(DECADE FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>200</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>dow</literal></term>
      <listitem>
       <para>
        Le jour de la semaine du dimanche (<literal>0</literal>) au samedi
        (<literal>6</literal>).
       </para>

<screen>SELECT EXTRACT(DOW FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>5</computeroutput></screen>
       <para>
	Cette numérotation du jour de la semaine est différente de celle
	de la fonction <function>to_char(..., 'D')</function>.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>doy</literal></term>
      <listitem>
       <para>
        Le jour de l'année (de 1 à 365/366).
       </para>

<screen>SELECT EXTRACT(DOY FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>47</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>epoch</literal></term>
      <listitem>
       <para>
        Pour les valeurs de type <type>date</type> et <type>timestamp</type>,
        le nombre de secondes depuis le 1er janvier 1970 (exactement depuis le
        1970-01-01 00:00:00 UTC). Ce nombre peut être négatif. Pour les valeurs de
        type <type>interval</type>, il s'agit du nombre total de secondes dans
        l'intervalle.
       </para>

<screen>SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2001-02-16 20:38:40-08');
<lineannotation>Résultat :
</lineannotation><computeroutput>982384720</computeroutput>

SELECT EXTRACT(EPOCH FROM INTERVAL '5 days 3 hours');
<lineannotation>Résultat :
</lineannotation><computeroutput>442800</computeroutput></screen>

       <para>
	Convertir une valeur epoch en valeur de type
	date/heure&nbsp;:
       </para>

<screen>SELECT TIMESTAMP WITH TIME ZONE 'epoch' + 982384720 * INTERVAL '1 second';</screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>hour</literal></term>
      <listitem>
       <para>
        Le champ heure (0 - 23).
       </para>

<screen>SELECT EXTRACT(HOUR FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>20</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>isodow</literal></term>
      <listitem>
       <para>
        Le jour de la semaine du lundi (<literal>1</literal>) au dimanche
        (<literal>7</literal>).
       </para>

<screen>
SELECT EXTRACT(ISODOW FROM TIMESTAMP '2001-02-18 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>7</computeroutput>
</screen>
       <para>
        Ceci est identique à <literal>dow</literal> sauf pour le dimanche. Cela
        correspond à la numérotation du jour de la semaine suivant le format
	<acronym>ISO</acronym> 8601.
       </para>

      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>isoyear</literal></term>
      <listitem>
       <para>
        L'année <acronym>ISO</acronym> 8601 dans laquelle se trouve la date
	(non applicable aux intervalles).
       </para>

<screen>
SELECT EXTRACT(ISOYEAR FROM DATE '2006-01-01');
<lineannotation>Résultat : </lineannotation><computeroutput>2005</computeroutput>
SELECT EXTRACT(ISOYEAR FROM DATE '2006-01-02');
<lineannotation>Résultat : </lineannotation><computeroutput>2006</computeroutput>
</screen>

       <para>
        Chaque année <acronym>ISO</acronym> commence avec le lundi de la
	semaine contenant le 4 janvier, donc soit début janvier, soit
	fin décembre. L'année <acronym>ISO</acronym> peut être différente de
	l'année grégorienne. Voir le champ <literal>week</literal> pour plus
	d'informations.
       </para>
       <para>
        Ce champ n'est disponible que depuis la version 8.3 de PostgreSQL.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>microseconds</literal></term>
      <listitem>
       <para>
        Le champ secondes, incluant la partie décimale, multiplié par
        1&nbsp;000&nbsp;000. Cela inclut l'intégralité des secondes.
       </para>

<screen>SELECT EXTRACT(MICROSECONDS FROM TIME '17:12:28.5');
<lineannotation>Résultat :
</lineannotation><computeroutput>28500000</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>millennium</literal></term>
      <listitem>
       <para>
        Le millénaire.
       </para>

<screen>SELECT EXTRACT(MILLENNIUM FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>3</computeroutput></screen>

	<para>
	 Les années 1900 sont dans le second millénaire. Le troisième millénaire
	 commence le 1er janvier 2001.
	</para>

	<para>
	Les versions de <productname>PostgreSQL</productname> antérieures à la 8.0
	ne suivaient pas les conventions de numérotation des millénaires mais
	renvoyaient seulement le champ année divisé par 1000.
	</para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>milliseconds</literal></term>
      <listitem>
       <para>
        Le champ secondes, incluant la partie décimale, multiplié par 1000.
        Cela inclut l'intégralité des secondes.
       </para>

<screen>SELECT EXTRACT(MILLISECONDS FROM TIME '17:12:28.5');
<lineannotation>Résultat :
</lineannotation><computeroutput>28500</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>minute</literal></term>
      <listitem>
       <para>
        Le champ minutes (0 - 59).
       </para>

<screen>SELECT EXTRACT(MINUTE FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>38</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>month</literal></term>
      <listitem>
       <para>
        Pour les valeurs de type <type>timestamp</type>, le numéro du mois dans
        l'année (de 1 à 12)&nbsp;; pour les valeurs de type
        <type>interval</type>, le nombre de mois, modulo 12 (0 - 11).
       </para>

<screen>SELECT EXTRACT(MONTH FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>2</computeroutput>

SELECT EXTRACT(MONTH FROM INTERVAL '2 years 3 months');
<lineannotation>Résultat : </lineannotation><computeroutput>3</computeroutput>

SELECT EXTRACT(MONTH FROM INTERVAL '2 years 13 months');
<lineannotation>Résultat : </lineannotation><computeroutput>1</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>quarter</literal></term>
      <listitem>
       <para>
        Le trimestre (1 - 4) dont le jour fait partie.
       </para>

<screen>SELECT EXTRACT(QUARTER FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>1</computeroutput></screen>
      </listitem>
     </varlistentry>

    <!-- SAS leap second : seconde d'ajustement, ajoutée pour rattraper le
    temps UTC  -->
     <varlistentry>
      <term><literal>second</literal></term>
      <listitem>
       <para>
        Le champs secondes, incluant la partie décimale (0 -
        59<footnote><simpara>60 si les secondes d'ajustement
	(<foreignphrase>leap second</foreignphrase>) sont implantées par
        le système d'exploitation.</simpara></footnote>).
       </para>

<screen>SELECT EXTRACT(SECOND FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>40</computeroutput>

SELECT EXTRACT(SECOND FROM TIME '17:12:28.5');
<lineannotation>Résultat :
</lineannotation><computeroutput>28.5</computeroutput></screen>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term><literal>timezone</literal></term>
      <listitem>
       <para>
        Le décalage du fuseau horaire depuis UTC, mesuré en secondes. Les
        valeurs positives correspondent aux fuseaux horaires à l'est d'UTC, les 
        valeurs négatives à l'ouest d'UTC.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>timezone_hour</literal></term>
      <listitem>
       <para>
        Le composant heure du décalage du fuseau horaire.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>timezone_minute</literal></term>
      <listitem>
       <para>
        Le composant minute du décalage du fuseau horaire.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>week</literal></term>
      <listitem>
       <para>
        Le numéro de la semaine dans l'année, à laquelle appartient le jour. Par
        définition (<acronym>ISO</acronym> 8601), la première semaine d'une
        année contient le 4 janvier de cette année. (La semaine 
        <acronym>ISO</acronym>-8601 commence un lundi.) Dit autrement, le
        premier jeudi d'une année se trouve dans la première semaine de cette
        année.
       </para>
       <para>
        De ce fait, les dates de début janvier peuvent
	faire partie de la 52è ou 53è semaine de l'année précédente. Par exemple,
        <literal>2005-01-01</literal> fait partie de la 53è semaine de 2004 et
        <literal>2006-01-01</literal> fait partie de la 52è semaine de l'année 2005.
       </para>

<screen>SELECT EXTRACT(WEEK FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>7</computeroutput></screen>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><literal>year</literal></term>
      <listitem>
       <para>
        Le champ année. Il n'y a pas de <literal>0 AD</literal>,
        la soustraction d'années <literal>BC</literal> aux années
	<literal>AD</literal> nécessite donc une attention particulière.
       </para>

<screen>SELECT EXTRACT(YEAR FROM TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat :
</lineannotation><computeroutput>2001</computeroutput></screen>
      </listitem>
     </varlistentry>

    </variablelist>

   </para>

   <para>
    La fonction <function>extract</function> a pour but principal l'exécution
    de calculs. Pour le formatage des valeurs date/heure en vue de leur affichage, voir la
    <xref linkend="functions-formatting"/>.
   </para>

   <para>
    La fonction <function>date_part</function> est modelée sur l'équivalent
    traditionnel <productname>Ingres</productname> de la fonction
    <function>extract</function> du standard <acronym>SQL</acronym>&nbsp;:
<synopsis>date_part('<replaceable>champ</replaceable>', <replaceable>source</replaceable>)</synopsis>
    Le paramètre <replaceable>champ</replaceable> est obligatoirement une
    valeur de type chaîne et non pas un nom. Les noms de champ valide pour
    <function>date_part</function> sont les mêmes que pour
    <function>extract</function>.
   </para>

<screen>SELECT date_part('day', TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>16</computeroutput>

SELECT date_part('hour', INTERVAL '4 hours 3 minutes');
<lineannotation>Résultat : </lineannotation><computeroutput>4</computeroutput></screen>

  </sect2>

  <sect2 id="functions-datetime-trunc">
   <title><function>date_trunc</function></title>

   <indexterm>
    <primary>date_trunc</primary>
   </indexterm>

   <para>
    La fonction <function>date_trunc</function> est conceptuellement similaire
    à la fonction <function>trunc</function> pour les nombres.
   </para>

   <para>
<synopsis>date_trunc('<replaceable>champ</replaceable>', <replaceable>source</replaceable>)</synopsis>
    <replaceable>source</replaceable> est une expression de type
    <type>timestamp</type> ou <type>interval</type>.
    (Les valeurs de type <type>date</type> et
    <type>time</type> sont converties automatiquement en,
    respectivement, <type>timestamp</type> ou
    <type>interval</type>).
    <replaceable>champ</replaceable> indique la précision avec laquelle tronquer
    la valeur en entrée. La valeur de retour est de type
    <type>timestamp</type> ou <type>interval</type> avec tous les champs
    moins significatifs que celui sélectionné positionnés à zéro (ou un pour la date
    et le mois).
   </para>

   <para>
    Les valeurs valides pour <replaceable>champ</replaceable> sont&nbsp;:
    <simplelist>
     <member><literal>microseconds</literal></member>
     <member><literal>milliseconds</literal></member>
     <member><literal>second</literal></member>
     <member><literal>minute</literal></member>
     <member><literal>hour</literal></member>
     <member><literal>day</literal></member>
     <member><literal>week</literal></member>
     <member><literal>month</literal></member>
     <member><literal>quarter</literal></member>
     <member><literal>year</literal></member>
     <member><literal>decade</literal></member>
     <member><literal>century</literal></member>
     <member><literal>millennium</literal></member>
    </simplelist>
   </para>

   <para>
    Exemples&nbsp;:
<screen>SELECT date_trunc('hour', TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>2001-02-16
20:00:00</computeroutput>

SELECT date_trunc('year', TIMESTAMP '2001-02-16 20:38:40');
<lineannotation>Résultat : </lineannotation><computeroutput>2001-01-01
00:00:00</computeroutput></screen>
   </para>
  </sect2>

  <sect2 id="functions-datetime-zoneconvert">
   <title><literal>AT TIME ZONE</literal></title>

   <indexterm>
    <primary>fuseau horaire</primary>
    <secondary>conversion</secondary>
   </indexterm>

   <indexterm>
    <primary>AT TIME ZONE</primary>
   </indexterm>

   <para>
    La construction <literal>AT TIME ZONE</literal> permet les conversions
    d'<quote>estampilles temporelles</quote> (<foreignphrase>time
    stamps</foreignphrase>) dans les différents fuseaux horaires. 
    Le <xref linkend="functions-datetime-zoneconvert-table"/> affiche ses variantes.
   </para>

    <table id="functions-datetime-zoneconvert-table">
     <title>Variantes <literal>AT TIME ZONE</literal></title>
     <tgroup cols="3">
      <colspec colnum="1" colwidth="1.3*"/>
      <colspec colnum="2" colwidth="0.4*"/>
      <colspec colnum="3" colwidth="1.3*"/>
      <thead>
       <row>
	<entry>Expression</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
       </row>
      </thead>

      <tbody>
       <row>
	<entry>
	 <literal><type>timestamp without time zone</type> AT TIME ZONE
<replaceable>zone</replaceable></literal>
	</entry>
	<entry><type>timestamp with time zone</type></entry>
	<entry>Traite l'estampille donnée <emphasis>without time
	zone</emphasis> (sans fuseau),
	comme située dans le fuseau horaire indiqué.</entry>
       </row>

       <row>
	<entry>
	 <literal><type>timestamp with time zone</type> AT TIME ZONE
<replaceable>zone</replaceable></literal>
	</entry>
	<entry><type>timestamp without time zone</type></entry>
	<entry>Convertit l'estampille donnée <emphasis>with time
	zone</emphasis> (avec fuseau)
	dans le nouveau fuseau horaire, sans désignation du fuseau.</entry>
       </row>

       <row>
	<entry>
	 <literal><type>time with time zone</type> AT TIME ZONE
<replaceable>zone</replaceable></literal>
	</entry>
	<entry><type>time with time zone</type></entry>
	<entry>Convertit l'heure donnée <emphasis>with time
	zone</emphasis> (avec fuseau) dans
	le nouveau fuseau horaire.</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Dans ces expressions, le fuseau horaire désiré <replaceable>zone</replaceable>
    peut être indiqué comme une chaîne texte (par exemple, 
    <literal>'PST'</literal>) ou comme un intervalle (c'est-à-dire
    <literal>INTERVAL '-08:00'</literal>). Dans le cas textuel, un nom de
    fuseau peut être indiqué de toute façon décrite dans <xref
    linkend="datatype-timezones"/>.
   </para>

   <para>
    Exemples (en supposant que le fuseau horaire local soit
    <literal>PST8PDT</literal>)&nbsp;:
<screen>SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
<lineannotation>Résultat : </lineannotation><computeroutput>2001-02-16
19:38:40-08</computeroutput>

SELECT TIMESTAMP WITH TIME ZONE '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
<lineannotation>Résultat : </lineannotation><computeroutput>2001-02-16
18:38:40</computeroutput></screen>
    Le premier exemple prend une <quote>estampille temporelle sans fuseau</quote>
    et l'interprète comme une date MST (UTC-7), qui est ensuite convertie en PST
    (UTC-8) pour l'affichage. Le second exemple prend une estampille indiquée
    en EST (UTC-5) et la convertit en heure locale, c'est-à-dire en MST (UTC-7).
   </para>

   <para>
    La fonction <literal><function>timezone</function>(<replaceable>zone</replaceable>,
    <replaceable>timestamp</replaceable>)</literal> est équivalente à la construction
    conforme au standard SQL, <literal><replaceable>timestamp</replaceable> AT TIME ZONE
    <replaceable>zone</replaceable></literal>. 
   </para>
  </sect2>

  <sect2 id="functions-datetime-current">
   <title>Date/Heure courante</title>

   <indexterm>
    <primary>date</primary>
    <secondary>courante</secondary>
   </indexterm>

   <indexterm>
    <primary>heure</primary>
    <secondary>courante</secondary>
   </indexterm>

   <para>
    <productname>PostgreSQL</productname> fournit diverses fonctions
    qui renvoient des valeurs relatives aux date et heure courantes. Ces
    fonctions du standard SQL renvoient toutes des valeurs fondées sur l'heure
    de début de la transaction en cours&nbsp;:
<synopsis>
CURRENT_DATE&nbsp;;
CURRENT_TIME&nbsp;;
CURRENT_TIMESTAMP&nbsp;;
CURRENT_TIME(<replaceable>precision</replaceable>)&nbsp;;
CURRENT_TIMESTAMP(<replaceable>precision</replaceable>)&nbsp;;
LOCALTIME&nbsp;;
LOCALTIMESTAMP&nbsp;;
LOCALTIME(<replaceable>precision</replaceable>)&nbsp;;
LOCALTIMESTAMP(<replaceable>precision</replaceable>).
</synopsis>
    </para>

    <para>
     <function>CURRENT_TIME</function> et
     <function>CURRENT_TIMESTAMP</function> délivrent les valeurs avec
     indication du fuseau horaire&nbsp;;
     <function>LOCALTIME</function> et
     <function>LOCALTIMESTAMP</function> délivrent les valeurs sans
     indication du fuseau horaire.
    </para>

    <para>
     <function>CURRENT_TIME</function>,
     <function>CURRENT_TIMESTAMP</function>,
     <function>LOCALTIME</function>, et
     <function>LOCALTIMESTAMP</function>
     acceptent un paramètre optionnel de précision. Celui-ci 
     permet d'arrondir le résultat au nombre de chiffres indiqués pour la
     partie fractionnelle des secondes. Sans ce paramètre de précision, le
     résultat est donné avec toute la précision disponible.
    </para>

   <para>
    Quelques exemples&nbsp;:
<screen>SELECT CURRENT_TIME;
<lineannotation>Résultat :
</lineannotation><computeroutput>14:39:53.662522-05</computeroutput>

SELECT CURRENT_DATE;
<lineannotation>Résultat :
</lineannotation><computeroutput>2001-12-23</computeroutput>

SELECT CURRENT_TIMESTAMP;
<lineannotation>Résultat : </lineannotation><computeroutput>2001-12-23
14:39:53.662522-05</computeroutput>

SELECT CURRENT_TIMESTAMP(2);
<lineannotation>Résultat : </lineannotation><computeroutput>2001-12-23
14:39:53.66-05</computeroutput>

SELECT LOCALTIMESTAMP;
<lineannotation>Résultat : </lineannotation><computeroutput>2001-12-23
14:39:53.662522</computeroutput></screen>
   </para>

   <para>
    Comme ces fonctions renvoient l'heure du début de la transaction
    en cours, leurs valeurs ne
    changent pas au cours de la transaction. Il s'agit d'une
    fonctionnalité&nbsp;: le but est de permettre à une même transaction
    de disposer d'une notion cohérente de l'heure <quote>courante</quote>. Les
    multiples modifications au sein d'une même transaction portent ainsi
    toutes la même heure.
   </para>

   <note>
    <para>
     D'autres systèmes de bases de données actualisent ces valeurs
     plus fréquemment.
    </para>
   </note>

   <para>
    <productname>PostgreSQL</productname> fournit aussi des fonctions qui
    renvoient
    l'heure de début de l'instruction en cours, voire l'heure de l'appel de la
    fonction. La liste complète des fonctions ne faisant pas partie du standard
    SQL est&nbsp;:
<synopsis>transaction_timestamp()
statement_timestamp()
clock_timestamp()
timeofday()
now()
</synopsis>
   </para>

   <para>
    <function>transaction_timestamp()</function> est un peu l'équivalent de
    <function>CURRENT_TIMESTAMP</function> mais est nommé ainsi pour expliciter
    l'information retournée.
    <function>statement_timestamp()</function> renvoie l'heure de début de
    l'instruction en cours (plus exactement, l'heure de réception du
    dernier message de la commande en provenance du client).
    <function>statement_timestamp()</function> et <function>transaction_timestamp()</function>
    renvoient la même valeur pendant la première commande d'une transaction,
    mais leurs résultats peuvent différer pour les commandes suivantes.
    <function>clock_timestamp()</function> renvoie l'heure courante, et, de ce
    fait, sa valeur change même à l'intérieur d'une commande SQL unique.
    <function>timeofday()</function> est une fonction historique de
    <productname>PostgreSQL</productname>. Comme
    <function>clock_timestamp()</function>, elle renvoie l'heure courante, mais
    celle-ci est alors formatée comme une chaîne <type>text</type> et non comme
    une valeur de type <type>timestamp with time zone</type>.
    <function>now()</function> est l'équivalent traditionnel <productname>PostgreSQL</productname>
    de <function>CURRENT_TIMESTAMP</function>.
   </para>

   <para>
    Tous les types de données date/heure acceptent aussi la valeur littérale 
    spéciale <literal>now</literal> pour indiquer la date et l'heure courantes
    (interprétés comme l'heure de début de la transaction).
    De ce fait, les trois instructions suivantes renvoient le même résultat&nbsp;:
<programlisting>SELECT CURRENT_TIMESTAMP;
SELECT now();
SELECT TIMESTAMP 'now'; -- utilisation incorrecte avec DEFAULT</programlisting>
   </para>

    <tip>
     <para>
      La troisième forme ne doit pas être utilisée pour la spécification 
      de la clause <literal>DEFAULT</literal> à la création d'une table. Le système
      convertirait <literal>now</literal> en valeur de type
      <type>timestamp</type> dès l'analyse de la constante. À chaque fois que la
      valeur par défaut est nécessaire, c'est l'heure de création de la
      table qui est alors utilisée. Les deux premières formes ne sont pas
      évaluées avant l'utilisation de la valeur par défaut, il s'agit 
      d'appels de fonctions. C'est donc bien le comportement attendu, l'heure
      d'insertion comme valeur par défaut, qui est obtenu.
     </para>
    </tip>
  </sect2>

  <sect2 id="functions-datetime-delay">
   <title>Retarder l'exécution</title>

   <indexterm>
    <primary>pg_sleep</primary>
   </indexterm>
   <indexterm>
    <primary>sleep</primary>
   </indexterm>
   <indexterm>
    <primary>delay</primary>
   </indexterm>

   <para>
    La fonction suivante permet de retarder l'exécution du processus
    serveur&nbsp;:
<synopsis>
pg_sleep(<replaceable>seconds</replaceable>)
</synopsis>

    <function>pg_sleep</function> endort le processus de la session courante
    pendant <replaceable>seconds</replaceable> secondes.
    <replaceable>seconds</replaceable> est une valeur de type
    <type>double precision</type>, ce qui autorise les délais en fraction de secondes. Par exemple&nbsp;:

<programlisting>SELECT pg_sleep(1.5);
</programlisting>
   </para>

   <note>
     <para>
      La résolution réelle de l'intervalle est spécifique à la plateforme&nbsp;;
      0,01 seconde est une valeur habituelle. Le délai dure au minimum celui
      précisé. Il peut toutefois être plus long du fait de certains facteurs
      tels que la charge serveur.
     </para>
   </note>

   <warning>
     <para>
      Il convient de s'assurer que la session courante ne détient pas plus de verrous que
      nécessaires lors de l'appel à <function>pg_sleep</function>. Dans le cas
      contraire, d'autres sessions peuvent être amenées à attendre que le
      processus de retard courant ne termine, ralentissant ainsi tout le système.
     </para>
   </warning>
  </sect2>

 </sect1>

 <sect1 id="functions-enum">
  <title>Fonctions de support enum</title>

  <para>
   Pour les types enum (décrit dans <xref linkend="datatype-enum"/>),
   il existe plusieurs fonctions qui autorisent une programmation plus claire
   sans coder en dur les valeurs particulières d'un type enum.
   Elles sont listées dans <xref linkend="functions-enum-table"/>. Les exemples
   supposent un type enum créé ainsi&nbsp;:

<programlisting>
CREATE TYPE couleurs AS ENUM ('rouge', 'orange', 'jaune', 'vert', 'bleu', 'violet');
</programlisting>

  </para>

  <table id="functions-enum-table">
    <title>Fonctions de support enum</title>
    <tgroup cols="4">
     <thead>
      <row>
       <entry>Fonction</entry>
       <entry>Description</entry>
       <entry>Exemple</entry>
       <entry>Résultat de l'exemple</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry><literal>enum_first(anyenum)</literal></entry>
       <entry>Renvoie la première valeur du type enum en entrée</entry>
       <entry><literal>enum_first(null::couleurs)</literal></entry>
       <entry><literal>rouge</literal></entry>
      </row>
      <row>
       <entry><literal>enum_last(anyenum)</literal></entry>
       <entry>Renvoie la dernière valeur du type enum en entrée</entry>
       <entry><literal>enum_last(null::couleurs)</literal></entry>
       <entry><literal>violet</literal></entry>
      </row>
      <row>
       <entry><literal>enum_range(anyenum)</literal></entry>
       <entry>Renvoie toutes les valeurs du type enum en entrée dans un tableau
        trié</entry>
       <entry><literal>enum_range(null::couleurs)</literal></entry>
       <entry><literal>{rouge,orange,jaune,vert,bleu,violet}</literal></entry>
      </row>
      <row>
       <entry morerows="2"><literal>enum_range(anyenum, anyenum)</literal></entry>
       <entry morerows="2">
        Renvoie les éléments entre deux valeurs enum données dans un tableau
	trié. Les valeurs doivent être du même type enum. Si le premier paramètre
	est NULL, le résultat se termine avec la dernière valeur du type enum.
       </entry>
       <entry><literal>enum_range('orange'::couleurs, 'vert'::couleurs)</literal></entry>
       <entry><literal>{orange,jaune,vert}</literal></entry>
      </row>
      <row>
       <entry><literal>enum_range(NULL, 'vert'::couleurs)</literal></entry>
       <entry><literal>{rouge,orange,jaune,vert}</literal></entry>
      </row>
      <row>
       <entry><literal>enum_range('orange'::couleurs, NULL)</literal></entry>
       <entry><literal>{orange,jaune,vert,bleu,violet}</literal></entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    En dehors de la forme à deux arguments de
    <function>enum_range</function>, ces fonctions ne tiennent pas compte de
    la valeur qui leur est fournie&nbsp;; elles ne s'attachent qu'au type de
    donnée déclaré. NULL ou une valeur spécifique du type peut être
    passée, le résultat est le même. Il est plus commun d'appliquer ces
    fonctions à la colonne d'une table ou à l'argument d'une fonction
    qu'à un nom de type en dur, comme le suggèrent les exemples.
   </para>
 </sect1>

 <sect1 id="functions-geometry">
  <title>Fonctions et opérateurs géométriques</title>

   <para>
    Les types géométriques <type>point</type>, <type>box</type>,
    <type>lseg</type>, <type>line</type>, <type>path</type>,
    <type>polygon</type> et <type>circle</type> disposent d'un large ensemble de
    fonctions et opérateurs natifs. Ils sont listés dans le <xref
    linkend="functions-geometry-op-table"/>, le <xref
    linkend="functions-geometry-func-table"/> et le <xref
    linkend="functions-geometry-conv-table"/>.
   </para>

   <caution>
    <para>
     L'opérateur <quote>identique à</quote>, <literal>~=</literal>, représente
     la notion habituelle d'égalité pour les types <type>point</type>,
     <type>box</type>, <type>polygon</type> et <type>circle</type>. Certains
     disposent également d'un opérateur <literal>=</literal>, mais
     <literal>=</literal> ne compare que les égalités d'<emphasis>aires</emphasis>. Les autres opérateurs de
     comparaison scalaires (<literal>&lt;=</literal> et autres) comparent de la
     même façon des aires pour ces types.
    </para>
   </caution>

   <table id="functions-geometry-op-table">
     <title>Opérateurs géométriques</title>
     <tgroup cols="3">
      <colspec colnum="1" colwidth="0.8*"/>
      <colspec colnum="2" colwidth="1.6*"/>
      <colspec colnum="3" colwidth="1.6*"/>
      <thead>
       <row>
	<entry>Opérateur</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal>+</literal> </entry>
	<entry>Translation</entry>
	<entry><literal>box '((0,0),(1,1))' + point '(2.0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>-</literal> </entry>
	<entry>Translation</entry>
	<entry><literal>box '((0,0),(1,1))' - point '(2.0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>*</literal> </entry>
	<entry>Mise à l'échelle/rotation</entry>
	<entry><literal>box '((0,0),(1,1))' * point '(2.0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>/</literal> </entry>
	<entry>Mise à l'échelle/rotation</entry>
	<entry><literal>box '((0,0),(2,2))' / point '(2.0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>#</literal> </entry>
	<entry>Point ou boîte d'intersection</entry>
	<entry><literal>'((1,-1),(-1,1))' # '((1,1),(-1,-1))'</literal></entry>
       </row>
       <row>
	<entry><literal>#</literal> </entry>
	<entry>Nombre de points dans le chemin ou le polygone</entry>
	<entry><literal># '((1,0),(0,1),(-1,0))'</literal></entry>
       </row>
       <row>
	<entry><literal>@-@</literal> </entry>
	<entry>Longueur ou circonférence</entry>
	<entry><literal>@-@ path '((0,0),(1,0))'</literal></entry>
       </row>
       <row>
	<entry><literal>@@</literal> </entry>
	<entry>Centre</entry>
	<entry><literal>@@ circle '((0,0),10)'</literal></entry>
       </row>
       <row>
	<entry><literal>##</literal> </entry>
	<entry>Point de la seconde opérande le plus proche de la première</entry>
	<entry><literal>point '(0,0)' ## lseg '((2,0),(0,2))'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;-&gt;</literal> </entry>
	<entry>Distance entre</entry>
	<entry><literal>circle '((0,0),1)' &lt;-&gt; circle
'((5,0),1)'</literal></entry>
       </row>
       <row>
	<entry><literal>&amp;&amp;</literal> </entry>
	<entry>Recouvrement&nbsp;?</entry>
	<entry><literal>box '((0,0),(1,1))' &amp;&amp; box
'((0,0),(2,2))'</literal></entry>
       </row>
       <row>
        <entry><literal>&lt;&lt;</literal> </entry>
        <entry>Est strictement à gauche de&nbsp;?</entry>
        <entry><literal>circle '((0,0),1)' &lt;&lt; circle '((5,0),1)'</literal></entry>
       </row>
       <row>
        <entry><literal>&gt;&gt;</literal> </entry>
	<entry>Est strictement à droite de&nbsp;?</entry>
        <entry><literal>circle '((5,0),1)' &gt;&gt; circle '((0,0),1)'</literal></entry>
       </row>
       <row>
	<entry><literal>&amp;&lt;</literal> </entry>
	<entry>Ne s'étend pas à droite de&nbsp;?</entry>
	<entry><literal>box '((0,0),(1,1))' &amp;&lt; box
'((0,0),(2,2))'</literal></entry>
       </row>
       <row>
	<entry><literal>&amp;&gt;</literal> </entry>
	<entry>Ne s'étend pas à gauche de&nbsp;?</entry>
	<entry><literal>box '((0,0),(3,3))' &amp;&gt; box
'((0,0),(2,2))'</literal></entry>
       </row>
       <row>
        <entry><literal>&lt;&lt;|</literal> </entry>
	<entry>Est strictement en-dessous de&nbsp;?</entry>
        <entry><literal>box '((0,0),(3,3))' &lt;&lt;| box '((3,4),(5,5))'</literal></entry>
       </row>
       <row>
        <entry><literal>|&gt;&gt;</literal> </entry>
	<entry>Est strictement au-dessus de&nbsp;?</entry>
        <entry><literal>box '((3,4),(5,5))' |&gt;&gt; box '((0,0),(3,3))'</literal></entry>
       </row>
       <row>
        <entry><literal>&amp;&lt;|</literal> </entry>
        <entry>Ne s'étend pas au-dessus de&nbsp;?</entry>
        <entry><literal>box '((0,0),(1,1))' &amp;&lt;| box '((0,0),(2,2))'</literal></entry>
       </row>
       <row>
        <entry><literal>|&amp;&gt;</literal> </entry>
        <entry>Ne s'étend pas en-dessous de&nbsp;?</entry>
        <entry><literal>box '((0,0),(3,3))' |&amp;&gt; box '((0,0),(2,2))'</literal></entry>
       </row>
       <row>
        <entry><literal>&lt;^</literal> </entry>
        <entry>Est en-dessous de (peut toucher)&nbsp;?</entry>
        <entry><literal>circle '((0,0),1)' &lt;^ circle '((0,5),1)'</literal></entry>
       </row>
       <row>
        <entry><literal>&gt;^</literal> </entry>
	<entry>Est au-dessus de (peut toucher)&nbsp;?</entry>
        <entry><literal>circle '((0,5),1)' &gt;^ circle '((0,0),1)'</literal></entry>
       </row>
       <row>
	<entry><literal>?#</literal> </entry>
	<entry>Intersection&nbsp;?</entry>
	<entry><literal>lseg '((-1,0),(1,0))' ?# box
'((-2,-2),(2,2))'</literal></entry>
       </row>
       <row>
	<entry><literal>?-</literal> </entry>
	<entry>Horizontal&nbsp;?</entry>
	<entry><literal>?- lseg '((-1,0),(1,0))'</literal></entry>
       </row>
       <row>
	<entry><literal>?-</literal> </entry>
	<entry>Sont alignés horizontalement&nbsp;?</entry>
	<entry><literal>point '(1,0)' ?- point '(0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>?|</literal> </entry>
	<entry>Vertical&nbsp;?</entry>
	<entry><literal>?| lseg '((-1,0),(1,0))'</literal></entry>
       </row>
       <row>
	<entry><literal>?|</literal> </entry>
	<entry>Sont verticalement alignés&nbsp;?</entry>
	<entry><literal>point '(0,1)' ?| point '(0,0)'</literal></entry>
       </row>
       <row>
	<entry><literal>?-|</literal> </entry>
	<entry>Perpendiculaires&nbsp;?</entry>
	<entry><literal>lseg '((0,0),(0,1))' ?-| lseg '((0,0),(1,0))'</literal></entry>
       </row>
       <row>
	<entry><literal>?||</literal> </entry>
	<entry>Parallèles&nbsp;?</entry>
	<entry><literal>lseg '((-1,0),(1,0))' ?|| lseg
'((-1,2),(1,2))'</literal></entry>
       </row>
       <row>
	<entry><literal>@&gt;</literal> </entry>
	<entry>Contient&nbsp;?</entry>
	<entry><literal>circle '((0,0),2)' @&gt; point '(1,1)'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;@</literal> </entry>
	<entry>Contenu ou dessus&nbsp;?</entry>
	<entry><literal>point '(1,1)' &lt;@ circle '((0,0),2)'</literal></entry>
       </row>
       <row>
	<entry><literal>~=</literal> </entry>
	<entry>Identique à&nbsp;?</entry>
	<entry><literal>polygon '((0,0),(1,1))' ~= polygon
'((1,1),(0,0))'</literal></entry>
       </row>
      </tbody>
     </tgroup>
   </table>


   <note>
    <para>
     Avant <productname>PostgreSQL</productname> 8.2, les opérateurs
     <literal>@&gt;</literal> et <literal>&lt;@</literal> s'appelaient
     respectivement <literal>~</literal> et <literal>@</literal>. Ces noms sont
     toujours disponibles mais, obsolètes, ils seront éventuellement supprimés.
    </para>
   </note>

   <indexterm>
    <primary>area</primary>
   </indexterm>
   <indexterm>
    <primary>center</primary>
   </indexterm>
   <indexterm>
    <primary>diameter</primary>
   </indexterm>
   <indexterm>
    <primary>height</primary>
   </indexterm>
   <indexterm>
    <primary>isclosed</primary>
   </indexterm>
   <indexterm>
    <primary>isopen</primary>
   </indexterm>
   <indexterm>
    <primary>length</primary>
   </indexterm>
   <indexterm>
    <primary>npoints</primary>
   </indexterm>
   <indexterm>
    <primary>pclose</primary>
   </indexterm>
   <indexterm>
    <primary>popen</primary>
   </indexterm>
   <indexterm>
    <primary>radius</primary>
   </indexterm>
   <indexterm>
    <primary>width</primary>
   </indexterm>

   <table id="functions-geometry-func-table">
     <title>Fonctions géométriques</title>
     <tgroup cols="4">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal><function>area</function>
	(<replaceable>object</replaceable>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>aire</entry>
	<entry><literal>area(box '((0,0),(1,1))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>center</function>
	(<replaceable>object</replaceable>)</literal></entry>
	<entry><type>point</type></entry>
	<entry>centre</entry>
	<entry><literal>center(box '((0,0),(1,2))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>diameter</function>(<type>circle</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>diamètre du cercle</entry>
	<entry><literal>diameter(circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>height</function>(<type>box</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>taille verticale (hauteur) de la boîte</entry>
	<entry><literal>height(box '((0,0),(1,1))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>isclosed</function>(<type>path</type>)</literal></entry>
	<entry><type>boolean</type></entry>
	<entry>chemin fermé&nbsp;?</entry>
	<entry><literal>isclosed(path '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>isopen</function>(<type>path</type>)</literal></entry>
	<entry><type>boolean</type></entry>
	<entry>chemin ouvert&nbsp;?</entry>
	<entry><literal>isopen(path '[(0,0),(1,1),(2,0)]')</literal></entry>
       </row>
       <row>
	<entry><literal><function>length</function>(<replaceable>object</replaceable>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>longueur</entry>
	<entry><literal>length(path '((-1,0),(1,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>npoints</function>(<type>path</type>)</literal></entry>
	<entry><type>int</type></entry>
	<entry>nombre de points</entry>
	<entry><literal>npoints(path '[(0,0),(1,1),(2,0)]')</literal></entry>
       </row>
       <row>
	<entry><literal><function>npoints</function>(<type>polygon</type>)</literal></entry>
	<entry><type>int</type></entry>
	<entry>nombre de points</entry>
	<entry><literal>npoints(polygon '((1,1),(0,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>pclose</function>(<type>path</type>)</literal></entry>
	<entry><type>path</type></entry>
	<entry>convertit un chemin en chemin fermé</entry>
	<entry><literal>pclose(path '[(0,0),(1,1),(2,0)]')</literal></entry>
       </row>
<!--![IGNORE[ Not defined by this name. Implements the intersection opérateur '#' 
       <row>
	<entry><literal><function>point</function>(<type>lseg</type>,
<type>lseg</type>)</literal></entry>
	<entry><type>point</type></entry>
	<entry>intersection</entry>
	<entry><literal>point(lseg '((-1,0),(1,0))',lseg
'((-2,-2),(2,2))')</literal></entry>
       </row>
]]-->
       <row>
	<entry><literal><function>popen</function>(<type>path</type>)</literal></entry>
	<entry><type>path</type></entry>
	<entry>convertit un chemin en chemin ouvert</entry>
	<entry><literal>popen(path '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>radius</function>(<type>circle</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>rayon du cercle</entry>
	<entry><literal>radius(circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>width</function>(<type>box</type>)</literal></entry>
	<entry><type>double precision</type></entry>
	<entry>taille horizontale (largeur) d'une boîte</entry>
	<entry><literal>width(box '((0,0),(1,1))')</literal></entry>
       </row>
      </tbody>
     </tgroup>
   </table>


   <table id="functions-geometry-conv-table">
     <title>Fonctions de conversion de types géométriques</title>
     <tgroup cols="4">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal><function>box</function>(<type>circle</type>)</literal></entry>
	<entry><type>box</type></entry>
	<entry>cercle vers boîte</entry>
	<entry><literal>box(circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>box</function>(<type>point</type>,
<type>point</type>)</literal></entry>
	<entry><type>box</type></entry>
	<entry>points vers boîte</entry>
	<entry><literal>box(point '(0,0)', point '(1,1)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>box</function>(<type>polygon</type>)</literal></entry>
	<entry><type>box</type></entry>
	<entry>polygone vers boîte</entry>
	<entry><literal>box(polygon '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>circle</function>(<type>box</type>)</literal></entry>
	<entry><type>circle</type></entry>
	<entry>boîte vers cercle</entry>
	<entry><literal>circle(box '((0,0),(1,1))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>circle</function>(<type>point</type>, <type>double
precision</type>)</literal></entry>
	<entry><type>circle</type></entry>
	<entry>centre et rayon vers cercle</entry>
	<entry><literal>circle(point '(0,0)', 2.0)</literal></entry>
       </row>
       <row>
        <entry><literal><function>circle</function>(<type>polygon</type>)</literal></entry>
        <entry><type>circle</type></entry>
        <entry>polygone vers cercle</entry>
        <entry><literal>circle(polygon '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>lseg</function>(<type>box</type>)</literal></entry>
	<entry><type>lseg</type></entry>
	<entry>diagonale de boîte vers segment de ligne</entry>
	<entry><literal>lseg(box '((-1,0),(1,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>lseg</function>(<type>point</type>,
<type>point</type>)</literal></entry>
	<entry><type>lseg</type></entry>
	<entry>points vers segment de ligne</entry>
	<entry><literal>lseg(point '(-1,0)', point '(1,0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>path</function>(<type>polygon</type>)</literal></entry>
	<entry><type>path</type></entry>
	<entry>polygone vers chemin</entry>
	<entry><literal>path(polygon '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
        <entry><literal><function>point</function>(<type>double
	       precision</type>, <type>double precision</type>)</literal></entry>
        <entry><type>point</type></entry>
        <entry>point de construction</entry>
        <entry><literal>point(23.4, -44.5)</literal></entry>
       </row>
       <row>
        <entry><literal><function>point</function>(<type>box</type>)</literal></entry>
        <entry><type>point</type></entry>
        <entry>centre de la boîte</entry>
        <entry><literal>point(box '((-1,0),(1,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>point</function>(<type>circle</type>)</literal></entry>
	<entry><type>point</type></entry>
	<entry>centre du cercle</entry>
	<entry><literal>point(circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
        <entry><literal><function>point</function>(<type>lseg</type>)</literal></entry>
        <entry><type>point</type></entry>
        <entry>centre de segment de ligne</entry>
        <entry><literal>point(lseg '((-1,0),(1,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>point</function>(<type>polygon</type>)</literal></entry>
	<entry><type>point</type></entry>
	<entry>centre de polygone</entry>
	<entry><literal>point(polygon '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>polygon</function>(<type>box</type>)</literal></entry>
	<entry><type>polygon</type></entry>
	<entry>boîte vers polygone à quatre points</entry>
	<entry><literal>polygon(box '((0,0),(1,1))')</literal></entry>
       </row>
       <row>
	<entry><literal><function>polygon</function>(<type>circle</type>)</literal></entry>
	<entry><type>polygon</type></entry>
	<entry>cercle vers polygone à 12 points</entry>
	<entry><literal>polygon(circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>polygon</function>(<replaceable
class="parameter">npts</replaceable>, <type>circle</type>)</literal></entry>
	<entry><type>polygon</type></entry>
	<entry>cercle vers polygone à <replaceable
        class="parameter">npts</replaceable> points</entry>
	<entry><literal>polygon(12, circle '((0,0),2.0)')</literal></entry>
       </row>
       <row>
	<entry><literal><function>polygon</function>(<type>path</type>)</literal></entry>
	<entry><type>polygon</type></entry>
	<entry>chemin vers polygone</entry>
	<entry><literal>polygon(path '((0,0),(1,1),(2,0))')</literal></entry>
       </row>
      </tbody>
     </tgroup>
   </table>

    <para>
     Il est possible d'accéder aux deux composants d'un <type>point</type>
     comme si c'était un tableau avec des index 0 et 1. Par exemple, si
     <literal>t.p</literal> est une colonne de type <type>point</type>, alors
     <literal>SELECT p[0] FROM t</literal> récupère la coordonnée X et
     <literal>UPDATE t SET p[1] = ...</literal> modifie la coordonnée Y. De la même
     façon, une valeur de type <type>box</type> ou <type>lseg</type> peut être
     traitée comme un tableau de deux valeurs de type <type>point</type>.
    </para>

    <para>
     La fonction <function>area</function> est utilisable avec les types
     <type>box</type>, <type>circle</type> et <type>path</type>.
     Elle ne fonctionne avec le type
     de données <type>path</type> que s'il n'y a pas d'intersection entre les points du
     <type>path</type>. Le <type>path</type>
     <literal>'((0,0),(0,1),(2,1),(2,2),(1,2),(1,0),(0,0))'::PATH</literal>,
     par exemple, ne fonctionne pas. Le <type>path</type>, 
     visuellement identique,
     <literal>'((0,0),(0,1),(1,1),(1,2),(2,2),(2,1),(1,1),(1,0),(0,0))'::PATH</literal>,
     quant à lui, fonctionne. Si les concepts de <type>path</type> avec intersection et sans intersection
     sont sources de confusion, dessiner les deux <type>path</type> ci-dessus côte-à-côte.
    </para>

  </sect1>


 <sect1 id="functions-net">
  <title>Fonctions et opérateurs sur les adresses réseau</title>

  <para>
   Le <xref linkend="cidr-inet-operators-table"/> affiche les opérateurs
   disponibles pour les types <type>cidr</type> et <type>inet</type>. Les
   opérateurs <literal>&lt;&lt;</literal>,
   <literal>&lt;&lt;=</literal>, <literal>&gt;&gt;</literal> et
   <literal>&gt;&gt;=</literal> testent l'inclusion de sous-réseau. Ils ne considèrent
   que les parties réseau des deux adresses, ignorant toute partie
   hôte, et déterminent si une partie réseau est identique ou consitue un
   sous-réseau de l'autre.
  </para>

    <table id="cidr-inet-operators-table">
     <title>Opérateurs <type>cidr</type> et <type>inet</type></title>
     <tgroup cols="3">
      <colspec colnum="1" colwidth="0.4*"/>
      <colspec colnum="2" colwidth="1*"/>
      <colspec colnum="3" colwidth="1.6*"/>
      <thead>
       <row>
	<entry>Opérateur</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal>&lt;</literal> </entry>
	<entry>est plus petit que</entry>
	<entry><literal>inet '192.168.1.5' &lt; inet '192.168.1.6'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;=</literal> </entry>
	<entry>est plus petit que ou égal à</entry>
	<entry><literal>inet '192.168.1.5' &lt;= inet '192.168.1.5'</literal></entry>
       </row>
       <row>
	<entry><literal>=</literal> </entry>
	<entry>est égal à</entry>
	<entry><literal>inet '192.168.1.5' = inet '192.168.1.5'</literal></entry>
       </row>
       <row>
	<entry><literal>&gt;=</literal> </entry>
	<entry>est plus grand ou égal à</entry>
	<entry><literal>inet '192.168.1.5' &gt;= inet '192.168.1.5'</literal></entry>
       </row>
       <row>
	<entry><literal>&gt;</literal> </entry>
	<entry>est plus grand que</entry>
	<entry><literal>inet '192.168.1.5' &gt; inet '192.168.1.4'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;&gt;</literal> </entry>
	<entry>n'est pas égal à</entry>
	<entry><literal>inet '192.168.1.5' &lt;&gt; inet
'192.168.1.4'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;&lt;</literal> </entry>
	<entry>est contenu dans</entry>
	<entry><literal>inet '192.168.1.5' &lt;&lt; inet
'192.168.1/24'</literal></entry>
       </row>
       <row>
	<entry><literal>&lt;&lt;=</literal> </entry>
	<entry>est contenu dans ou égal à</entry>
	<entry><literal>inet '192.168.1/24' &lt;&lt;= inet
'192.168.1/24'</literal></entry>
       </row>
       <row>
	<entry><literal>&gt;&gt;</literal> </entry>
	<entry>contient</entry>
	<entry><literal>inet'192.168.1/24' &gt;&gt; inet
'192.168.1.5'</literal></entry>
       </row>
       <row>
	<entry><literal>&gt;&gt;=</literal> </entry>
	<entry>contient ou est égal à</entry>
	<entry><literal>inet '192.168.1/24' &gt;&gt;= inet
'192.168.1/24'</literal></entry>
       </row>
       <row>
        <entry> <literal>~</literal> </entry>
        <entry>bitwise NOT</entry>
        <entry><literal>~ inet '192.168.1.6'</literal></entry>
       </row>
       <row>
        <entry> <literal>&amp;</literal> </entry>
        <entry>bitwise AND</entry>
        <entry><literal>inet '192.168.1.6' &amp; inet '0.0.0.255'</literal></entry>
       </row>
       <row>
        <entry> <literal>|</literal> </entry>
        <entry>bitwise OR</entry>
        <entry><literal>inet '192.168.1.6' | inet '0.0.0.255'</literal></entry>
       </row>
       <row>
        <entry> <literal>+</literal> </entry>
        <entry>addition</entry>
        <entry><literal>inet '192.168.1.6' + 25</literal></entry>
       </row>
       <row>
        <entry> <literal>-</literal> </entry>
        <entry>soustraction</entry>
        <entry><literal>inet '192.168.1.43' - 36</literal></entry>
       </row>
       <row>
        <entry> <literal>-</literal> </entry>
        <entry>soustraction</entry>
        <entry><literal>inet '192.168.1.43' - inet '192.168.1.19'</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  <para>
   Le <xref linkend="cidr-inet-functions-table"/> affiche les fonctions
   utilisables avec les types <type>cidr</type> et <type>inet</type>. Les
   fonctions <function>abbrev</function>, <function>host</function>,
   <function>text</function> ont principalement pour but d'offrir des formats
   d'affichage alternatifs.
  </para>

    <table id="cidr-inet-functions-table">
     <title>Fonctions <type>cidr</type> et <type>inet</type></title>
     <tgroup cols="5">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><literal><function>abbrev</function>(<type>inet</type>)</literal></entry>
        <entry><type>text</type></entry>
        <entry>format textuel d'affichage raccourci</entry>
        <entry><literal>abbrev(inet '10.1.0.0/16')</literal></entry>
        <entry><literal>10.1.0.0/16</literal></entry>
       </row>
       <row>
        <entry><literal><function>abbrev</function>(<type>cidr</type>)</literal></entry>
        <entry><type>text</type></entry>
        <entry>format textuel d'affichage raccourci</entry>
        <entry><literal>abbrev(cidr '10.1.0.0/16')</literal></entry>
        <entry><literal>10.1/16</literal></entry>
       </row>
       <row>
	<entry><literal><function>broadcast</function>(<type>inet</type>)</literal></entry>
	<entry><type>inet</type></entry>
	<entry>adresse de broadcast pour le réseau</entry>
	<entry><literal>broadcast('192.168.1.5/24')</literal></entry>
	<entry><literal>192.168.1.255/24</literal></entry>
       </row>
       <row>
        <entry><literal><function>family</function>(<type>inet</type>)</literal></entry>
        <entry><type>int</type></entry>
        <entry>extraction de la famille d'adresse&nbsp;; <literal>4</literal>
	 pour IPv4, <literal>6</literal> pour IPv6</entry>
        <entry><literal>family('::1')</literal></entry>
        <entry><literal>6</literal></entry>
       </row>
       <row>
	<entry><literal><function>host</function>(<type>inet</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>extraction de l'adresse IP en texte</entry>
	<entry><literal>host('192.168.1.5/24')</literal></entry>
	<entry><literal>192.168.1.5</literal></entry>
       </row>
       <row>
        <entry><literal><function>hostmask</function>(<type>inet</type>)</literal></entry>
        <entry><type>inet</type></entry>
        <entry>construction du masque d'hôte pour le réseau</entry>
        <entry><literal>hostmask('192.168.23.20/30')</literal></entry>
        <entry><literal>0.0.0.3</literal></entry>
       </row>
       <row>
	<entry><literal><function>masklen</function>(<type>inet</type>)</literal></entry>
	<entry><type>int</type></entry>
	<entry>extraction de la longueur du masque réseau</entry>
	<entry><literal>masklen('192.168.1.5/24')</literal></entry>
	<entry><literal>24</literal></entry>
       </row>
       <row>
	<entry><literal><function>netmask</function>(<type>inet</type>)</literal></entry>
	<entry><type>inet</type></entry>
	<entry>construction du masque réseau</entry>
	<entry><literal>netmask('192.168.1.5/24')</literal></entry>
	<entry><literal>255.255.255.0</literal></entry>
       </row>
       <row>
	<entry><literal><function>network</function>(<type>inet</type>)</literal></entry>
	<entry><type>cidr</type></entry>
	<entry>extraction de la partie réseau de l'adresse</entry>
	<entry><literal>network('192.168.1.5/24')</literal></entry>
	<entry><literal>192.168.1.0/24</literal></entry>
       </row>
       <row>
        <entry><literal><function>set_masklen</function>(<type>inet</type>, <type>int</type>)</literal></entry>
        <entry><type>inet</type></entry>
        <entry>configure la longueur du masque réseau pour les valeurs <type>inet</type></entry>
        <entry><literal>set_masklen('192.168.1.5/24', 16)</literal></entry>
        <entry><literal>192.168.1.5/16</literal></entry>
       </row>
       <row>
        <entry><literal><function>set_masklen</function>(<type>cidr</type>, <type>int</type>)</literal></entry>
        <entry><type>cidr</type></entry>
        <entry>configure la longueur du masque réseau pour les valeurs <type>cidr</type></entry>
        <entry><literal>set_masklen('192.168.1.0/24'::cidr, 16)</literal></entry>
        <entry><literal>192.168.0.0/16</literal></entry>
       </row>
       <row>
	<entry><literal><function>text</function>(<type>inet</type>)</literal></entry>
	<entry><type>text</type></entry>
	<entry>extraction de l'adresse IP et de la longueur du masque
          réseau comme texte</entry>
	<entry><literal>text(inet '192.168.1.5')</literal></entry>
	<entry><literal>192.168.1.5/32</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  <para>
   Toute valeur <type>cidr</type> peut être convertie en <type>inet</type>
   implicitement ou explicitement&nbsp;; de ce fait, les fonctions indiquées
   ci-dessus comme opérant sur le type <type>inet</type> opèrent aussi sur
   le type <type>cidr</type>. (Lorsque les fonctions sont séparées pour les types
   <type>inet</type> et <type>cidr</type>, c'est que leur comportement peut
   différer.) Il est également permis de convertir une valeur
   <type>inet</type> en <type>cidr</type>. Dans ce cas, tout bit à la
   droite du masque réseau est silencieusement positionné à zéro pour créer une
   valeur <type>cidr</type> valide. De plus, une valeur
   de type texte peut être transtypée en <type>inet</type> ou <type>cidr</type>
   à l'aide de la syntaxe habituelle de transtypage&nbsp;: par exemple
   <literal>inet(<replaceable>expression</replaceable>)</literal> ou
   <literal><replaceable>nom_colonne</replaceable>::cidr</literal>.
  </para>

  <para>
   Le <xref linkend="macaddr-functions-table"/> affiche les fonctions
   utilsables avec le type <type>macaddr</type>. La fonction
   <literal><function>trunc</function>(<type>macaddr</type>)</literal> renvoie
   une adresse MAC avec les trois derniers octets initialisés à zéro. Ceci peut
   être utilisé pour associer le préfixe restant à un manufacturier.
  </para>

    <table id="macaddr-functions-table">
     <title>Fonctions <type>macaddr</type></title>
     <tgroup cols="5">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal><function>trunc</function>(<type>macaddr</type>)</literal></entry>
	<entry><type>macaddr</type></entry>
	<entry>initialiser les trois octets finaux à zéro</entry>
	<entry><literal>trunc(macaddr '12:34:56:78:90:ab')</literal></entry>
	<entry><literal>12:34:56:00:00:00</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Le type <type>macaddr</type> supporte aussi les opérateurs relationnels
    standard (<literal>&gt;</literal>, <literal>&lt;=</literal>, etc.) de tri lexicographique.
   </para>

  </sect1>

 <sect1 id="functions-textsearch">
  <title>Fonctions et opérateurs de la recherche plein texte</title>

   <indexterm zone="datatype-textsearch">
    <primary>recherche plein texte</primary>
    <secondary>fonctions et opérateurs</secondary>
   </indexterm>

   <indexterm zone="datatype-textsearch">
    <primary>recherche de texte</primary>
    <secondary>fonctions et opérateurs</secondary>
   </indexterm>

  <para>
   <xref linkend="textsearch-operators-table"/>,
   <xref linkend="textsearch-functions-table"/> et
   <xref linkend="textsearch-functions-debug-table"/>
   résume les fonctions et les opérateurs fournis pour la recherche plein texte.
   Voir <xref linkend="textsearch"/> pour une explication détaillée sur la
   fonctionnalité de recherche plein texte de
   <productname>PostgreSQL</productname>.
  </para>

    <table id="textsearch-operators-table">
     <title>Opérateurs de recherche plein texte</title>
     <tgroup cols="4">
      <colspec colnum="1" colwidth="0.4*"/>
      <colspec colnum="2" colwidth="1*"/>
      <colspec colnum="3" colwidth="0.8*"/>
      <colspec colnum="3" colwidth="0.8*"/>
      <thead>
       <row>
	<entry>Opérateur</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry> <literal>@@</literal> </entry>
        <entry><type>tsvector</type> correspond à <type>tsquery</type> ?</entry>
        <entry><literal>to_tsvector('fat cats ate rats') @@ to_tsquery('cat &amp; rat')</literal></entry>
        <entry><literal>t</literal></entry>
       </row>
       <row>
        <entry> <literal>@@@</literal> </entry>
        <entry>synonym obsolète de <literal>@@</literal></entry>
        <entry><literal>to_tsvector('fat cats ate rats') @@@ to_tsquery('cat &amp; rat')</literal></entry>
        <entry><literal>t</literal></entry>
       </row>
       <row>
        <entry> <literal>||</literal> </entry>
        <entry>concatène <type>tsvector</type>s</entry>
        <entry><literal>'a:1 b:2'::tsvector || 'c:1 d:2 b:3'::tsvector</literal></entry>
        <entry><literal>'a':1 'b':2,5 'c':3 'd':4</literal></entry>
       </row>
       <row>
        <entry> <literal>&amp;&amp;</literal> </entry>
        <entry>ET logique des <type>tsquery</type></entry>
        <entry><literal>'fat | rat'::tsquery &amp;&amp; 'cat'::tsquery</literal></entry>
        <entry><literal>( 'fat' | 'rat' ) &amp; 'cat'</literal></entry>
       </row>
       <row>
        <entry> <literal>||</literal> </entry>
        <entry>OU logique des <type>tsquery</type></entry>
        <entry><literal>'fat | rat'::tsquery || 'cat'::tsquery</literal></entry>
        <entry><literal>( 'fat' | 'rat' ) | 'cat'</literal></entry>
       </row>
       <row>
        <entry> <literal>!!</literal> </entry>
        <entry>inverse une <type>tsquery</type></entry>
        <entry><literal>!! 'cat'::tsquery</literal></entry>
        <entry><literal>!'cat'</literal></entry>
       </row>
       <row>
        <entry> <literal>@&gt;</literal> </entry>
        <entry><type>tsquery</type> en contient une autre&nbsp;?</entry>
        <entry><literal>'cat'::tsquery @&gt; 'cat &amp; rat'::tsquery</literal></entry>
        <entry><literal>f</literal></entry>
       </row>
       <row>
        <entry> <literal>&lt;@</literal> </entry>
        <entry><type>tsquery</type> est contenu dans&nbsp;?</entry>
        <entry><literal>'cat'::tsquery &lt;@ 'cat &amp; rat'::tsquery</literal></entry>
        <entry><literal>t</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

    <note>
     <para>
      Les opérateurs de confinement de <type>tsquery</type> considèrent seulement
      les lexèmes listés dans les deux requêtes, ignorant les opérateurs de
      combinaison.
     </para>
    </note>

    <para>
     En plus des opérateurs présentés dans la table, les opérateurs de comparaison
     B-tree habituels (<literal>=</literal>, <literal>&lt;</literal>, etc) sont
     définis pour les types <type>tsvector</type> et <type>tsquery</type>. Ils
     ne sont pas très utiles dans le cadre de la recherche plein texte mais
     permettent la construction d'index d'unicité sur ces types de colonne.
    </para>

    <table id="textsearch-functions-table">
     <title>Fonctions de la recherche plein texte</title>
     <tgroup cols="5">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><literal><function>to_tsvector</function>(<optional> <replaceable class="parameter">config</replaceable> <type>regconfig</type> , </optional> <replaceable class="parameter">document</replaceable> <type>text</type>)</literal></entry>
        <entry><type>tsvector</type></entry>
        <entry>réduire le texte du document en un <type>tsvector</type></entry>
        <entry><literal>to_tsvector('english', 'The Fat Rats')</literal></entry>
        <entry><literal>'fat':2 'rat':3</literal></entry>
       </row>
       <row>
        <entry><literal><function>length</function>(<type>tsvector</type>)</literal></entry>
        <entry><type>integer</type></entry>
        <entry>nombre de lexemes dans <type>tsvector</type></entry>
        <entry><literal>length('fat:2,4 cat:3 rat:5A'::tsvector)</literal></entry>
        <entry><literal>3</literal></entry>
       </row>
       <row>
        <entry><literal><function>setweight</function>(<type>tsvector</type>, <type>"char"</type>)</literal></entry>
        <entry><type>tsvector</type></entry>
        <entry>affecte un poids à chaque élément d'un <type>tsvector</type></entry>
        <entry><literal>setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')</literal></entry>
        <entry><literal>'cat':3A 'fat':2A,4A 'rat':5A</literal></entry>
       </row>
       <row>
        <entry><literal><function>strip</function>(<type>tsvector</type>)</literal></entry>
        <entry><type>tsvector</type></entry>
        <entry>supprime les positions et les poids du <type>tsvector</type></entry>
        <entry><literal>strip('fat:2,4 cat:3 rat:5A'::tsvector)</literal></entry>
        <entry><literal>'cat' 'fat' 'rat'</literal></entry>
       </row>
       <row>
        <entry><literal><function>to_tsquery</function>(<optional> <replaceable class="parameter">config</replaceable> <type>regconfig</type> , </optional> <replaceable class="parameter">requete</replaceable> <type>text</type>)</literal></entry>
        <entry><type>tsquery</type></entry>
        <entry>normalise les mots et les convertit en un <type>tsquery</type></entry>
        <entry><literal>to_tsquery('english', 'The &amp; Fat &amp; Rats')</literal></entry>
        <entry><literal>'fat' &amp; 'rat'</literal></entry>
       </row>
       <row>
        <entry><literal><function>plainto_tsquery</function>(<optional> <replaceable class="parameter">config</replaceable> <type>regconfig</type> , </optional> <replaceable class="parameter">requete</replaceable> <type>text</type>)</literal></entry>
        <entry><type>tsquery</type></entry>
        <entry>crée un <type>tsquery</type> en ignorant la ponctuation</entry>
        <entry><literal>plainto_tsquery('english', 'The Fat Rats')</literal></entry>
        <entry><literal>'fat' &amp; 'rat'</literal></entry>
       </row>
       <row>
        <entry><literal><function>numnode</function>(<type>tsquery</type>)</literal></entry>
        <entry><type>integer</type></entry>
        <entry>nombre de lexèmes et d'opérateurs dans <type>tsquery</type></entry>
        <entry><literal> numnode('(fat &amp; rat) | cat'::tsquery)</literal></entry>
        <entry><literal>5</literal></entry>
       </row>
       <row>
        <entry><literal><function>querytree</function>(<replaceable class="parameter">requete</replaceable> <type>tsquery</type>)</literal></entry>
        <entry><type>text</type></entry>
        <entry>récupère la partie indexable d'un <type>tsquery</type></entry>
        <entry><literal>querytree('foo &amp; ! bar'::tsquery)</literal></entry>
        <entry><literal>'foo'</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_rank</function>(<optional> <replaceable class="parameter">poids</replaceable> <type>float4[]</type>, </optional> <replaceable class="parameter">vecteur</replaceable> <type>tsvector</type>, <replaceable class="parameter">requete</replaceable> <type>tsquery</type> <optional>, <replaceable class="parameter">normalisation</replaceable> <type>integer</type> </optional>)</literal></entry>
        <entry><type>float4</type></entry>
        <entry>renvoie le score d'un document pour une requête</entry>
        <entry><literal>ts_rank(textsearch, query)</literal></entry>
        <entry><literal>0.818</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_rank_cd</function>(<optional> <replaceable class="parameter">poids</replaceable> <type>float4[]</type>, </optional> <replaceable class="parameter">vecteur</replaceable> <type>tsvector</type>, <replaceable class="parameter">requete</replaceable> <type>tsquery</type> <optional>, <replaceable class="parameter">normalisation</replaceable> <type>integer</type> </optional>)</literal></entry>
        <entry><type>float4</type></entry>
        <entry>renvoie le score d'un document pour une requête en utilisant une densité personnalisée</entry>
        <entry><literal>ts_rank_cd('{0.1, 0.2, 0.4, 1.0}', textsearch, query)</literal></entry>
        <entry><literal>2.01317</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_headline</function>(<optional> <replaceable class="parameter">config</replaceable> <type>regconfig</type>, </optional> <replaceable class="parameter">document</replaceable> <type>text</type>, <replaceable class="parameter">requete</replaceable> <type>tsquery</type> <optional>, <replaceable class="parameter">options</replaceable> <type>text</type> </optional>)</literal></entry>
        <entry><type>text</type></entry>
        <entry>affiche la correspondance d'une requête dans un document</entry>
        <entry><literal>ts_headline('x y z', 'z'::tsquery)</literal></entry>
        <entry><literal>x y &lt;b&gt;z&lt;/b&gt;</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_rewrite</function>(<replaceable class="parameter">requete</replaceable> <type>tsquery</type>, <replaceable class="parameter">cible</replaceable> <type>tsquery</type>, <replaceable class="parameter">substitution</replaceable> <type>tsquery</type>)</literal></entry>
        <entry><type>tsquery</type></entry>
        <entry>remplace la cible avec la substitution à l'intérieur de la requête</entry>
        <entry><literal>ts_rewrite('a &amp; b'::tsquery, 'a'::tsquery, 'foo|bar'::tsquery)</literal></entry>
        <entry><literal>'b' &amp; ( 'foo' | 'bar' )</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_rewrite</function>(<replaceable class="parameter">requete</replaceable> <type>tsquery</type>, <replaceable class="parameter">select</replaceable> <type>text</type>)</literal></entry>
        <entry><type>tsquery</type></entry>
        <entry>remplace en utilisant les cibles et substitutions à partir d'une commande <command>SELECT</command></entry>
        <entry><literal>SELECT ts_rewrite('a &amp; b'::tsquery, 'SELECT t,s FROM aliases')</literal></entry>
        <entry><literal>'b' &amp; ( 'foo' | 'bar' )</literal></entry>
       </row>
       <row>
        <entry><literal><function>get_current_ts_config</function>()</literal></entry>
        <entry><type>regconfig</type></entry>
        <entry>récupère la configuration par défaut de la recherche plein texte</entry>
        <entry><literal>get_current_ts_config()</literal></entry>
        <entry><literal>english</literal></entry>
       </row>
       <row>
        <entry><literal><function>tsvector_update_trigger</function>()</literal></entry>
        <entry><type>trigger</type></entry>
        <entry>fonction déclencheur pour la mise à jour automatique de colonne <type>tsvector</type></entry>
        <entry><literal>CREATE TRIGGER ... tsvector_update_trigger(tsvcol, 'pg_catalog.swedish', title, body)</literal></entry>
        <entry><literal></literal></entry>
       </row>
       <row>
        <entry><literal><function>tsvector_update_trigger_column</function>()</literal></entry>
        <entry><type>trigger</type></entry>
        <entry>fonction déclencheur pour la mise à jour automatique de colonne <type>tsvector</type></entry>
        <entry><literal>CREATE TRIGGER ... tsvector_update_trigger_column(tsvcol, configcol, title, body)</literal></entry>
        <entry><literal></literal></entry>
        <entry><literal></literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  <note>
   <para>
    Toutes les fonctions de recherche plein texte qui acceptent un argument
    <type>regconfig</type> optionel utilisent la configuration indiqée par
    <xref linkend="guc-default-text-search-config"/> en cas d'omission de cet
    argument.
   </para>
  </note>

  <para>
   Les fonctions de <xref linkend="textsearch-functions-debug-table"/>
   sont listées séparément, car elles ne font pas partie des fonctions
   utilisées dans les opérations de recherche plein texte de tous les jours.
   Elles sont utiles pour le développement et le débogage de nouvelles
   configurations de recherche plein texte.
  </para>

    <table id="textsearch-functions-debug-table">
     <title>Fonctions de débogage de la recherche plein texte</title>
     <tgroup cols="5">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><literal><function>ts_debug</function>(<optional> <replaceable class="parameter">config</replaceable> <type>regconfig</type>, </optional> <replaceable class="parameter">document</replaceable> <type>text</type>, OUT <replaceable class="parameter">alias</replaceable> <type>text</type>, OUT <replaceable class="parameter">description</replaceable> <type>text</type>, OUT <replaceable class="parameter">jeton</replaceable> <type>text</type>, OUT <replaceable class="parameter">dictionnaires</replaceable> <type>regdictionary[]</type>, OUT <replaceable class="parameter">dictionnaire</replaceable> <type>regdictionary</type>, OUT <replaceable class="parameter">lexemes</replaceable> <type>text[]</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>teste une configuration</entry>
        <entry><literal>ts_debug('english', 'The Brightest supernovaes')</literal></entry>
        <entry><literal>(asciiword,"Word, all ASCII",The,{english_stem},english_stem,{}) ...</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_lexize</function>(<replaceable class="parameter">dict</replaceable> <type>regdictionary</type>, <replaceable class="parameter">jeton</replaceable> <type>text</type>)</literal></entry>
        <entry><type>text[]</type></entry>
        <entry>teste un dictionnaire</entry>
        <entry><literal>ts_lexize('english_stem', 'stars')</literal></entry>
        <entry><literal>{star}</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_parse</function>(<replaceable class="parameter">nom_analyseur</replaceable> <type>text</type>, <replaceable class="parameter">document</replaceable> <type>text</type>, OUT <replaceable class="parameter">id_jeton</replaceable> <type>integer</type>, OUT <replaceable class="parameter">jeton</replaceable> <type>text</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>teste un analyseur</entry>
        <entry><literal>ts_parse('default', 'foo - bar')</literal></entry>
        <entry><literal>(1,foo) ...</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_parse</function>(<replaceable class="parameter">oid_analyseur</replaceable> <type>oid</type>, <replaceable class="parameter">document</replaceable> <type>text</type>, OUT <replaceable class="parameter">id_jeton</replaceable> <type>integer</type>, OUT <replaceable class="parameter">jeton</replaceable> <type>text</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>teste un analyseur</entry>
        <entry><literal>ts_parse(3722, 'foo - bar')</literal></entry>
        <entry><literal>(1,foo) ...</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_token_type</function>(<replaceable class="parameter">nom_analyseur</replaceable> <type>text</type>, OUT <replaceable class="parameter">id_jeton</replaceable> <type>integer</type>, OUT <replaceable class="parameter">alias</replaceable> <type>text</type>, OUT <replaceable class="parameter">description</replaceable> <type>text</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>obtient les types de jeton définis par l'analyseur</entry>
        <entry><literal>ts_token_type('default')</literal></entry>
        <entry><literal>(1,asciiword,"Word, all ASCII") ...</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_token_type</function>(<replaceable class="parameter">oid_analyseur</replaceable> <type>oid</type>, OUT <replaceable class="parameter">id_jeton</replaceable> <type>integer</type>, OUT <replaceable class="parameter">alias</replaceable> <type>text</type>, OUT <replaceable class="parameter">description</replaceable> <type>text</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>obtient les types de jeton définis par l'analyseur</entry>
        <entry><literal>ts_token_type(3722)</literal></entry>
        <entry><literal>(1,asciiword,"Word, all ASCII") ...</literal></entry>
       </row>
       <row>
        <entry><literal><function>ts_stat</function>(<replaceable class="parameter">sqlquery</replaceable> <type>text</type>, <optional> <replaceable class="parameter">poids</replaceable> <type>text</type>, </optional> OUT <replaceable class="parameter">mot</replaceable> <type>text</type>, OUT <replaceable class="parameter">ndoc</replaceable> <type>integer</type>, OUT <replaceable class="parameter">nentry</replaceable> <type>integer</type>)</literal></entry>
        <entry><type>setof record</type></entry>
        <entry>obtient des statistiques sur une colonne <type>tsvector</type></entry>
        <entry><literal>ts_stat('SELECT vector from apod')</literal></entry>
        <entry><literal>(foo,10,15) ...</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

 </sect1>


 <sect1 id="functions-xml">
  <title>Fonctions XML</title>

  <para>
   Les fonctions et expressions décrites dans cette section opèrent sur des
   valeurs de type <type>xml</type>. Lire la <xref
   linkend="datatype-xml"/> pour des informations sur le type <type>xml</type>.
   Les expressions <function>xmlparse</function> et
   <function>xmlserialize</function> permettant de convertir vers ou à partir
   du type <type>xml</type> ne sont pas reprises ici. L'utilisation d'un grand
   nombre de ces fonctions nécessite que l'installation soit construite avec
   <command>configure --with-libxml</command>.
  </para>

  <sect2>
   <title>Produire un contenu XML</title>

   <para>
    Un ensemble de fonctions et expressions de type fonction est disponible
    pour produire du contenu XML à partir de données SQL. En tant que telles, elles conviennent
    particulièrement bien pour formater les résultats de requêtes en XML
    à traiter dans les applications clientes.
   </para>

   <sect3>
    <title><literal>xmlcomment</literal></title>

    <indexterm>
     <primary>xmlcomment</primary>
    </indexterm>

<synopsis>
<function>xmlcomment</function>(<replaceable>text</replaceable>)
</synopsis>

    <para>
     La fonction <function>xmlcomment</function> crée une valeur XML contenant
     un commentaire XML avec, comme contenu, le texte indiqué. Le texte ne
     peut pas contenir <quote><literal>--</literal></quote> ou se terminer par un
     <quote><literal>-</literal></quote> de sorte que que la construction résultante
     représente un commentaire XML valide. Si l'argument est NULL, le résultat
     est NULL.
    </para>

    <para>
     Exemple&nbsp;:
<screen><![CDATA[
SELECT xmlcomment('bonjour');

  xmlcomment
--------------
 <!--bonjour-->
]]></screen>
    </para>
   </sect3>

   <sect3>
    <title><literal>xmlconcat</literal></title>

    <indexterm>
     <primary>xmlconcat</primary>
    </indexterm>

 <synopsis>
 <function>xmlconcat</function>(<replaceable>xml</replaceable><optional>, ...</optional>)
 </synopsis>
 
    <para>
     La fonction <function>xmlconcat</function> concatène une liste de valeurs
     XML individuelles pour créer une valeur simple contenant un fragment de
     contenu XML. Les valeurs NULL sont omises&nbsp;; le résultat est NULL
     seulement s'il n'y a pas d'arguments non NULL.
    </para>

    <para>
     Exemple&nbsp;:
<screen><![CDATA[
SELECT xmlconcat('<abc/>', '<bar>foo</bar>');

      xmlconcat
----------------------
 <abc/><bar>foo</bar>
]]></screen>
    </para>

    <para>
     Les déclarations XML, si elles sont présentes, sont combinées come suit. Si
     toutes les valeurs en argument ont la même déclaration de version XML,
     cette version est utilisée dans le résultat. Sinon aucune version n'est
     utilisée. Si toutes les valeurs en argument ont la valeur de déclaration
     « standalone » à <quote>yes</quote>, alors cette valeur est utilisée dans
     le résultat. Si toutes les valeurs en argument ont une valeur de déclaration
     « standalone » et qu'au moins l'une d'entre elles est <quote>no</quote>, alors
     cette valeur est utilisée dans
     le résultat. Sinon le résultat n'a aucune déclaration « standalone ».
     Si le résultat nécessite une déclaration « standalone »
     sans déclaration de version, une déclaration de version 1.0 est
     utilisée car le standard XML impose qu'une déclaration XML contienne
     une déclaration de version. Les déclarations d'encodage sont ignorées et
     supprimées dans tous les cas.
    </para>

    <para>
     Exemple&nbsp;:
<screen><![CDATA[
SELECT xmlconcat('<?xml version="1.1"?><foo/>', '<?xml version="1.1" standalone="no"?><bar/>');

             xmlconcat
-----------------------------------
 <?xml version="1.1"?><foo/><bar/>
]]></screen>
    </para>
   </sect3>
 
   <sect3>
    <title><literal>xmlelement</literal></title>
 
   <indexterm>
    <primary>xmlelement</primary>
   </indexterm>
 
<synopsis>
 <function>xmlelement</function>(name <replaceable>nom</replaceable> <optional>, xmlattributes(<replaceable>valeur</replaceable> <optional>AS <replaceable>nom_attribut</replaceable></optional> <optional>, ... </optional>)</optional> <optional><replaceable>, contenu, ...</replaceable></optional>)
 </synopsis>
 
    <para>
     L'expression <function>xmlelement</function> produit un élément XML avec
     le nom, les attributs et le contenu donnés.
    </para>

    <para>
     Exemples&nbsp;:
<screen><![CDATA[
SELECT xmlelement(name foo);

 xmlelement
------------
 <foo/>

SELECT xmlelement(name foo, xmlattributes('xyz' as bar));

    xmlelement
------------------
 <foo bar="xyz"/>

SELECT xmlelement(name foo, xmlattributes(current_date as bar), 'cont', 'ent');

             xmlelement
-------------------------------------
 <foo bar="2007-01-26">content</foo>
]]></screen>
    </para>

    <para>
     Les noms d'élément et d'attribut qui ne sont pas des noms XML valides
     sont modifiés en remplaçant les caractères indésirables par une
     séquence <literal>_x<replaceable>HHHH</replaceable>_</literal>, où
     <replaceable>HHHH</replaceable> est le codage Unicode du caractère en
     notation hexadécimal. Par exemple&nbsp;:
<screen><![CDATA[
SELECT xmlelement(name "foo$bar", xmlattributes('xyz' as "a&b"));

            xmlelement
----------------------------------
 <foo_x0024_bar a_x0026_b="xyz"/>
]]></screen>
    </para>

    <para>
     Un nom explicit d'attribut n'a pas besoin d'être indiqué si la valeur
     de l'attribut est la référence d'une colonne, auquel cas le nom de la
     colonne est utilisé comme nom de l'attribut par défaut. Dans tous les
     autres cas, l'attribut doit avoir un nom explicite. Donc, cet
     exemple est valide&nbsp;:
<screen>
CREATE TABLE test (a xml, b xml);
SELECT xmlelement(name test, xmlattributes(a, b)) FROM test;
</screen>
     Mais ceux-ci ne le sont pas&nbsp;:
<screen>
SELECT xmlelement(name test, xmlattributes('constant'), a, b) FROM test;
SELECT xmlelement(name test, xmlattributes(func(a, b))) FROM test;
</screen>
    </para>

    <para>
     Si le contenu de l'élément est précisé, il est formaté en fonction du
     type de données. Si le contenu est lui-même de type <type>xml</type>, des
     documents XML complexes peuvent être construits. Par exemple&nbsp;:
<screen><![CDATA[
SELECT xmlelement(name foo, xmlattributes('xyz' as bar),
                            xmlelement(name abc),
                            xmlcomment('test'),
                            xmlelement(name xyz));

                  xmlelement
----------------------------------------------
 <foo bar="xyz"><abc/><!--test--><xyz/></foo>
]]></screen>

     Le contenu des autres types est formaté avec des données XML valides.
     Cela signifie en particulier que les caractères &lt;, &gt;, et &amp; sont
     convertis en entités. Les données binaires (type <type>bytea</type>) sont
     représentées dans un encodage base64 ou hexadécimal, suivant la
     configuration du paramètre <xref linkend="guc-xmlbinary"/>. Le comportement
     particulier pour les types de données individuels devrait évoluer
     pour aligner les types de données SQL et PostgreSQL avec la spécification
     de XML Schema, auquel cas une description plus précise sera ajoutée.
    </para>
   </sect3>
 
   <sect3>
    <title><literal>xmlforest</literal></title>
 
   <indexterm>
    <primary>xmlforest</primary>
   </indexterm>
 
 <synopsis>
 <function>xmlforest</function>(<replaceable>contenu</replaceable> <optional>AS <replaceable>nom</replaceable></optional> <optional>, ...</optional>)
 </synopsis>
 
    <para>
     L'expression <function>xmlforest</function> produit un arbre XML
     (autrement dit une séquence) d'éléments utilisant les noms et le contenu
     donnés.
    </para>

    <para>
     Exemples&nbsp;:
<screen><![CDATA[
SELECT xmlforest('abc' AS foo, 123 AS bar);

          xmlforest
------------------------------
 <foo>abc</foo><bar>123</bar>


SELECT xmlforest(table_name, column_name)
FROM information_schema.columns
WHERE table_schema = 'pg_catalog';

                                         xmlforest
-------------------------------------------------------------------------------------------
 <table_name>pg_authid</table_name><column_name>rolname</column_name>
 <table_name>pg_authid</table_name><column_name>rolsuper</column_name>
 ...
]]></screen>

     Comme indiqué dans le second exemple, le nom de l'élément peut être omis
     si la valeur du contenu est une référence de colonne, auquel cas le nom
     de la colonne est utilisé par défaut. Sinon, un nom doit être indiqué.
    </para>

    <para>
     Les noms d'éléments qui ne sont pas des noms XML valides sont échappés
     comme indiqué pour <function>xmlelement</function> ci-dessus. De façon
     similaire, les données de contenu sont échappées pour rendre le contenu
     XML valide sauf s'il est déjà de type <type>xml</type>.
    </para>

    <para>
     Les arbres XML ne sont pas des documents XML valides s'ils sont
     constitués de plus d'un élément. Il peut donc s'avérer utile d'emballer
     les expressions <function>xmlforest</function> dans
     <function>xmlelement</function>.
    </para>
   </sect3>
 
   <sect3>
    <title><literal>xmlpi</literal></title>
 
   <indexterm>
    <primary>xmlpi</primary>
   </indexterm>
 
 <synopsis>
 <function>xmlpi</function>(name <replaceable>target</replaceable> <optional>, <replaceable>content</replaceable></optional>)
 </synopsis>
 
    <para>
     L'expression <function>xmlpi</function> crée une instruction de
     traitement XML. Le contenu, si présent, ne doit pas contenir la
     séquence de caractères <literal>?&gt;</literal>.
    </para>

    <para>
     Exemple&nbsp;:
<screen><![CDATA[
SELECT xmlpi(name php, 'echo "hello world";');

            xmlpi
-----------------------------
 <?php echo "hello world";?>
]]></screen>
    </para>
   </sect3>
 
   <sect3>
    <title><literal>xmlroot</literal></title>
 
   <indexterm>
    <primary>xmlroot</primary>
   </indexterm>
 
 <synopsis>
 <function>xmlroot</function>(<replaceable>xml</replaceable>, version <replaceable>text</replaceable> | no value <optional>, standalone yes|no|no value</optional>)
 </synopsis>
 
    <para>
     L'expression <function>xmlroot</function> modifie les propriétés du
     nœud racine d'une valeur XML. Si une version est indiquée, elle
     remplace la valeur dans la déclaration de version du n&oelig;ud racine.
     Si un paramètre « standalone » est spécifié, il remplace la valeur dans la
     déclaration « standalone » du n&oelig;ud racine.
    </para>

    <para>
<screen><![CDATA[
SELECT xmlroot(xmlparse(document '<?xml version="1.1"?><content>abc</content>'), 
               version '1.0', standalone yes);

                xmlroot
----------------------------------------
 <?xml version="1.0" standalone="yes"?>
 <content>abc</content>
]]></screen>
    </para>
   </sect3>

   <sect3 id="functions-xml-xmlagg">
    <title><literal>xmlagg</literal></title>

    <indexterm>
     <primary>xmlagg</primary>
    </indexterm>

<synopsis>
<function>xmlagg</function>(<replaceable>xml</replaceable>)
</synopsis>

    <para>
     La fonction <function>xmlagg</function> est, à la différence des
     fonctions décrites ici, une fonction d'aggrégat. Elle concatène les valeurs
     en entrée pour les passer en argument à la fonction d'aggrégat, comme le
     fait la fonction <function>xmlconcat</function>.
     Voir <xref linkend="functions-aggregate"/> pour plus d'informations sur
     les fonctions d'agrégat.
    </para>

    <para>
     Exemple&nbsp;:
<screen><![CDATA[
CREATE TABLE test (y int, x xml);
INSERT INTO test VALUES (1, '<foo>abc</foo>');
INSERT INTO test VALUES (2, '<bar/>');
SELECT xmlagg(x) FROM test;
        xmlagg
----------------------
 <foo>abc</foo><bar/>
]]></screen>
    </para>

    <para>
     Pour déterminer l'ordre de la concaténation, l'approche suivante peut
     être utilisée&nbsp;:
<screen><![CDATA[
SELECT xmlagg(x) FROM (SELECT * FROM test ORDER BY y DESC) AS tab;
        xmlagg
----------------------
 <bar/><foo>abc</foo>
]]></screen>

     De nouveau, voir <xref linkend="functions-aggregate"/> pour plus
     d'informations.
    </para>
   </sect3>

   <sect3>
    <title>Prédicats XML</title>

    <indexterm>
     <primary>IS DOCUMENT</primary>
    </indexterm>

<synopsis>
<replaceable>xml</replaceable> IS DOCUMENT
</synopsis>

    <para>
     L'expression <literal>IS DOCUMENT</literal> renvoie true si la valeur
     de l'argument XML est un document XML correct, false dans le cas
     contraire (c'est-à-dire qu'il s'agit d'un fragment de document)
     ou NULL si l'argument est NULL. Voir la <xref linkend="datatype-xml"/>
     pour les différences entre documents et fragments de contenu.
    </para>
   </sect3>
  </sect2>

  <sect2 id="functions-xml-processing">
   <title>Traiter du XML</title>

   <indexterm>
    <primary>XPath</primary>
   </indexterm>

   <para>
    Pour traiter les valeurs du type <type>xml</type>, PostgreSQL fournit la
    fonction <function>xpath</function>, qui évalue les expressions XPath 1.0.
   </para>

<synopsis>
<function>xpath</function>(<replaceable>xpath</replaceable>, <replaceable>xml</replaceable><optional>, <replaceable>nsarray</replaceable></optional>)
</synopsis>

   <para>
    La fonction <function>xpath</function> évalue l'expression XPath
    <replaceable>xpath</replaceable> avec la valeur XML
    <replaceable>xml</replaceable>. Elle renvoie un tableau de valeurs XML
    correspondant à l'ensemble de nœuds produit par une expression XPath.
   </para>

  <para>
    Le second argument doit être un document XML bien formé. En particulier, il
    doit avoir un seul élément de n&oelig;ud racine.
  </para>

   <para>
    Le troisième argument de la fonction est un tableau de correspondances
    de <foreignphrase>namespace</foreignphrase>. Ce tableau doit avoir deux dimensions dont la seconde
    a une longueur 2 (en fait, c'est un tableau de tableaux à exactement
    deux éléments). Le premier élément de chaque entrée du tableau est le
    nom du <foreignphrase>namespace</foreignphrase>, le second étant l'URI du
    <foreignphrase>namespace</foreignphrase>.
   </para>

   <para>
    Exemple&nbsp;:
<screen><![CDATA[
SELECT xpath('/my:a/text()', '<my:a xmlns:my="http://example.com">test</my:a>', 
             ARRAY[ARRAY['my', 'http://example.com']]);

 xpath  
--------
 {test}
(1 row)
]]></screen>
   </para>
  </sect2>

  <sect2 id="functions-xml-mapping">
   <title>Transformer les tables en XML</title>

   <indexterm zone="functions-xml-mapping"> 
    <primary>export XML</primary>
   </indexterm>

   <para>
    Les fonctions suivantes transforment le contenu de tables relationnelles
    en valeurs XML. Il s'agit en quelque sorte d'un export XML.
<synopsis>
table_to_xml(tbl regclass, nulls boolean, tableforest boolean, targetns text)
query_to_xml(query text, nulls boolean, tableforest boolean, targetns text)
cursor_to_xml(cursor refcursor, count int, nulls boolean, 
              tableforest boolean, targetns text)</synopsis>
    Le type en retour de ces fonctions est <type>xml</type>.
   </para>

   <para>
    <function>table_to_xml</function> transforme le contenu de la table
    passée en argument (paramètre <parameter>tbl</parameter>).
    <type>regclass</type> accepte des chaînes identifiant les tables en
    utilisant la notation habituelle, incluant les qualifications possibles du
    schéma et les guillemets doubles. <function>query_to_xml</function> exécute
    la requête dont le texte est passé par le paramètre
    <parameter>query</parameter> et transforme le résultat.
    <function>cursor_to_xml</function> récupère le nombre indiqué de lignes à
    partir du curseur indiqué par le paramètre
    <parameter>cursor</parameter>. Cette variante est recommandée si la
    transformation se fait sur de grosses tables car la valeur en résultat est
    construite en mémoire pour chaque fonction.
   </para>

   <para>
    Si <parameter>tableforest</parameter> vaut false, alors le document XML
    résultant ressemble à ceci&nbsp;:
<screen><![CDATA[
<tablename>
  <row>
    <columnname1>donnees</columnname1>
    <columnname2>donnees</columnname2>
  </row>

  <row>
    ...
  </row>

  ...
</tablename>
]]></screen>

    Si <parameter>tableforest</parameter> vaut true, le résultat est un fragment
    XML qui ressemble à ceci&nbsp;:
<screen><![CDATA[
<tablename>
  <columnname1>donnees</columnname1>
  <columnname2>donnees</columnname2>
</tablename>

<tablename>
  ...
</tablename>

...
]]></screen>

    Si aucune table n'est disponible, c'est-à-dire lors d'une transformation
    à partir d'une requête ou d'un curseur, la chaîne <literal>table</literal>
    est utilisée dans le premier format, et la chaîne <literal>row</literal>
    dans le second.
   </para>

   <para>
    Le choix entre ces formats dépend de l'utilisateur. Le premier format
    est un document XML correct, ce qui est important dans beaucoup
    d'applications. Le second format tend à être plus utile dans la fonction
    <function>cursor_to_xml</function> si les valeurs du résultat sont à
    rassembler plus tard dans un document. Les fonctions pour produire du
    contenu XML discutées ci-dessus, en particulier
    <function>xmlelement</function>, peuvent être utilisées pour modifier
    les résultats.
   </para>

   <para>
    Les valeurs des données sont transformées de la même façon que ce qui
    est décrit ci-dessus pour la fonction <function>xmlelement</function>.
   </para>

   <para>
    Le paramètre <parameter>nulls</parameter> détermine si les valeurs NULL
    doivent être incluses en sortie. À true, les valeurs NULL dans les colonnes
    sont représentées ainsi&nbsp;:
<screen><![CDATA[
<columnname xsi:nil="true"/>
]]></screen>
    où <literal>xsi</literal> est le préfixe de l'espace de noms XML pour
    l'instance XML Schema. Une déclaration appropriée d'un espace de noms
    est ajoutée à la valeur du résultat. À false, les colonnes contenant
    des valeurs NULL sont simplement omises de la sortie.
   </para>

   <para>
    Le paramètre <parameter>targetns</parameter> indique l'espace de noms
    souhaité pour le résultat. Si aucun espace de nom particulier n'est demandé, une
    chaîne vide doit être passée.
   </para>

   <para>
    Les fonctions suivantes renvoient des documents XML Schema décrivant la
    transformation réalisée par les fonctions ci-dessus.
<synopsis>
table_to_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text)
query_to_xmlschema(query text, nulls boolean, tableforest boolean, targetns text)
cursor_to_xmlschema(cursor refcursor, nulls boolean, tableforest boolean, targetns text)
</synopsis>
    Il est essentiel que les mêmes paramètres soient passés pour obtenir les
    bonnes transformations de données XML et des documents XML Schema.
   </para>

   <para>
    Les fonctions suivantes réalisent la transformation des données XML et du
    XML Schema correspondant en un seul document (ou arbre), liés ensemble.
    Elles sont utiles lorsque les résultats doivent être auto-contenus et
    auto-descriptifs.
<synopsis>
table_to_xml_and_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text)
query_to_xml_and_xmlschema(query text, nulls boolean, tableforest boolean, targetns text)
</synopsis>
   </para>

   <para>
    De plus, les fonctions suivantes sont disponibles pour produire des
    transformations analogues de schémas complets ou de bases de données
    complètes.
<synopsis>
schema_to_xml(schema name, nulls boolean, tableforest boolean, targetns text)
schema_to_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text)
schema_to_xml_and_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text)

database_to_xml(nulls boolean, tableforest boolean, targetns text)
database_to_xmlschema(nulls boolean, tableforest boolean, targetns text)
database_to_xml_and_xmlschema(nulls boolean, tableforest boolean, targetns text)
</synopsis>

    Elles peuvent produire beaucoup de données, qui
    sont construites en mémoire. Lors de transformations de gros schémas ou
    de grosses bases, il peut être utile de considérer la transformation
    séparée des tables, parfois même via un curseur.
   </para>

   <para>
    Le résultat de la transformation du contenu d'un schéma ressemble à
    ceci&nbsp;:

<screen><![CDATA[
<nomschema>

transformation-table1

transformation-table2

...

</nomschema>]]></screen>

    où le format de transformation d'une table dépend du paramètre
    <parameter>tableforest</parameter> comme expliqué ci-dessus.
   </para>

   <para>
    Le résultat de la transformation du contenu d'une base ressemble à
    ceci&nbsp;:

<screen><![CDATA[
<nombase>

<nomschema1>
  ...
</nomschema1>

<nomschema2>
  ...
</nomschema2>

...

</nombase>]]></screen>

    avec une transformation du schéma identique à celle indiquée ci-dessus.
   </para>

   <para>
    En exemple de l'utilisation de la sortie produite par ces fonctions, la
    <xref linkend="xslt-xml-html"/> montre une feuille de style XSLT qui
    convertit la sortie de <function>table_to_xml_and_xmlschema</function> en
    un document HTML contenant un affichage en tableau des données de la
    table. D'une façon similaire, les données en résultat de ces fonctions
    peuvent être converties dans d'autres formats basés sur le XML.
   </para>

   <figure id="xslt-xml-html">
    <title>Feuille de style XSLT pour convertir du SQL/XML en HTML</title>
<programlisting><![CDATA[
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns="http://www.w3.org/1999/xhtml"
>

  <xsl:output method="xml"
      doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
      doctype-public="-//W3C/DTD XHTML 1.0 Strict//EN"
      indent="yes"/>

  <xsl:template match="/*">
    <xsl:variable name="schema" select="//xsd:schema"/>
    <xsl:variable name="tabletypename"
                  select="$schema/xsd:element[@name=name(current())]/@type"/>
    <xsl:variable name="rowtypename"
                  select="$schema/xsd:complexType[@name=$tabletypename]/xsd:sequence/xsd:element[@name='row']/@type"/>

    <html>
      <head>
        <title><xsl:value-of select="name(current())"/></title>
      </head>
      <body>
        <table>
          <tr>
            <xsl:for-each select="$schema/xsd:complexType[@name=$rowtypename]/xsd:sequence/xsd:element/@name">
              <th><xsl:value-of select="."/></th>
            </xsl:for-each>
          </tr>

          <xsl:for-each select="row">
            <tr>
              <xsl:for-each select="*">
                <td><xsl:value-of select="."/></td>
              </xsl:for-each>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>

</xsl:stylesheet>
]]></programlisting>
   </figure>
  </sect2>
 </sect1>


 <sect1 id="functions-sequence">
  <title>Fonctions de manipulation de séquences</title>

  <indexterm>
   <primary>séquence</primary>
  </indexterm>
  <indexterm>
   <primary>nextval</primary>
  </indexterm>
  <indexterm>
   <primary>currval</primary>
  </indexterm>
  <indexterm>
   <primary>lastval</primary>
  </indexterm>
  <indexterm>
   <primary>setval</primary>
  </indexterm>

  <para>
   Cette section décrit les fonctions de <productname>PostgreSQL</productname>
   opérant sur les <firstterm>objets de séquence</firstterm>. Les objets de
   séquence (aussi appelés générateurs de séquence ou simplement séquences)
   sont des tables spéciales, mono-lignes, créées avec la commande
   <xref linkend="sql-createsequence" endterm="sql-createsequence-title"/>. Une
   séquence est habituellement
   utilisée pour engendrer 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
   successives à partir d'objets séquence.
  </para>

   <table id="functions-sequence-table">
    <title>Fonctions séquence</title>
    <tgroup cols="3">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <thead>
      <row>
        <entry>Fonction</entry>
        <entry>Type de retour</entry>
        <entry>Description</entry>
      </row>
     </thead>
     <tbody>
      <row>
	<entry><literal><function>currval</function>(<type>regclass</type>)</literal></entry>
	<entry><type>bigint</type></entry>
	<entry>Renvoie la valeur la plus récemment obtenue avec
        <function>nextval</function> pour la séquence indiquée</entry>
      </row>
      <row>
        <entry><literal><function>lastval</function>()</literal></entry>
        <entry><type>bigint</type></entry>
        <entry>Renvoie la valeur la plus récemment obtenue avec
        <function>nextval</function> pour toute séquence</entry>
      </row>
      <row>
	<entry><literal><function>nextval</function>(<type>regclass</type>)</literal></entry>
	<entry><type>bigint</type></entry>
	<entry>Incrémente la séquence et renvoie la nouvelle valeur</entry>
      </row>
      <row>
	<entry><literal><function>setval</function>(<type>regclass</type>,
<type>bigint</type>)</literal></entry>
	<entry><type>bigint</type></entry>
	<entry>Positionne la valeur courante de la séquence</entry>
      </row>
      <row>
	<entry><literal><function>setval</function>(<type>regclass</type>,
<type>bigint</type>, <type>boolean</type>)</literal></entry>
	<entry><type>bigint</type></entry>
	<entry>Positionne la valeur courante de la séquence et le drapeau
          <literal>is_called</literal></entry>
      </row>
     </tbody>
    </tgroup>
   </table>

  <para>
   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
   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
   compatibilité avec la gestion des noms <acronym>SQL</acronym> ordinaires,
   la chaîne est convertie en minuscules, sauf si le nom de la séquence est
   entouré de guillemets doubles. Du coup&nbsp;:
<programlisting>nextval('foo')      <lineannotation>opère sur la séquence <literal>foo</literal></lineannotation>
nextval('FOO')      <lineannotation>opère sur la séquence <literal>foo</literal></lineannotation>
nextval('"Foo"')    <lineannotation>opère sur la séquence <literal>Foo</literal></lineannotation></programlisting>
   Le nom de la séquence peut, au besoin, être qualifié du nom du schéma&nbsp;:
<programlisting>nextval('mon_schema.foo')     <lineannotation>opère sur <literal>mon_schema.foo</literal></lineannotation>
nextval('"mon_schema".foo')   <lineannotation>identique à ci-dessus</lineannotation>
nextval('foo')                <lineannotation>parcourt le chemin de recherche
pour trouver <literal>foo</literal></lineannotation></programlisting>
   Voir la <xref linkend="datatype-oid"/> pour plus d'informations sur
   <type>regclass</type>.
  </para>

  <note>
   <para>
    Avant la version 8.1 de <productname>PostgreSQL</productname>, les arguments des
    fonctions de traitement de séquences étaient du type <type>text</type>, et non <type>regclass</type>.
    De ce fait, les conversions précédemment décrites d'une chaîne de caractères
    en valeur OID se produisaient à chaque appel. Pour des raisons de compatibilité, 
    cette fonctionnalité existe toujours. Mais, en interne, un transtypage implicite
    est effectué entre <type>text</type> et <type>regclass</type> avant l'appel de la fonction.
   </para>

   <para>
    Lorsque l'argument d'une fonction de traitement de séquences est écrit comme une simple chaîne
    de caractères, il devient une constante de type <type>regclass</type>.
    Puisqu'il ne s'agit que d'un OID, il permet de suivre 
    la séquence originelle même en cas de renommage, changement de schéma...
    Ce principe de <quote>lien fort</quote> est en général souhaitable lors de 
    références à la séquence dans les vues et valeurs par défaut de colonnes.
    Un <quote>lien faible</quote> est généralement souhaité lorsque la référence
    à la séquence est résolue à l'exécution. Ce comportement peut être obtenu en forçant le 
    stockage des constantes sous la forme de constantes <type>text</type> plutôt
    que <type>regclass</type>&nbsp;:
<programlisting>nextval('foo'::text)      <lineannotation><literal>foo</literal> est recherché à l'exécution</lineannotation></programlisting>
    Le lien faible est le seul comportement accessible dans les versions de <productname>PostgreSQL</productname>
    antérieures à 8.1. Il peut donc être nécessaire de le conserver pour maintenir la sémantique d'anciennes
    applications.
   </para>

   <para>
    L'argument d'une fonction de traitement de séquences peut être une expression ou une constante.
    S'il s'agit d'une expression textuelle, le transtypage implicite impose
    une recherche à l'exécution.
   <!-- run-time lookup -->
   </para>
  </note>

  <para>
   Les fonctions séquence disponibles sont&nbsp;:

    <variablelist>
     <varlistentry>
      <term><function>nextval</function></term>
      <listitem>
       <para>
        Avance l'objet séquence à sa prochaine valeur et renvoie cette valeur.
        Ce fonctionnement est atomique&nbsp;: même si de multiples sessions
        exécutent <function>nextval</function> concurrentiellement, chacune
	obtient sans risque une valeur de séquence distincte.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><function>currval</function></term>
      <listitem>
       <para>
        Renvoie la valeur la plus récemment retournée par
        <function>nextval</function> pour cette séquence dans la session
        courante. (Une erreur est rapportée si <function>nextval</function> n'a
        jamais été appelée pour cette séquence dans cette session.) 
	Parce qu'elle renvoie une valeur locale à la session, la réponse est
	prévisible<!-- predictable -->, que d'autres sessions aient exécuté ou non la
	fonction <function>nextval</function> après la session en cours.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><function>lastval</function></term>
      <listitem>
       <para>
        Renvoie la valeur la plus récemment retournée par
        <function>nextval</function> dans la session courante. Cette fonction est
        identique à <function>currval</function>, sauf qu'au lieu de prendre le
	nom de la séquence comme argument, elle récupère la valeur de la dernière
	séquence utilisée par <function>nextval</function> dans la session en
	cours. Si <function>nextval</function> n'a pas encore été appelée dans la
	session en cours, un appel à <function>lastval</function> produit une
	erreur.
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><function>setval</function></term>
      <listitem>
       <para>
        Réinitialise la valeur du compteur de l'objet séquence. La forme avec
        deux paramètres initialise le champ <literal>last_value</literal> de la
        séquence à la valeur précisée et initialise le champ
        <literal>is_called</literal> à <literal>true</literal>, signifiant que
        le prochain <function>nextval</function> avance la séquence avant de
        renvoyer une valeur. La valeur renvoyée par <function>currval</function>
	est aussi configuré à la valeur indiquée. Dans la forme à trois paramètres,
        <literal>is_called</literal> peut être initialisé à
	<literal>true</literal> ou à <literal>false</literal>.
	<literal>true</literal> a le même effet que la forme à deux paramètres.
	Positionné à <literal>false</literal>, le prochain
        <function>nextval</function> retourne exactement la valeur indiquée
        et l'incrémentation de la séquence commence avec le
	<function>nextval</function> suivant. De plus, la valeur indiquée par
	<function>currval</function> n'est pas modifiée dans ce cas. (Il s'agit
	d'une modification du comportement des versions antérieures à la 8.3.)
        Par exemple,

<screen>SELECT setval('foo', 42);           <lineannotation>Le <function>nextval</function> suivant retourne 43</lineannotation>
SELECT setval('foo', 42, true);     <lineannotation>Comme ci-dessus</lineannotation>
SELECT setval('foo', 42, false);    <lineannotation>Le <function>nextval</function> suivant retourne 42</lineannotation></screen>

        Le résultat renvoyé par <function>setval</function> est la valeur
        du second argument.
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
  </para>

  <para>
   Si un objet séquence a été créé avec les paramètres par défaut, les
   appels à <function>nextval</function> sur celui-ci renvoient des valeurs
   successives à partir de 1. D'autres comportements peuvent être obtenus en
   utilisant des paramètres spéciaux de la commande <xref
   linkend="sql-createsequence" endterm="sql-createsequence-title"/>&nbsp;; voir
   la page de référence de la commande pour plus d'informations.
  </para>

  <important>
   <para>
    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
    <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>
    ne sont jamais annulées non plus.
   </para>
  </important>

 </sect1>


 <sect1 id="functions-conditional">
  <title>Expressions conditionnelles</title>

  <indexterm>
   <primary>CASE</primary>
  </indexterm>

  <indexterm>
   <primary>expression conditionnelle</primary>
  </indexterm>

  <para>
   Cette section décrit les expressions conditionnelles respectueuses du standard
   <acronym>SQL</acronym> disponibles avec <productname>PostgreSQL</productname>.
  </para>

  <tip>
   <para>
    S'il s'avère nécessaire d'aller au-delà des possibilités offertes par les expressions conditionnelles,
    il faut considérer l'écriture d'une procédure stockée dans un langage de programmation plus
    expressif.
   </para>
  </tip>

  <sect2>
   <title><literal>CASE</literal></title>

  <para>
   L'expression <acronym>SQL</acronym> <token>CASE</token> est une expression
   conditionnelle générique, similaire aux instructions if/else des
   autres langages de programmation&nbsp;:

<synopsis>CASE WHEN <replaceable>condition</replaceable> THEN <replaceable>résultat</replaceable>
     <optional>WHEN ...</optional>
     <optional>ELSE <replaceable>résultat</replaceable></optional>
END</synopsis>

   Les clauses <token>CASE</token> peuvent être utilisées partout où une
   expression est valide. Chaque <replaceable>condition</replaceable> est une
   expression qui renvoie un résultat de type <type>boolean</type>. Si le
   résultat de la condition est vrai, alors la valeur de l'expression
   <token>CASE</token> est le <replaceable>résultat</replaceable> qui suit la
   condition. Si le résultat de la condition n'est pas vrai, toutes les clauses
   <token>WHEN</token> suivantes sont
   parcourues de la même façon. Si aucune <replaceable>condition</replaceable>
   <token>WHEN</token> n'est vraie, alors la valeur de l'expression
   <token>CASE</token> est le <replaceable>résultat</replaceable> de la clause
   <token>ELSE</token>. Si la clause <token>ELSE</token> est omise et
   qu'aucune condition ne correspond, alors le résultat est nul.
  </para>

   <para>
    Un exemple&nbsp;:
<screen>SELECT * FROM test;

 a
---
 1
 2
 3


SELECT a,
       CASE WHEN a=1 THEN 'un'
            WHEN a=2 THEN 'deux'
            ELSE 'autre'
       END
    FROM test;

 a | case
---+-------
 1 | un
 2 | deux
 3 | autre</screen>
   </para>

  <para>
   Les types de données de toutes les expressions
   <replaceable>résultat</replaceable> doivent être convertibles dans un
   type de sortie unique. Voir la <xref linkend="typeconv-union-case"/> pour plus de
   détails.
  </para>

  <para>
   L'expression <token>CASE</token> qui suit est une variante de la forme
   générale ci-dessus&nbsp;:

<synopsis>CASE <replaceable>expression</replaceable>
    WHEN <replaceable>valeur</replaceable> THEN
    <replaceable>résultat</replaceable>
    <optional>WHEN ...</optional>
    <optional>ELSE <replaceable>résultat</replaceable></optional>
END</synopsis>

   La première <replaceable>expression</replaceable> est calculée et comparée à chacune
   des <replaceable>valeur</replaceable> des clauses
   <token>WHEN</token> jusqu'à en trouver une égale. Si aucune ne correspond, le
   <replaceable>résultat</replaceable> de la clause
   <token>ELSE</token> (ou une valeur NULL) est renvoyé(e). C'est similaire
   à l'instruction <function>switch</function> du langage C.
  </para>

   <para>
    L'exemple ci-dessus peut être réécrit en utilisant la syntaxe
    <token>CASE</token> simple&nbsp;:
<screen>SELECT a,
       CASE a WHEN 1 THEN 'un'
              WHEN 2 THEN 'deux'
              ELSE 'autre'
       END
    FROM test;

 a | case
---+-------
 1 | un
 2 | deux
 3 | autre</screen>
   </para>

   <para>
    Une expression <token>CASE</token> n'évalue pas les sous-expressions qui
    ne sont pas nécessaires pour déterminer le résultat. Par exemple, une
    façon possible d'éviter une division par zéro&nbsp;:
<programlisting>SELECT ... WHERE CASE WHEN x &lt;&gt; 0 THEN y/x &gt; 1.5 ELSE false END;</programlisting>
   </para>
  </sect2>

  <sect2>
   <title><literal>COALESCE</literal></title>

  <indexterm>
   <primary>COALESCE</primary>
  </indexterm>

  <indexterm>
   <primary>NVL</primary>
  </indexterm>

  <indexterm>
   <primary>IFNULL</primary>
  </indexterm>

<synopsis><function>COALESCE</function>(<replaceable>valeur</replaceable> <optional>, ...</optional>)</synopsis>

  <para>
   La fonction <function>COALESCE</function> renvoie le premier de ses
   arguments qui n'est pas nul. Une valeur NULL n'est renvoyée que si tous
   les arguments sont nuls. Cette fonction est souvent utile pour substituer une
   valeur par défaut aux valeurs NULL lorsque la donnée est récupérée pour
   affichage. Par exemple&nbsp;:
<programlisting>SELECT COALESCE(description, description_courte, '(aucune)') ...</programlisting>
  </para>

   <para>
    À l'instar d'une expression <token>CASE</token>, <function>COALESCE</function>
    n'évalue pas les arguments inutiles à la détermination du
    résultat&nbsp;; c'est-à-dire que tous les arguments à la droite du premier
    argument non nul ne sont pas évalués. Cette fonction SQL standard fournit
    des fonctionnalités similaires à <function>NVL</function> et <function>IFNULL</function>,
    qui sont utilisées dans d'autres systèmes de bases de données.
   </para>
  </sect2>

  <sect2>
   <title><literal>NULLIF</literal></title>

  <indexterm>
   <primary>NULLIF</primary>
  </indexterm>

<synopsis><function>NULLIF</function>(<replaceable>valeur1</replaceable>, <replaceable>valeur2</replaceable>)</synopsis>

  <para>
   La fonction <function>NULLIF</function> renvoie une valeur NULL si
   <replaceable>valeur1</replaceable> et <replaceable>valeur2</replaceable>
   sont égales&nbsp;; sinon, elle renvoie <replaceable>valeur1</replaceable>.
  </para>
  <para>
   On peut s'en servir pour effectuer l'opération inverse de l'exemple de
   <function>COALESCE</function> donné ci-dessus&nbsp;:
<programlisting>SELECT NULLIF(valeur, '(aucune)') ...</programlisting>
  </para>
  <para>
   Si <replaceable>valeur1</replaceable> est <literal>(aucune)</literal>, renvoie une
   valeur NULL. Sinon, renvoie <replaceable>valeur1</replaceable>.
  </para>

  </sect2>

  <sect2>
   <title><literal>GREATEST</literal> et <literal>LEAST</literal></title>

  <indexterm>
   <primary>GREATEST</primary>
  </indexterm>
  <indexterm>
   <primary>LEAST</primary>
  </indexterm>

<synopsis><function>GREATEST</function>(<replaceable>valeur</replaceable> <optional>, ...</optional>)</synopsis>
<synopsis><function>LEAST</function>(<replaceable>valeur</replaceable> <optional>, ...</optional>)</synopsis>

   <para>
    Les fonctions <function>GREATEST</function> et <function>LEAST</function> sélectionnent,
    respectivement, la valeur la plus grande et la valeur la plus petite
    d'une liste d'expressions. Elles doivent être
    toutes convertibles en un type de données commun, type du
    résultat (voir la <xref linkend="typeconv-union-case"/> pour les détails).
    Les valeurs NULL contenues dans la liste sont ignorées. Le résultat est
    NULL uniquement si toutes les expressions sont NULL.
   </para>

   <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
    de retourner NULL si l'un quelconque des arguments est NULL, plutôt que 
    lorsque tous les arguments sont NULL.
   </para>
  </sect2>

 </sect1>


 <sect1 id="functions-array">
  <title>Fonctions et opérateurs de tableaux</title>

  <para>
   Le <xref linkend="array-operators-table"/> présente les opérateurs disponibles
   pour les types tableaux.
  </para>

    <table id="array-operators-table">
     <title>Opérateurs pour les tableaux</title>
     <tgroup cols="4">
      <colspec colnum="1" colwidth="0.5*"/>
      <colspec colnum="2" colwidth="0.5*"/>
      <colspec colnum="3" colwidth="1.5*"/>
      <colspec colnum="3" colwidth="1.5*"/>
      <thead>
       <row>
	<entry>Opérateur</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry><literal>=</literal> </entry>
	<entry>égal à</entry>
	<entry><literal>ARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>&lt;&gt;</literal> </entry>
	<entry>différent de</entry>
	<entry><literal>ARRAY[1,2,3] &lt;&gt; ARRAY[1,2,4]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>&lt;</literal> </entry>
	<entry>inférieur à</entry>
	<entry><literal>ARRAY[1,2,3] &lt; ARRAY[1,2,4]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>&gt;</literal> </entry>
	<entry>supérieur à</entry>
	<entry><literal>ARRAY[1,4,3] &gt; ARRAY[1,2,4]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>&lt;=</literal> </entry>
	<entry>inférieur ou égal à</entry>
	<entry><literal>ARRAY[1,2,3] &lt;= ARRAY[1,2,3]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>&gt;=</literal> </entry>
	<entry>supérieur ou égal à</entry>
	<entry><literal>ARRAY[1,4,3] &gt;= ARRAY[1,4,3]</literal></entry>
	<entry><literal>t</literal></entry>
       </row>

       <row>
        <entry> <literal>@&gt;</literal> </entry>
        <entry>contient</entry>
        <entry><literal>ARRAY[1,4,3] @&gt; ARRAY[3,1]</literal></entry>
        <entry><literal>t</literal></entry>
       </row>

       <row>
        <entry> <literal>&lt;@</literal> </entry>
        <entry>est contenu par</entry>
        <entry><literal>ARRAY[2,7] &lt;@ ARRAY[1,7,4,2,6]</literal></entry>
        <entry><literal>t</literal></entry>
       </row>

<!-- overlap ? Superposition, chevauchement, croisement, intersection ?-->
       <row>
        <entry> <literal>&amp;&amp;</literal> </entry>
        <entry>se chevauchent (ont des éléments en commun)</entry>
        <entry><literal>ARRAY[1,4,3] &amp;&amp; ARRAY[2,1]</literal></entry>
        <entry><literal>t</literal></entry>
       </row>

       <row>
	<entry><literal>||</literal> </entry>
	<entry>concaténation de tableaux</entry>
	<entry><literal>ARRAY[1,2,3] || ARRAY[4,5,6]</literal></entry>
	<entry><literal>{1,2,3,4,5,6}</literal></entry>
       </row>

       <row>
	<entry><literal>||</literal> </entry>
	<entry>concaténation de tableaux</entry>
	<entry><literal>ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9]]</literal></entry>
	<entry><literal>{{1,2,3},{4,5,6},{7,8,9}}</literal></entry>
       </row>

       <row>
	<entry><literal>||</literal> </entry>
	<entry>concaténation d'un élément avec un tableau</entry>
	<entry><literal>3 || ARRAY[4,5,6]</literal></entry>
	<entry><literal>{3,4,5,6}</literal></entry>
       </row>

       <row>
	<entry><literal>||</literal> </entry>
	<entry>concaténation d'un tableau avec un élément</entry>
	<entry><literal>ARRAY[4,5,6] || 7</literal></entry>
	<entry><literal>{4,5,6,7}</literal></entry>
       </row>
      </tbody>
     </tgroup>
    </table>

<!-- SAS 20080806 : row-major doit-il être conservé, sans traduction ? 
     Non. Traduit pas premier index, ou lignes, un tableau à deux dimensions
     est une matrice [ligne][colonne] -->
  <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,
   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
   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
   anciennes versions indiquent que deux tableaux de même contenu sont
   identiques même si le nombre de dimensions ou les échelles d'indices
   diffèrent.)
  </para>

  <para>
   Voir la <xref linkend="arrays"/> pour plus de détails sur le comportement des
   opérateurs.
  </para>

  <para>
   Le <xref linkend="array-functions-table"/> présente les fonctions utilisables 
   avec des types tableaux. Voir la <xref
   linkend="arrays"/> pour plus d'informations et des exemples d'utilisation de ces
   fonctions.
  </para>

  <indexterm>
    <primary>array_append</primary>
  </indexterm>
  <indexterm>
    <primary>array_cat</primary>
  </indexterm>
  <indexterm>
    <primary>array_ndims</primary>
  </indexterm>
  <indexterm>
    <primary>array_dims</primary>
  </indexterm>
  <indexterm>
    <primary>array_fill</primary>
  </indexterm>
  <indexterm>
    <primary>array_length</primary>
  </indexterm>
  <indexterm>
    <primary>array_lower</primary>
  </indexterm>
  <indexterm>
    <primary>array_prepend</primary>
  </indexterm>
  <indexterm>
    <primary>array_to_string</primary>
  </indexterm>
 <indexterm>
    <primary>array_upper</primary>
  </indexterm>
  <indexterm>
    <primary>string_to_array</primary>
  </indexterm>
  <indexterm>
    <primary>unnest</primary>
  </indexterm>

    <table id="array-functions-table">
     <title>Fonctions pour les tableaux</title>
     <tgroup cols="5">
      <thead>
       <row>
	<entry>Fonction</entry>
	<entry>Type de retour</entry>
	<entry>Description</entry>
	<entry>Exemple</entry>
	<entry>Résultat</entry>
       </row>
      </thead>
      <tbody>
       <row>
	<entry>
     <literal>
      <function>array_append</function>
      (<type>anyarray</type>, <type>anyelement</type>)
     </literal>
    </entry>
	<entry><type>anyarray</type></entry>
	<entry>ajoute un élément à la fin d'un tableau</entry>
	<entry><literal>array_append(ARRAY[1,2], 3)</literal></entry>
	<entry><literal>{1,2,3}</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_cat</function>
      (<type>anyarray</type>, <type>anyarray</type>)
     </literal>
    </entry>
	<entry><type>anyarray</type></entry>
	<entry>concatène deux tableaux</entry>
	<entry><literal>array_cat(ARRAY[1,2,3], ARRAY[4,5])</literal></entry>
	<entry><literal>{1,2,3,4,5}</literal></entry>
       </row>
       <row>
        <entry>
         <literal>
          <function>array_ndims</function>(<type>anyarray</type>)
         </literal>
        </entry>
        <entry><type>int</type></entry>
        <entry>renvoit le nombre de dimensions du tableau</entry>
        <entry><literal>array_ndims(ARRAY[[1,2,3], [4,5,6]])</literal></entry>
        <entry><literal>2</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_dims</function> (<type>anyarray</type>)
     </literal>
    </entry>
	<entry><type>text</type></entry>
	<entry>renvoie une représentation textuelle des dimensions d'un
	  tableau</entry>
	<entry><literal>array_dims(array[[1,2,3], [4,5,6]])</literal></entry>
	<entry><literal>[1:2][1:3]</literal></entry>
       </row>
       <row>
        <entry>
         <literal>
          <function>array_fill</function>(<type>anyelement</type>, <type>int[]</type>,
          <optional>, <type>int[]</type></optional>)
         </literal>
        </entry>
        <entry><type>anyarray</type></entry>
        <entry>renvoit un tableau initialisé avec une valeur et des dimensions
	 fournies, en option avec des limites basses autre que 1</entry>
        <entry><literal>array_fill(7, ARRAY[3], ARRAY[2])</literal></entry>
        <entry><literal>[2:4]={7,7,7}</literal></entry>
       </row>
       <row>
        <entry>
         <literal>
          <function>array_length</function>(<type>anyarray</type>, <type>int</type>)
         </literal>
        </entry>
        <entry><type>int</type></entry>
        <entry>renvoit la longueur de la dimension du tableau</entry>
        <entry><literal>array_length(array[1,2,3], 1)</literal></entry>
        <entry><literal>3</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_lower</function> (<type>anyarray</type>, <type>int</type>)
     </literal>
    </entry>
	<entry><type>int</type></entry>
	<entry>renvoie la limite inférieure du tableau donné</entry>
	<entry><literal>array_lower('[0:2]={1,2,3}'::int[], 1)</literal></entry>
	<entry><literal>0</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_prepend</function>
      (<type>anyelement</type>, <type>anyarray</type>)
     </literal>
    </entry>
	<entry><type>anyarray</type></entry>
	<entry>ajoute un élément au début d'un tableau</entry>
	<entry><literal>array_prepend(1, ARRAY[2,3])</literal></entry>
	<entry><literal>{1,2,3}</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_to_string</function> (<type>anyarray</type>, <type>text</type>)
     </literal>
    </entry>
	<entry><type>text</type></entry>
	<entry>concatène des éléments de tableau en utilisant le délimiteur
         fourni</entry>
	<entry><literal>array_to_string(array[1, 2, 3], '~^~')</literal></entry>
	<entry><literal>1~^~2~^~3</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>array_upper</function> (<type>anyarray</type>, <type>int</type>)
     </literal>
    </entry>
	<entry><type>int</type></entry>
	<entry>renvoie la limite supérieure du tableau donné</entry>
	<entry><literal>array_upper(ARRAY[1,2,3,4], 1)</literal></entry>
	<entry><literal>4</literal></entry>
       </row>
       <row>
	<entry>
     <literal>
      <function>string_to_array</function>
      (<type>text</type>, <type>text</type>)
     </literal>
    </entry>
	<entry><type>text[]</type></entry>
	<entry>divise une chaîne en tableau d'éléments en utilisant le délimiteur
         fourni</entry>
	<entry><literal>string_to_array( 'xx~^~yy~^~zz',
'~^~')</literal></entry>
	<entry><literal>{xx,yy,zz}</literal></entry>
       </row>
       <row>
        <entry>
         <literal>
          <function>unnest</function>(<type>anyarray</type>)
         </literal>
        </entry>
        <entry><type>setof anyelement</type></entry>
        <entry>étend un tableau à un ensemble de lignes</entry>
        <entry><literal>unnest(ARRAY[1,2])</literal></entry>
        <entry><literal>1</literal><para><literal>2</literal></para> (2 rows)</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    Voir aussi <xref linkend="functions-aggregate"/> à propose la fonction
    d'agrégat <function>array_agg</function> à utiliser avec les tableaux.
   </para>
  </sect1>

 <sect1 id="functions-aggregate">
  <title>Fonctions d'agrégat</title>

  <indexterm zone="functions-aggregate">
   <primary>fonction d'agrégat</primary>
   <secondary>intégrée</secondary>
  </indexterm>

  <para>
   Les <firstterm>fonctions d'agrégat</firstterm> calculent une
   valeur unique à partir d'un ensemble de valeurs en entrée. Les fonctions d'agrégats
   intégrées sont listées dans <xref linkend="functions-aggregate-table"/> et
   <xref linkend="functions-aggregate-statistics-table"/>. La syntaxe
   particulière des fonctions d'agrégat est décrite dans la
   <xref linkend="syntax-aggregates"/>.
   La <xref linkend="tutorial-agg"/> fournit un supplément d'informations
   introductives.
  </para>

<!-- Fonctions d'agrégat tout-terrain -->
<!-- Fonctions d'agrégat multi-usage -->
  <table id="functions-aggregate-table">
   <title>Fonctions d'agrégat générales</title>

   <tgroup cols="4">
    <thead>
     <row>
      <entry>Fonction</entry>
      <entry>Type d'argument</entry>
      <entry>Type de retour</entry>
      <entry>Description</entry>
     </row>
    </thead>

    <tbody>
     <row>
      <entry>
       <indexterm>
        <primary>array_agg</primary>
       </indexterm>
       <function>array_agg(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       any
      </entry>
      <entry>
       tableau du type de l'argument
      </entry>
      <entry>les valeurs entrées concaténées dans un tableau</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>average</primary>
       </indexterm>
       <function>avg(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, 
       <type>double precision</type>, <type>numeric</type> ou <type>interval</type>
      </entry>
      <entry>
       <type>numeric</type> pour tout argument de type entier,
       <type>double precision</type> pour tout argument en virgule flottante,
       sinon identique au type de données de l'argument
      </entry>
      <entry>la moyenne arithmétique de toutes les valeurs en
       entrée</entry>
     </row>

     <row>
       <entry>
         <indexterm>
           <primary>bit_and</primary>
         </indexterm>
         <function>bit_and(<replaceable class="parameter">expression</replaceable>)</function>
       </entry>
       <entry>
         <type>smallint</type>, <type>int</type>, <type>bigint</type> ou
         <type>bit</type>
       </entry>
       <entry>
         identique au type de données de l'argument
       </entry>
       <entry>le AND bit à bit de toutes les valeurs non NULL en entrée ou
         NULL s'il n'y en a pas</entry>
     </row>
     
     <row>
       <entry>
         <indexterm>
           <primary>bit_or</primary>
         </indexterm>
         <function>bit_or(<replaceable class="parameter">expression</replaceable>)</function>
       </entry>
       <entry>
         <type>smallint</type>, <type>int</type>, <type>bigint</type> ou
         <type>bit</type>
       </entry>
       <entry>
         identique au type de données de l'argument
       </entry>
       <entry>le OR bit à bit de toutes les valeurs non NULL en entrée ou
         NULL s'il n'y en a pas</entry>
     </row>
     
     <row>
       <entry>
         <indexterm>
           <primary>bool_and</primary>
         </indexterm>
         <function>bool_and(<replaceable class="parameter">expression</replaceable>)</function>
       </entry>
       <entry>
         <type>bool</type>
       </entry>
       <entry>
         <type>bool</type>
       </entry>
       <entry>true si toutes les valeurs en entrée valent true, false sinon</entry>
     </row>
     
     <row>
       <entry>
         <indexterm>
           <primary>bool_or</primary>
         </indexterm>
         <function>bool_or(<replaceable class="parameter">expression</replaceable>)</function>
       </entry>
       <entry>
         <type>bool</type>
       </entry>
       <entry>
         <type>bool</type>
       </entry>
       <entry>true si au moins une valeur en entrée vaut true, false sinon</entry>
     </row>
     
     <row>
      <entry><function>count(*)</function></entry>
      <entry></entry>
      <entry><type>bigint</type></entry>
      <entry>nombre de lignes en entrée</entry>
     </row>

     <row>
      <entry><function>count(<replaceable class="parameter">expression</replaceable>)</function></entry>
      <entry>tout type</entry>
      <entry><type>bigint</type></entry>
      <entry>
       nombre de lignes en entrée pour lesquelles
       l'<replaceable class="parameter">expression</replaceable> n'est pas NULL
      </entry>
     </row>

     <row>
      <entry><indexterm><primary>every</primary></indexterm>
       <function>every(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry><type>bool</type></entry>
      <entry><type>bool</type></entry>
      <entry>équivalent à <function>bool_and</function></entry>
     </row>

     <row>
      <entry><function>max(<replaceable class="parameter">expression</replaceable>)</function></entry>
      <entry>tout type <type>array</type>, <type>numeric</type>,
      <type>string</type> ou <type>date</type>/<type>time</type></entry>
      <entry>identique au type en argument</entry>
      <entry>
       valeur maximale de l'<replaceable class="parameter">expression</replaceable> pour toutes les valeurs en
       entrée
      </entry>
     </row>

     <row>
      <entry><function>min(<replaceable class="parameter">expression</replaceable>)</function></entry>
      <entry>tout type <type>array</type>, <type>numeric</type>, <type>string</type> ou
      <type>date</type>/<type>time</type></entry>
      <entry>identique au type en argument</entry>
      <entry>
       valeur minimale de l'<replaceable class="parameter">expression</replaceable> pour toutes les valeurs en
       entrée
      </entry>
     </row>

     <row>
      <entry><function>sum(<replaceable class="parameter">expression</replaceable>)</function></entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double precision</type>, <type>numeric</type> ou
       <type>interval</type>
      </entry>
      <entry>
       <type>bigint</type> pour les arguments de type <type>smallint</type> ou
       <type>int</type>, <type>numeric</type> pour les arguments de type
       <type>bigint</type>, <type>double precision</type>
       pour les arguments en virgule flottante, sinon identique au type de
       données de l'argument
      </entry>
      <entry>somme de l'<replaceable class="parameter">expression</replaceable>
       pour toutes les valeurs en entrée</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>xmlagg</primary>
       </indexterm>
       <function>xmlagg(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       <type>xml</type>
      </entry>
      <entry>
       <type>xml</type>
      </entry>
      <entry>concaténation de valeurs XML (voir aussi <xref
       linkend="functions-xml-xmlagg"/>)</entry>
     </row>

    </tbody>
   </tgroup>
  </table>

  <para>
   En dehors de <function>count</function>, ces
   fonctions renvoient une valeur NULL si aucune ligne n'est sélectionnée. En
   particulier, une somme (<function>sum</function>) sur aucune ligne renvoie
   NULL et non zéro, et <function>array_agg</function> renvoit NULL plutôt
   qu'un tableau vide quand il n'y a pas de lignes en entrée. La fonction
   <function>coalesce</function> peut être utilisée pour substituer des zéros
   ou un tableau vide aux valeurs NULL quand cela est nécessaire.
  </para>

  <note>
  <indexterm>
  <primary>ANY</primary>
  </indexterm>
  <indexterm>
  <primary>SOME</primary>
  </indexterm>
   <para>
    Les agrégats booléens <function>bool_and</function> et
    <function>bool_or</function> correspondent aux agrégats standard du SQL
    <function>every</function> et <function>any</function> ou
    <function>some</function>. 
    Pour <function>any</function> et <function>some</function>, il
    semble qu'il y a une ambiguïté dans la syntaxe standard&nbsp;:
<programlisting>SELECT b1 = ANY((SELECT b2 FROM t2 ...)) FROM t1 ...;</programlisting>
    Ici, <function>ANY</function> peut être considéré soit comme introduisant
    une sous-requête soit comme étant une fonction d'agrégat, si la sous-requête
    renvoit une ligne avec une valeur booléenne si l'expression de sélection ne
    renvoie qu'une ligne. Du coup, le nom standard ne peut être donné à ces
    agrégats.
   </para>
  </note>

  <note>
   <para>
    Les utilisateurs habitués à travailler avec d'autres systèmes de gestion de
    bases de données SQL peuvent être surpris par les performances de
    l'agrégat <function>count</function> lorsqu'il est appliqué à la
    table entière. En particulier, une requête identique à
<programlisting>SELECT count(*) FROM ma_table;</programlisting>
    est exécuté par <productname>PostgreSQL</productname> à l'aide d'un
    parcours séquentiel de la table entière.
   </para>
  </note>
  
  <para>
   Les fonctions d'agrégat <function>array_agg</function> et
   <function>xmlagg</function>, ainsi que d'autres fonctions similaires d'agrégats
   définies par l'utilisateur, produisent des valeurs de résultats qui ont un sens
   différents, dépendant de l'ordre des valeurs en entrée. Dans l'implantation
   actuelle, l'ordre des entrées est en principe non spécifiée. Fournir les
   valeurs à partir d'une sous-requête triée fonctionnera généralement. Par
   exemple&nbsp;:

<screen><![CDATA[
SELECT xmlagg(x) FROM (SELECT x FROM test ORDER BY y DESC) AS tab;
]]></screen>

   Mais cette syntaxe n'est pas autorisée dans le standard SQL et n'est pas
   portable vers d'autres systèmes de bases de données. Une version future
   de <productname>PostgreSQL</productname> pourrait fournir une fonctionnalité
   supplémentaire pour contrôler l'ordre d'une meilleure façon
   (<literal>xmlagg(expr ORDER BY expr, expr, ...)</literal>).
  </para>

  <para>
   <xref linkend="functions-aggregate-statistics-table"/> présente les fonctions
   d'agrégat typiquement utilisées dans l'analyse statistique.
   (Elles sont séparées pour éviter de grossir la liste des agrégats les plus
   utilisés.) Là où la description mentionne
   <replaceable class="parameter">N</replaceable>, cela représente le nombre
   de lignes en entrée pour lesquelles toutes les expressions en entrée sont
   non NULL. Dans tous les cas, NULL est renvoyé si le calcul n'a pas de
   signification, par exemple si <replaceable class="parameter">N</replaceable>
   vaut zéro.
  </para>

  <indexterm>
   <primary>statistiques</primary>
  </indexterm>
  <indexterm>
   <primary>régression linéaire</primary>
  </indexterm>

  <table id="functions-aggregate-statistics-table">
   <title>Fonctions d'agrégats pour les statistiques</title>

   <tgroup cols="4">
    <thead>
     <row>
      <entry>Fonction</entry>
      <entry>Type de l'argument</entry>
      <entry>Type renvoyé</entry>
      <entry>Description</entry>
     </row>
    </thead>

    <tbody>

     <row>
      <entry>
       <indexterm>
        <primary>corrélation</primary>
       </indexterm>
       <function>corr(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>coefficient de corrélation</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>covariance</primary>
        <secondary>population</secondary>
       </indexterm>
       <function>covar_pop(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>covariance de population</entry>
     </row>
<!-- Ne parle-t-on pas plutôt de covariance d'échantillon ? -->
     <row>
      <entry>
       <indexterm>
        <primary>covariance</primary>
        <secondary>exemple</secondary>
       </indexterm>
       <function>covar_samp(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>covariance exemple</entry>
     </row>

     <row>
      <entry>
       <function>regr_avgx(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>moyenne de la variable indépendante
      (<literal>sum(<replaceable class="parameter">X</replaceable>)/<replaceable class="parameter">N</replaceable></literal>)</entry>
     </row>

     <row>
      <entry>
       <function>regr_avgy(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>moyenne de la variable dépendante
      (sum(<replaceable class="parameter">Y</replaceable>) /
      <replaceable class="parameter">N</replaceable>)</entry>
     </row>

     <row>
      <entry>
       <function>regr_count(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>bigint</type>
      </entry>
      <entry>nombre de lignes dans lesquelles les deux expressions sont non NULL</entry>
     </row>
<!-- Je doute de la traduction de y-intercept of the least-squares-fit linear
equation determined by the (X, Y) pairs, mais je n'ai pas de traduction plus
absconse à fournir... -->
<!-- A vrai dire, je manque du vocabulaire statistique nécessaire à une
relecture efficace de cette partie -->
     <row>
      <entry>
       <indexterm>
        <primary>regression intercept</primary>
       </indexterm>
       <function>regr_intercept(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>interception de l'axe y pour l'équation linéaire de la méthode
      des moindres carrés déterminée par les paires (<replaceable
      class="parameter">X</replaceable>, <replaceable
      class="parameter">Y</replaceable>)</entry>
     </row>

     <row>
      <entry>
       <function>regr_r2(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>carré du coefficient de corrélation</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>regression slope</primary>
       </indexterm>
       <function>regr_slope(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>inclinaison pour l'équation linéaire de la méthode des moindres
      carrés déterminée par les paires (<replaceable class="parameter">X</replaceable>,
      <replaceable class="parameter">Y</replaceable>)</entry>
     </row>

     <row>
      <entry>
       <function>regr_sxx(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry><literal>sum(<replaceable class="parameter">X</replaceable>^2) - 
       sum(<replaceable class="parameter">X</replaceable>)^2 / 
           <replaceable class="parameter">N</replaceable></literal>
          (<quote>somme des carrés</quote> de la variable indépendante)</entry>
     </row>

     <row>
      <entry>
       <function>regr_sxy(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry><literal>sum(<replaceable class="parameter">X</replaceable>*<replaceable class="parameter">Y</replaceable>) -
                      sum(<replaceable class="parameter">X</replaceable>) * 
		      sum(<replaceable class="parameter">Y</replaceable>) /
		      <replaceable class="parameter">N</replaceable></literal> 
		      (<quote>somme des produits</quote> de la variable indépendante
		      multipliée par la variable dépendante)</entry>
     </row>

     <row>
      <entry>
       <function>regr_syy(<replaceable class="parameter">Y</replaceable>, <replaceable class="parameter">X</replaceable>)</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry><literal>sum(<replaceable class="parameter">Y</replaceable>^2) -
                      sum(<replaceable class="parameter">Y</replaceable>)^2 / 
		      <replaceable class="parameter">N</replaceable></literal>
		      (<quote>somme des carrés</quote> de la variable dépendante)</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>standard deviation</primary>
       </indexterm>
       <function>stddev(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>alias historique pour <function>stddev_samp</function></entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>standard deviation</primary>
        <secondary>population</secondary>
       </indexterm>
       <function>stddev_pop(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>déviation standard de la population pour les valeurs en entrée</entry>
     </row>

<!-- là encore, il s'agit peut-être plutôt d'un échantillon -->
     <row>
      <entry>
       <indexterm>
        <primary>standard deviation</primary>
        <secondary>sample</secondary>
       </indexterm>
       <function>stddev_samp(<replaceable class="parameter">expression</replaceable>)</function>
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>exemple de déviation standard pour les valeurs en entrée</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>variance</primary>
       </indexterm>
       <function>variance</function>(<replaceable class="parameter">expression</replaceable>)
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>alias historique de <function>var_samp</function></entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>variance</primary>
        <secondary>population</secondary>
       </indexterm>
       <function>var_pop</function>(<replaceable class="parameter">expression</replaceable>)
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>variance de la population pour les valeurs en entrée (carré de la
       déviation standard de la population)</entry>
     </row>

<!-- Echantillon, toujours ? -->
     <row>
      <entry>
       <indexterm>
        <primary>variance</primary>
        <secondary>sample</secondary>
       </indexterm>
       <function>var_samp</function>(<replaceable class="parameter">expression</replaceable>)
      </entry>
      <entry>
       <type>smallint</type>, <type>int</type>,
       <type>bigint</type>, <type>real</type>, <type>double
       precision</type> ou <type>numeric</type>
      </entry>
      <entry>
       <type>double precision</type> pour les arguments en virgule flottante,
       <type>numeric</type> sinon
      </entry>
      <entry>exemple de la variance des valeurs en entrée (carré de la
       déviation standard)</entry>
     </row>
    </tbody>
   </tgroup>
  </table>

 </sect1>


 <sect1 id="functions-window">
  <title>Fonctions Window</title>

  <indexterm zone="functions-window">
   <primary>fonction window</primary>
   <secondary>interne</secondary>
  </indexterm>

  <para>
   Les <firstterm>fonction Window</firstterm> fournissent la possibilité de
   réaliser des calculs au travers d'ensembles de lignes relatifs à la ligne
   de la requête en cours. Voir <xref linkend="tutorial-window"/> pour une
   introduction à cette fonctionnalité.
  </para>

  <para>
   Les fonctions window internes sont listées dans <xref
   linkend="functions-window-table"/>. Notez que ces fonctions
   <emphasis>doivent</emphasis> être appelées en utilisant la syntaxe des
   fonctions window&nbsp;; autrement dit, une clause
   <literal>OVER</literal> est requise.
  </para>

  <para>
   En plus de ces fonctions, toute fonction d'agrégat interne ou définie par
   l'utilisateur peut être utilisée comme une fonction window (voir <xref
   linkend="functions-aggregate"/> pour une liste des agrégats internes).
   Les fonctions d'agrégat agissent comme des fonctions window seulement
   quand une clause <literal>OVER</literal> suit l'appel&nbsp;; sinon
   elles agissent comme des agrégats standards.
  </para>

  <table id="functions-window-table">
   <title>Fonctions Window généralistes</title>

   <tgroup cols="3">
    <thead>
     <row>
      <entry>Fonction</entry>
      <entry>Type renvoyé</entry>
      <entry>Description</entry>
     </row>
    </thead>

    <tbody>
     <row>
      <entry>
       <indexterm>
        <primary>row_number</primary>
       </indexterm>
       <function>row_number()</function>
      </entry>
      <entry>
       <type>bigint</type>
      </entry>
      <entry>numéro de la ligne en cours de traitement dans sa partition, en
       comptant à partir de 1</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>rank</primary>
       </indexterm>
       <function>rank()</function>
      </entry>
      <entry>
       <type>bigint</type>
      </entry>
      <entry>rang de la ligne en cours de traitement, avec des trous&nbsp;;
       identique <function>row_number</function> pour le premier pair</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>dense_rank</primary>
       </indexterm>
       <function>dense_rank()</function>
      </entry>
      <entry>
       <type>bigint</type>
      </entry>
      <entry>rang de la ligne en cours de traitement, sans trous&nbsp;; cette
       fonction compte les groupes de pairs</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>percent_rank</primary>
       </indexterm>
       <function>percent_rank()</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>rang relatif de la ligne en cours de traitement&nbsp;;:
       (<function>rank</function> - 1) / (nombre total de lignes - 1)</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>cume_dist</primary>
       </indexterm>
       <function>cume_dist()</function>
      </entry>
      <entry>
       <type>double precision</type>
      </entry>
      <entry>rang relatif de la ligne en cours de traitement&nbsp;:
       (nombre de lignes précédentes, ou pair de la ligne en cours) / (nombre de lignes total)</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>ntile</primary>
       </indexterm>
       <function>ntile(<replaceable class="parameter">num_buckets</replaceable> <type>integer</type>)</function>
      </entry>
      <entry>
       <type>integer</type>
      </entry>
      <entry>entier allant de 1 à la valeur de l'argument, divisant la partition
       aussi équitablement que possible</entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>lag</primary>
       </indexterm>
       <function>
         lag(<replaceable class="parameter">value</replaceable> <type>any</type>
             [, <replaceable class="parameter">offset</replaceable> <type>integer</type>
             [, <replaceable class="parameter">default</replaceable> <type>any</type> ]])
       </function>
      </entry>
      <entry>
       <type>même type que <replaceable class="parameter">value</replaceable></type>
      </entry>
      <entry>
       renvoit <replaceable class="parameter">value</replaceable> évalué à la
       ligne qui est <replaceable class="parameter">offset</replaceable> lignes
       avant la ligne actuelle à l'intérieur de la partition&nbsp;; s'il n'y a
       pas de ligne, renvoit à la place <replaceable
       class="parameter">default</replaceable>. <replaceable
       class="parameter">offset</replaceable> et <replaceable
       class="parameter">default</replaceable> sont évalués par rapport à la
       ligne en cours. Si omis, <replaceable
       class="parameter">offset</replaceable> a comme valeur par défaut 1 et
       <replaceable class="parameter">default</replaceable> est NULL
      </entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>lead</primary>
       </indexterm>
       <function>
         lead(<replaceable class="parameter">value</replaceable> <type>any</type>
              [, <replaceable class="parameter">offset</replaceable> <type>integer</type>
              [, <replaceable class="parameter">default</replaceable> <type>any</type> ]])
       </function>
      </entry>
      <entry>
       <type>same type as <replaceable class="parameter">value</replaceable></type>
      </entry>
      <entry>
       renvoit <replaceable class="parameter">value</replaceable> évalué à la
       ligne qui est <replaceable class="parameter">offset</replaceable> lignes
       après la ligne actuelle à l'intérieur de la partition&nbsp;; s'il n'y a
       pas de ligne, renvoit à la place <replaceable
       class="parameter">default</replaceable>. <replaceable
       class="parameter">offset</replaceable> et <replaceable
       class="parameter">default</replaceable> sont évalués par rapport à la
       ligne en cours. Si omis, <replaceable
       class="parameter">offset</replaceable> a comme valeur par défaut 1 et
       <replaceable class="parameter">default</replaceable> est NULL
      </entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>first_value</primary>
       </indexterm>
       <function>first_value(<replaceable
class="parameter">value</replaceable> <type>any</type>)</function>
      </entry>
      <entry>
       <type>même type que <replaceable class="parameter">value</replaceable></type>
      </entry>
      <entry>
       renvoit <replaceable class="parameter">value</replaceable> évaluée à la
       ligne qui est la première ligne du frame window
      </entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>last_value</primary>
       </indexterm>
       <function>last_value(<replaceable class="parameter">value</replaceable> <type>any</type>)</function>
      </entry>
      <entry>
       <type>même type que <replaceable class="parameter">value</replaceable></type>
      </entry>
      <entry>
       renvoit <replaceable class="parameter">value</replaceable> évaluée à la
       ligne qui est la dernière ligne du frame window
      </entry>
     </row>

     <row>
      <entry>
       <indexterm>
        <primary>nth_value</primary>
       </indexterm>
       <function>
         nth_value(<replaceable class="parameter">value</replaceable> <type>any</type>, <replaceable class="parameter">nth</replaceable> <type>integer</type>)
       </function>
      </entry>
      <entry>
       <type>même type que <replaceable class="parameter">value</replaceable></type>
      </entry>
      <entry>
       renvoit <replaceable class="parameter">value</replaceable> évaluée à la
       ligne qui est la<replaceable class="parameter">nth</replaceable>-ième
       ligne de la frame window (en comptant à partir de 1)&nbsp;; NULL si
       aucune ligne
      </entry>
     </row>
    </tbody>
   </tgroup>
  </table>

  <para>
   Toutes les fonctions listées dans <xref
   linkend="functions-window-table"/> dépendent du tri indiqué par la clause
   <literal>ORDER BY</literal> de la définition window associée. Les lignes qui
   ne sont pas distinctes dans le tri <literal>ORDER BY</literal> sont des
   <firstterm>pairs</firstterm>&nbsp;; les quatre fonctions de rang sont
   définies de ce façon à ce qu'elles donnent la même réponse pour toutes les
   lignes pairs.
  </para>

  <para>
   Notez que <function>first_value</function>,
   <function>last_value</function> et <function>nth_value</function>
   considèrent seulement les lignes à l'intérieur du <quote>frame window</quote>
   qui contient par défaut les lignes du début de la partition jusqu'au dernier
   pair de la ligne en cours. Cela risque de données des résultats inintéressants
   pour <function>nth_value</function> et tout particulièrement
   <function>last_value</function>. Vous pouvez redéfinir le frame comme
   étant la partition complète en ajoutant <literal>ROWS BETWEEN UNBOUNDED
   PRECEDING AND UNBOUNDED FOLLOWING</literal> à la clause <literal>OVER</literal>.
   Voir <xref linkend="syntax-window-functions"/> pour plus d'informations.
  </para>

  <para>
   Quand une fonction d'agrégat est utilisée comme fonction window, il aggrège
   les lignes sur le frame window de la ligne en cours de traitement. Un agrégat utilisé avec <literal>ORDER
   BY</literal> et la définition de la frame window par défaut produit un
   comportement de type <quote>somme en cours d'exécution</quote>, qui pourrait
   ou ne pas être souhaité. Pour
   obtenir un agrégat sur la partition complète, omettez <literal>ORDER
   BY</literal> ou utilisez <literal>ROWS BETWEEN UNBOUNDED PRECEDING AND
   UNBOUNDED FOLLOWING</literal>.
   Other frame specifications can be used to obtain other effects.
  </para>

  <note>
   <para>
    Le standard SQL définit une option <literal>RESPECT NULLS</literal> ou
    <literal>IGNORE NULLS</literal> pour <function>lead</function>,
    <function>lag</function>, <function>first_value</function>,
    <function>last_value</function> et <function>nth_value</function>.
    Ceci n'est pas implanté dans <productname>PostgreSQL</productname>&nbsp;:
    le comportement est toujours le même que dans le comportement par défaut
    du standard, nommément <literal>RESPECT NULLS</literal>. De la même façon,
    les options <literal>FROM FIRST</literal> ou <literal>FROM LAST</literal>
    pour <function>nth_value</function> ne sont pas implantées&nbsp;: seul le
    comportement <literal>FROM FIRST</literal> est supporté par défaut. (Vous
    pouvez obtenir le résultat d'un <literal>FROM LAST</literal> en inversant
    l'ordre du <literal>ORDER BY</literal>.)
   </para>
  </note>

 </sect1>

 <sect1 id="functions-subquery">
  <title>Expressions de sous-requêtes</title>

  <indexterm>
   <primary>EXISTS</primary>
  </indexterm>

  <indexterm>
   <primary>IN</primary>
  </indexterm>

  <indexterm>
   <primary>NOT IN</primary>
  </indexterm>

  <indexterm>
   <primary>ANY</primary>
  </indexterm>

  <indexterm>
   <primary>ALL</primary>
  </indexterm>

  <indexterm>
   <primary>SOME</primary>
  </indexterm>

  <indexterm>
   <primary>sous-requête</primary>
  </indexterm>

  <para>
   Cette section décrit les expressions de sous-requêtes compatibles
   <acronym>SQL</acronym> disponibles sous
   <productname>PostgreSQL</productname>. Toutes les formes d'expressions
   documentées dans cette section renvoient des résultats booléens (true/false).
  </para>

  <sect2>
   <title><literal>EXISTS</literal></title>

<synopsis>EXISTS ( <replaceable>sous-requête</replaceable> )</synopsis>

  <para>
   L'argument d'<token>EXISTS</token> est une instruction <command>SELECT</command>
   arbitraire ou une <firstterm>sous-requête</firstterm>. La sous-requête est
   évaluée pour déterminer si elle renvoie des lignes. Si elle en renvoie au
   moins une, le résultat d'<token>EXISTS</token> est vrai
   (<quote>true</quote>)&nbsp;; si elle n'en renvoie aucune, le résultat
   d'<token>EXISTS</token> est faux (<quote>false</quote>).
  </para>

  <para>
   La sous-requête peut faire référence à des variables de la requête
   englobante qui agissent comme des constantes à chaque évaluation de la
   sous-requête.
  </para>

  <para>
   La sous-requête n'est habituellement pas exécutée plus qu'il n'est
   nécessaire pour déterminer si au moins une ligne est 
   renvoyée. Elle n'est donc pas forcément exécutée dans son intégralité. Il
   est de ce fait fortement déconseillé d'écrire
   une sous-requête qui présente des effets de bord (tels que l'appel de fonctions de
   séquence)&nbsp;; il est extrèmement difficile de prédire si ceux-ci se
   produisent.
  </para>

  <para>
   Puisque le résultat ne dépend que d'un éventuel retour de lignes, et pas de
   leur contenu, la liste des champs retournés par la sous-requête n'a normalement aucun intérêt.
   Une convention de codage habituelle consiste à écrire tous les tests <literal>EXISTS</literal> sous la forme
   <literal>EXISTS(SELECT 1 WHERE ...)</literal>. Il y a toutefois des
   exceptions à cette règle, comme les sous-requêtes
   utilisant <token>INTERSECT</token>.
  </para>

  <para>
   L'exemple suivant, simpliste, ressemble à une jointure interne sur <literal>col2</literal>
   mais il sort au plus une ligne pour chaque ligne de
   <literal>tab1</literal>, même s'il y a plusieurs correspondances dans les lignes de
   <literal>tab2</literal>&nbsp;:
<screen>SELECT col1
FROM tab1
WHERE EXISTS(SELECT 1 FROM tab2 WHERE col2 = tab1.col2);</screen>
  </para>
  </sect2>

  <sect2>
   <title><literal>IN</literal></title>

<synopsis><replaceable>expression</replaceable> IN (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté droit est une sous-expression entre parenthèses qui ne peut
   retourner qu'une seule colonne. L'expression de gauche est évaluée et comparée à chaque ligne du
   résultat de la sous-requête. Le résultat de <token>IN</token> est vrai
   (<quote>true</quote>) si une ligne équivalente de la sous-requête est trouvée. Le
   résultat est faux (<quote>false</quote>) si aucune ligne correspondante n'est
   trouvée (ce qui inclut le cas spécial de la sous-requête ne retournant aucune
   ligne).
  </para>

  <para>
   Si l'expression de gauche est NULL ou s'il n'existe pas de
   correspondance avec les valeurs du côté droit et qu'au moins une ligne du
   côté droit est NULL, le résultat de la construction <token>IN</token> est
   NULL, et non faux. Ceci est en accord avec les règles normales du SQL pour
   les combinaisons booléennes de valeurs NULL.
  </para>

  <para>
   Comme avec <token>EXISTS</token>, on ne peut pas assumer que la
   sous-requête est évaluée complètement.
  </para>

  <synopsis><replaceable>constructeur_ligne</replaceable> IN (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté gauche de cette forme de <token>IN</token> est un constructeur de ligne
   comme décrit dans la <xref linkend="sql-syntax-row-constructors"/>.
   Le côté droit est une sous-requête entre
   parenthèses qui doit renvoyer exactement autant de colonnes qu'il y a
   d'expressions dans le côté gauche. Les expressions côté gauche sont évaluées
   et comparées ligne à ligne au résultat de la sous-requête. Le résultat de
   <token>IN</token> est vrai (<quote>true</quote>) si une ligne équivalente
   de la sous-requête est trouvée. Le résultat est faux (<quote>false</quote>) si
   aucune ligne correspondante n'est trouvée (ce qui inclut le cas spécial de
   la sous-requête ne retournant aucune ligne).
  </para>

<!-- NULL, nul... -->
  <para>
   Comme d'habitude, les valeurs NULL dans les lignes sont combinées suivant
   les règles habituelles des expressions booléennes SQL. Deux lignes sont
   considérées égales si tous leurs membres correspondant sont non nuls et égaux&nbsp;;
   les lignes diffèrent si le contenu de leurs membres sont non nuls et
   différents&nbsp;; sinon le résultat de la comparaison de la ligne est inconnu,
   donc nul. Si tous les résultats par lignes sont différents ou nuls,
   avec au moins un NULL, alors le résultat de <token>IN</token> est nul.
  </para>
  </sect2>

  <sect2>
   <title><literal>NOT IN </literal></title>

<synopsis><replaceable>expression</replaceable> NOT IN (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté droit est une sous-requête entre parenthèses, qui doit
   retourner exactement une colonne. L'expression de gauche est évalué et
   comparée à chaque ligne de résultat de la sous-requête.
   Le résultat de <token>NOT IN</token> n'est <quote>true</quote> que si des
   lignes différentes de la sous-requête sont trouvées (ce qui inclut le cas
   spécial de la sous-requête ne retournant pas de ligne). 
   Le résultat est <quote>false</quote> si une ligne égale est trouvée.
  </para>

  <para>
   Si l'expression de gauche est nulle, ou qu'il n'y a pas de valeur égale à
   droite et qu'au moins une ligne de droite est nulle, le résultat du 
   <token>NOT IN</token> est nul, pas vrai. Cela concorde avec les règles
   normales du SQL pour les combinaisons bouléennes de valeurs nulles.
  </para>

  <para>
   Comme pour <token>EXISTS</token>, on ne peut assumer que la sous-requête est
   évaluée dans son intégralité.
  </para>


<synopsis><replaceable>constructeur_ligne</replaceable> NOT IN (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté gauche de cette forme de <token>NOT IN</token> est un constructeur
   de lignes, comme décrit dans la <xref linkend="sql-syntax-row-constructors"/>.
   Le côté droit est une sous-requête entre parenthèses qui doit renvoyer
   exactement autant de colonnes qu'il y a d'expressions dans la ligne de gauche. 
   Les expressions de gauche sont évaluées et comparée ligne à ligne au
   résultat de la sous-requête. Le résultat de <token>NOT IN</token>
   n'est vrai (<quote>true</quote>) que si seules des lignes différentes de la sous-requête
   sont trouvées (ce qui inclut le cas spécial de la sous-requête ne retournant
   aucune ligne). Le résultat est faux (<quote>false</quote>) si une ligne égale est
   trouvée.
  </para>

  <para>
   Comme d'habitude, les valeurs nulles des lignes sont combinées en accord
   avec les règles normales des expressions bouléennes SQL. Deux lignes sont
   considérées égales si tous leurs membres correspondants sont non-nuls et
   égaux&nbsp;; les lignes sont différentes si les membres correspondants sont
   non-nuls et différents&nbsp;; dans tous les autres cas, le résultat de cette
   comparaison de ligne est inconnu (nul). Si tous les résultats par ligne sont
   différents ou nuls, avec au minimum un nul, alors le résultat du <token>NOT
   IN</token> est nul.
  </para>
 </sect2>

  <sect2>
   <title><literal>ANY</literal>/<literal>SOME</literal></title>

<synopsis><replaceable>expression</replaceable> <replaceable>opérateur</replaceable> ANY (<replaceable>sous-requête</replaceable>)
<replaceable>expression</replaceable> <replaceable>opérateur</replaceable> SOME (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté droit est une sous-requête entre parenthèses qui ne doit retourner
   qu'une seule colonne. L'expression du côté gauche est évaluée et comparée à
   chaque ligne du résultat de la sous-requête à l'aide de
   l'<replaceable>opérateur</replaceable> indiqué, ce qui doit aboutir à un
   résultat booléen. Le résultat de <token>ANY</token> est vrai
   (<quote>true</quote>) si l'un des résultats est vrai. Le résultat est faux
   (<quote>false</quote>) si aucun
   résultat vrai n'est trouvé (ce qui inclut le cas spécial de la requête ne
   retournant aucune ligne).
  </para>

  <para>
   <token>SOME</token> est un synonyme de <token>ANY</token>.
   <token>IN</token> est équivalent à <literal>= ANY</literal>.
  </para>

  <para>
   En l'absence de succès, mais si au moins une ligne du côté droit conduit à
   NULL avec l'opérateur, le résultat de la construction <token>ANY</token>
   est nul et non faux. Ceci est en accord avec les règles standard SQL
   pour les combinaisons booléenne de valeurs NULL.
  </para>

  <para>
   Comme pour <token>EXISTS</token>, on ne peut assumer que la sous-requête
   est évaluée entièrement.
  </para>

<synopsis><replaceable>constructeur_ligne</replaceable> <replaceable>operator</replaceable> ANY (<replaceable>sous-requête</replaceable>)
<replaceable>constructeur_ligne</replaceable> <replaceable>operator</replaceable> SOME (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté gauche de cette forme <token>ANY</token> est un constructeur de
   ligne, tel que décrit dans la <xref linkend="sql-syntax-row-constructors"/>.
   Le côté droit est une sous-requête entre
   parenthèses, qui doit renvoyer exactement autant de colonnes qu'il y a
   d'expressions dans la ligne de gauche. Les expressions du côté gauche sont
   évaluées et comparées ligne à ligne au résultat de la
   sous-requête à l'aide de l'<replaceable>opérateur</replaceable> donné.
   Le résultat de <token>ANY</token> est <quote>true</quote> si la comparaison
   renvoie true pour une ligne quelconque de la sous-requête.
   Le résultat est <quote>false</quote> si la comparaison renvoie false pour
   chaque ligne de la sous-requête (ce qui inclut le cas spécial de la sous-requête
   ne retournant aucune ligne). Le résultat est NULL si la comparaison ne renvoie
   true pour aucune ligne, et renvoie NULL pour au moins une ligne.
  </para>

  <para>
   Voir <xref linkend="row-wise-comparison"/> pour la signification détaillée
   d'une comparaison ligne à ligne. <!-- row-wise comparison -->
  </para>
  </sect2>

  <sect2>
   <title><literal>ALL</literal></title>

<synopsis><replaceable>expression</replaceable> <replaceable>opérateur</replaceable> ALL
(<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté droit est une sous-requête entre parenthèses qui ne doit renvoyer
   qu'une seule colonne. L'expression gauche est évaluée et comparée à chaque
   ligne du résultat de la sous-requête à l'aide de
   l'<replaceable>opérateur</replaceable>, ce qui doit renvoyer un résultat booléen.
   Le résultat de <token>ALL</token> est vrai (<quote>true</quote>) si toutes les
   lignes renvoient true (ce qui inclut le cas spécial de la sous-requête ne
   retournant aucune ligne). Le résultat est faux (<quote>false</quote>) si un résultat
   faux est découvert. Le résultat est NULL si la comparaison ne renvoie 
   false pour aucune ligne, mais NULL pour au moins une ligne.
  </para>

  <para>
   <token>NOT IN</token> est équivalent à <literal>&lt;&gt; ALL</literal>.
  </para>

  <para>
   Comme pour <token>EXISTS</token>, on ne peut assumer que la
   sous-requête est évaluée entièrement.
  </para>

<synopsis><replaceable>constructeur_ligne</replaceable> <replaceable>opérateur</replaceable> ALL (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté gauche de cette forme de <token>ALL</token> est un constructeur de
   lignes, tel que décrit dans la <xref linkend="sql-syntax-row-constructors"/>.
   Le côté droit est une sous-requête entre
   parenthèses qui doit renvoyer exactement le même nombre de colonnes qu'il y a
   d'expressions dans la colonne de gauche. Les expressions du côté gauche sont
   évaluées et comparées ligne à ligne au résultat de la
   sous-requête à l'aide de l'<replaceable>opérateur</replaceable> donné.
   Le résultat de <token>ALL</token> est <quote>true</quote> si la comparaison
   renvoie true pour toutes les lignes de la sous-requête (ce qui inclut le cas
   spécial de la sous-requête ne retournant aucune ligne).
   Le résultat est <quote>false</quote> si la comparaison renvoie false pour
   une ligne quelconque de la sous-requête.
   Le résultat est NULL si la comparaison ne renvoie false pour aucune ligne
   de la sous-requête, mais NULL pour au moins une ligne.
  </para>

  <para>
   Voir <xref linkend="row-wise-comparison"/> pour la signification détaillée 
   d'une comparaison ligne à ligne.
  </para>
  </sect2>

  <sect2>
   <title>Comparaison de lignes</title>

   <indexterm zone="functions-subquery">
    <primary>comparaison</primary>
    <secondary>ligne de résultats d'une sous-requête</secondary>
   </indexterm>

<synopsis><replaceable>constructeur_ligne</replaceable> <replaceable>opérateur</replaceable> (<replaceable>sous-requête</replaceable>)</synopsis>

  <para>
   Le côté gauche est un constructeur de lignes, tel que décrit dans la 
   <xref linkend="sql-syntax-row-constructors"/>. Le côté droit est une
   sous-requête entre parenthèses qui doit renvoyer exactement autant de
   colonnes qu'il y a d'expressions du côté gauche. De plus, la
   sous-requête ne peut pas renvoyer plus d'une ligne. (Si elle ne renvoie aucune
   ligne, le résultat est considéré nul.) Le côté gauche est évalué
   et comparé ligne complète avec la ligne de résultat de la sous-requête.
  </para>

  <para>
   Voir <xref linkend="row-wise-comparison"/> pour plus de détails sur la
   signification d'une comparaison ligne à ligne.
  </para>
  </sect2>
 </sect1>

 <sect1 id="functions-comparisons">
  <title>Comparaisons de lignes et de tableaux</title>

  <indexterm>
   <primary>IN</primary>
  </indexterm>

  <indexterm>
   <primary>NOT IN</primary>
  </indexterm>

  <indexterm>
   <primary>ANY</primary>
  </indexterm>

  <indexterm>
   <primary>ALL</primary>
  </indexterm>

  <indexterm>
   <primary>SOME</primary>
  </indexterm>

  <indexterm>
   <primary>comparaison par ligne</primary>
  </indexterm>

  <indexterm>
   <primary>comparaison</primary>
   <secondary>par ligne</secondary>
  </indexterm>

  <indexterm>
   <primary>IS DISTINCT FROM</primary>
  </indexterm>

  <indexterm>
   <primary>IS NOT DISTINCT FROM</primary>
  </indexterm>

  <para>
   Cette section décrit des constructions adaptées aux
   comparaisons entre groupes de valeurs. Ces formes sont
   syntaxiquement liées aux formes des sous-requêtes de la section
   précédente, mais elles n'impliquent pas de sous-requêtes. Les formes qui
   impliquent des sous-expressions de tableaux sont des extensions de
   <productname>PostgreSQL</productname>&nbsp;; le reste est compatible avec
   <acronym>SQL</acronym>. Toutes les formes d'expression documentées dans cette
   section renvoient des résultats booléens (true/false).
  </para>

  <sect2>
   <title><literal>IN</literal></title>

<synopsis><replaceable>expression</replaceable> IN (<replaceable>valeur</replaceable> <optional>, ...</optional>)</synopsis>

  <para>
   Le côté droit est une liste entre parenthèses d'expressions scalaires. Le
   résultat est vrai (<quote>true</quote>) si le côté gauche de l'expression
   est égal à une des expressions du côté droit. C'est une notation raccourcie
   de

<synopsis><replaceable>expression</replaceable> = <replaceable>valeur1</replaceable>
OR
<replaceable>expression</replaceable> = <replaceable>valeur2</replaceable>
OR
...</synopsis>
  </para>

  <para>
   Si l'expression du côté gauche renvoie NULL, ou s'il n'y a pas
   de valeur égale du côté droit et qu'au moins une expression du côté
   droit renvoie NULL, le résultat de la construction
   <token>IN</token> est NULL et non pas faux. Ceci est en accord avec les
   règles du standard SQL pour les combinaisons booléennes de valeurs NULL.
  </para>
  </sect2>

  <sect2>
   <title><literal>NOT IN</literal></title>

<synopsis><replaceable>expression</replaceable> NOT IN (<replaceable>valeur</replaceable> <optional>, ...</optional>)</synopsis>

  <para>
   Le côté droit est une liste entre parenthèses d'expressions scalaires. Le
   résultat est vrai (<quote>true</quote>) si le résultat de l'expression du côté gauche est
   différent de toutes les expressions du côté droit. C'est une notation
   raccourcie de

<synopsis><replaceable>expression</replaceable> &lt;&gt; <replaceable>valeur1</replaceable>
AND
<replaceable>expression</replaceable> &lt;&gt; <replaceable>valeur2</replaceable>
AND
...</synopsis>
  </para>

  <para>
   Si l'expression du côté gauche renvoie NULL, ou s'il
   existe des valeurs différentes du côté droit et qu'au moins une expression
   du côté droit renvoie NULL, le résultat de la construction
   <token>NOT IN</token> est NULL et non pas vrai. Ceci est en accord avec les
   règles du standard du SQL pour les combinaisons booléennes de valeurs NULL.
  </para>

  <tip>
  <para>
   <literal>x NOT IN y</literal> est équivalent à <literal>NOT (x IN
   y)</literal> dans tout les cas. Néanmoins, les valeurs NULL ont plus de
   chances de surprendre le novice avec <token>NOT IN</token> qu'avec
   <token>IN</token>. Quand cela est possible, il est préférable d'exprimer
   la condition de façon positive.
  </para>
  </tip>
  </sect2>

  <sect2>
   <title><literal>ANY</literal>/<literal>SOME</literal> (array)</title>

<synopsis><replaceable>expression</replaceable> <replaceable>opérateur</replaceable> ANY (<replaceable>expression tableau</replaceable>)
<replaceable>expression</replaceable> <replaceable>opérateur</replaceable> SOME (<replaceable>expression tableau</replaceable>)</synopsis>

  <para>
   Le côté droit est une expression entre parenthèses qui doit renvoyer une
   valeur de type array. L'expression du côté gauche est évaluée et comparée à
   chaque élément du tableau en utilisant l'<replaceable>opérateur</replaceable>
   donné, qui doit renvoyer un résultat booléen. Le résultat de
   <token>ANY</token> est vrai (<quote>true</quote>) si un résultat vrai est obtenu. Le
   résultat est faux (<quote>false</quote>) si aucun résultat vrai n'est trouvé
   (ce qui inclut le cas spécial du tableau qui ne contient aucun élément).
  </para>

  <para>
   Si l'expression de tableau ramène un tableau NULL, le résultat de
   <token>ANY</token> est NULL. Si l'expression du côté gauche retourne
   NULL, le résultat de <token>ANY</token> est habituellement NULL (bien qu'un
   opérateur de comparaison non strict puisse conduire à un résultat différent).
   De plus, si le tableau du côté droit contient des éléments NULL et qu'aucune
   comparaison vraie n'est obtenue, le résultat de <token>ANY</token> est NULL,
   et non pas faux (<quote>false</quote>) (là aussi avec l'hypothèse d'un opérateur de comparaison
   strict). Ceci est en accord avec les règles du standard SQL pour les
   combinaisons booléennes de valeurs NULL.
  </para>

  <para>
   <token>SOME</token> est un synonyme de <token>ANY</token>.
  </para>
  </sect2>

  <sect2>
   <title><literal>ALL</literal> (array)</title>

<synopsis><replaceable>expression</replaceable> <replaceable>opérateur</replaceable> ALL (<replaceable>expression tableau</replaceable>)</synopsis>

  <para>
   Le côté droit est une expression entre parenthèses qui doit renvoyer une
   valeur de type tableau. L'expression du côté gauche est évaluée et comparée à
   chaque élément du tableau à l'aide de l'<replaceable>opérateur</replaceable>
   donné, qui doit renvoyer un résultat booléen. Le résultat de <token>ALL</token>
   est vrai (<quote>true</quote>) si toutes les comparaisons renvoient vrai (ce
   qui inclut le cas spécial du tableau qui ne contient aucun élément). Le résultat est faux
   (<quote>false</quote>) si un résultat faux est trouvé.
  </para>

  <para>
   Si l'expression de tableau ramène un tableau NULL, le résultat de
   <token>ALL</token> est NULL. Si l'expression du côté gauche retourne
   NULL, le résultat de <token>ALL</token> est habituellement NULL (bien qu'un
   opérateur de comparaison non strict puisse conduire à un résultat différent).
   De plus, si le tableau du côté droit contient des éléments NULL et qu'aucune
   comparaison false n'est obtenue, le résultat de <token>ALL</token> est NULL,
   et non pas true (là aussi avec l'hypothèse d'un opérateur de comparaison
   strict). Ceci est en accord avec les règles du standard SQL pour les
   combinaisons booléennes de valeurs NULL.
  </para>
  </sect2>

  <sect2 id="row-wise-comparison">
   <title>Comparaison de lignes entières</title>

<synopsis><replaceable>constructeur_ligne</replaceable> opérateur <replaceable>constructeur_ligne</replaceable></synopsis>

  <para>
   Chaque côté est un constructeur de lignes, tel que décrit dans la <xref
   linkend="sql-syntax-row-constructors"/>. Les deux valeurs de lignes doivent
   avoir le même nombre de lignes.  Chaque côté est évalué. Ils sont alors
   comparés sur toute la ligne. Les comparaisons de lignes sont autorisées
   quand l'<replaceable>opérateur</replaceable> est
   <literal>=</literal>,
   <literal>&lt;&gt;</literal>,
   <literal>&lt;</literal>,
   <literal>&lt;=</literal>,
   <literal>&gt;</literal>,
   <literal>&gt;=</literal>,
   ou a une sémantique similaire à l'un d'eux. (Pour être précis, un opérateur
   peut être un opérateur de comparaison de ligne s'il est membre d'une classe
   d'opérateurs B-Tree ou est le négateur du membre <literal>=</literal> d'une classe
   d'opérateurs B-Tree.)
  </para>

  <para>
   Les cas <literal>=</literal> et <literal>&lt;&gt;</literal> fonctionnent
   légèrement différemment des autres. Les lignes sont
   considérées égales si leurs membres correspondants sont non-nuls et
   égaux&nbsp;; les lignes sont différentes si des membres correspondants sont
   non-nuls et différents&nbsp;; autrement, le résultat de la comparaison de ligne est
   inconnu (NULL).
  </para>

  <para>
   Pour les cas <literal>&lt;</literal>, <literal>&lt;=</literal>,
   <literal>&gt;</literal> et <literal>&gt;=</literal>, les éléments de ligne
   sont comparés de gauche à droite. La comparaison s'arrête dès qu'une paire
   d'éléments différents ou NULL est découverte. Si un des éléments de cette paire est NULL,
   le résultat de la comparaison de la ligne est inconnu, donc NULL&nbsp;; sinon
   la comparaison de cette paire d'éléments détermine le résultat. Par exemple,
   <literal>ROW(1,2,NULL) &lt; ROW(1,3,0)</literal>
   est vrai, non NULL, car la troisième paire d'éléments n'est pas considérée.
  </para>

  <note>
   <para>
    Avant <productname>PostgreSQL</productname> 8.2, les cas
    <literal>&lt;</literal>, <literal>&lt;=</literal>, <literal>&gt;</literal>
    et <literal>&gt;=</literal> n'étaient pas gérés d'après les spécifications
    SQL. Une comparaison comme <literal>ROW(a,b) &lt; ROW(c,d)</literal>
    était codée sous la forme <literal>a &lt; c AND b &lt; d</literal> alors que
    le bon comportement est équivalent à
    <literal>a &lt; c OR (a = c AND b &lt; d)</literal>.
   </para>
  </note>

  <synopsis><replaceable>constructeur_ligne</replaceable> IS DISTINCT FROM <replaceable>constructeur_ligne</replaceable></synopsis>

  <para>
    Cette construction est similaire à une comparaison de ligne
    <literal>&lt;&gt;</literal>, mais elle ne conduit pas à un résultat NULL pour des
    entrées NULL. Au lieu de cela, une valeur NULL est considérée différente
    (distincte) d'une valeur non-NULL et deux valeurs NULL sont considérées
    égales (non distinctes). Du coup, le résultat est toujours soit
    true soit false, jamais NULL.
  </para>

<synopsis>
<replaceable>constructeur_ligne</replaceable> IS NOT DISTINCT FROM <replaceable>constructeur_ligne</replaceable>
</synopsis>

  <para>
   Cette construction est similaire à une comparaison de lignes
   <literal>=</literal>, mais elle ne conduit pas à un résultat NULL pour des
   entrées NULL. Au lieu de cela, une valeur NULL est considérée différente
   (distincte) d'une valeur non NULL et deux valeurs NULL sont considérées
   identiques (non distinctes). Du coup, le résultat
   est toujours soit true soit false, jamais NULL.
  </para>

  <note>
   <para>
    Le standard SQL requiert qu'une comparaison d'une ligne complète renvoit
    NULL si le résultat dépend de la comparaison de deux valeurs NULL ou d'une
    valeur NULL et d'une valeur non NULL. <productname>PostgreSQL</productname>
    le fait en comparant le résultat de deux constructeurs de lignes ou en
    comparant un constructeur de ligne avec le résultat d'une sous-requête
    (comme dans <xref linkend="functions-subquery"/>). Dans d'autres contextes
    où deux valeurs de type composite sont comparées, deux champs NULL sont
    considérés égaux, et un champ NULL est considéré plus grand qu'un champ
    non NULL. Ceci est nécessaire pour voir un comportement de tri et
    d'indexage cohérent pour les types composites.
   </para>
  </note>

  </sect2>
</sect1>

<sect1 id="functions-srf">
  <title>Fonctions retournant des ensembles</title>
  
  <indexterm zone="functions-srf">
    <primary>fonctions retournant des ensembles</primary>
    <secondary>fonctions</secondary>
  </indexterm>
  
  <indexterm>
   <primary>generate_series</primary>
  </indexterm>

  <para>
    Cette section décrit des fonctions qui peuvent renvoyer plus d'une
    ligne. Actuellement, les seules fonctions dans cette classe sont les
    fonctions de génération de séries, détaillées dans le <xref
    linkend="functions-srf-series"/> et
   <xref linkend="functions-srf-subscripts"/>.
  </para>
    
    <table id="functions-srf-series">
      <title>Fonctions de génération de séries</title>
      <tgroup cols="4">
      <colspec colnum="1" colwidth="2*"/>
      <colspec colnum="2" colwidth="1*"/>
      <colspec colnum="3" colwidth="1*"/>
      <colspec colnum="4" colwidth="3*"/>
        <thead>
          <row>
            <entry>Fonction</entry>
            <entry>Type d'argument</entry>
            <entry>Type de retour</entry>
            <entry>Description</entry>
          </row>
        </thead>
        
        <tbody>
          <row>
            <entry><literal><function>generate_series</function> (<parameter>début</parameter>, <parameter>fin</parameter>)</literal></entry>
            <entry><type>int</type> ou <type>bigint</type></entry>
            <entry><type>setof int</type> ou <type>setof bigint</type>
             (même type que l' argument)</entry>
            <entry>
              Produit une série de valeurs, de <parameter>début</parameter> à
              <parameter>fin</parameter> avec un incrément de un.
            </entry>
          </row>
          
          <row>
            <entry><literal><function>generate_series</function> (<parameter>début</parameter>, <parameter>fin</parameter>, <parameter>pas</parameter>)</literal></entry>
            <entry><type>int</type> ou <type>bigint</type></entry>
            <entry><type>setof int</type> ou <type>setof bigint</type>
             (même type que l'argument)</entry>
            <entry>
              Produit une série de valeurs, de <parameter>début</parameter> à
              <parameter>fin</parameter> avec un incrément de <parameter>pas</parameter>.
            </entry>
          </row>

     <row>
      <entry><literal><function>generate_series</function>(<parameter>début</parameter>, <parameter>fin</parameter>, <parameter>pas</parameter> <type>interval</type>)</literal></entry>
      <entry><type>timestamp</type> or <type>timestamp with time zone</type></entry>
      <entry><type>setof timestamp</type> ou <type>setof timestamp with time zone</type> (identique au type de l'argument)</entry>
      <entry>
       Génère une série de valeurs, allant de <parameter>start</parameter> à
       <parameter>stop</parameter> avec une taille pour chaque étape de
       <parameter>pas</parameter>
      </entry>
     </row>
          
        </tbody>
      </tgroup>
    </table>
    
    <para>
      Quand <parameter>pas</parameter> est positif, aucune ligne n'est
      renvoyée si <parameter>début</parameter> est supérieur à
      <parameter>fin</parameter>. À l'inverse, quand
      <parameter>pas</parameter> est négatif, aucune ligne n'est renvoyée
      si <parameter>début</parameter> est inférieur à
      <parameter>fin</parameter>. De même, aucune ligne n'est renvoyée pour
      les entrées <literal>NULL</literal>. Une erreur est levée si
      <parameter>pas</parameter> vaut zéro.
    </para>
    
    <para>
     Quelques exemples&nbsp;:
      <programlisting>SELECT * FROM generate_series(2,4);
 generate_series
-----------------
 2
 3
 4
(3 rows)

SELECT * FROM generate_series(5,1,-2);
 generate_series
-----------------
 5
 3
 1
(3 rows)

SELECT * FROM generate_series(4,3);
 generate_series
-----------------
(0 rows)

-- cet exemple se base sur l'opérateur date-plus-entier
SELECT current_date + s.a AS dates FROM generate_series(0,14,7) AS s(a);
    dates
------------
 2004-02-05
 2004-02-12
 2004-02-19
(3 rows)

SELECT * FROM generate_series('2008-03-01 00:00'::timestamp,
                              '2008-03-04 12:00', '10 hours');
   generate_series   
---------------------
 2008-03-01 00:00:00
 2008-03-01 10:00:00
 2008-03-01 20:00:00
 2008-03-02 06:00:00
 2008-03-02 16:00:00
 2008-03-03 02:00:00
 2008-03-03 12:00:00
 2008-03-03 22:00:00
 2008-03-04 08:00:00
(9 rows)</programlisting>
    </para>

  <table id="functions-srf-subscripts">
   <title>Fonctions de génération d'indices</title>
   <tgroup cols="3">
   <colspec colnum="1" colwidth="2*"/>
   <colspec colnum="2" colwidth="1*"/>
   <colspec colnum="3" colwidth="3*"/>
    <thead>
     <row>
      <entry>Nom</entry>
      <entry>Type de retour</entry>
      <entry>Description</entry>
     </row>
    </thead>

    <tbody>
     <row>
      <entry><literal><function>generate_subscripts</function>(<parameter>array anyarray</parameter>, <parameter>dim int</parameter>)</literal></entry>
      <entry><type>setof int</type></entry>
      <entry>
       Génère une série comprenant les indices du tableau donné.
      </entry>
     </row>

     <row>
      <entry><literal><function>generate_subscripts</function>(<parameter>array anyarray</parameter>, <parameter>dim int</parameter>, <parameter>reverse boolean</parameter>)</literal></entry>
      <entry><type>setof int</type></entry>
      <entry>
       Génère une série comprenant les indices du tableau donné. Quand
       <parameter>reverse</parameter> vaut true, la série est renvoyé en ordre
       inverse.
      </entry>
     </row>

    </tbody>
   </tgroup>
  </table>

  <indexterm>
   <primary>generate_subscripts</primary>
  </indexterm>

  <para>
   <function>generate_subscripts</function> est une fonction qui génère un
   ensemble d'indices valides pour la dimension indiquée du tableau
   fourni.
   Aucune ligne n'est renvoyée pour les tableaux qui n'ont pas la dimension
   requise ou pour les tableaux NULL (mais les indices valides sont renvoyées
   pour les éléments d'un tableau NULL). Quelques exemples suivent&nbsp;:
<programlisting>
-- usage basique
select generate_subscripts('{NULL,1,NULL,2}'::int[], 1) as s;
 s 
---
 1
 2
 3
 4
(4 rows)

-- presenting an array, the subscript and the subscripted
-- value requires a subquery
select * from arrays;
         a          
--------------------
 {-1,-2}
 {100,200}
(2 rows)

select a as array, s as subscript, a[s] as value
from (select generate_subscripts(a, 1) as s, a from arrays) foo;
   array   | subscript | value 
-----------+-----------+-------
 {-1,-2}   |         1 |    -1
 {-1,-2}   |         2 |    -2
 {100,200} |         1 |   100
 {100,200} |         2 |   200
(4 rows)

-- tableau 2D
create or replace function unnest2(anyarray)
returns setof anyelement as $$
select $1[i][j] 
   from generate_subscripts($1,1) g1(i),
        generate_subscripts($1,2) g2(j);
$$ language sql immutable;
CREATE FUNCTION
postgres=# select * from unnest2(array[[1,2],[3,4]]);
 unnest2 
---------
       1
       2
       3
       4
(4 rows)
</programlisting>
  </para>

  </sect1>

  <sect1 id="functions-info">
    <title>Fonctions d'informations système</title>

    <para>
      Le <xref linkend="functions-info-session-table"/> présente diverses
      fonctions qui extraient des informations de session et système.
      </para>

  <para>
   En plus des fonctions listées dans cette section, il existe plusieurs
   fonctions relatives au système de statistiques qui fournissent aussi
   des informations système. Voir <xref linkend="monitoring-stats-views"/>
   pour plus d'informations.
  </para>

      <table id="functions-info-session-table">
        <title>Fonctions d'information de session</title>
        <tgroup cols="3">
         <colspec colnum="1" colwidth="1.0*"/>
         <colspec colnum="2" colwidth="0.8*"/>
         <colspec colnum="3" colwidth="1.2*"/>
          <thead>
            <row>
              <entry>Nom</entry>
              <entry>Type de retour</entry>
              <entry>Description</entry>
            </row>
          </thead>

          <tbody>
            <row>
             <entry><literal><function>current_catalog</function></literal></entry>
             <entry><type>name</type></entry>
             <entry>nom de la base de données en cours (appelée
	      <quote>catalog</quote> dans le standard SQL)</entry>
            </row>

            <row>
              <entry><literal><function>current_database</function>()</literal></entry>
              <entry><type>nom</type></entry>
              <entry>nom de la base de données courante</entry>
            </row>

            <row>
              <entry><literal><function>current_schema</function>[()]</literal></entry>
              <entry><type>nom</type></entry>
              <entry>nom du schéma courant</entry>
            </row>

            <row>
              <entry><literal><function>current_schemas</function>(<type>boolean</type>)</literal></entry>
              <entry><type>nom[]</type></entry>
              <entry>nom des schémas dans le chemin de recherche, avec
	      optionnellement les schémas implicites</entry>
            </row>

            <row>
              <entry><literal><function>current_user</function></literal></entry>
              <entry><type>nom</type></entry>
              <entry>nom d'utilisateur du contexte d'exécution courant</entry>
            </row>

            <row>
             <entry><literal><function>current_query</function></literal></entry>
             <entry><type>text</type></entry>
             <entry>texte la requête en cours d'exécution, tel qu'elle a été
	      soumise par le client (pourrait contenir plus d'une instruction)
	      </entry>
            </row>  

            <row>
             <!-- See also the entry for this in monitoring.sgml -->
             <entry><literal><function>pg_backend_pid</function>()</literal></entry>
             <entry><type>int</type></entry>
             <entry>Identifiant du processus serveur attaché à la session en
	      cours
             </entry>
      </row>

            <row>
              <entry><literal><function>inet_client_addr</function>()</literal></entry>
              <entry><type>inet</type></entry>
              <entry>adresse de la connexion distante</entry>
            </row>

            <row>
              <entry><literal><function>inet_client_port</function>()</literal></entry>
              <entry><type>int</type></entry>
              <entry>port de la connexion distante</entry>
            </row>

            <row>
              <entry><literal><function>inet_server_addr</function>()</literal></entry>
              <entry><type>inet</type></entry>
              <entry>adresse de la connexion locale</entry>
            </row>

            <row>
              <entry><literal><function>inet_server_port</function>()</literal></entry>
              <entry><type>int</type></entry>
              <entry>port de la connexion locale</entry>
            </row>

            <row>
              <entry><literal><function>pg_my_temp_schema</function>()</literal></entry>
              <entry><type>oid</type></entry>
              <entry>OID du schéma temporaire de la session, 0 si aucun</entry>
            </row>

            <row>
              <entry><literal><function>pg_is_other_temp_schema</function>(<type>oid</type>)</literal></entry>
              <entry><type>boolean</type></entry>
              <entry>s'agit-il du schéma temporaire d'une autre session&nbsp;?</entry>
            </row>

            <row>
              <entry><literal><function>pg_postmaster_start_time</function>()</literal></entry>
              <entry><type>timestamp with time zone</type></entry>
              <entry>heure de démarrage du serveur</entry>
            </row>

            <row>
             <entry><literal><function>pg_conf_load_time</function>()</literal></entry>
             <entry><type>timestamp with time zone</type></entry>
             <entry>heure de chargement de la configuration</entry>
            </row>

            <row>
              <entry><literal><function>session_user</function></literal></entry>
              <entry><type>name</type></entry>
              <entry>nom de l'utilisateur de session</entry>
            </row>

            <row>
              <entry><literal><function>user</function></literal></entry>
              <entry><type>name</type></entry>
              <entry>équivalent à <function>current_user</function></entry>
            </row>

            <row>
              <entry><literal><function>version</function>()</literal></entry>
              <entry><type>text</type></entry>
              <entry>informations de version de <productname>PostgreSQL</productname></entry>
            </row>
          </tbody>
        </tgroup>
      </table>

      <note>
        <para>
          <function>current_catalog</function>, <function>current_schema</function>,
          <function>current_user</function>, <function>session_user</function>,
          et <function>user</function> ont un statut syntaxique spécial en
          <acronym>SQL</acronym>&nbsp;: ils doivent être appelés sans
          parenthèses à droite (optionnel avec PostgreSQL dans le cas de
          <function>current_schema</function>).
        </para>
      </note>

      <indexterm>
        <primary>user</primary>
        <secondary>en cours</secondary>
      </indexterm>

      <indexterm>
        <primary>schéma</primary>
        <secondary>en cours</secondary>
      </indexterm>

      <indexterm>
        <primary>chemin de recherche</primary>
        <secondary>en cours</secondary>
      </indexterm>
      
   <indexterm>
    <primary>current_catalog</primary>
   </indexterm>

   <indexterm>
    <primary>current_database</primary>
   </indexterm>

   <indexterm>
    <primary>current_schema</primary>
   </indexterm>

   <indexterm>
    <primary>current_user</primary>
   </indexterm>

      <para>
        <function>session_user</function> est habituellement l'utilisateur
        qui a initié la connexion à la base de données&nbsp;; mais les
        superutilisateurs peuvent modifier ce paramétrage avec
	<xref linkend="sql-set-session-authorization" endterm="sql-set-session-authorization-title"/>.
        <function>current_user</function> est l'identifiant de l'utilisateur,
        utilisable pour les vérifications de permissions. Il est habituellement
	identique à l'utilisateur de la session, mais il peut être modifié avec
	<xref linkend="sql-set-role" endterm="sql-set-role-title"/>. Il change
	aussi pendant l'exécution des fonctions comprenant l'attribut <literal>SECURITY
        DEFINER</literal>. En langage Unix, l'utilisateur de la session
        est le <quote>real user</quote> (NdT&nbsp;: l'utilisateur réel) et
        l'utilisateur courant est l'<quote>effective user</quote>
        (NdT&nbsp;: l'utilisateur effectif) .
      </para>

      <para>
        <function>current_schema</function> renvoie le nom du premier
        schéma dans le chemin de recherche (ou une valeur NULL si ce dernier
        est vide). C'est le schéma utilisé pour toute création de table ou
        autre objet nommé sans précision d'un schéma cible.
        <function>current_schemas(boolean)</function> renvoie un tableau
        qui contient les noms de tous les schémas du chemin de recherche. L'option
        booléenne indique si les schémas système implicitement inclus,
        comme <literal>pg_catalog</literal>, doivent être inclus dans le chemin de
        recherche retourné.
      </para>
      
      <note>
        <para>
          Le chemin de recherche est modifiable à l'exécution. La commande
          est&nbsp;:
<programlisting>SET search_path TO <replaceable>schema</replaceable> <optional>, <replaceable>schema</replaceable>, ...</optional></programlisting>
        </para>
      </note>
  
  <indexterm>
    <primary>inet_client_addr</primary>
  </indexterm>
  
  <indexterm>
    <primary>inet_client_port</primary>
  </indexterm>
  
  <indexterm>
    <primary>inet_server_addr</primary>
  </indexterm>
  
  <indexterm>
    <primary>inet_server_port</primary>
  </indexterm>
  
  <para>
    <function>inet_client_addr</function> renvoie l'adresse IP du client
    courant et <function>inet_client_port</function> le numéro du port.
    <function>inet_server_addr</function> renvoie l'adresse IP sur laquelle
    le serveur a accepté la connexion courante et 
    <function>inet_server_port</function> le numéro du port. Toutes
    ces fonctions renvoient NULL si la connexion courante est établie via
    une socket de domaine Unix.
  </para>
  
   <indexterm>
    <primary>pg_my_temp_schema</primary>
   </indexterm>

   <indexterm>
    <primary>pg_is_other_temp_schema</primary>
   </indexterm>

   <para>
    <function>pg_my_temp_schema</function> renvoie l'OID du schéma
    temporaire de la session courante, ou 0 s'il n'existe pas (parce qu'il
    n'y a pas eu de création de tables temporaires).
    <function>pg_is_other_temp_schema</function> renvoie true si l'OID donné
    est l'OID d'un schéma temporaire d'une autre session. (Ceci peut être
    utile pour exclure les tables temporaires d'autres sessions lors de
    l'affichage d'un catalogue, par exemple.)
   </para>

   <indexterm>
    <primary>pg_postmaster_start_time</primary>
   </indexterm>

   <para>
     <function>pg_postmaster_start_time</function> renvoie la date et l'heure
     (type <type>timestamp with time zone</type>) de démarrage du serveur.
   </para>

   <indexterm>
    <primary>pg_conf_load_time</primary>
   </indexterm>

   <para>
    <function>pg_conf_load_time</function> renvoit <type>timestamp with time
    zone</type> indiquant à quel moment les fichiers de configuration du
    serveur ont été chargés. (Si la session en cours était déjà là à ce
    moment, ce sera le moment où la sessions elle-même a relu les fichiers
    de configurations. Cela veut dire que ce que renvoit cette fonction
    peut varier un peu suivant les sessions. Sinon, c'est le temps où le
    processus maître a relu les fichiers de configuration.)
   </para>

  <indexterm>
    <primary>version</primary>
  </indexterm>
  
  <para>
    <function>version</function> renvoie une chaîne qui décrit la version
    du serveur <productname>PostgreSQL</productname>.
  </para>
  
  <indexterm>
    <primary>droit</primary>
    <secondary>requête</secondary>
  </indexterm>
  
  <para>
    Le <xref linkend="functions-info-access-table"/> liste les fonctions qui
    permettent aux utilisateurs de consulter les privilèges d'accès. Voir la
    <xref linkend="ddl-priv"/> pour plus d'informations sur les privilèges.
  </para>
      
  <table id="functions-info-access-table">
    <title>Fonctions de consultation des privilèges d'accès</title>
    <tgroup cols="3">
    <thead>
      <row>
        <entry>Nom</entry>
        <entry>Type de retour</entry>
        <entry>Description</entry>
      </row>
    </thead>
          
    <tbody>
      <row>
       <entry><literal><function>has_any_column_privilege</function>(<parameter>user</parameter>,
                                  <parameter>table</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur a-t-il un droit sur une des colonnes de cette table
       </entry>
      </row>
      <row>
       <entry><literal><function>has_any_column_privilege</function>(<parameter>table</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur actuel a-t-il un droit sur une des colonnes de
        cette table</entry>
      </row>
      <row>
       <entry><literal><function>has_column_privilege</function>(<parameter>user</parameter>,
                                  <parameter>table</parameter>,
                                  <parameter>column</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur a-t-il un droit sur la colonne</entry>
      </row>
      <row>
       <entry><literal><function>has_column_privilege</function>(<parameter>table</parameter>,
                                  <parameter>column</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur actuel a-t-il un droit sur la colonne</entry>
      </row>
      <row>
        <entry><literal><function>has_database_privilege</function>
          (<parameter>utilisateur</parameter>,
          <parameter>base</parameter>,
          <parameter>privilège</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry><parameter>utilisateur</parameter> a-t-il le privilège
	<parameter>privilège</parameter> sur <parameter>base</parameter></entry>
      </row>
      <row>
        <entry><literal><function>has_database_privilege</function>
          (<parameter>base</parameter>,
          <parameter>privilège</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry>l'utilisateur courant a-t-il le privilège
	        <parameter>privilège</parameter> sur
		<parameter>base</parameter></entry>
      </row>
      <row>
       <entry><literal><function>has_foreign_data_wrapper_privilege</function>(<parameter>user</parameter>,
                                  <parameter>fdw</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur a-t-il un droit sur ce wrapper de données distantes
       </entry>
      </row>
      <row>
       <entry><literal><function>has_foreign_data_wrapper_privilege</function>(<parameter>fdw</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur actuel a-t-il un droit sur ce wrapper de données
        distantes</entry>
      </row>
      <row>
        <entry><literal><function>has_function_privilege</function>
          (<parameter>utilisateur</parameter>,
          <parameter>fonction</parameter>,
          <parameter>privilège</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry><parameter>utilisateur</parameter> a-t-il le privilège
	        <parameter>privilège</parameter> sur
		<parameter>fonction</parameter></entry>
      </row>
      <row>
        <entry><literal><function>has_function_privilege</function>
          (<parameter>fonction</parameter>,
          <parameter>privilège</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry>l'utilisateur courant a-t-il e privilège
	        <parameter>privilège</parameter> sur
		<parameter>fonction</parameter></entry>
      </row>
      <row>
        <entry><literal><function>has_language_privilege</function>
          (<parameter>utilisateur</parameter>,
          <parameter>langage</parameter>,
          <parameter>privilège</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry><parameter>utilisateur</parameter> a-t-il le privilège
	<parameter>privilège</parameter> sur <parameter>langage</parameter></entry>
      </row>
      <row>
        <entry><literal><function>has_language_privilege</function>
          (<parameter>langage</parameter>,
          <parameter>droit</parameter>)</literal>
        </entry>
        <entry><type>boolean</type></entry>
        <entry>l'utilisateur courant a-t-il le privilège
	<parameter>privilège</parameter> sur <parameter>langage</parameter></entry>
      </row>
      <row>
       <entry><literal><function>has_schema_privilege</function>(<parameter>utilisateur</parameter>,
                                  <parameter>schéma</parameter>,
                                  <parameter>privilège</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry><parameter>utilisateur</parameter> a-t-il le privilège
       <parameter>privilège</parameter> sur <parameter>schéma</parameter></entry>
      </row>
      <row>
       <entry><literal><function>has_schema_privilege</function>(<parameter>schéma</parameter>,
                                  <parameter>privilège</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur courant a-t-il le privilège
              <parameter>privilège</parameter> sur
	      <parameter>schéma</parameter></entry>
      </row>
      <row>
       <entry><literal><function>has_server_privilege</function>(<parameter>user</parameter>,
                                  <parameter>server</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur a-t-il un droit sur ce serveur distant</entry>
      </row>
      <row>
       <entry><literal><function>has_server_privilege</function>(<parameter>server</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur actuel a-t-il un droit sur ce serveur distant</entry>
      </row>
      <row>
       <entry><literal><function>has_table_privilege</function>(<parameter>utilisateur</parameter>,
                                  <parameter>table</parameter>,
                                  <parameter>privilège</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry><parameter>utilisateur</parameter> a-t-il le privilège
       <parameter>privilège</parameter> sur <parameter>table</parameter></entry>
      </row>
      <row>
       <entry><literal><function>has_table_privilege</function>(<parameter>table</parameter>,
                                  <parameter>privilege</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur courant a-t-il le privilège
              <parameter>privilège</parameter> sur <parameter>table</parameter></entry>
      </row>
        <row>
          <entry><literal><function>has_tablespace_privilege</function>
            (<parameter>utilisateur</parameter>, <parameter>tablespace</parameter>,
            <parameter>privilège</parameter>)</literal>
          </entry>
          <entry><type>boolean</type></entry>
          <entry><parameter>utilisateur</parameter> a-t-il le privilège
	  <parameter>privilège</parameter> sur
	  <parameter>tablespace</parameter></entry>
        </row>
        <row>
          <entry><literal><function>has_tablespace_privilege</function>
            (<parameter>tablespace</parameter>,
            <parameter>privilège</parameter>)</literal>
          </entry>
          <entry><type>boolean</type></entry>
          <entry>l'utilisateur courant a-t-il le privilège
	         <parameter>privilège</parameter> sur
	         <parameter>tablespace</parameter></entry>
        </row>
      <row>
       <entry><literal><function>pg_has_role</function>(<parameter>utilisateur</parameter>,
                                  <parameter>rôle</parameter>,
                                  <parameter>privilège</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry><parameter>utilisateur</parameter> a-t-il le privilège
                 <parameter>privilège</parameter> sur
		 <parameter>rôle</parameter></entry>
      </row>
      <row>
       <entry><literal><function>pg_has_role</function>(<parameter>rôle</parameter>,
                                  <parameter>privilège</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'utilisateur courant a-t-il le privilège
                <parameter>privilège</parameter> sur
		<parameter>rôle</parameter></entry>
      </row>
        </tbody>
        </tgroup>
      </table>

   <indexterm>
    <primary>has_any_column_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_column_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_database_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_function_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_foreign_data_wrapper_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_language_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_schema_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_server_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_table_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>has_tablespace_privilege</primary>
   </indexterm>
   <indexterm>
    <primary>pg_has_role</primary>
   </indexterm>
   
   <para>
    <function>has_table_privilege</function> vérifie si l'utilisateur possède
    un privilège particulier d'accès à une table. L'utilisateur peut être
    indiqué par son nom ou son OID (<literal>pg_authid.oid</literal>). Si
    l'argument est omis, <function>current_user</function> est utilisé. La table
    peut être indiquée par son nom ou par son OID. (Il existe donc six
    versions de <function>has_table_privilege</function> qui se distinguent
    par le nombre et le type de leurs arguments.) Lors de l'indication par
    nom, il est possible de préciser le schéma. Les privilèges possibles,
    indiqués sous la forme d'une chaîne de caractères, sont&nbsp;:
    <literal>SELECT</literal>, <literal>INSERT</literal>,
    <literal>UPDATE</literal>, <literal>DELETE</literal>,
    <literal>TRUNCATE</literal>, <literal>REFERENCES</literal> ou
    <literal>TRIGGER</literal>. En option, <literal>WITH GRANT OPTION</literal>
    peut être ajouté à un type de droit pour tester si le droit est obtenu
    avec l'option « grant ». De plus, plusieurs types de droit peuvent être
    listés, séparés par des virgules, auquel cas le résultat sera
    <literal>true</literal> si un des droits listés est obtenu. (la casse des
    droits n'a pas d'importance et les espaces blancs supplémentaires sont
    autorisés entre mais pas dans le nom des droits.)
    Certains exemples&nbsp;:
<programlisting>
SELECT has_table_privilege('myschema.mytable', 'select');
SELECT has_table_privilege('joe', 'mytable', 'INSERT, SELECT WITH GRANT OPTION');
</programlisting>
   </para>

   <para>
    <function>has_any_column_privilege</function> vérifie si un utilisateur
    peut accéder à une colonne d'une table d'une façon particulière. Les
    possibilités pour que ces arguments correspondent à ceux de
    <function>has_table_privilege</function>, sauf que le type de droit d'accès
    désiré doit être évalué à une combinaison de
    <literal>SELECT</literal>, <literal>INSERT</literal>,
    <literal>UPDATE</literal> ou <literal>REFERENCES</literal>. Notez qu'avoir
    un droit au niveau de la table le donne implicitement pour chaque colonne de
    la table, donc <function>has_any_column_privilege</function> renverra
    toujours <literal>true</literal> si <function>has_table_privilege</function>
    le fait pour les mêmes arguments. Mais
    <function>has_any_column_privilege</function> réussit aussi s'il y a un droit
    « grant » sur une colonne pour ce droit.
   </para>

   <para>
    <function>has_column_privilege</function> vérifie si un utilisateur peut
    accéder à une colonne d'une façon particulière. Les possibilités pour
    ses arguments sont analogues à <function>has_table_privilege</function>,
    avec un supplément&nbsp;: la colonne doit être indiquée soit par nom soit
    par numéro d'attribut. Le type de droit d'accès désiré doit être une
    combinaison de <literal>SELECT</literal>, <literal>INSERT</literal>,
    <literal>UPDATE</literal> ou <literal>REFERENCES</literal>. Notez qu'avoir
    un de ces droits au niveau table les donne implicitement pour chaque
    colonne de la table.
   </para>

   <para>
    <function>has_database_privilege</function> vérifie si un utilisateur peut
    accéder à une base de données d'une façon particulière. Les possibilités
    pour ses arguments sont analogues à <function>has_table_privilege</function>.
    Le type de droit d'accès désiré doit être une combinaison de
    <literal>CREATE</literal>, <literal>CONNECT</literal>,
    <literal>TEMPORARY</literal> ou <literal>TEMP</literal> (qui est équivalent
    à <literal>TEMPORARY</literal>).
   </para>

   <para>
    <function>has_function_privilege</function> vérifie si un utilisateur peut
    accéder à une fonction d'une façon particulière. Les possibilités pour ses
    arguments sont analogues à <function>has_table_privilege</function>. Lors
    de la spécification d'une fonction par une chaîne texte plutôt que par un
    OID, l'entrée autorisée est la même que pour le type de données
    <type>regprocedure</type>  (voir <xref linkend="datatype-oid"/>). Le type
    de droit d'accès désiré doit être <literal>EXECUTE</literal>.
    Voici un exemple&nbsp;:
<programlisting>
SELECT has_function_privilege('joeuser', 'myfunc(int, text)', 'execute');
</programlisting>
   </para>

   <para>
    <function>has_foreign_data_wrapper_privilege</function> vérifie si un
    utilisateur peut accéder à un wrapper de données distantes d'une façon
    particulière. Les possibilités pour ses arguments sont analogues à
    <function>has_table_privilege</function>. Le type de droit d'accès désiré
    doit être <literal>USAGE</literal>.
   </para>

   <para>
    <function>has_language_privilege</function> vérifie si un utilisateur peut
    accéder à un langage de procédure d'une façon particulière. Les possibilités
    pour ses arguments sont analogues à <function>has_table_privilege</function>.
    Le type de droit d'accès désiré doit être <literal>USAGE</literal>.
   </para>

   <para>
    <function>has_schema_privilege</function> vérifie si un utilisateur peut
    accéder à un schéma d'une façon particulière. Les possibilités pour ses
    arguments sont analogues à <function>has_table_privilege</function>. Le
    type de droits d'accès désiré doit être une combinaison de
    <literal>CREATE</literal> et <literal>USAGE</literal>.
   </para>

   <para>
    <function>has_server_privilege</function> vérifie si un utilisateur peut
    accéder à un serveur distant d'une façon particulière. Les possibilités
    pour ses arguments sont analogues à <function>has_table_privilege</function>.
    Le type de droit d'accès désiré doit être <literal>USAGE</literal>.
   </para>

   <para>
    <function>has_tablespace_privilege</function> vérifie si l'utilisateur
    possède un privilège particulier d'accès à un
    <foreignphrase>tablespace</foreignphrase>. Ses
    arguments sont analogues à <function>has_table_privilege</function>.
    Le seul privilège possible est <literal>CREATE</literal>.
   </para>

   <para>
    <function>pg_has_role</function> vérifie si l'utilisateur possède
    un privilège particulier d'accès à un rôle. Ses arguments sont
    analogues à <function>has_table_privilege</function>. Le privilège
    doit être une combinaison de <literal>MEMBER</literal> et <literal>USAGE</literal>.
    <literal>MEMBER</literal> indique une appartenance directe ou indirecte au
    rôle (c'est-à-dire le droit d'exécuter <literal>SET ROLE</literal>) alors que
    <literal>USAGE</literal> indique que les droits du rôle sont
    immédiatement disponibles sans avoir à exécuter <literal>SET ROLE</literal>.
   </para>

      <para>
        Le <xref linkend="functions-info-schema-table"/> affiche les fonctions qui
        permettent de savoir si un objet particulier est <firstterm>visible</firstterm> dans le chemin
        de recherche courant. Une table est dite visible si son schéma
        contenant est dans le chemin de recherche et qu'aucune table de même
        nom ne la précède dans le chemin de recherche. C'est équivalent
        au fait que la table peut être référencée par son nom sans qualification
 	explicite de schéma. Par exemple, pour lister les noms de toutes les
	tables visibles&nbsp;:
<programlisting>SELECT relname FROM pg_class WHERE pg_table_is_visible(oid);</programlisting>
      </para>
      
      <table id="functions-info-schema-table">
        <title>Fonctions d'interrogation de visibilité dans les schémas</title>
        <tgroup cols="3">
         <colspec colnum="1" colwidth="1.3*"/>
         <colspec colnum="2" colwidth="0.4*"/>
         <colspec colnum="3" colwidth="1.3*"/>
          <thead>
            <row><entry>Nom</entry> <entry>Type de retour</entry> <entry>Description</entry></row>
          </thead>

          <tbody>
            <row>
              <entry><literal><function>pg_conversion_is_visible</function>
	      (<parameter>conversion_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
	      <entry>la conversion est-elle visible dans le chemin de recherche</entry>
            </row>
            <row>
              <entry><literal><function>pg_function_is_visible</function>
	      (<parameter>function_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
	      <entry>la fonction est-elle visible dans le chemin de recherche</entry>
            </row>
            <row>
              <entry><literal><function>pg_operator_is_visible</function>
	      (<parameter>operator_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
	      <entry>l'opérateur est-il visible dans le chemin de recherche</entry>
            </row>
            <row>
              <entry><literal><function>pg_opclass_is_visible</function>
	      (<parameter>opclass_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
	      <entry>la classe d'opérateur est-elle visible dans le chemin de recherche</entry>
            </row>
            <row>
              <entry><literal><function>pg_table_is_visible</function>(<parameter>table_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
              <entry>la table est-elle visible dans le chemin de recherche</entry>
            </row>
      <row>
       <entry><literal><function>pg_ts_config_is_visible</function>(<parameter>config_oid</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>la configuration de la recherche textuelle est-elle visible dans
       le chemin de recherche</entry>
      </row>
      <row>
       <entry><literal><function>pg_ts_dict_is_visible</function>(<parameter>dict_oid</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>le dictionnaire de recherche textuelle est-il visible dans le
       chemin de recherche</entry>
      </row>
      <row>
       <entry><literal><function>pg_ts_parser_is_visible</function>(<parameter>parser_oid</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>l'analyseur syntaxique de recherche textuelle est-il visible dans
       le chemin de recherche</entry>
      </row>
      <row>
       <entry><literal><function>pg_ts_template_is_visible</function>(<parameter>template_oid</parameter>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>le modèle de recherche textuelle est-il visible dans le chemin de
       recherche</entry>
      </row>
            <row>
              <entry><literal><function>pg_type_is_visible</function>(<parameter>type_oid</parameter>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
              <entry>le type (ou domaine) est-il visible dans le chemin de recherche</entry>
            </row>
          </tbody>
        </tgroup>
      </table>

      <indexterm>
        <primary>pg_conversion_is_visible</primary>
      </indexterm>
      <indexterm>
        <primary>pg_function_is_visible</primary>
      </indexterm>
      <indexterm>
        <primary>pg_operator_is_visible</primary>
      </indexterm>
      <indexterm>
        <primary>pg_opclass_is_visible</primary>
      </indexterm>
      <indexterm>
        <primary>pg_table_is_visible</primary>
      </indexterm>
   <indexterm>
    <primary>pg_ts_config_is_visible</primary>
   </indexterm>
   <indexterm>
    <primary>pg_ts_dict_is_visible</primary>
   </indexterm>
   <indexterm>
    <primary>pg_ts_parser_is_visible</primary>
   </indexterm>
   <indexterm>
    <primary>pg_ts_template_is_visible</primary>
   </indexterm>
      <indexterm>
        <primary>pg_type_is_visible</primary>
      </indexterm>

      <para>
       Chaque fonction vérifie la visibilité d'un type d'objet de la base de 
       données. <function>pg_table_is_visible</function> peut aussi être utilisée avec
	des vues, index et séquences, <function>pg_type_is_visible</function>
	avec les domaines. Pour les fonctions et les
	opérateurs, un objet est visible dans le chemin de recherche si aucun
	objet de même nom <emphasis>et prenant des arguments de mêmes types
	de données</emphasis> n'est précédemment présent dans le chemin de recherche. Pour les
	classes d'opérateurs, on considère à la fois le nom et la méthode
	d'accès à l'index associé.
      </para>

      <para>
	Toutes ces fonctions nécessitent des OID pour identifier les objets
	à vérifier. Pour tester un objet par son nom, il
	est préférable d'utiliser les types d'alias d'OID (<type>regclass</type>,
	<type>regtype</type>, <type>regprocedure</type> ou
	<type>regoperator</type>). Par exemple
 <programlisting>SELECT pg_type_is_visible('mon_schema.widget'::regtype);</programlisting>
	Il n'est pas très utile de tester ainsi un nom non qualifié
	&mdash; si le nom peut être reconnu, c'est qu'il est visible.
      </para>

<indexterm>
  <primary>format_type</primary>
</indexterm>

   <indexterm>
    <primary>pg_get_keywords</primary>
   </indexterm>

<indexterm>
  <primary>pg_get_viewdef</primary>
</indexterm>

<indexterm>
  <primary>pg_get_ruledef</primary>
</indexterm>

   <indexterm>
    <primary>pg_get_functiondef</primary>
   </indexterm>

   <indexterm>
    <primary>pg_get_function_arguments</primary>
   </indexterm>

   <indexterm>
    <primary>pg_get_function_identity_arguments</primary>
   </indexterm>

   <indexterm>
    <primary>pg_get_function_result</primary>
   </indexterm>

<indexterm>
  <primary>pg_get_indexdef</primary>
</indexterm>

<indexterm>
  <primary>pg_get_triggerdef</primary>
</indexterm>

<indexterm>
  <primary>pg_get_constraintdef</primary>
</indexterm>

<indexterm>
  <primary>pg_get_expr</primary>
</indexterm>

<indexterm>
  <primary>pg_get_userbyid</primary>
</indexterm>

<indexterm>
  <primary>pg_get_serial_sequence</primary>
</indexterm>

<indexterm>
  <primary>pg_tablespace_databases</primary>
</indexterm>

   <indexterm>
    <primary>pg_typeof</primary>
   </indexterm>

      <para>
        Le <xref linkend="functions-info-catalog-table"/> liste les fonctions qui
	extraient des informations des catalogues système.
      </para>

      <table id="functions-info-catalog-table">
        <title>Fonctions d'information du catalogue système</title>
          <tgroup cols="3">
          <colspec colnum="1" colwidth="1.3*"/>
          <colspec colnum="2" colwidth="0.4*"/>
          <colspec colnum="3" colwidth="1.3*"/>
          <thead>
            <row><entry>Nom</entry> <entry>Type de retour</entry> <entry>Description</entry></row>
          </thead>

          <tbody>
            <row>
              <entry><literal><function>format_type</function>
	      (<parameter>type_oid</parameter>, <parameter>typemod</parameter>)</literal></entry>
              <entry><type>text</type></entry>
              <entry>récupère le nom SQL d'un type de données</entry>
            </row>
      <row>
       <entry><literal><function>pg_get_keywords</function>()</literal></entry>
       <entry><type>setof record</type></entry>
       <entry>obtient une liste des mots clés SQL et leurs catégories</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_constraintdef</function>(<parameter>constraint_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la définition d'une contrainte</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_constraintdef</function>(<parameter>constraint_oid</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la définition d'une contrainte</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_expr</function>(<parameter>expr_text</parameter>, <parameter>relation_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>décompile la forme interne d'une expression, en supposant que
       toutes les variables qu'elle contient font référence à la relation indiquée par le second paramètre</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_expr</function>(<parameter>expr_text</parameter>, <parameter>relation_oid</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>décompile la forme interne d'une expression, en supposant que
       toutes les variables qu'elle contient font référence à la relation indiquée par le second paramètre</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_functiondef</function>(<parameter>func_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>obtient une définition de la fonction</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_function_arguments</function>(<parameter>func_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>obtient une définition de la liste des arguments de la fonction
        (avec les valeurs par défaut)</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_function_identity_arguments</function> (<parameter>func_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>obtient une définition de la liste des arguments de la fonction
        (sans valeurs par défaut)</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_function_result</function>(<parameter>func_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>obtient la clause <literal>RETURNS</literal> pour la fonction</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_indexdef</function>(<parameter>index_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>CREATE INDEX</command> de l'index</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_indexdef</function>(<parameter>index_oid</parameter>, <parameter>column_no</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>CREATE INDEX</command> pour l'index,
        ou la définition d'une seule colonne d'index quand
        <parameter>column_no</parameter> ne vaut pas zéro</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_ruledef</function>(<parameter>rule_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>CREATE RULE</command> pour une règle</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_ruledef</function>(<parameter>rule_oid</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>CREATE RULE</command> de la règle</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_serial_sequence</function>(<parameter>table_name</parameter>, <parameter>column_name</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère le nom de la séquence qu'une colonne <type>serial</type> ou
        <type>bigserial</type> utilise</entry>
      </row>
      <row>
       <entry><function>pg_get_triggerdef</function>(<parameter>trigger_oid</parameter>)</entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>CREATE [ CONSTRAINT ] TRIGGER</command>
        du déclencheur</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_userbyid</function>(<parameter>role_oid</parameter>)</literal></entry>
       <entry><type>name</type></entry>
       <entry>récupère le nom du rôle possédant cet OID</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_viewdef</function>(<parameter>view_name</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>SELECT</command> sous-jacente à la
        vue (<emphasis>obsolète</emphasis>)</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_viewdef</function>(<parameter>view_name</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>SELECT</command> sous-jacente à la
        vue (<emphasis>obsolète</emphasis>)</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_viewdef</function>(<parameter>view_oid</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>SELECT</command> sous-jacente à la
        vue</entry>
      </row>
      <row>
       <entry><literal><function>pg_get_viewdef</function>(<parameter>view_oid</parameter>, <parameter>pretty_bool</parameter>)</literal></entry>
       <entry><type>text</type></entry>
       <entry>récupère la commande <command>SELECT</command> sous-jacente à la
        vue</entry>
      </row>
      <row>
       <entry><literal><function>pg_tablespace_databases</function>(<parameter>tablespace_oid</parameter>)</literal></entry>
       <entry><type>setof oid</type></entry>
       <entry>récupère l'ensemble des OID des bases qui possèdent des objets dans ce
        tablespace</entry>
      </row>
      <row>
       <entry><literal><function>pg_typeof</function>(<parameter>any</parameter>)</literal></entry>
       <entry><type>regtype</type></entry>
       <entry>obtient le type de données de toute valeur</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

  <para>
   <function>format_type</function> renvoie le nom SQL d'un type de données
   identifié par son OID de type et éventuellement un modificateur
   de type. On passe NULL pour le modificateur de type si aucun modificateur
   spécifique n'est connu.
  </para>

  <para>
   <function>pg_get_keywords</function> renvoit un ensemble d'enregistrements
   décrivant les mots clés SQL reconnus par le serveur. La colonne
   <structfield>word</structfield> contient le mot clé. La colonne
   <structfield>catcode</structfield> contient un code de catégorie&nbsp;:
   <literal>U</literal> pour non réservé, <literal>C</literal> pour nom de
   colonne, <literal>T</literal> pour nom d'un type ou d'une fonction et
   <literal>R</literal> pour réservé. La colonne
   <structfield>catdesc</structfield> contient une chaîne pouvant être
   traduite décrivant la catégorie.
  </para>

  <para>
   <function>pg_get_constraintdef</function>,
   <function>pg_get_indexdef</function>, <function>pg_get_ruledef</function>
   et <function>pg_get_triggerdef</function> reconstruisent respectivement
   la commande de création d'une contrainte, d'un index, d'une règle ou d'un
   déclencheur. (Il s'agit d'une reconstruction décompilée, pas
   du texte originale de la commande.)
   <function>pg_get_expr</function> décompile la forme interne d'une expression
   individuelle, comme la valeur par défaut d'une colonne. Cela peut être utile
   pour examiner le contenu des catalogues système. Si l'expression contient
   des variables, spécifiez l'OID de la relation à laquelle elles font référence
   dans le second paramètre&nbsp;; si aucune variable n'est attendue, zéro est
   suffisant.
   <function>pg_get_viewdef</function> reconstruit la requête <command>SELECT</command>
   qui définit une vue. La plupart de ces fonctions existent en deux versions,
   l'une d'elles permettant, optionnellement, d'<quote>afficher joliment</quote>
   le résultat. Ce format est plus lisible, mais il est probable que les
   futures versions de <productname>PostgreSQL</productname> continuent
   d'interprêter le format par défaut actuel de la même façon&nbsp;; la version
   <quote>jolie</quote> doit être évitée dans les sauvegardes. Passer
   <literal>false</literal> pour le paramètre de <quote>jolie</quote> sortie
   conduit au même résultat que la variante sans ce paramètre.
  </para>

  <para>
   <function>pg_get_functiondef</function> renvoit une instruction
   <command>CREATE OR REPLACE FUNCTION</command> complète pour une fonction.
   <function>pg_get_function_arguments</function> renvoit une liste
   des arguments d'un fonction, de la façon dont elle apparaîtrait dans
   <command>CREATE FUNCTION</command>.
   <function>pg_get_function_result</function> renvoit de façon similaire
   la clause <literal>RETURNS</literal> appropriée pour la fonction.
   <function>pg_get_function_identity_arguments</function> renvoit la liste
   d'arguments nécessaire pour identifier une fonction, dans la forme qu'elle
   devrait avoir pour faire partie d'un <command>ALTER FUNCTION</command>, par
   exemple. Cette forme omet les valeurs par défaut.
  </para>

  <para>
   <function>pg_get_serial_sequence</function> renvoie le nom de la séquence
   associée à une colonne ou NULL si aucune séquence n'est associée
   à la colonne. Le premier argument en entrée est un nom de table,
   éventuellement qualifié du schéma. Le second paramètre est un nom de colonne. Comme
   le premier paramètre peut contenir le nom du schéma et de
   la table, il n'est pas traité comme un identifiant entre guillemets
   doubles, ce qui signifie qu'il est converti en minuscules par défaut, alors que le second
   paramètre, simple nom de colonne, est traité comme s'il était entre
   guillemets doubles et sa casse est préservée. La fonction renvoie une valeur
   convenablement formatée pour être traitée par les fonctions de traitement des
   séquences (voir <xref linkend="functions-sequence"/>). Cette association
   peut être modifiée ou supprimée avec <command>ALTER SEQUENCE OWNED
   BY</command>. (La fonction aurait probablement dû s'appeler
   <function>pg_get_owned_sequence</function>&nbsp;; son nom reflète le fait
   qu'elle est typiquement utilisée avec les colonnes <type>serial</type> et
   <type>bigserial</type>.)
  </para>

  <para>
   <function>pg_get_userbyid</function> récupère le nom d'un rôle d'après son OID.
  </para>

  <para>
   <function>pg_tablespace_databases</function> autorise l'examen d'un
   <foreignphrase>tablespace</foreignphrase>. Il renvoie l'ensemble des OID
   des bases qui possèdent des objets stockés
   dans le <foreignphrase>tablespace</foreignphrase>. Si la fonction renvoie
   une ligne, le <foreignphrase>tablespace</foreignphrase>
   n'est pas vide et ne peut pas être supprimée. Pour afficher les objets
   spécifiques peuplant le <foreignphrase>tablespace</foreignphrase>, il est
   nécessaire de se connecter aux bases identifiées par
   <function>pg_tablespace_databases</function> et de requêter le catalogue
   <structname>pg_class</structname>.
  </para>

  <para>
   <function>pg_typeof</function> renvoit l'OID du type de données de la valeur
   qui lui est passé. Ceci est utile pour dépanner ou pour construire
   dynamiquement des requêtes SQL. La fonction est déclarée comme renvoyant
   <type>regtype</type>, qui est une type d'alias d'OID (voir
   <xref linkend="datatype-oid"/>)&nbsp;; cela signifie que c'est la même chose
   qu'un OID pour un bit de comparaison mais que cela s'affiche comme un nom de
   type. Par exemple&nbsp;:
<programlisting>
SELECT pg_typeof(33);

 pg_typeof 
-----------
 integer
(1 row)

SELECT typlen FROM pg_type WHERE oid = pg_typeof(33);
 typlen 
--------
      4
(1 row)
</programlisting>
  </para>

   <indexterm>
    <primary>col_description</primary>
   </indexterm>

   <indexterm>
    <primary>obj_description</primary>
   </indexterm>

   <indexterm>
    <primary>shobj_description</primary>
   </indexterm>

   <indexterm>
    <primary>commentaire</primary>
    <secondary sortas="database objects">sur les objets de la base</secondary>
   </indexterm>

   <para>
    Les fonctions affichées dans <xref linkend="functions-info-comment-table"/>
    extraient les commentaires stockées précédemment avec la commande <xref
    linkend="sql-comment" endterm="sql-comment-title"/>. Une valeur NULL est
    renvoyée si aucun commentaire ne correspond aux paramètres
    donnés.
   </para>

   <table id="functions-info-comment-table">
      <title>Fonctions d'informations sur les commentaires</title>
      <tgroup cols="3">
      <colspec colnum="1" colwidth="1.3*"/>
      <colspec colnum="2" colwidth="0.4*"/>
      <colspec colnum="3" colwidth="1.3*"/>
      <thead>
        <row><entry>Nom</entry> <entry>Type de retour</entry> <entry>Description</entry></row>
      </thead>

      <tbody>
        <row>
         <entry><literal><function>col_description</function>(<parameter>table_oid</parameter>,  <parameter>column_number</parameter>)</literal></entry>
         <entry><type>text</type></entry>
         <entry>récupère le commentaire d'une colonne de la table</entry>
        </row>
        <row>
          <entry><literal><function>obj_description</function>
	  (<parameter>object_oid</parameter>, <parameter>catalog_name</parameter>)</literal></entry>
          <entry><type>text</type></entry>
          <entry>récupère le commentaire d'un objet de la base de données</entry>
        </row>
        <row>
          <entry><literal><function>obj_description</function>(<parameter>object_oid</parameter>)</literal></entry>
          <entry><type>text</type></entry>
	  <entry>récupère le commentaire d'un objet de la base de données
 	  (<emphasis>obsolète</emphasis>)</entry>
        </row>
        <row>
         <entry><literal><function>shobj_description</function>(<parameter>object_oid</parameter>, <parameter>catalog_name</parameter>)</literal></entry>
         <entry><type>text</type></entry>
         <entry>récupère le commentaire d'un objet partagé de la base de
	 données</entry>
        </row>
      </tbody>
    </tgroup>
  </table>

   <para>
    <function>col_description</function> renvoie le commentaire d'une colonne
    de table, la colonne étant précisée par l'OID de la table et son
     numéro de colonne.
    <function>obj_description</function> ne peut pas être utilisée pour les
    colonnes de table car les colonnes n'ont pas d'OID propres.
   </para>

   <para>
     La forme à deux paramètres de <function>obj_description</function>
     renvoie le commentaire d'un objet de la base de données, précisé
     par son OID et le nom du catalogue système le contenant. Par exemple,
     <literal>obj_description(123456,'pg_class')</literal> récupère le
     commentaire pour la table d'OID 123456. La forme à un paramètre de
     <function>obj_description</function> ne requiert que l'OID de l'objet.
     Elle est maintenant obsolète car il n'existe aucune garantie que les
     OID soient uniques au travers des différents catalogues système&nbsp;;
     un mauvais commentaire peut alors être renvoyé.
   </para>
   
   <para>
     <function>shobj_description</function> est utilisé comme
     <function>obj_description</function>, mais pour
     les commentaires des objets partagés. Certains catalogues
     systèmes sont globaux à toutes les bases de données à l'intérieur de
     chaque cluster et leurs descriptions sont stockées globalement.
   </para>

   <indexterm>
    <primary>txid_current</primary>
   </indexterm>

   <indexterm>
    <primary>txid_current_snapshot</primary>
   </indexterm>

   <indexterm>
    <primary>txid_snapshot_xmin</primary>
   </indexterm>

   <indexterm>
    <primary>txid_snapshot_xmax</primary>
   </indexterm>

   <indexterm>
    <primary>txid_snapshot_xip</primary>
   </indexterm>

   <indexterm>
    <primary>txid_visible_in_snapshot</primary>
   </indexterm>

   <para>
    Les fonctions présentées dans <xref linkend="functions-txid-snapshot"/>
    remontent à l'utilisateur des informations de transaction de niveau interne
    au serveur. L'usage principal de ces fonctions est de déterminer les
    transactions commitées entre deux instantanés («&nbsp;snapshots&nbsp;»).
   </para>

   <table id="functions-txid-snapshot">
    <title>ID de transaction et instantanés</title>
    <tgroup cols="3">
      <colspec colnum="1" colwidth="2*"/>
      <colspec colnum="2" colwidth="1*"/>
      <colspec colnum="3" colwidth="3*"/>
     <thead>
      <row><entry>Nom</entry> <entry>Type retour</entry> <entry>Description</entry></row>
     </thead>

     <tbody>
      <row>
       <entry><literal><function>txid_current</function>()</literal></entry>
       <entry><type>bigint</type></entry>
       <entry>récupère l'ID de transaction courant</entry>
      </row>
      <row>
       <entry><literal><function>txid_current_snapshot</function>()</literal></entry>
       <entry><type>txid_snapshot</type></entry>
       <entry>récupère l'instantané courant</entry>
      </row>
      <row>
       <entry><literal><function>txid_snapshot_xmin</function>(<parameter>txid_snapshot</parameter>)</literal></entry>
       <entry><type>bigint</type></entry>
       <entry>récupère le xmin de l'instantané</entry>
      </row>
      <row>
       <entry><literal><function>txid_snapshot_xmax</function>(<parameter>txid_snapshot</parameter>)</literal></entry>
       <entry><type>bigint</type></entry>
       <entry>récupère le xmax de l'instantané</entry>
      </row>
      <row>
       <entry><literal><function>txid_snapshot_xip</function>(<parameter>txid_snapshot</parameter>)</literal></entry>
       <entry><type>setof bigint</type></entry>
       <entry>récupère l'ID de la transaction en cours dans l'instantané</entry>
      </row>
      <row>
       <entry><literal><function>txid_visible_in_snapshot</function>(<parameter>bigint</parameter>, <parameter>txid_snapshot</parameter>)</literal></entry>
       <entry><type>boolean</type></entry>
       <entry>l'ID de transaction est-il visible dans l'instantané&nbsp;?
        (ne pas utiliser les identifiants de sous-transactions)</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    Le type interne ID de transaction (<type>xid</type>) est sur 32 bits. Il boucle
    donc tous les 4 milliards de transactions. Cependant, ces fonctions exportent 
    au format 64 bits, étendu par un compteur <quote>epoch</quote>, de façon à éviter 
    tout cycle sur la durée de vie de l'installation. Le type de données
    utilisé par ces fonctions, <type>txid_snapshot</type>, stocke l'information
    de visibilité des ID de transaction à un instant particulier. Ces composants sont décrits
    dans <xref linkend="functions-txid-snapshot-parts"/>.
   </para>

   <table id="functions-txid-snapshot-parts">
    <title>Composants de l'instantané</title>
    <tgroup cols="2">
    <colspec colnum="1" colwidth="2*"/>
    <colspec colnum="2" colwidth="3*"/>
     <thead>
      <row>
       <entry>Nom</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>

      <row>
       <entry><type>xmin</type></entry>
       <entry>
         ID de transaction (txid) le plus ancien encore actif. Toutes les
	 transactions plus anciennes sont soient commitées et visibles, soient
	 annulées et mortes.
       </entry>
      </row>

      <row>
       <entry><type>xmax</type></entry>
       <entry>
        Premier txid non encore assigné. Tous les txids plus grands ou égals à celui-ci ne sont
	pas encore démarrés à ce moment de l'instantané, et donc invisibles.
       </entry>
      </row>

      <row>
       <entry><type>xip_list</type></entry>
       <entry>
        Active les identifiants de transactions (txids) au moment de la prise
	de l'image. La liste inclut seulement les identifiants actifs entre
	<literal>xmin</literal> et <literal>xmax</literal>&nbsp;; il pourrait
	y avoir des identifiants plus gros que <literal>xmax</literal>. Un identifiant qui est
	<literal>xmin &lt;= txid &lt; xmax</literal> et qui n'est pas dans cette
	liste est déjà terminé au moment de la prise de l'image, et du coup est
	soit visible soit mort suivant son statut de validation. La liste
	n'inclut pas les identifiants de transactions des sous-transactions.
       </entry>
      </row>

     </tbody>
    </tgroup>
   </table>

   <para>
    La représentation textuelle du <type>txid_snapshot</type> est
    <literal><replaceable>xmin</replaceable>:<replaceable>xmax</replaceable>:<replaceable>xip_list</replaceable></literal>.
    Ainsi <literal>10:20:10,14,15</literal> signifie
    <literal>xmin=10, xmax=20, xip_list=10, 14, 15</literal>.
   </para>
  </sect1>

<sect1 id="functions-admin">
  <title>Fonctions d'administration système</title>
  
  <para>
    Le <xref linkend="functions-admin-set-table"/> affiche les fonctions
    disponibles pour consulter et modifier les paramètres de configuration
    en exécution.
  </para>
    
    <table id="functions-admin-set-table">
      <title>Fonctions agissant sur les paramètres de configuration</title>
      <tgroup cols="3">
        <colspec colnum="1" colwidth="1.3*"/>
        <colspec colnum="2" colwidth="0.4*"/>
        <colspec colnum="3" colwidth="1.3*"/>
        <thead>
          <row>
            <entry>Nom</entry>
            <entry>Type de retour</entry>
            <entry>Description</entry>
         </row>
        </thead>
        
        <tbody>
          <row>
            <entry>
              <literal><function>current_setting</function>
               (<parameter>nom_paramètre</parameter>)</literal>
            </entry>
            <entry><type>text</type></entry>
            <entry>valeur courante du paramètre</entry>
          </row>
          <row>
            <entry>
              <literal><function>set_config
               (<parameter>nom_paramètre</parameter>,
               <parameter>nouvelle_valeur</parameter>,
               <parameter>est_local</parameter>)</function></literal>
            </entry>
            <entry><type>text</type></entry>
            <entry>configure le paramètre et renvoie la nouvelle
             valeur</entry>
          </row>
        </tbody>
      </tgroup>
    </table>
    
    <indexterm>
      <primary>SET</primary>
    </indexterm>
    
    <indexterm>
      <primary>SHOW</primary>
    </indexterm>
    
    <indexterm>
      <primary>configuration</primary>
      <secondary sortas="server">du serveur</secondary>
      <tertiary>fonctions</tertiary>
    </indexterm>
    
    <para>
      La fonction <function>current_setting</function> renvoie la valeur
      courante du paramètre <parameter>nom_paramètre</parameter>. Elle
      correspond à la commande <acronym>SQL</acronym> 
      <command>SHOW</command>. Par exemple&nbsp;:
      <programlisting>SELECT current_setting('datestyle');

 current_setting
-----------------
ISO, MDY
(1 row)</programlisting>
    </para>
    
    <para>
      <function>set_config</function> positionne le paramètre
      <parameter>nom_paramètre</parameter> à
      <parameter>nouvelle_valeur</parameter>.  Si 
      <parameter>est_local</parameter> vaut <literal>true</literal>, la
      nouvelle valeur s'applique uniquement à la transaction en cours. Si
      la nouvelle valeur doit s'appliquer à la session en cours,
      on utilise <literal>false</literal>. La fonction correspond à
      la commande SQL <command>SET</command>. Par exemple&nbsp;:
      <programlisting>SELECT set_config('log_statement_stats', 'off', false);

 set_config
------------
off
(1 row)</programlisting>
    </para>
    
    <indexterm>
      <primary>pg_cancel_backend</primary>
    </indexterm>
   <indexterm>
    <primary>pg_terminate_backend</primary>
   </indexterm>
    <indexterm>
      <primary>pg_reload_conf</primary>
    </indexterm>
    <indexterm>
      <primary>pg_rotate_logfile</primary>
    </indexterm>
    <indexterm>
      <primary>signal</primary>
      <secondary sortas="backend">processus serveur</secondary>
    </indexterm>
    
    <para>
      Les fonctions présentées dans le <xref linkend="functions-admin-signal-table"/>
      envoient des signaux de contrôle aux autres processus serveur.
      L'utilisation de ces fonctions est restreinte aux superutilisateurs.
    </para>
      
      <table id="functions-admin-signal-table">
        <title>Fonctions d'envoi de signal au serveur</title>
        <tgroup cols="3">
          <colspec colnum="1" colwidth="1.3*"/>
          <colspec colnum="2" colwidth="0.4*"/>
          <colspec colnum="3" colwidth="1.3*"/>
          <thead>
            <row>
              <entry>Nom</entry>
              <entry>Type de retour</entry>
              <entry>Description</entry>
            </row>
          </thead>
          
          <tbody>
            <row>
              <entry>
                <literal><function>pg_cancel_backend</function>
                (<parameter>pid</parameter> <type>int</type>)</literal>
              </entry>
              <entry><type>boolean</type></entry>
              <entry>Annule une requête en cours sur le serveur</entry>
            </row>
      <row>
       <entry>
        <literal><function>pg_terminate_backend</function>(<parameter>pid</parameter> <type>int</type>)</literal>
        </entry>
       <entry><type>boolean</type></entry>
       <entry>Termine une processus serveur</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_reload_conf</function>()</literal>
        </entry>
       <entry><type>boolean</type></entry>
       <entry>Impose le rechargement des fichiers de configuration par les processus
       serveur</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_rotate_logfile</function>()</literal>
        </entry>
       <entry><type>boolean</type></entry>
       <entry>Impose une rotation du journal des traces du serveur</entry>
      </row>
          </tbody>
        </tgroup>
      </table>
      
   <para>
    Ces fonctions renvoient <literal>true</literal> en cas de succès,
    <literal>false</literal> en cas d'échec.
   </para>

   <para>
    <function>pg_cancel_backend</function> et
    <function>pg_terminate_backend</function> envoie un signal
    (respectivement <systemitem>SIGINT</systemitem> ou
    <systemitem>SIGTERM</systemitem>) au processus serveur identifié
    par l'ID du processus. L'identifiant du processus serveur actif
    peut être trouvé dans la colonne <structfield>procpid</structfield>
    dans la vue <structname>pg_stat_activity</structname> ou en listant les
    processus <command>postgres</command> sur le serveur avec
    <application>ps</application> sur Unix ou le <application>Gestionnaire
    des tâches</application> sur <productname>Windows</productname>.
   </para>

   <para>
    <function>pg_reload_conf</function> envoie un signal <systemitem>SIGHUP</systemitem>
    au serveur, ce qui impose le rechargement
    des fichiers de configuration par tous les processus serveur.
   </para>

   <para>
    <function>pg_rotate_logfile</function> signale au gestionnaire de journaux de trace
    de basculer immédiatement vers un nouveau fichier de sortie. Cela ne fonctionne
    que lorsque le collecteur de traces interne est actif, puisqu'il n'y a pas
    de sous-processus de gestion des fichiers journaux dans le cas contraire.
   </para>

    <indexterm>
      <primary>pg_start_backup</primary>
    </indexterm>
    <indexterm>
      <primary>pg_stop_backup</primary>
    </indexterm>
   <indexterm>
    <primary>pg_switch_xlog</primary>
   </indexterm>
   <indexterm>
    <primary>pg_current_xlog_location</primary>
   </indexterm>
   <indexterm>
    <primary>pg_current_xlog_insert_location</primary>
   </indexterm>
   <indexterm>
    <primary>pg_xlogfile_name_offset</primary>
   </indexterm>
   <indexterm>
    <primary>pg_xlogfile_name</primary>
   </indexterm>
    <indexterm>
      <primary>sauvegarde</primary>
    </indexterm>
    
    <para>
     Les fonctions présentées dans le
     <xref linkend="functions-admin-backup-table"/> aident à l'exécution de
     sauvegardes à chaud. L'utilisation des trois premières fonctions
     est réservée aux superutilisateurs.
    </para>
      
      <table id="functions-admin-backup-table">
        <title>Fonctions de contrôle de la sauvegarde</title>
        <tgroup cols="3">
          <colspec colnum="1" colwidth="1.3*"/>
          <colspec colnum="2" colwidth="0.4*"/>
          <colspec colnum="3" colwidth="1.3*"/>
          <thead>
            <row>
              <entry>Nom</entry>
              <entry>Type de retour</entry>
              <entry>Description</entry>
            </row>
          </thead>
          
          <tbody>
            <row>
              <entry>
                <literal><function>pg_start_backup</function>
                (<parameter>label</parameter> <type>text</type> <optional>,
                 <parameter>fast</parameter> <type>boolean</type> </optional>)</literal>
              </entry>
              <entry><type>text</type></entry>
              <entry>Préparation de la sauvegarde à chaud</entry>
            </row>
            <row>
              <entry>
                <literal><function>pg_stop_backup</function>()</literal>
              </entry>
              <entry><type>text</type></entry>
              <entry>Arrêt de la sauvegarde à chaud</entry>
            </row>
           <row>
             <entry><literal><function>pg_switch_xlog</function>()</literal></entry>
             <entry><type>text</type></entry>
             <entry>Passage forcé à un nouveau journal de transactions</entry>
           </row>
           <row>
             <entry>
	       <literal><function>pg_current_xlog_location</function>()</literal>
	     </entry>
             <entry><type>text</type></entry>
             <entry>Récupération de l'emplacement d'écriture du journal de transactions
	       courant</entry>
           </row>
           <row>
            <entry>
              <literal><function>pg_current_xlog_insert_location</function>()</literal>
            </entry>
            <entry><type>text</type></entry>
            <entry>Récupération de l'emplacement d'insertion du journal de transactions
	      courant</entry>
           </row>
           <row>
            <entry>
              <literal><function>pg_xlogfile_name_offset</function>(<parameter>location</parameter> <type>text</type>)</literal>
            </entry>
            <entry><type>text</type>, <type>integer</type></entry>
            <entry>Conversion de la chaîne décrivant l'emplacement du journal de
	      transactions en nom de fichier et décalage en octets
	      dans le fichier</entry>
           </row>
           <row>
             <entry>
               <literal><function>pg_xlogfile_name</function>(<parameter>location</parameter> <type>text</type>)</literal>
             </entry>
             <entry><type>text</type></entry>
             <entry>Conversion de la chaîne décrivant l'emplacement du journal de
	       transactions en nom de fichier</entry>
           </row>
          </tbody>
        </tgroup>
      </table>

    <para>
      <function>pg_start_backup</function> accepte un label
      utilisateur de la sauvegarde (typiquement, le nom du fichier
      d'enregistrement de la sauvegarde). La fonction écrit un fichier de
      label (<filename>backup_label</filename>) dans le répertoire de données du cluster, réalise un point de
      retournement, et renvoie la position du début de la sauvegarde dans le
      journal de transactions au format texte. Ce résultat ne nécessite pas
      qu'on s'y intéresse, mais il est fourni dans cette éventualité.
<programlisting>postgres=# select pg_start_backup('le_label_ici');
 pg_start_backup
-----------------
 0/D4445B8
(1 row)</programlisting>
    Il existe un second paramètre booléen optionnel. Si <literal>true</literal>,
    il précise l'exécution de <function>pg_start_backup</function> aussi
    rapidement que possible. Cela force un point de retournement immédiat qui
    causera un pic dans les opérations d'entrées/sorties, ralentissant toutes
    les requêtes exécutées en parallèle.
    </para>

    <para>
      <function>pg_stop_backup</function> supprime le fichier de label créé par
      <function>pg_start_backup</function> et crée, à la place, un fichier
      d'historique dans l'aire de stockage des archives des journaux de transactions.
      Ce fichier contient le label passé à <function>pg_start_backup</function>,
      les emplacements de début et de fin des journaux de transactions
      correspondant à la sauvegarde et les heures de début et de fin de la sauvegarde. La
      valeur de retour est l'emplacement du journal de la transaction de fin de
      sauvegarde (de peu d'intérêt, là encore). Après notification de l'emplacement de fin, le
      point d'insertion courant du journal de transactions est automatiquement
      avancé au prochain journal de transactions, de façon à ce que le journal
      de transactions de fin de sauvegarde puisse être archivé immédiatement pour
      terminer la sauvegarde.
    </para>

   <para>
    <function>pg_switch_xlog</function> bascule sur le prochain journal de
    transactions, ce qui permet d'archiver le journal courant (en supposant que
    l'archivage continu soit utilisé). La fonction retourne l'emplacement de la
    transaction finale + 1 dans le journal ainsi terminé. 
    S'il n'y a pas eu d'activité dans les journaux de
    transactions depuis le dernier changement de journal,
    <function>pg_switch_xlog</function> ne fait rien et renvoie l'emplacement
    de fin du journal de transactions en cours.
   </para>

   <para>
    <function>pg_current_xlog_location</function> affiche la position d'écriture
    du journal de transactions en cours dans le même format que celui utilisé
    dans les fonctions ci-dessus. De façon similaire,
    <function>pg_current_xlog_insert_location</function> affiche le point
    d'insertion dans le journal de transactions courant. Le point d'insertion est la
    fin <quote>logique</quote> du journal de transactions à tout instant alors
    que l'emplacement d'écriture est la fin de ce qui a déjà été écrit à partir
    des tampons internes du serveur. La position d'écriture est la fin de ce
    qui peut être examiné extérieurement au serveur. C'est habituellement
    l'information nécessaire à qui souhaite archiver des journaux de
    transactions partiels. Le point d'insertion n'est donné principalement que 
    pour des raisons de débogage du serveur. Il s'agit là d'opérations de
    lecture seule qui ne nécessitent pas de droits superutilisateur.
   </para>

   <para>
    <function>pg_xlogfile_name_offset</function> peut être utilisée pour
    extraire le nom du journal de transactions correspondant et le décalage en octets
    à partir du résultat de n'importe quelle fonction ci-dessus. Par exemple&nbsp;:
<programlisting>postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
        file_name         | file_offset 
--------------------------+-------------
 00000001000000000000000D |     4039624
(1 row)</programlisting>
    De façon similaire, <function>pg_xlogfile_name</function> n'extrait que
    le nom du journal de la transaction. Quand la position dans le journal de
    la transaction donnée est exactement sur une limite de journal,
    les deux fonctions renvoient le nom du journal précédent.
    C'est généralement le comportement souhaité pour gérer l'archivage
    des journaux, car le fichier précédent est le dernier à devoir être
    archivé.
   </para>

    <para>
      Pour les détails sur le bon usage de ces fonctions, voir la
      <xref linkend="continuous-archiving"/>.
    </para>


   <para>
    Les fonctions présentées dans le <xref linkend="functions-admin-dbsize"/>
    calculent l'utilisation de l'espace disque par les objets de la base de
    données.
   </para>

   <indexterm>
    <primary>pg_column_size</primary>
   </indexterm>
   <indexterm>
    <primary>pg_database_size</primary>
   </indexterm>
   <indexterm>
    <primary>pg_relation_size</primary>
   </indexterm>
   <indexterm>
    <primary>pg_size_pretty</primary>
   </indexterm>
   <indexterm>
    <primary>pg_tablespace_size</primary>
   </indexterm>
   <indexterm>
    <primary>pg_total_relation_size</primary>
   </indexterm>

   <table id="functions-admin-dbsize">
    <title>Fonctions de calcul de la taille des objets de la base de
      données</title>
    <tgroup cols="3">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <thead>
      <row>
       <entry>Nom</entry>
       <entry>Code de retour</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry>
	    <literal><function>pg_column_size</function>(<type>any</type>)</literal>
	   </entry>
       <entry><type>int</type></entry>
       <entry>Nombre d'octets utilisés pour stocker une valeur particulière
        (éventuellement compressée)</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_database_size</function>(<type>oid</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>Espace disque utilisé par la base de données d'OID indiqué</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_database_size</function>(<type>name</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>Espace disque utilisé par la base de données de nom indiqué</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_relation_size</function>(<parameter>relation</parameter> <type>regclass</type>, <parameter>fork</parameter> <type>text</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>
        Espace disque utilisé par le fork indiqué, <literal>'main'</literal>,
        <literal>'fsm'</literal> ou <literal>'vm'</literal>, d'une table ou index d'OID ou de nom indiqué.
       </entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_relation_size</function>(<parameter>relation</parameter> <type>regclass</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>
        Raccourci pour <literal>pg_relation_size(..., 'main')</literal>
       </entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_size_pretty</function>(<type>bigint</type>)</literal>
        </entry>
       <entry><type>text</type></entry>
       <entry>Convertit une taille en octets en format interprétable par
       l'utilisateur avec unités</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_tablespace_size</function>(<type>oid</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>Espace disque utilisé par le
       <foreignphrase>tablespace</foreignphrase> d'OID indiqué</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_tablespace_size</function>(<type>name</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>Espace disque utilisé par le
       <foreignphrase>tablespace</foreignphrase> de nom indiqué</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_total_relation_size</function>(<type>regclass</type>)</literal>
        </entry>
       <entry><type>bigint</type></entry>
       <entry>
        Espace disque total utilisé par la table de cet OID ou nom, incluant
	les index et les données de la partie TOAST.
       </entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <para>
    <function>pg_column_size</function> affiche l'espace utilisé pour stocker toute
    valeur individuelle.
   </para>

   <para>
    <function>pg_database_size</function> et <function>pg_tablespace_size</function> acceptent
    l'OID ou le nom d'une base de données ou d'un
    <foreignphrase>tablespace</foreignphrase> et renvoient l'espace disque total utilisé.
   </para>

   <para>
    <function>pg_relation_size</function> accepte l'OID ou le nom d'une table, d'un
    index ou d'une table toast et renvoie la taille en octets. Indiquer
    <literal>'main'</literal> ou laisser le second argument renvoit la taille du
    morceau de données principal de la relation. Indiquer
    <literal>'fsm'</literal> renvoit la taille de la carte des espaces libres
    (voir <xref linkend="storage-fsm"/>) associée à cette relation. Indiquer
    <literal>'vm'</literal> renvoit la taille de la carte de visibilité
    (voir <xref linkend="storage-vm"/>) associée avec la relation.
   </para>

   <para>
    <function>pg_size_pretty</function> peut être utilisé pour formater le résultat
    d'une des autres fonctions de façon interprétable par l'utilisateur,
    en utilisant kB, MB, GB ou TB suivant le cas.
   </para>

   <para>
    <function>pg_total_relation_size</function> accepte l'OID ou le nom d'une table
    ou d'une table toast, et renvoie la taille en octets des données et de
    tous les index et tables toast associées.
   </para>

   <para>
    Les fonctions présentées dans le <xref
    linkend="functions-admin-genfile"/> fournissent un accès natif aux fichiers
    situés sur le serveur. Seuls les fichiers contenus dans le répertoire du
    cluster et ceux du répertoire <varname>log_directory</varname>
    sont accessibles. On utilise un chemin relatif pour les fichiers contenus
    dans le répertoire du cluster et un chemin correspondant à la configuration du
    paramètre <varname>log_directory</varname> pour les journaux de trace.
    L'utilisation de ces fonctions est restreinte aux superutilisateurs.
   </para>

   <table id="functions-admin-genfile">
    <title>Fonctions d'accès générique aux fichiers</title>
    <tgroup cols="3">
     <colspec colnum="1" colwidth="1.3*"/>
     <colspec colnum="2" colwidth="0.4*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <thead>
      <row>
       <entry>Nom</entry>
       <entry>Code de retour</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry>
        <literal><function>pg_ls_dir</function>(<parameter>nom_répertoire</parameter> <type>text</type>)</literal>
       </entry>
       <entry><type>setof text</type></entry>
       <entry>Liste le contenu d'un répertoire</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_read_file</function>(<parameter>nom_fichier</parameter> <type>text</type>, <parameter>décalage</parameter> <type>bigint</type>, <parameter>longueur</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>text</type></entry>
       <entry>Renvoie le contenu d'un fichier texte</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_stat_file</function>(<parameter>nom_fichier</parameter> <type>text</type>)</literal>
       </entry>
       <entry><type>record</type></entry>
       <entry>Renvoie les informations concernant un fichier</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

   <indexterm>
    <primary>pg_ls_dir</primary>
   </indexterm>
   <para>
    <function>pg_ls_dir</function> renvoie tous les noms contenus dans le
    répertoire indiqué, à l'exception des entrées spéciales
    <quote><literal>.</literal></quote> et <quote><literal>..</literal></quote>.
   </para>

   <indexterm>
    <primary>pg_read_file</primary>
   </indexterm>
   <para>
    <function>pg_read_file</function> renvoie une partie d'un fichier texte,
    débutant au <parameter>décalage</parameter> indiqué, renvoyant au plus
    <parameter>longueur</parameter> octets (moins si la fin du fichier est atteinte
    avant). Si le <parameter>décalage</parameter> est négatif, il est relatif à la fin
    du fichier.
   </para>

   <indexterm>
    <primary>pg_stat_file</primary>
   </indexterm>
   <para>
    <function>pg_stat_file</function> renvoie un enregistrement contenant la taille
    du fichier, les date et heure de dernier accès, les date et heure de
    dernière modification, les date et heure de dernier changement de statut
    (plateformes Unix seulement), les date et heure de création (Windows
    seulement) et un booléen indiquant s'il s'agit d'un répertoire. Les
    usages habituels incluent&nbsp;:
<programlisting>SELECT * FROM pg_stat_file('nomfichier');
SELECT (pg_stat_file('nomfichier')).modification;</programlisting>
   </para>

   <para>
    Les fonctions présentées dans <xref linkend="functions-advisory-locks"/> gèrent
    les verrous consultatifs. Pour les détails sur le bon usage de ces fonctions,
    voir <xref linkend="advisory-locks"/>.
   </para>

   <table id="functions-advisory-locks">
    <title>Fonctions de verrous consultatifs</title>
    <tgroup cols="3">
    <colspec colnum="1" colwidth="2*"/>
    <colspec colnum="2" colwidth="1*"/>
    <colspec colnum="3" colwidth="3*"/>
     <thead>
      <row><entry>Nom</entry> <entry>Type renvoyé</entry> <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry>
        <literal><function>pg_advisory_lock</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>void</type></entry>
       <entry>Obtient un verrou consultatif exclusif</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_advisory_lock</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>void</type></entry>
       <entry>Obtient un verrou consultatif exclusif</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_advisory_lock_shared</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>void</type></entry>
       <entry>Obtient un verrou consultatif partagé</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_advisory_lock_shared</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>void</type></entry>
       <entry>Obtient un verrou consultatif partagé</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_try_advisory_lock</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Obtient un verrou consultatif exclusif si disponible</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_try_advisory_lock</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Obtient un verrou consultatif exclusif si disponible</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_try_advisory_lock_shared</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Obtient un verrou consultatif partagé si disponible</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_try_advisory_lock_shared</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Obtient un verrou consultatif partagé si disponible</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_advisory_unlock</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Relâche un verrou consultatif exclusif</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_advisory_unlock</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Relâche un verrou consultatif exclusif</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_advisory_unlock_shared</function>(<parameter>key</parameter> <type>bigint</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Relâche un verrou consultatif partagé</entry>
      </row>
      <row>
       <entry>
        <literal><function>pg_advisory_unlock_shared</function>(<parameter>key1</parameter> <type>int</type>, <parameter>key2</parameter> <type>int</type>)</literal>
       </entry>
       <entry><type>boolean</type></entry>
       <entry>Relâche un verrou consultatif partagé</entry>
      </row>

      <row>
       <entry>
        <literal><function>pg_advisory_unlock_all</function>()</literal>
       </entry>
       <entry><type>void</type></entry>
       <entry>Relâche tous les verrous consultatifs détenus par la session en cours</entry>
      </row>

     </tbody>
    </tgroup>
   </table>

   <indexterm zone="functions-admin">
    <primary>pg_advisory_lock</primary>
   </indexterm>
   <para>
    <function>pg_advisory_lock</function> verrouille une ressource applicative
    qui peut être identifiée soit par une valeur de clé sur 64
    bits soit par deux valeurs de clé sur 32 bits (les deux espaces
    de clé ne se surchargent pas). The key type is specified in
<literal>pg_locks.objid</literal>.
    Si une autre session détient déjà un verrou
    sur la même ressource, la fonction attend que la ressource
    devienne disponible. Le verrou est exclusif. Les demandes de verrou
    s'empilent de sorte que, si une même ressource est verrouillée trois fois,
    elle doit être déverrouillée trois fois pour être disponible par les autres
    sessions.
   </para>

   <indexterm>
    <primary>pg_advisory_lock_shared</primary>
   </indexterm>
   <para>
    <function>pg_advisory_lock_shared</function> fonctionne de façon identique
    à <function>pg_advisory_lock</function> sauf que le verrou peut être
    partagé avec d'autres sessions qui réclament des verrous partagés. Seules
    les demandes de verrou exclusif sont bloquées.
   </para>

   <indexterm>
    <primary>pg_try_advisory_lock</primary>
   </indexterm>
   <para>
    <function>pg_try_advisory_lock</function> est similaire à
    <function>pg_advisory_lock</function> sauf que la fonction n'attend pas
    la disponibilité du verrou. Si le verrou peut être obtenu immédiatement,
    la fonction renvoie <literal>true</literal>, sinon, elle renvoie
    <literal>false</literal>.
   </para>

   <indexterm>
    <primary>pg_try_advisory_lock_shared</primary>
   </indexterm>
   <para>
    <function>pg_try_advisory_lock_shared</function> fonctionne de la même façon
    que <function>pg_try_advisory_lock</function> sauf qu'elle tente d'acquérir
    un verrou partagé au lieu d'un verrou exclusif.
   </para>

   <indexterm>
    <primary>pg_advisory_unlock</primary>
   </indexterm>
   <para>
    <function>pg_advisory_unlock</function> relâche un verrou 
    exclusif précédemment acquis. Elle retourne <literal>true</literal> si le
    verrou est relaché avec succès. Si le verrou n'était pas détenu,
    <literal>false</literal> est renvoyé et un message d'avertissement
    SQL est émis par le serveur.
   </para>

   <indexterm>
    <primary>pg_advisory_unlock_shared</primary>
   </indexterm>
   <para>
    <function>pg_advisory_unlock_shared</function> fonctionne de la même façon
    que <function>pg_advisory_unlock</function> mais pour relâcher un verrou
    partagé.
   </para>

   <indexterm>
    <primary>pg_advisory_unlock_all</primary>
   </indexterm>
   <para>
    <function>pg_advisory_unlock_all</function> relâche tous les verrous
    consultatifs détenus par la session courante. (Cette fonction est appelée
    implicitement à la fin de la session, même si le client se déconnecte
    brutalement.)
   </para>

  </sect1>
  
  <sect1 id="functions-trigger">
   <title>Fonctions trigger</title>

   <indexterm>
     <primary>suppress_redundant_updates_trigger</primary>
   </indexterm>

   <para>
      Actuellement, <productname>PostgreSQL</productname> fournit une fonction
      de trigger interne, <function>suppress_redundant_updates_trigger</function>,
      qui empêchera toute mise à jour qui ne modifie pas réellement les données
      de cette ligne, en contrate au comportement normal qui réalise toujours
      une mise à jour, que les données soient réellement changées ou pas. (Ce
      comportement normal fait que les mises à jour s'exécutent rapidement car
      aucune vérification n'est nécessaire et c'est aussi utile dans certains
      cas.)
    </para>

    <para>
      Idéalement, vous devriez normalement éviter d'exécuter des mises à jour
      qui ne modifient pas réellement les données de l'enregistrement. Les mise
      à jour redondantes peuvent coûter considérablement en temps d'exécution,
      tout spécialement si vous avez beaucoup d'index à modifier, et en espace
      dans des lignes mortes que vous devrez finir par VACUUMées. Néanmoins,
      la détection de telles situations dans le code client n'est pas toujours
      facile, voire même possible, et écrire des expressions pour détecter ce
      type de cas peut facilement amener des erreyrs. Une alternative est
      d'utiliser <function>suppress_redundant_updates_trigger</function>, qui
      ignorera les mises à jour qui ne modifient pas réellement les données.
      Néanmoins, vous devez être très prudent quant à son utilisation. Le trigger
      consomme un temps petit, mais à ne pas négliger, pour vérifier que la mise
      à jour doit se faire. Autrement dit, si la plupart des enregistrements
      affectés par une mise à jour seront réellement modifiés, utiliser ce
      trigger rendra la mise à jour bien plus lente.
    </para>

    <para>
      La fonction <function>suppress_redundant_updates_trigger</function> peut
      être ajoutée à une table de cette façon&nbsp;:
<programlisting>
CREATE TRIGGER z_min_update 
BEFORE UPDATE ON tablename
FOR EACH ROW EXECUTE PROCEDURE suppress_redundant_updates_trigger();
</programlisting>
      Dans la plupart des cas, vous voudrez déclencher ce tigger en dernier pour
      chaque ligne. Gardez en tête que les triggers sont déclenchés dans l'ordre
      alphabétique de leur nom, vous choisirez donc un nom de trigger qui vient
      apr_s le nom des autres trigegrs que vous pourriez avoir sur la table.
    </para>
    
    <para>
      Pour plus d'informations sur la création des trigger, voir
      <xref linkend="sql-createtrigger"/>.
    </para>
  </sect1>
</chapter>