root/traduc/trunk/postgresql/datatype.xml

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

 <chapter id="datatype">
  <title id="datatype-title">Types de données</title>

  <indexterm zone="datatype">
   <primary>Types de données</primary>
  </indexterm>

  <indexterm>
   <primary>type</primary>
   <see>type de données</see>
  </indexterm>

  <para>
   <productname>PostgreSQL</productname> offre un large choix de types de 
   données disponibles nativement.
   Les utilisateurs peuvent ajouter de nouveaux types à 
   <productname>PostgreSQL</productname> en utilisant la commande <xref
   linkend="sql-createtype" endterm="sql-createtype-title"/>.
  </para>

  <para>
   Le <xref linkend="datatype-table"/> montre tous les types de données
   généraux disponibles nativement.
   La plupart des types de données alternatifs listés dans la colonne
   <quote>Alias</quote> sont les noms utilisés en interne par
   <productname>PostgreSQL</productname> pour des raisons historiques.
   Il existe également d'autres types de données internes ou obsolètes,
   mais ils ne sont pas listés ici.
 
  </para>

   <table id="datatype-table">
    <title>Types de données</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>Alias</entry>
       <entry>Description</entry>
      </row>
     </thead>

     <tbody>
      <row>
       <entry><type>bigint</type></entry>
       <entry><type>int8</type></entry>
       <entry>Entier signé sur 8 octets</entry>
      </row>

      <row>
       <entry><type>bigserial</type></entry>
       <entry><type>serial8</type></entry>
       <entry>Entier sur 8 octets à incrémentation automatique</entry>
      </row>

      <row>
       <entry><type>bit [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry></entry>
       <entry>Suite de bits de longueur fixe</entry>
      </row>

      <row>
       <entry><type>bit varying [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry><type>varbit</type></entry>
       <entry>Suite de bits de longueur variable</entry>
      </row>

      <row>
       <entry><type>boolean</type></entry>
       <entry><type>bool</type></entry>
       <entry>Booléen (Vrai/Faux)</entry>
      </row>

      <row>
       <entry><type>box</type></entry>
       <entry></entry>
       <entry>Boîte rectangulaire dans le plan</entry>
      </row>

      <row>
       <entry><type>bytea</type></entry>
       <entry></entry>
       <entry>Donnée binaire (<quote>tableau d'octets</quote>)</entry>
      </row>

      <row>
       <entry><type>character varying [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry><type>varchar [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry>Chaîne de caractères de longueur variable</entry>
      </row>

      <row>
       <entry><type>character [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry><type>char [ (<replaceable>n</replaceable>) ]</type></entry>
       <entry>Chaîne de caractères de longueur fixe</entry>
      </row>

      <row>
       <entry><type>cidr</type></entry>
       <entry></entry>
       <entry>Adresse réseau IPv4 ou IPv6 </entry>
      </row>

      <row>
       <entry><type>circle</type></entry>
       <entry></entry>
       <entry>Cercle dans le plan</entry>
      </row>

      <row>
       <entry><type>date</type></entry>
       <entry></entry>
       <entry>Date du calendrier (année, mois, jour)</entry>
      </row>

      <row>
       <entry><type>double precision</type></entry>
       <entry><type>float8</type></entry>
       <entry>Nombre à virgule flottante de double précision</entry>
      </row>

      <row>
       <entry><type>inet</type></entry>
       <entry></entry>
       <entry>Adresse d'ordinateur IPv4 ou IPv6</entry>
      </row>

      <row>
       <entry><type>integer</type></entry>
       <entry><type>int</type>, <type>int4</type></entry>
       <entry>Entier signé sur 4 octets</entry>
      </row>

      <row>
       <entry><type>interval [ (<replaceable>p</replaceable>) ]</type></entry>
       <entry></entry>
       <entry>Intervalle de temps</entry>
      </row>

      <row>
       <entry><type>line</type></entry>
       <entry></entry>
       <entry>Droite (infinie) dans le plan</entry>
      </row>

      <row>
       <entry><type>lseg</type></entry>
       <entry></entry>
       <entry>Segment de droite dans le plan</entry>
      </row>

      <row>
       <entry><type>macaddr</type></entry>
       <entry></entry>
       <entry>Adresse MAC</entry>
      </row>

      <row>
       <entry><type>money</type></entry>
       <entry></entry>
       <entry>Montant monétaire</entry>
      </row>

      <row>
       <entry><type>numeric [ (<replaceable>p</replaceable>,
         <replaceable>s</replaceable>) ]</type></entry>
       <entry><type>decimal [ (<replaceable>p</replaceable>,
         <replaceable>s</replaceable>) ]</type></entry>
       <entry>Nombre exact dont la précision peut être précisée</entry>
      </row>

      <row>
       <entry><type>path</type></entry>
       <entry></entry>
       <entry>Chemin géométrique dans le plan</entry>
      </row>

      <row>
       <entry><type>point</type></entry>
       <entry></entry>
       <entry>Point géométrique dans le plan</entry>
      </row>

      <row>
       <entry><type>polygon</type></entry>
       <entry></entry>
       <entry>Chemin géométrique fermé dans le plan</entry>
      </row>

      <row>
       <entry><type>real</type></entry>
       <entry><type>float4</type></entry>
       <entry>Nombre à virgule flottante de simple précision</entry>
      </row>

      <row>
       <entry><type>smallint</type></entry>
       <entry><type>int2</type></entry>
       <entry>Entier signé sur 2 octets</entry>
      </row>

      <row>
       <entry><type>serial</type></entry>
       <entry><type>serial4</type></entry>
       <entry>Entier sur 4 octets à incrémentation automatique</entry>
      </row>

      <row>
       <entry><type>text</type></entry>
       <entry></entry>
       <entry>Chaîne de caractères de longueur variable</entry>
      </row>

      <row>
       <entry><type>time [ (<replaceable>p</replaceable>) ] [ without time zone ]</type></entry>
       <entry></entry>
       <entry>Heure du jour</entry>
      </row>

      <row>
       <entry><type>time [ (<replaceable>p</replaceable>) ] with time zone</type></entry>
       <entry><type>timetz</type></entry>
       <entry>Heure du jour, avec fuseau horaire</entry>
      </row>

      <row>
       <entry><type>timestamp [ (<replaceable>p</replaceable>) ] [ without time zone ]</type></entry>
       <entry></entry>
       <entry>Date et heure</entry>
      </row>

      <row>
       <entry><type>timestamp [ (<replaceable>p</replaceable>) with time zone</type></entry>
       <entry><type>timestamptz</type></entry>
       <entry>Date et heure, avec fuseau horaire</entry>
      </row>

      <row>
       <entry><type>tsquery</type></entry>
       <entry></entry>
       <entry>requête pour la recherche plein texte</entry>
      </row>

      <row>
       <entry><type>tsvector</type></entry>
       <entry></entry>
       <entry>document pour la recherche plein texte</entry>
      </row>

      <row>
       <entry><type>txid_snapshot</type></entry>
       <entry></entry>
       <entry>image de l'identifiant de transaction au niveau utilisateur</entry>
      </row>

      <row>
       <entry><type>uuid</type></entry>
       <entry></entry>
       <entry>identifiant unique universel</entry>
      </row>

      <row>
       <entry><type>xml</type></entry>
       <entry></entry>
       <entry>données XML</entry>
      </row>
     </tbody>
    </tgroup>
   </table>

  <note>
   <title>Compatibilité</title>
   <para>
    Les types suivants sont conformes à la norme <acronym>SQL</acronym>:
    <type>bigint</type>, <type>bit</type>, <type>bit varying</type>, <type>boolean</type>, 
    <type>char</type>,
    <type>character varying</type>, <type>character</type>,
    <type>varchar</type>, <type>date</type>, 
    <type>double precision</type>, <type>integer</type>, <type>interval</type>,
    <type>numeric</type>, <type>decimal</type>, <type>real</type>,
    <type>smallint</type>, <type>time</type> (avec et sans fuseau horaire),
        <type>timestamp</type> (avec et sans fuseau horaire), <type>xml</type>, .
   </para>
  </note>

<!-- invertible = inversable ? -->
  <para>
   Chaque type de données a une représentation externe déterminée par
   ses fonctions d'entrée et de sortie. De nombreux types de données
   internes ont un format externe évident. Cependant, certains types
   sont spécifiques à <productname>PostgreSQL</productname>,
   comme les chemins géométriques, ou acceptent différents formats,
   comme les types de données de date et d'heure.
   Certaines fonctions d'entrée et de sortie ne sont pas inversables&nbsp;:
   le résultat de la fonction de sortie peut manquer de précision
   comparé à l'entrée initiale.
  </para>

  <sect1 id="datatype-numeric">
   <title>Types numériques</title>

   <indexterm zone="datatype-numeric">
    <primary>Type de données</primary>
    <secondary>numeric</secondary>
   </indexterm>

   <para>
    Les types numériques sont constitués d'entiers de 2, 4 ou 8 octets,
    de nombres à virgule flottante de 4 ou 8 octets et de décimaux dont
    la précision peut être indiquée. Le <xref linkend="datatype-numeric-table"/>
    précise les types disponibles.
   </para>

    <table id="datatype-numeric-table">
     <title>Types numériques</title>
     <tgroup cols="4">
     <colspec colnum="1" colwidth="0.7*"/>
     <colspec colnum="2" colwidth="0.7*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1.3*"/>
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Taille de stockage</entry>
        <entry>Description</entry>
        <entry>Étendue</entry>
       </row>
      </thead>

      <tbody>
       <row>
        <entry><type>smallint</type></entry>
        <entry>2 octets</entry>
        <entry>entier de faible étendue</entry>
        <entry>de -32768 à +32767</entry>
       </row>
       <row>
       <entry><type>integer</type></entry>
        <entry>4 octets</entry>
        <entry>entier habituel</entry>
        <entry>de -2147483648 à +2147483647</entry>
       </row>
       <row>
        <entry><type>bigint</type></entry>
        <entry>8 octets</entry>
        <entry>grand entier</entry>
        <entry>de -9223372036854775808 à 9223372036854775807</entry>
       </row>

       <row>
        <entry><type>decimal</type></entry>
        <entry>variable</entry>
        <entry>précision indiquée par l'utilisateur, valeur exacte</entry>
        <entry>pas de limite</entry>
       </row>
       <row>
        <entry><type>numeric</type></entry>
        <entry>variable</entry>
        <entry>précision indiquée par l'utilisateur, valeur exacte</entry>
        <entry>pas de limite</entry>
       </row>

       <row>
        <entry><type>real</type></entry>
        <entry>4 octets</entry>
        <entry>précision variable, valeur inexacte</entry>
        <entry>précision de 6 décimales</entry>
       </row>
       <row>
        <entry><type>double precision</type></entry>
        <entry>8 octets</entry>
        <entry>précision variable, valeur inexacte</entry>
        <entry>précision de 15 décimales</entry>
       </row>

       <row>
        <entry><type>serial</type></entry>
        <entry>4 octets</entry>
        <entry>entier à incrémentation automatique</entry>
        <entry>de 1 à 2147483647</entry>
       </row>

       <row>
        <entry><type>bigserial</type></entry>
        <entry>8 octets</entry>
        <entry>entier de grande taille à incrémentation automatique</entry>
        <entry>de 1 à 9223372036854775807</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

   <para>
    La syntaxe des constantes pour les types numériques est décrite
    dans la <xref linkend="sql-syntax-constants"/>. Les types numériques
    ont un ensemble complet d'opérateurs arithmétiques et de fonctions.
    On peut se référer au <xref linkend="functions"/> pour plus d'informations.
    Les sections suivantes décrivent ces types en détail.
   </para>

   <sect2 id="datatype-int">
    <title>Types entiers</title>

    <indexterm zone="datatype-int">
     <primary>integer</primary>
    </indexterm>

    <indexterm zone="datatype-int">
     <primary>smallint</primary>
    </indexterm>

    <indexterm zone="datatype-int">
     <primary>bigint</primary>
    </indexterm>

    <indexterm>
     <primary>int4</primary>
     <see>integer</see>
    </indexterm>

    <indexterm>
     <primary>int2</primary>
     <see>smallint</see>
    </indexterm>

    <indexterm>
     <primary>int8</primary>
     <see>bigint</see>
    </indexterm>

    <para>
     Les types <type>smallint</type>, <type>integer</type> et
     <type>bigint</type> stockent des nombres entiers, c'est-à-dire
     sans décimale, de différentes étendues.
     Toute tentative d'y stocker une valeur en dehors de l'échelle
     produit une erreur.
    </para>

    <para>
     Le type <type>integer</type> est le plus courant. Il offre un
     bon compromis entre capacité, espace utilisé et performance.
     Le type <type>smallint</type> n'est utilisé que si l'économie
     d'espace disque est le premier critère de choix.
     Le type <type>bigint</type> ne doit être utilisé que si le 
     type <type>integer</type> n'offre pas une étendue suffisante
     car le type <type>integer</type> est nettement plus rapide.
    </para>

    <para>
     Le type <type>bigint</type> peut ne pas fonctionner correctement
     sur toutes les plates-formes, car il repose sur la capacité du
     compilateur à supporter les entiers de 8 octets.
     Sur une machine qui ne les supporte pas, <type>bigint</type> se
     comporte comme <type>integer</type> (mais prend bien huit octets
     d'espace de stockage). Cela dit, les auteurs n'ont pas connaissance 
     de plate-forme raisonnable sur laquelle il en va ainsi.
    </para>

    <para>
     <acronym>SQL</acronym> ne définit que les types de données
     <type>integer</type> (ou <type>int</type>),
     <type>smallint</type> et <type>bigint</type>. Les noms
     de types <type>int2</type>, <type>int4</type>, et
     <type>int8</type> sont des extensions, partagées par
     d'autres systèmes de bases de données <acronym>SQL</acronym>.
    </para>

   </sect2>

   <sect2 id="datatype-numeric-decimal">
    <title>Nombres à précision arbitraire</title>

    <indexterm>
     <primary>numeric (data type)</primary>
    </indexterm>

   <indexterm>
    <primary>nombres à virgule flottante</primary>
   </indexterm>

    <indexterm>
     <primary>decimal</primary>
     <see>numeric</see>
    </indexterm>

    <para>
     Le type <type>numeric</type> peut stocker des nombres contenant 
     jusqu'à 1000 chiffres significatifs et effectuer des calculs
     exacts. Il est spécialement recommandé pour stocker les montants
     financiers et autres quantités pour lesquelles l'exactitude est 
     indispensable. Néanmoins, l'arithmétique sur les valeurs
     <type>numeric</type> est très lente comparée aux types entiers ou aux
     types à virgule flottante décrits dans la section suivante.
    </para>

    <para>
     Dans ce qui suit, on utilise les termes suivants&nbsp;:
     l'<firstterm>échelle</firstterm> d'un <type>numeric</type> est le
     nombre de chiffres décimaux de la partie fractionnaire, à droite du
     séparateur de décimales. La 
     <firstterm>précision</firstterm> d'un <type>numeric</type> est le
     nombre total de chiffres significatifs dans le nombre complet, 
     c'est-à-dire le nombre de chiffres de part et d'autre du séparateur.
     Donc, le nombre 23.5141
     a une précision de 6 et une échelle de 4. On peut considérer que 
     les entiers ont une échelle de 0.
   </para>

    <para>
     La précision maximale et l'échelle maximale d'une colonne <type>numeric</type>
     peuvent être toutes deux réglées.
     Pour déclarer une colonne de type numérique, il faut utiliser la
     syntaxe&nbsp;:
<programlisting>NUMERIC(<replaceable>précision</replaceable>, <replaceable>échelle</replaceable>)</programlisting>
     La précision doit être strictement positive, l'échelle positive
     ou NULL.
     Alternativement&nbsp;:
<programlisting>NUMERIC(<replaceable>précision</replaceable>)</programlisting>
     indique une échelle de 0.
<programlisting>NUMERIC</programlisting>
     sans précision ni échelle crée une colonne dans laquelle on
     peut stocker des valeurs de n'importe quelle précision ou
     échelle, dans la limite de la précision implantée. Une colonne de ce type
     n'impose aucune précision à la valeur entrée,
     alors que les colonnes <type>numeric</type> ayant une échelle 
     forcent les valeurs entrées à cette échelle. (Le standard 
     <acronym>SQL</acronym> demande une précision par défaut de 0, 
     c'est-à-dire de forcer la transformation en entiers. Les auteurs
     trouvent cela inutile. Dans un souci de portabilité, 
     il est préférable de toujours indiquer explicitement la précision et
     l'échelle.)
    </para>

    <para>
     Si l'échelle d'une valeur à stocker est supérieure à celle de la colonne, le
     système arrondit la valeur au nombre de décimales indiqué pour la colonne.
     Si le nombre de chiffres à gauche du point
     décimal est supérieur à la différence entre la précision déclarée et l'échelle
     déclarée, une erreur est levée.
    </para>

    <para>
     Les valeurs numériques sont stockées physiquement sans zéro avant ou
     après. Du coup, la précision déclarée et l'échelle de la colonne sont
     des valeurs maximales, pas des allocations fixes (en ce sens, le type
     numérique est plus proche de <type>varchar(<replaceable>n</replaceable>)</type> que
     de <type>char(<replaceable>n</replaceable>)</type>). Le besoin pour le
     stockage réel est de deux octets pour chaque groupe de quatre chiffres
     décimaux, plus cinq à huit octets d'en-tête.
    </para>

    <indexterm>
     <primary>NaN</primary>
     <see>not a number</see>
   </indexterm>

    <indexterm>
     <primary>not a number</primary>
     <secondary>numeric (type de données)</secondary>
    </indexterm>

    <para>
      En plus des valeurs numériques ordinaires, le type <type>numeric</type>
      autorise la valeur spéciale <literal>NaN</literal> qui signifie   
      <quote>not-a-number</quote> (NdT&nbsp;: pas un nombre). Toute opération
      sur <literal>NaN</literal> retourne <literal>NaN</literal>. Pour écrire cette
      valeur comme une constante dans une requête SQL, elle doit être placée
      entre guillemets. Par exemple,
      <literal>UPDATE table SET x = 'NaN'</literal>. En saisie, la chaîne
      <literal>NaN</literal> est reconnue quelque soit
      la casse utilisée.
    </para>

    <note>
     <para>
      Dans la plupart des implémentations du concept <quote>not-a-number</quote>,
      <literal>NaN</literal> est considéré différent de toute valeur numérique
      (ceci incluant <literal>NaN</literal>). Pour autoriser le tri des valeurs
      de type <type>numeric</type> et les utiliser dans des index basés sur le
      tri, <productname>PostgreSQL</productname> traite les valeurs
      <literal>NaN</literal> comme identiques entre elles, mais toutes supérieures
      aux valeurs non <literal>NaN</literal>.
     </para>
    </note>

    <para>
     Les types <type>decimal</type> et <type>numeric</type> sont 
     équivalents. Les deux types sont dans le standard 
     <acronym>SQL</acronym>.
    </para>
   </sect2>


   <sect2 id="datatype-float">
    <title>Types à virgule flottante</title>

    <indexterm zone="datatype-float">
     <primary>real</primary>
    </indexterm>

    <indexterm zone="datatype-float">
     <primary>double precision</primary>
    </indexterm>

    <indexterm>
     <primary>float4</primary>
     <see>real</see>
    </indexterm>

    <indexterm>
     <primary>float8</primary>
     <see>double precision</see>
    </indexterm>

    <indexterm zone="datatype-float">
     <primary>floating point</primary>
    </indexterm>

    <para>
     Les types de données <type>real</type> et <type>double
     precision</type> sont des types numériques inexacts de précision
     variable. En pratique, ils sont généralement conformes à la norme
     <acronym>IEEE</acronym> 754 pour l'arithmétique binaire à 
     virgule flottante (respectivement simple et double précision), 
     dans la mesure où les processeurs, le système d'exploitation et
     le compilateur les supportent.
    </para>

    <para>
     Inexact signifie que certaines valeurs ne peuvent être converties
     exactement dans le format interne. Elles sont, de ce fait, stockées sous
     une forme approchée. Ainsi, stocker puis réafficher ces valeurs
     peut faire apparaître de légers écarts.
     Prendre en compte ces erreurs et la façon dont elles se propagent
     au cours des calculs est le sujet d'une branche entière des
     mathématiques et de l'informatique, qui n'est pas le sujet de ce
     document, à l'exception des points suivants&nbsp;:
     <itemizedlist>
      <listitem>
       <para>
        pour un stockage et des calculs exacts, comme
        pour les valeurs monétaires, le type <type>numeric</type> doit être
        privilégié&nbsp;;
      </para>
      </listitem>

      <listitem>
       <para>
        pour des calculs compliqués avec ces types 
        pour quoi que ce soit d'important, et particulièrement pour
        le comportement aux limites (infini, zéro), l'implantation spécifique
        à la plate-forme doit être étudié avec soin&nbsp;;
       </para>
      </listitem>

      <listitem>
       <para>
        tester l'égalité de deux valeurs à virgule flottante peut ne
        pas donner le résultat attendu.
       </para>
      </listitem>
     </itemizedlist>
    </para>

    <para>
     Sur la plupart des plates-formes, le type <type>real</type> a une
     étendue d'au moins 1E-37 à 1E37 avec une précision d'au moins
     6 chiffres décimaux. Le type <type>double precision</type> a
     généralement une étendue de 1E-307 à 1E+308 avec une précision
     d'au moins 15 chiffres. Les valeurs trop grandes ou trop petites 
     produisent une erreur. Un arrondi peut avoir lieu si la précision
     d'un nombre en entrée est trop grande. Les nombres trop proches
     de zéro qui ne peuvent être représentés autrement que par zéro
     produisent une erreur (underflow).
    </para>

    <indexterm>
     <primary>not a number</primary>
     <secondary>double precision</secondary>
    </indexterm>

    <para>
     En plus des valeurs numériques ordinaires, les types à virgule flottante
     ont plusieurs valeurs spéciales&nbsp;:
<literallayout><literal>Infinity</literal>
<literal>-Infinity</literal>
<literal>NaN</literal></literallayout>
     Elles représentent les valeurs spéciales de l'IEEE 754,
     respectivement <quote>infinity</quote> (NdT&nbsp;: infini),
     <quote>negative infinity</quote> (NdT&nbsp;: infini négatif) et
     <quote>not-a-number</quote> (NdT&nbsp;: pas un nombre) (sur une machine
     dont l'arithmétique à virgule flottante ne suit pas l'IEEE 754, ces
     valeurs ne fonctionnent probablement pas comme espéré). Lorsqu'elles
     sont saisies en tant que constantes dans une commande SQL, ces valeurs
     doivent être placées entre guillemets. Par exemple, <literal>UPDATE
     table SET x = 'Infinity'</literal>. En entrée, ces valeurs sont reconnues
     quelque soit la casse utilisée.
    </para>

    <note>
     <para>
      IEEE754 spécifie que <literal>NaN</literal> ne devrait pas être considéré
      égale à toute autre valeur en virgule flottante (ceci incluant
      <literal>NaN</literal>). Pour permettre le tri des valeurs en virgule
      flottante et leur utilisation dans des index basés sur des arbres,
      <productname>PostgreSQL</productname> traite les valeurs
      <literal>NaN</literal> comme identiques entre elles, mais supérieures
      à toute valeur différente de <literal>NaN</literal>.
     </para>
    </note>

    <para>
     <productname>PostgreSQL</productname> autorise aussi la notation
     <type>float</type> du standard SQL, ainsi que 
     <type>float(<replaceable>p</replaceable>)</type> pour indiquer
     des types numériques inexacts. <replaceable>p</replaceable>
     indique la précision minimale acceptable en chiffres binaires.
     <productname>PostgreSQL</productname> accepte de
     <type>float(1)</type> à <type>float(24)</type>, qu'il transforme en
     type <type>real</type>, et de
     <type>float(25)</type> à <type>float(53)</type>, qu'il transforme en
     type <type>double precision</type>. Toute valeur de 
     <replaceable>p</replaceable> hors de la zone des valeurs possibles
     produit une erreur. <type>float</type> sans précision est compris
     comme <type>double precision</type>.
    </para>

    <note>
     <para>
      Avant <productname>PostgreSQL</productname> 7.4, la précision
      d'un <type>float(<replaceable>p</replaceable>)</type> était
      supposée indiquer une précision en chiffres décimaux.
      Cela a été corrigé pour respecter le standard SQL, qui
      indique que la précision est indiquée en chiffres binaires.
      L'affirmation que les <type>real</type> et les
      <type>double precision</type> ont exactement 24 et 53 bits
      dans la mantisse est correcte pour les implémentations des
      nombres à virgule flottante respectant le standard IEEE.
      Sur les plates-formes non-IEEE, c'est peut-être un peu sous-estimé
      mais, pour plus de simplicité, la gamme de valeurs pour
      <replaceable>p</replaceable> est utilisée sur toutes les
      plates-formes.
     </para>
    </note>

   </sect2>

   <sect2 id="datatype-serial">
    <title>Types seriés</title>

    <indexterm zone="datatype-serial">
     <primary>serial</primary>
    </indexterm>

    <indexterm zone="datatype-serial">
     <primary>bigserial</primary>
    </indexterm>

    <indexterm zone="datatype-serial">
     <primary>serial4</primary>
    </indexterm>

    <indexterm zone="datatype-serial">
     <primary>serial8</primary>
    </indexterm>

    <indexterm>
     <primary>auto-increment</primary>
     <see>serial</see>
    </indexterm>

    <indexterm>
     <primary>séquence</primary>
     <secondary>type serial</secondary>
    </indexterm>

    <para>
     Les types de données <type>serial</type> et <type>bigserial</type>
     ne sont pas de vrais types, mais plutôt un raccourci de notation
     pour créer des colonnes d'identifiants uniques (similaires à la
     propriété <literal>AUTO_INCREMENT</literal> utilisée par d'autres
     SGBD). Dans la version actuelle, indiquer&nbsp;:

<programlisting>CREATE TABLE <replaceable class="parameter">nom_de_table</replaceable> (
    <replaceable class="parameter">nom_de_colonne</replaceable> SERIAL
);</programlisting>

     est équivalent à écrire :

<programlisting>CREATE SEQUENCE <replaceable class="parameter">nom_de_table</replaceable>_<replaceable class="parameter">nom_de_colonne</replaceable>_seq;
CREATE TABLE <replaceable class="parameter">nom_de_table</replaceable> (
    <replaceable class="parameter">nom_de_colonne</replaceable> integer NOT NULL DEFAULT nextval('<replaceable class="parameter">nom_de_table</replaceable>_<replaceable class="parameter">nom_de_colonne</replaceable>_seq') NOT NULL
);
ALTER SEQUENCE <replaceable class="parameter">nom_de_table</replaceable>_<replaceable class="parameter">nom_de_colonne</replaceable>_seq OWNED BY <replaceable class="parameter">nom_de_table</replaceable>.<replaceable class="parameter">nom_de_colonne</replaceable>;</programlisting>

     Une colonne d'entiers a ainsi été créée dont la valeur par défaut
     est assignée par un générateur de
     séquence. Une contrainte <literal>NOT NULL</literal> est ajoutée pour
     s'assurer qu'une valeur NULL ne puisse pas être explicitement 
     insérée. (Dans la plupart des cas, une 
     contrainte <literal>UNIQUE</literal> ou <literal>PRIMARY KEY</literal>
     peut être ajoutée pour
     interdire que des doublons soient créés par accident, mais ce
     n'est pas automatique.) Enfin, la séquence est marquée <quote>owned by</quote>
     (possédée par) la colonne pour qu'elle soit supprimée si la colonne ou
     la table est supprimée.
    </para>

    <note>
     <para>
      Avant <productname>PostgreSQL</productname> 7.3, 
      <type>serial</type> sous-entendait <literal>UNIQUE</literal>.
      Ce n'est plus automatique. Pour qu'une colonne de type
      serial soit unique ou soit une clé primaire, il faut le préciser,
      comme pour les autres types.
     </para>
    </note>

    <para>
     Pour insérer la valeur suivante de la séquence dans la colonne
     <type>serial</type>, il faut préciser que la valeur par
     défaut de la colonne doit être utilisée. Cela peut se faire de deux façons&nbsp;: soit en
     excluant cette colonne de la liste des colonnes de la commande 
     <command>INSERT</command> soit en utilisant le mot clé
     <literal>DEFAULT</literal>.
    </para>

    <para>
     Les types <type>serial</type> et <type>serial4</type> sont
     identiques&nbsp;: ils créent tous les deux des colonnes 
     <type>integer</type>. Les types <type>bigserial</type> et 
     <type>serial8</type> fonctionnent de la même façon mais créent des
     colonnes <type>bigint</type>. <type>bigserial</type> doit
     être utilisé si plus de 2<superscript>31</superscript>
     identifiants sont prévus sur la durée de vie de la table.
    </para>

    <para>
     La séquence créée pour une colonne <type>serial</type> est automatiquement
     supprimée quand la colonne correspondante est supprimée. La séquence peut
     être détruite sans supprimer la colonne, mais 
     la valeur par défaut de la colonne est alors également supprimée.
    </para>
   </sect2>
  </sect1>

  <sect1 id="datatype-money">
   <title>Types monétaires</title>

   <para>
    Le type <type>money</type> stocke un montant en devise avec
    un nombre fixe de décimales. Voir le <xref linkend="datatype-money-table"/>.
    De nombreux formats sont acceptés en entrée, dont les entiers et
    les nombre à virgule flottante, ainsi que les formats classiques
    de devises, comme <literal>'$1,000.00'</literal>. 
    Le format de sortie est généralement dans le dernier format, mais dépend
    de la locale.
    Les valeurs numériques qui ne sont pas entre guillemets peuvent être
    converties dans le type <type>money</type> en convertissant la valeur
    numérique en <type>text</type> puis en <type>money</type>&nbsp;:
<programlisting>
SELECT 1234::text::money;
</programlisting>
    Il n'existe pas de moyen simple de faire l'inverse d'une façon
    indépendante de la locale, donc en convertissant une valeur de type
    <type>money</type> en un type numérique.
    Si vous connaissez le symbole de la monnaie et le séparateur des
    milliers, vous pouvez utiliser <function>regexp_replace()</function>&nbsp;:
<programlisting>
SELECT regexp_replace('52093.89'::money::text, '[$,]', '', 'g')::numeric;
</programlisting>

   </para>

   <para>
    Comme l'affichage de ce type de données est sensible à la casse, charger
    des données du type  <type>money</type> dans une base de données qui a une
    configuration différente de <varname>lc_monetary</varname> pourrait ne pas
    fonctionner. Pour éviter les problèmes, assurez-vous, avant de restaurer une
    sauvegarde, que la variable <varname>lc_monetary</varname> a la même valeur
    ou une valeur équivalente à celle qui était configurée lors de la
    sauvegarde.
   </para>

    <table id="datatype-money-table">
     <title>Types monétaires</title>
     <tgroup cols="4">
     <colspec colnum="1" colwidth="0.7*"/>
     <colspec colnum="2" colwidth="0.7*"/>
     <colspec colnum="3" colwidth="1.3*"/>
     <colspec colnum="4" colwidth="1.3*"/>
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Taille de stockage</entry>
        <entry>Description</entry>
        <entry>Étendue</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>money</entry>
        <entry>8 octets</entry>
        <entry>montant monétaire</entry>
        <entry>-92233720368547758.08 à +92233720368547758.07</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
  </sect1>


  <sect1 id="datatype-character">
   <title>Types caractère</title>

   <indexterm zone="datatype-character">
    <primary>Chaîne de caractères</primary>
    <secondary>types de données</secondary>
   </indexterm>

   <indexterm>
    <primary>Chaîne</primary>
    <see>Chaîne de caractères</see>
   </indexterm>

   <indexterm zone="datatype-character">
    <primary>character</primary>
   </indexterm>

   <indexterm zone="datatype-character">
    <primary>character varying</primary>
   </indexterm>

   <indexterm zone="datatype-character">
    <primary>text</primary>
   </indexterm>

   <indexterm zone="datatype-character">
    <primary>char</primary>
   </indexterm>

   <indexterm zone="datatype-character">
    <primary>varchar</primary>
   </indexterm>

    <table id="datatype-character-table">
     <title>Types caractère</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Description</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><type>character varying(<replaceable>n</replaceable>)</type>, <type>varchar(<replaceable>n</replaceable>)</type></entry>
        <entry>Longueur variable avec limite</entry>
       </row>
       <row>
        <entry><type>character(<replaceable>n</replaceable>)</type>, <type>char(<replaceable>n</replaceable>)</type></entry>
        <entry>longueur fixe, complété par des espaces</entry>
       </row>
       <row>
        <entry><type>text</type></entry>
        <entry>longueur variable illimitée</entry>
       </row>
     </tbody>
     </tgroup>
    </table>

   <para>
    Le <xref linkend="datatype-character-table"/> présente les types
    génériques disponibles dans <productname>PostgreSQL</productname>.
   </para>

   <para>
    <acronym>SQL</acronym> définit deux types de caractères principaux&nbsp;:
    <type>character varying(<replaceable>n</replaceable>)</type> et
    <type>character(<replaceable>n</replaceable>)</type> où <replaceable>n</replaceable>
    est un entier positif.
    Ces deux types permettent de stocker des chaînes de caractères de taille
    inférieure ou égale à <replaceable>n</replaceable>. Toute tentative
    d'insértion d'une chaîne plus longue conduit à une erreur, à moins que les 
    caractères en excès ne soient tous des espaces, auquel cas la chaîne 
    est tronquée à la taille maximale (cette exception étrange est imposée
    par la norme <acronym>SQL</acronym>).
    Si la chaîne à stocker est plus petite que la taille déclarée,
    les valeurs de type <type>character</type> sont complétées par des
    espaces, celles de type <type>character varying</type> sont stockées en
    l'état.
   </para>

    <para>
     Si une valeur est explicitement transtypée en  
     <type>character varying(<replaceable>n</replaceable>)</type> ou en
     <type>character(<replaceable>n</replaceable>)</type>, une valeur trop
     longue est tronquée à <replaceable>n</replaceable> caractères sans
     qu'aucune erreur ne soit levée (ce comportement est aussi imposé par
     la norme <acronym>SQL</acronym>.)
    </para>

   <para>
    Les notations <type>varchar(<replaceable>n</replaceable>)</type> et
    <type>char(<replaceable>n</replaceable>)</type> sont des alias de
    <type>character varying(<replaceable>n</replaceable>)</type> et
    <type>character(<replaceable>n</replaceable>)</type>, respectivement.
    <type>character</type> sans indication de taille est équivalent à
    <type>character(1)</type>. Si <type>character varying</type> est
    utilisé sans indicateur de taille, le type accepte des chaînes de
    toute taille. Il s'agit là d'une spécificité de 
    <productname>PostgreSQL</productname>.
   </para>

   <para>
    De plus, <productname>PostgreSQL</productname> propose aussi le type
    <type>text</type>, qui permet de stocker des chaînes de n'importe
    quelle taille. Bien que le type <type>text</type> ne soit pas
    dans le standard <acronym>SQL</acronym>, plusieurs autres systèmes de
    gestion de bases de données SQL le proposent également.
   </para>

<!-- padded : complété, aligné, autre chose ? padding : remplissage -->
<!-- trailing spaces : espaces finales -->
   <para>
    Les valeurs de type <type>character</type> sont complétées physiquement à
    l'aide d'espaces pour atteindre la longueur <replaceable>n</replaceable>
    indiquée. Ces valeurs sont également
    stockées et affichées de cette façon. Les espaces de remplissage
    n'ont, toutefois, aucune signification sémantique. Les espaces finales
    sont ignorées lors de la comparaison de deux valeurs de type
    <type>character</type> et sont supprimées lors de la conversion
    d'une valeur <type>character</type> en un des autres types chaîne. Ces
    espaces <emphasis>ont</emphasis> une signification sémantique pour
    les valeurs de type <type>character varying</type> et <type>text</type>.
   </para>

   <para>
    L'espace nécessaire pour une chaîne de caractères courte (jusqu'à 126 octets)
    est de un octet, plus la taille de la chaîne qui inclut le remplissage avec
    des espaces dans le cas du type <type>character</type>. Les chaînes plus
    longues ont quatre octets d'en-tête au lieu d'un seul. Les chaînes longues
    sont automatiquement compressées par le système, donc le besoin pourrait
    être moindre. Les chaînes vraiment très longues sont stockées dans des
    tables supplémentaires, pour qu'elles n'empêchent pas d'accéder rapidement
    à des valeurs plus courtes.
    Dans tous les cas, la taille maximale possible pour une chaîne de