root/traduc/branches/bv747/manuel/datatype.sgml

<!--
$Header: /var/lib/cvs/pgsql-fr/sgml/datatype.sgml,v 1.7.2.2 2005/07/15 06:33:36 guillaume Exp $
-->

 <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> a un large choix de types de 
   données disponibles nativement.
   Les utilisateurs peuvent ajouter de nouveaux types à 
   <productname>PostgreSQL</productname> en utilisant la commande
   <command>CREATE TYPE</command>.
  </para>

  <para>
   <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.
   De plus, certains types de données internes ou obsolètes sont 
   disponibles, mais ils ne sont pas listés ici.
 
  </para>

   <table id="datatype-table">
    <title>Types de données</title>
    <tgroup cols="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é de 8 octets</entry>
      </row>

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

      <row>
       <entry><type>bit</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(<replaceable>n</replaceable>)</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> Boite rectangulaire dans le plan</entry>
      </row>

      <row>
       <entry><type>bytea</type></entry>
       <entry></entry>
       <entry>Donnée binaire</entry>
      </row>

      <row>
       <entry><type>character varying(<replaceable>n</replaceable>)</type></entry>
       <entry><type>varchar(<replaceable>n</replaceable>)</type></entry>
       <entry>Suite 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>Suite 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é de 4 octets</entry>
      </row>

      <row>
       <entry><type>interval(<replaceable>p</replaceable>)</type></entry>
       <entry></entry>
       <entry>Interval de temps</entry>
      </row>

      <row>
       <entry><type>line</type></entry>
       <entry></entry>
       <entry>Ligne infinie dans le plan (partiellement disponible)</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 d'une devise</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 de la précision indiquée</entry>
      </row>
      
      <row>
       <entry><type>path</type></entry>
       <entry></entry>
       <entry>Chemin ouvert et fermé 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é de 2 octets</entry>
      </row>

      <row>
       <entry><type>serial</type></entry>
       <entry><type>serial4</type></entry>
       <entry>Entier de 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><type>timestamp</type></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>
     </tbody>
    </tgroup>
   </table>

  <note>
   <title>Compatibilité</title>
   <para>
    Les types suivants sont conformes à la norme <acronym>SQL</acronym>:
    <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).
   </para>
  </note>

  <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 type de données
   internes ont un format externe évident. Cependant, certains types
   sont soit spécifiques à <productname>PostgreSQL</productname>,
   comme les chemins ouverts et fermés, ou ont différents formats 
   possibles, comme les types de données de date et d'heure.
   Certaines fonctions d'entrée et de sortie ne sont pas inversables:
   Le résultat de la fonction de sortie peut perdre de la précision
   comparé à l'entrée initiale.
  </para>

  <para>
   Certains des opérateurs et des fonctions (comme l'addition et la
   multiplication) n'effectuent pas de vérification d'erreur à 
   l'exécution, pour améliorer la vitesse d'exécution.
   Dans certains systèmes, pour certains types de données, les 
   opérateurs numériques peuvent causer des dépassements de précision
   sans afficher erreur.
  </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 nombre à virgule flottante de 4 ou 8 octets, et de décimaux à
    précision fixe.
</para>

    <table id="datatype-numeric-table">
     <title>Types numériques</title>
     <tgroup cols="4">
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Taille de stockage</entry>
        <entry>Description</entry>
        <entry>Étendue</entry>
       </row>
      </thead>

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

       <row>
        <entry><type>decimal</></entry>
        <entry>variable</entry>
        <entry>Précision indiquée par l'utilisateur. Valeurs exactes</entry>
        <entry>pas de limite</entry>
       </row>
       <row>
        <entry><type>numeric</></entry>
        <entry>variable</entry>
        <entry>Précision indiquée par l'utilisateur. Valeurs exactes</entry>
        <entry>pas de limite</entry>
       </row>

       <row>
        <entry><type>real</></entry>
        <entry>4 octets</entry>
        <entry>Précision variable. Valeurs inexactes</entry>
        <entry>précision de 6 décimales</entry>
       </row>
       <row>
        <entry><type>double precision</></entry>
        <entry>8 octets</entry>
        <entry>Précision variable. Valeurs inexactes</entry>
        <entry>précision de 15 décimales</entry>
       </row>

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

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

   <para>
    La syntaxe des constantes pour les types numériques est décrite
    dans <xref linkend="sql-syntax-constants">. Les types numériques
    ont un ensemble complet d'opérateurs arithmétiques et de fonctions.
    Référez vous à <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 trop grande ou trop petite
     produite une erreur.
    </para>

    <para>
     Le type <type>integer</type> est le plus courant. Il offre un
     bon compromis entre capacité, espace utilisé et performances.
     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). Ceci dit, nous ne connaissons pas de
     plate-forme raisonnable sur laquelle il en va ainsi.
    </para>

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

    <note>
     <para>
      Si vous avez une colonne de type <type>smallint</type> ou
      <type>bigint</type> avec un index, vous pourrez rencontrer des 
      problèmes pour que le système utilise cet index. Par exemple, 
      une clause de la forme
<programlisting>
... WHERE smallint_column = 42
</programlisting>
      n'utilisera pas l'index, parce que le système assigne le type
      <type>integer</type> à la constante 42, et 
      <productname>PostgreSQL</productname> ne sait pour l'instant
      pas utiliser un index lorsque deux types de données différents
      sont utilisés. Un contournement est d'entourer la constante
      entre apostrophes, comme:
<programlisting>
... WHERE smallint_column = '42'
</programlisting>
      Cela forcera le système à retarder la résolution de type, ce
      qui permettra d'assigner le bon type à la constante.
     </para>
    </note>

   </sect2>

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

    <indexterm zone="datatype-numeric-decimal">
     <primary>numeric (data type)</primary>
    </indexterm>

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

    <para>
     Le type <type>numeric</type> peut stocker des nombres avec 
     jusqu'à 1000 chiffres significatifs et effectuer des calculs
     exacts. Il est spécialement recommander pour stocker les montants
     financiers et autres quantités pour lesquelles l'exactitude est 
     indispensable. Néanmoins, le type <type>numeric</type> est très
     lent comparé aux types à virgule flottante décrits dans la
     section suivante.
    </para>

    <para>
     Dans ce qui suit, on utilise les termes suivants: 
     L'<firstterm>échelle</firstterm> d'un <type>numeric</type> est le
     nombre de chiffres décimaux de la partie fractionnaire. La 
     <firstterm>précision</firstterm> d'un <type>numeric</type> est le
     nombre total de chiffres significatifs dans le nombre entier, 
     c'est à dire avant et après la virgule. 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 et l'échelle d'un numérique peuvent être réglés.
     Pour déclarer une colonne de type numérique, il faut utiliser la
     syntaxe.
<programlisting>
NUMERIC(<replaceable>précision</replaceable>, <replaceable>échelle</replaceable>)
</programlisting>
     La précision pour être strictement positive, l'échelle positive
     ou nulle.
     Alternativement, 
<programlisting>
NUMERIC(<replaceable>précision</replaceable>)
</programlisting>
     indique une échelle de 0.  Préciser
<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, jusqu'à la limite de précision. Une colonne de ce type
     ne forcera aucune valeur entrée à une précision particulière,
     alors que les colonnes <type>numeric</type> avec 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. Nous
     trouvons ça inutile. Si vous êtes soucieux de portabilité, 
     précisez toujours la précision et l'échelle explicitement.)
    </para>

    <para>
     Si la précision ou l'échelle d'une valeur sont supérieures à la
     précision ou à l'échelle d'une colonne, le système tentera 
     d'arrondir la valeur. Si la valeur ne peut être arrondie d'une
     manière qui corresponde aux limites déclarées, alors une erreur
     est produite.
    </para>

    <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 à précision variable
     inexacts. 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, et sont stockées sous forme
     d'approximations, si bien que 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. Nous n'en dirons pas plus que 
     ce qui suit:
     <itemizedlist>
      <listitem>
       <para>
        Si vous avez besoin d'un stockage et de calculs exacts, comme
        pour les valeurs monétaires, utilisez plutôt le type
        <type>numeric</type>.
      </para>
      </listitem>

      <listitem>
       <para>
        Si vous voulez faire des calculs compliqués avec ces types 
        pour quoi que ce soit d'important, et particulièrement si
        vous comptez sur certains comportements aux limites (infinis, 
        zéro), alors vous devriez étudier le comportement de votre
        plate-forme avec soin.
       </para>
      </listitem>

      <listitem>
       <para>
        Tester l'égalité de deux valeurs à virgule flottante peux 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>

    <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. Ici, <replaceable>p</replaceable>
     indique la précision minimale acceptable en chiffres binaires.
     <productname>PostgreSQL</productname> accepte 
     <type>float(1)</type> à <type>float(24)</type>, transformés en
     type <type>real</type> et 
     <type>float(25)</type> to <type>float(53)</type>, transformés en
     type <type>double precision</type>. Toute valeur de 
     <replaceable>p</replaceable> hors de la zone de valeurs possible
     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.
      Nous l'avons corrigée 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 Série</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 décrire des colonnes d'identifiants uniques (similaires à la
     propriété <literal>AUTO_INCREMENT</literal> utilisée par d'autres
     SGBD). Dans la version actuelle, indiquer 

<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">colname</replaceable>_seq;
CREATE TABLE <replaceable class="parameter">nom_de_table</replaceable> (
    <replaceable class="parameter">nom_de_colonne</replaceable> integer DEFAULT nextval('<replaceable class="parameter">nom_de_table</replaceable>_<replaceable class="parameter">nom_de_colonne</replaceable>_seq') NOT NULL
);
</programlisting>

     Ainsi, nous avons créé une colonne d'entiers et fait en sorte
     que ses valeurs par défaut soient assignées par un générateur de
     séquence. Une contrainte <literal>NOT NULL</literal> est ajoutée pour
     s'assurer qu'une valeur Nulle ne puisse pas être explicitement 
     insérée. Dans la plupart des cas, vous voudrez aussi ajouter une 
     contrainte <literal>UNIQUE</literal> ou <literal>PRIMARY KEY</literal> pour
     interdire que des doublons soient créés par accident, mais ce
     n'est pas automatique.
    </para>

    <note>
     <para>
      Avant <productname>PostgreSQL</productname> 7.3, 
      <type>serial</type> sous entendait <literal>UNIQUE</literal>.
      Ce n'est plus automatique. Si vous souhaitez qu'une colonne
      serial soit unique ou soit une clé primaire, il faut le préciser,
      comme pour un autre type.
     </para>
    </note>

    <para>
     Pour insérer la valeur suivante de la séquence dans la colonne 
     <type>serial</type>, il faut faire en sorte d'utiliser la valeur 
     par défaut de la colonne.
     Cela peut se faire de deux façons: soit en excluant cette
     colonne de la liste des colonnes de la commande 
     <command>INSERT</command>, ou en utilisant le mot clé
     <literal>DEFAULT</literal>.
    </para>

    <para>
     Les types <type>serial</type> et <type>serial4</type> sont
     identiques: 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, et créent des
     colonnes <type>bigint</type>. <type>bigserial</type> doit
     être utilisé si vous pensez utiliser plus de 2<superscript>31</superscript>
     identifiants dans toute la 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, et ne peut l'être autrement. (Ce n'était
     pas le cas avant la version 7.3 de 
     <productname>PostgreSQL</productname>. Notez que ce lien de
     suppression automatique de séquence ne fonctionnera pas pour
     une base restaurée d'une sauvegarde SQL (dump) antérieure à la 
     version 7.3. La sauvegarde ne contient en effet pas l'information
     nécessaire à l'établissement du lien de dépendance.)
     De plus, ce lien de dépendance n'est mis que pour la colonne de
     type <type>serial</> elle même. Si d'autres colonnes référencent
     la séquence (par exemple en appellent la fonction 
     <function>nextval</>), elles ne peuvent plus fonctionner si la 
     séquence est supprimée.
     Utiliser le type <type>serial</> de cette façon n'est pas recommandé.
     Si vous souhaitez remplir plusieurs colonnes avec le même générateur de 
     séquence, créez la séquence indépendamment.
    </para>
   </sect2>
  </sect1>

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

   <note>
    <para>
     Le type <type>money</type> est obsolète. Utilisez plutôt les  
     types <type>numeric</type> ou <type>decimal</type>, en 
     combinaison avec la fonction <function>to_char</function>.
    </para>
   </note>

   <para>
    Le type <type>money</type> stocke un montant d'une devise avec
    un nombre fixe de chiffres après la virgule. Voir <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 ce dernier, mais dépend de la
    localisation.
   </para>

    <table id="datatype-money-table">
     <title>Types monétaires</title>
     <tgroup cols="4">
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Taille de stockage</entry>
        <entry>Description</entry>
        <entry>Étendue</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>money</entry>
        <entry>4 octets</entry>
        <entry>montants de devise</entry>
        <entry>-21474836.48 à +21474836.47</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
  </sect1>


  <sect1 id="datatype-character">
   <title>Types caractères</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ères</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Description</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><type>character varying(<replaceable>n</>)</type>, <type>varchar(<replaceable>n</>)</type></entry>
        <entry>Longueur variable avec limite</entry>
       </row>
       <row>
        <entry><type>character(<replaceable>n</>)</type>, <type>char(<replaceable>n</>)</type></entry>
        <entry>longueur fixe, comblé avec des espaces</entry>
       </row>
       <row>
        <entry><type>text</type></entry>
        <entry>longueur variable illimitée</entry>
       </row>
     </tbody>
     </tgroup>
    </table>

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

   <para>
    <acronym>SQL</acronym> définit deux types de caractères principaux:
    <type>character varying(<replaceable>n</>)</type> et
    <type>character(<replaceable>n</>)</type>, où <replaceable>n</>
    est un entier positif.
    Ces deux types peuvent stocker des chaînes de caractères de taille
    inférieure ou égale à <replaceable>n</replaceable>. Une tentative d'insérer
    une chaîne trop longue donnera une erreur, à moins que les 
    caractères en trop soient tous des espaces, auquel cas la chaîne 
    sera tronquée à la taille maximale. (Cette exception un rien 
    étrange est imposée par la norme <acronym>SQL</acronym>).
    Si la chaîne à stocker est plus petite que la taille déclarée,
    elle sera complétée par des espaces pour le type 
    <type>character</type>, et elle sera stockée telle quelle pour le 
    type <type>character varying</type>.
   </para>

    <para>
     Si vous transtypez (cast) explicitement une valeur en 
     <type>character varying(<replaceable>n</replaceable>)</type> ou en
     <type>character(<replaceable>n</replaceable>)</type>, alors une chaîne trop
     longue sera tronquée à <replaceable>n</replaceable> caractères sans que
     cela génère d'erreur. (Ce comportement est aussi imposé par
     la norme <acronym>SQL</acronym>.)
    </para>

   <note>
    <para>
     Avant <productname>PostgreSQL</productname> 7.2, les chaînes trop longues
     étaient toujours tronquées sans générer d'erreur, que ce soit
     par une transformation explicite ou implicite.
    </para>
   </note>

   <para>
    Les notations <type>varchar(<replaceable>n</replaceable>)</type> et
    <type>char(<replaceable>n</replaceable>)</type> sont des alias pour
    <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
    toutes tailles. Il s'agit là d'une spécificité de 
    <productname>PostgreSQL</productname>.
   </para>

   <para>
    <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 aussi.
   </para>

   <para>
    L'espace de stockage utilisé pour les données de ces types est
    de 4 octets en plus de la taille de la chaîne, plus le remplissage
    dans le cas du type <type>character</type>.
    Les grandes chaînes sont automatiquement compressées par le 
    système, si bien que l'espace effectivement utilisé peut être
    inférieur. Les grandes chaînes sont aussi stockées dans des tables
    d'arrière plan, afin de ne pas ralentir l'accès aux autres
    colonnes plus petites.
    Dans tous les cas, la taille maximale possible pour une chaîne de 
    caractères est de l'ordre 1 Go. (La taille maximale pour 
    <replaceable>n</replaceable> dans la déclaration de type est plus petite
    que cela. Il ne serait pas très utile de le changer parce qu'avec 
    l'encodage des caractères sur plusieurs octets, le nombre de caractères
    et d'octets peuvent être très différents. Si vous voulez stocker
    de longues chaînes sans limite de taille spécifique, utilisez le type 
    <type>text</type> ou le type <type>character varying</type> sans indiquer
    de taille, plutôt que d'indiquer une limite de taille arbitraire.)
   </para>

   <tip>
    <para>
     Il n'y a pas de différence de performance entre ces trois types,
     à part la place disque supplémentaire pour le type qui remplit les
     vides avec des espaces.
    </para>
   </tip>

   <para>
    Voyez <xref linkend="sql-syntax-strings"> pour avoir plus d'informations
    sur la syntaxe des littéraux de chaînes, et <xref linkend="functions">
    pour avoir des informations sur les opérateurs et les fonctions.
   </para>

   <example>
    <title>Utilisation des types caractères</title>

<programlisting>
CREATE TABLE test1 (a character(4));
INSERT INTO test1 VALUES ('ok');
SELECT a, char_length(a) FROM test1; -- <co id="co.datatype-char">
<computeroutput>
  a   | char_length
------+-------------
 ok   |           4
</computeroutput>

CREATE TABLE test2 (b varchar(5));
INSERT INTO test2 VALUES ('ok');
INSERT INTO test2 VALUES ('bien      ');
INSERT INTO test2 VALUES ('trop long');
<computeroutput>ERROR:  value too long for type character varying(5)</computeroutput>
INSERT INTO test2 VALUES ('trop long'::varchar(5)); -- troncature explicite
SELECT b, char_length(b) FROM test2;
<computeroutput>
   b   | char_length
-------+-------------
 ok    |           2
 bien  |           5
 trop  |           5
</computeroutput>
</programlisting>
    <calloutlist>
     <callout arearefs="co.datatype-char">
      <para>
       La fonction <function>char_length</function> est décrite dans
       <xref linkend="functions-string">.
      </para>
     </callout>
    </calloutlist>
   </example>

   <para>
    Il y a deux autres types caractères de taille constante dans
    <productname>PostgreSQL</productname>, décrits dans <xref
    linkend="datatype-character-special-table">. Le type <type>name</type>
    existe <emphasis>seulement</emphasis> pour le stockage des identifiants
    dans les catalogues systèmes, et n'est pas destiné à être utilisé par
    les utilisateurs normaux. Sa taille est actuellement définie à 64 octets 
    (63 utilisables plus le terminateur), mais doit être référencée en
    utilisant la constante <symbol>NAMEDATALEN</symbol>. La taille est
    définie à la compilation (et est donc ajustable pour des besoins 
    particuliers). La taille maximale par défaut pourrait changer dans une
    prochaine version. Le type <type>"char"</type> (notez les guillemets)
    est différent de <type>char(1)</type> car il n'utilise qu'un seul octet 
    de stockage. Il est utilisé dans les catalogues systèmes comme un type 
    d'énumération économique.
   </para>

    <table id="datatype-character-special-table">
     <title>Types caractères spéciaux</title>
     <tgroup cols="3">
      <thead>
       <row>
        <entry>Nom</entry>
        <entry>Taille de stockage</entry>
        <entry>Description</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><type>"char"</type></entry>
        <entry>1 octet</entry>
        <entry>type interne de 1 caractère</entry>
       </row>
       <row>
        <entry><type>name</type></entry>
        <entry>64 octets</entry>
        <entry>type interne pour les noms d'objets</entry>
       </row>
      </tbody>
     </tgroup>
    </table>

  </sect1>

 <sect1 id="datatype-binary">
  <title>Types de données binaires</title>

  <indexterm zone="datatype-binary">
   <primary>binary data</primary>
  </indexterm>

  <indexterm zone="datatype-binary">
   <primary>bytea</primary>
  </indexterm>
   <para>
    Le type de données <type>bytea</type> permet de stocker des chaînes
    binaires; voir <xref linkend="datatype-binary-table">.
   </para>

   <table id="datatype-binary-table">
    <title>Types de données binaires</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Nom</entry>
       <entry>Espace de stockage</entry>
       <entry>Description</entry>