Changeset 756

Show
Ignore:
Timestamp:
10/17/07 22:39:31 (1 year ago)
Author:
gleu
Message:

Quelques nouvelles traductions (closes #174, #175, #176, #177, #178, #179).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • traduc/trunk/manuel/config.xml

    r753 r756  
    39223922       <indexterm><primary>tablespace</primary><secondary>temporary</secondary></indexterm> 
    39233923       <para> 
    3924         This variable specifies tablespace(s) in which to create temporary 
    3925         objects (temp tables and indexes on temp tables) when a 
    3926         <command>CREATE</command> command does not explicitly specify a tablespace. 
    3927         Temporary files for purposes such as sorting large data sets 
    3928         are also created in these tablespace(s). 
    3929        </para> 
    3930  
    3931        <para> 
    3932         The value is a list of names of tablespaces.  When there is more than 
    3933         one name in the list, <productname>PostgreSQL</productname> chooses a random 
    3934         member of the list each time a temporary object is to be created; 
    3935         except that within a transaction, successively created temporary 
    3936         objects are placed in successive tablespaces from the list. 
    3937         If any element of the list is an empty string, 
    3938         <productname>PostgreSQL</productname> will automatically use the default 
    3939         tablespace of the current database instead. 
    3940        </para> 
    3941  
    3942        <para> 
    3943         When <varname>temp_tablespaces</varname> is set interactively, specifying a 
    3944         nonexistent tablespace is an error, as is specifying a tablespace for 
    3945         which the user does not have <literal>CREATE</literal> privilege.  However, 
    3946         when using a previously set value, nonexistent tablespaces are 
    3947         ignored, as are tablespaces for which the user lacks 
    3948         <literal>CREATE</literal> privilege.  In particular, this rule applies when 
    3949         using a value set in <filename>postgresql.conf</filename>. 
     3924        Cette variable spécifie le (ou les) tablespace dans lequel sera créé 
     3925        les objets temporaires (tables et index temporaires sur des tables 
     3926        temporaires) quand une commande <command>CREATE</command> n'explicite 
     3927        pas un tablespace. Les fichiers temporaires dû à des tris de gros 
     3928        ensembles de données sont aussi créés dans ce tablespace. 
     3929       </para> 
     3930 
     3931       <para> 
     3932        Cette valeur est une liste de noms de tablespaces. Quand cette liste 
     3933        contient plus d'un nom, <productname>PostgreSQL</productname> choisit 
     3934        un membre de la liste au hasard à chaque fois qu'un objet temporaire doit 
     3935        être créé. Par contre, dans une transaction, les objets temporaires 
     3936        créés successivement sont placés dans les tablespaces successifs de la 
     3937        liste. Si un élément de la liste est une chaîne vide, 
     3938        <productname>PostgreSQL</productname> utilisera automatiquement le 
     3939        tablespace par défaut de la base en cours. 
     3940       </para> 
     3941 
     3942       <para> 
     3943        Quand <varname>temp_tablespaces</varname> est configuré interactivement, 
     3944        spécifier un tablespace inexistant est une erreur. De même, une erreur 
     3945        est renvoyée si l'utilisateur n'a pas le droit <literal>CREATE</literal> 
     3946        sur le tablespace indiqué. Néanmoins, lors de l'utilisation d'une 
     3947        valeur configurée précédemment, les tablespaces inexistants sont ignorés 
     3948        comme le sont les tablespaces pour lesquels l'utilisateur n'a pas le droit 
     3949        <literal>CREATE</literal>. En particulier, cette règle s'applique lors 
     3950        de l'utilisateur d'une valeur configurée dans le fichier 
     3951        <filename>postgresql.conf</filename>. 
    39503952       </para> 
    39513953 

  • traduc/trunk/manuel/cvs.xml

    r735 r756  
    4040  code source du serveur <productname>PostgreSQL</productname> vers un 
    4141  serveur local. 
    42   Our CVS Wiki, <ulink 
    43   url="http://developer.postgresql.org/index.php/Working_with_CVS"></ulink>, 
    44   has additional details on working with CVS. 
     42  Notre <ulink 
     43  url="http://developer.postgresql.org/index.php/Working_with_CVS">page wiki 
     44  sur CVS</ulink>, comprend des informations supplémentaires sur le travail 
     45  avec CVS. 
    4546 </para> 
    4647 
    …… 
    155156   ligne à <ulink url="http://www.nongnu.org/cvs/"></ulink>. 
    156157  </para> 
    157   <para> 
    158    <productname>CVS</productname> has deficiencies.  For example, 
    159    generating diffs that add or remove files requires write access to the 
    160    CVS repository.  To work around that deficiency, use 
    161    <productname>cvsutils</productname>, which is packaged in several 
    162    operating systems, and is available in source form at <ulink 
     158 
     159  <para> 
     160   <productname>CVS</productname> a des inconvénients. Par exemple, générer 
     161   des fichiers diff qui ajoutent ou suppriment des fichiers requièrent un 
     162   accès en écriture au dépôt CVS. Pour contourner ce problème, utiliser 
     163   <productname>cvsutils</productname> qui est disponible sur plusieurs 
     164   systèmes d'exploitation et aussi au format source sur <ulink 
    163165   url="http://www.red-bean.com/cvsutils/"></ulink>. 
    164166  </para> 
    165167 
    166168  <para> 
    167    Note that building <productname>PostgreSQL</productname> from a CVS 
    168    pull requires reasonably up-to-date versions of <application>bison</application> 
    169    and <application>flex</application>, which are not needed to build from a distribution 
    170    tarball because the files made with them are pre-built in a tarball. 
    171    Otherwise the tool requirements are the same as building from source. 
     169   Notez que la construction de <productname>PostgreSQL</productname> à partir 
     170   d'une récupération de la version CVS nécessite des versions à jour de 
     171   <application>bison</application> et <application>flex</application>, versions 
     172   qui ne sont pas nécessaire pour la contruction des sources provenant d'une 
     173   archive tar car les fichiers qu'ils créent sont pré-construits dans une 
     174   archive tar. Sinon, les outils nécessaires sont identiques. 
    172175  </para> 
    173176 </sect1> 
    …… 
    280283 
    281284 <sect1 id="rsync"> 
    282   <title>Getting The Source Via <productname>rsync</productname></title> 
    283  
    284   <para> 
    285    An alternative to using anonymous CVS for retrieving the 
    286    <productname>PostgreSQL</productname> source tree is 
    287    <productname>rsync</productname>, an incremental file transfer tool. 
    288    A major advantage to using <productname>rsync</productname> is that it 
    289    can reliably replicate the <emphasis>entire</emphasis> CVS repository 
    290    on your local system, allowing fast local access to <command>cvs</command> 
    291    operations such as <option>log</option> and <option>diff</option>. 
    292    Other advantages include fast synchronization to the 
    293    <productname>PostgreSQL</productname> server due to an efficient 
    294    streaming transfer protocol which only sends the changes since the last 
    295    update. 
    296   </para> 
    297  
    298   <para> 
    299    You can download the CVS repository using this command: 
     285  <title>Obtenir les sources via <productname>rsync</productname></title> 
     286 
     287  <para> 
     288   Une autre façon d'utiliser le CVS anonyme pour récupérer les sources de 
     289   <productname>PostgreSQL</productname> est 
     290   <productname>rsync</productname>, un outil de transfert incrémental de 
     291   fichiers. Un avantage majeur à l'utilisation de 
     292   <productname>rsync</productname> est qu'il peut répliquer de façon fiable 
     293   le dépôt CVS <emphasis>complet</emphasis> sur votre système local, en 
     294   utilisant l'accès local rapide aux opérations <command>cvs</command> comme 
     295   <option>log</option> et <option>diff</option>. Entre autres avantages, la 
     296   synchronisation rapide avec le serveur 
     297   <productname>PostgreSQL</productname> grâce à un protocole de transfert 
     298   efficace qui n'envoie que les modifications depuis la dernière mise à jour. 
     299  </para> 
     300 
     301  <para> 
     302   Vous pouvez télécharger le dépôt CVS en utilisant cette commande&nbsp;: 
    300303<programlisting> 
    301304rsync -avzCH --delete anoncvs.postgresql.org::pgsql-cvs cvsroot/ 
    302305</programlisting> 
    303    For full instructions, see the "rsync" section in the  
     306   Pour des instructions complètes, lire la section «&nbsp;rsync&nbsp;» dans 
     307   les 
    304308   <ulink url="http://pgfoundry.org/docman/view.php/1000040/4/PGBuildFarm-HOWTO.txt"> 
    305    pgbuildfarm instructions</ulink>. 
     309   instructions de pgbuildfarm</ulink>. 
    306310  </para> 
    307311 </sect1> 

  • traduc/trunk/manuel/datatype.xml

    r747 r756  
    246246       <entry><type>tsquery</type></entry> 
    247247       <entry></entry> 
    248        <entry>full text search query</entry> 
     248       <entry>requête pour la recherche plein texte</entry> 
    249249      </row> 
    250250 
    …… 
    252252       <entry><type>tsvector</type></entry> 
    253253       <entry></entry> 
    254        <entry>full text search document</entry> 
     254       <entry>document pour la recherche plein texte</entry> 
    255255      </row> 
    256256 
    …… 
    258258       <entry><type>uuid</type></entry> 
    259259       <entry></entry> 
    260        <entry>universally unique identifier</entry> 
     260       <entry>identifiant unique universel</entry> 
    261261      </row> 
    262262 
    …… 
    264264       <entry><type>xml</type></entry> 
    265265       <entry></entry> 
    266        <entry>XML data</entry> 
     266       <entry>données XML</entry> 
    267267      </row> 
    268268     </tbody> 
    …… 
    477477 
    478478   <indexterm> 
    479     <primary>arbitrary precision numbers</primary> 
     479    <primary>nombres à virgule flottante</primary> 
    480480   </indexterm> 
    481481 
    …… 
    558558    <indexterm> 
    559559     <primary>not a number</primary> 
    560      <secondary>numeric (data type)</secondary> 
     560     <secondary>numeric (type de données)</secondary> 
    561561    </indexterm> 
    562562 
    …… 
    575575    <note> 
    576576     <para> 
    577       In most implementations of the <quote>not-a-number</quote> concept, 
    578       <literal>NaN</literal> is not considered equal to any other numeric 
    579       value (including <literal>NaN</literal>).  In order to allow 
    580       <type>numeric</type> values to be sorted and used in tree-based 
    581       indexes, <productname>PostgreSQL</productname> treats <literal>NaN</literal> 
    582       values as equal, and greater than all non-<literal>NaN</literal> 
    583       values. 
     577      Dans la plupart des implémentations du concept <quote>not-a-number</quote>, 
     578      <literal>NaN</literal> est considéré différent de toute valeur numérique 
     579      (ceci incluant <literal>NaN</literal>). Pour autoriser le tri des valeurs 
     580      de type <type>numeric</type> et les utiliser dans des index basés sur le 
     581      tri, <productname>PostgreSQL</productname> traite les valeurs 
     582      <literal>NaN</literal> comme identiques entre elles, mais toutes supérieures 
     583      aux valeurs non <literal>NaN</literal>. 
    584584     </para> 
    585585    </note> 
    …… 
    701701    <note> 
    702702     <para> 
    703       IEEE754 specifies that <literal>NaN</literal> should not compare equal 
    704       to any other floating-point value (including <literal>NaN</literal>). 
    705       In order to allow floating-point values to be sorted and used 
    706       in tree-based indexes, <productname>PostgreSQL</productname> treats 
    707       <literal>NaN</literal> values as equal, and greater than all 
    708       non-<literal>NaN</literal> values. 
     703      IEEE754 spécifie que <literal>NaN</literal> ne devrait pas être considéré 
     704      égale à toute autre valeur en virgule flottante (ceci incluant 
     705      <literal>NaN</literal>). Pour permettre le tri des valeurs en virgule 
     706      flottante et leur utilisation dans des index basés sur des arbres, 
     707      <productname>PostgreSQL</productname> traite les valeurs 
     708      <literal>NaN</literal> comme identiques entre elles, mais supérieures 
     709      à toute valeur différente de <literal>NaN</literal>. 
    709710     </para> 
    710711    </note> 
    …… 
    10211022 
    10221023   <para> 
    1023     The storage requirement for a short string (up to 126 bytes) is 1 byte 
    1024     plus the actual string, which includes the space padding in the case of 
    1025     <type>character</type>.  Longer strings have 4 bytes overhead instead 
    1026     of 1.  Long strings are compressed by the system automatically, so 
    1027     the physical requirement on disk might be less. Very long values are also 
    1028     stored in background tables so that they do not interfere with rapid 
    1029     access to shorter column values.  
     1024    L'espace nécessaire pour une chaîne de caractères courte (jusqu'à 126 octets) 
     1025    est de un octet, plus la taille de la chaîne qui inclut le remplissage avec 
     1026    des espaces dans le cas du type <type>character</type>. Les chaînes plus 
     1027    longues ont quatre octets d'en-tête au lieu d'un seul. Les chaînes longues 
     1028    sont automatiquement compressées par le système, donc le besoin pourrait 
     1029    être moindre. Les chaînes vraiment très longues sont stockées dans des 
     1030    tables supplémentaires, pour qu'elles n'empêchent pas d'accéder rapidement 
     1031    à des valeurs plus courtes. 
    10301032    Dans tous les cas, la taille maximale possible pour une chaîne de  
    10311033    caractères est de l'ordre de 1 Go. (La taille maximale pour  
    …… 
    10431045    <para> 
    10441046     Il n'y a aucune différence de performance entre ces trois types, si ce 
    1045         n'est la place disque supplémentaire requise pour le type à remplissage 
    1046          and a few extra cycles to check the length when storing into 
    1047      a length-constrained column. Bien que 
    1048      <type>character(<replaceable>n</replaceable>)</type> ait des avantages en terme de 
    1049      performance sur certains autres systèmes de bases de données, il ne 
    1050      dispose pas de ce type d'avantages dans  
     1047    n'est la place disque supplémentaire requise pour le type à remplissage 
     1048     et quelques cycles CPU supplémentaires pour vérifier la longueur lors du 
     1049     stockage dans une colonne contrainte par la taille. Bien que 
     1050     <type>character(<replaceable>n</replaceable>)</type> ait des avantages en 
     1051     terme de performance sur certains autres systèmes de bases de données, il 
     1052     ne dispose pas de ce type d'avantages dans  
    10511053     <productname>PostgreSQL</productname>. Dans la plupart des situations, 
    10521054     les types <type>text</type> et <type>character varying</type> peuvent 
    …… 
    23792381     conduit le système à utiliser en réalité une abréviation très 
    23802382     particulière d'UTC. 
    2381      Another issue to keep in mind is that in POSIX time zone names, 
    2382      positive offsets are used for locations <emphasis>west</emphasis> of Greenwich. 
    2383      Everywhere else, <productname>PostgreSQL</productname> follows the 
    2384      ISO-8601 convention that positive timezone offsets are <emphasis>east</emphasis> 
    2385      of Greenwich. 
     2383     Un autre problème à conserver en tête est que, pour les noms des fuseaux 
     2384     horaires POSIX, les décalages positifs sont utilisés pour les emplacements 
     2385     situés à l'<emphasis>ouest</emphasis> de Greenwich. Partout ailleurs, 
     2386     <productname>PostgreSQL</productname> suit la convention ISO-8601 pour qui 
     2387     les décalages positifs de fuseaux horaires concernent 
     2388     l'<emphasis>est</emphasis> de Greenwich. 
    23862389    </para> 
    23872390 
    …… 
    24222425        les fuseaux horaires connus par 
    24232426        <productname>PostgreSQL</productname>&nbsp;; 
    2424         (These rules are also used to choose the default value of 
    2425         <xref linkend="guc-log-timezone"/>, if it is not specified.) 
     2427        (Ces règles sont aussi utilisées pour choisir la valeur par défaut de 
     2428        <xref linkend="guc-log-timezone"/>, si elle n'est pas précisée.) 
    24262429       </para> 
    24272430      </listitem> 
    …… 
    25472550 
    25482551  <sect1 id="datatype-enum"> 
    2549    <title>Enumerated Types</title> 
     2552   <title>Types énumération</title> 
    25502553 
    25512554   <indexterm zone="datatype-enum"> 
    25522555    <primary>data type</primary> 
    2553     <secondary>enumerated (enum)</secondary> 
    2554    </indexterm> 
    2555  
    2556    <para> 
    2557     Enumerated (enum) types are data types that 
    2558     are comprised of a static, predefined set of values with a 
    2559     specific order. They are equivalent to the <type>enum</type> 
    2560     types in a number of programming languages. An example of an enum 
    2561     type might be the days of the week, or a set of status values for 
    2562     a piece of data. 
     2556    <secondary>énumération (enum)</secondary> 
     2557   </indexterm> 
     2558 
     2559   <para> 
     2560    Les types énumérés (enum) sont des types de données qui comprennent un 
     2561    ensemble statique, prédéfini de valeurs dans un ordre spécifique. Ils sont 
     2562    équivalents aux types <type>enum</type> dans de nombreux langages de 
     2563    programmation. Les jours de la semaine ou un ensemble de valeurs de statut 
     2564    pour un type de données sont de bons exemples de type enum. 
    25632565   </para> 
    25642566 
    25652567   <sect2> 
    2566     <title>Declaration of Enumerated Types</title> 
    2567  
    2568     <para> 
    2569      Enum types are created using the <xref 
    2570      linkend="sql-createtype" endterm="sql-createtype-title"/> command, 
    2571      for example: 
     2568    <title>Déclaration de types énumérés</title> 
     2569 
     2570    <para> 
     2571     Les types enum sont créés en utilisant la commande <xref 
     2572     linkend="sql-createtype" endterm="sql-createtype-title"/>. 
     2573     Par exemple&nbsp;: 
    25722574 
    25732575<programlisting> 
    …… 
    25752577</programlisting> 
    25762578 
    2577      Once created, the enum type can be used in table and function 
    2578      definitions much like any other type: 
     2579     Une fois créé, le type enum peut être utilisé dans des définitions de 
     2580     table et de fonction, comme tous les autres types&nbsp;: 
    25792581    </para> 
    25802582 
    25812583    <example> 
    2582      <title>Basic Enum Usage</title> 
     2584     <title>Utilisation basique de enum</title> 
    25832585<programlisting> 
    2584 CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); 
    2585 CREATE TABLE person ( 
    2586     name text, 
    2587     current_mood mood 
     2586CREATE TYPE humeur AS ENUM ('triste', 'ok', 'heureux'); 
     2587CREATE TABLE personne ( 
     2588    nom text, 
     2589    humeur_actuelle humeur 
    25882590); 
    2589 INSERT INTO person VALUES ('Moe', 'happy'); 
    2590 SELECT * FROM person WHERE current_mood = 'happy'; 
    2591  name | current_mood  
    2592 ------+-------------- 
    2593  Moe  | happy 
     2591INSERT INTO personne VALUES ('Moe', 'heureux'); 
     2592SELECT * FROM personne WHERE humeur_actuelle = 'heureux'; 
     2593 name | humeur_actuelle 
     2594------+----------------- 
     2595 Moe  | heureux 
    25942596(1 row) 
    25952597</programlisting> 
    …… 
    25982600 
    25992601    <sect2> 
    2600      <title>Ordering</title> 
     2602     <title>Tri</title> 
    26012603 
    26022604     <para> 
    2603       The ordering of the values in an enum type is the 
    2604       order in which the values were listed when the type was declared. 
    2605       All standard comparison operators and related 
    2606       aggregate functions are supported for enums.  For example: 
     2605      L'ordre des valeurs dans un type enum correspond à l'ordre dans lequel 
     2606      les valeurs sont présentées lors de la déclaration du type. Tous les 
     2607      opérateurs de comparaison et les fonctions d'agrégats relatives peuvent 
     2608      être utilisés avec des types enum. Par exemple&nbsp;: 
    26072609     </para> 
    26082610 
    26092611     <example> 
    2610       <title>Enum Ordering</title> 
     2612      <title>Tri d'un enum</title> 
    26112613<programlisting> 
    2612 INSERT INTO person VALUES ('Larry', 'sad'); 
    2613 INSERT INTO person VALUES ('Curly', 'ok'); 
    2614 SELECT * FROM person WHERE current_mood > 'sad'; 
    2615  name  | current_mood  
    2616 -------+-------------- 
     2614INSERT INTO personne VALUES ('Larry', 'triste'); 
     2615INSERT INTO personne VALUES ('Curly', 'heureux'); 
     2616SELECT * FROM personne WHERE humeur_actuelle > 'triste'; 
     2617 nom   | humeur_actuelle 
     2618-------+----------------- 
    26172619 Moe   | happy 
    26182620 Curly | ok 
    26192621(2 rows) 
    26202622 
    2621 SELECT * FROM person WHERE current_mood > 'sad' ORDER BY current_mood; 
    2622  name  | current_mood  
     2623SELECT * FROM personne WHERE humeur_actuelle > 'triste' ORDER BY humeur_actuelle; 
     2624 nom   | humeur_actuelle  
    26232625-------+-------------- 
    26242626 Curly | ok 
    …… 
    26262628(2 rows) 
    26272629 
    2628 SELECT name FROM person 
    2629   WHERE current_mood = (SELECT MIN(current_mood) FROM person); 
    2630  name   
     2630SELECT nom FROM personne 
     2631  WHERE humeur_actuelle = (SELECT MIN(humeur_actuelle) FROM personne); 
     2632 nom 
    26312633------- 
    26322634 Larry 
    …… 
    26372639 
    26382640   <sect2> 
    2639     <title>Type Safety</title> 
    2640  
    2641     <para> 
    2642      Enumerated types are completely separate data types and may not 
    2643      be compared with each other. 
     2641    <title>Surêté du type</title> 
     2642 
     2643    <para> 
     2644     Les types énumérés sont des types de données complètement séparés et 
     2645     peuvent ne pas être comparables entre eux. 
    26442646    </para> 
    26452647 
    26462648    <example> 
    2647      <title>Lack of Casting</title> 
     2649     <title>Manque de conversion</title> 
    26482650<programlisting> 
    2649 CREATE TYPE happiness AS ENUM ('happy', 'very happy', 'ecstatic'); 
    2650 CREATE TABLE holidays (                                            
    2651     num_weeks int, 
    2652     happiness happiness 
     2651CREATE TYPE niveau_de_joie AS ENUM ('heureux', 'très heureux', 'ecstatique'); 
     2652CREATE TABLE vacances ( 
     2653    nombre_de_semaines int, 
     2654    niveau_de_joie niveau_de_joie 
    26532655); 
    2654 INSERT INTO holidays(num_weeks,happiness) VALUES (4, 'happy'); 
    2655 INSERT INTO holidays(num_weeks,happiness) VALUES (6, 'very happy'); 
    2656 INSERT INTO holidays(num_weeks,happiness) VALUES (8, 'ecstatic'); 
    2657 INSERT INTO holidays(num_weeks,happiness) VALUES (2, 'sad'); 
    2658 ERROR:  invalid input value for enum happiness: "sad" 
    2659 SELECT person.name, holidays.num_weeks FROM person, holidays 
    2660   WHERE person.current_mood = holidays.happiness; 
    2661 ERROR:  operator does not exist: mood = happiness 
     2656INSERT INTO vacances(nombre_de_semaines,niveau_de_joie) VALUES (4, 'heureux'); 
     2657INSERT INTO vacances(nombre_de_semaines,niveau_de_joie) VALUES (6, 'très heureux'); 
     2658INSERT INTO vacances(nombre_de_semaines,niveau_de_joie) VALUES (8, 'ecstatique'); 
     2659INSERT INTO vacances(nombre_de_semaines,niveau_de_joie) VALUES (2, 'triste'); 
     2660ERROR:  invalid input value for enum niveau_de_joie: "triste" 
     2661SELECT personne.nom, vacances.nombre_de_semaines FROM personne, vacances 
     2662  WHERE personne.humeur_actuelle = vacances.niveau_de_joie; 
     2663ERROR:  operator does not exist: humeur = niveau_de_joie 
    26622664</programlisting> 
    26632665    </example> 
    26642666 
    26652667    <para> 
    2666      If you really need to do something like that, you can either 
    2667      write a custom operator or add explicit casts to your query: 
     2668     Si vous avez vraiment besoin de ce type de conversion, vous pouvez soit 
     2669     écrire un opérateur personnalisé soit ajouter des conversions explicites 
     2670     dans votre requête&nbsp;: 
    26682671    </para> 
    26692672 
    26702673    <example> 
    2671      <title>Comparing Different Enums by Casting to Text</title> 
     2674     <title>Comparer différent enums en convertissant en texte</title> 
    26722675<programlisting> 
    2673 SELECT person.name, holidays.num_weeks FROM person, holidays 
    2674   WHERE person.current_mood::text = holidays.happiness::text; 
    2675  name | num_weeks  
    2676 ------+----------- 
     2676SELECT personne.nom, vacances.nombre_de_semaines FROM personne, vacances 
     2677  WHERE personne.humeur_actuelle::text = vacances.niveau_de_joie::text; 
     2678 nom  | nombre_de_semaines  
     2679------+-------------------- 
    26772680 Moe  |         4 
    26782681(1 row) 
    …… 
    26832686 
    26842687   <sect2> 
    2685     <title>Implementation Details</title> 
     2688    <title>Détails d'implémentation</title> 
    26862689     
    26872690    <para> 
    2688      An enum value occupies four bytes on disk.  The length of an enum 
    2689      value's textual label is limited by the <symbol>NAMEDATALEN</symbol> 
    2690      setting compiled into <productname>PostgreSQL</productname>; in standard 
    2691      builds this means at most 63 bytes. 
    2692     </para> 
    2693  
    2694     <para> 
    2695      Enum labels are case sensitive, so 
    2696      <type>'happy'</type> is not the same as <type>'HAPPY'</type>. 
    2697      Spaces in the labels are significant, too. 
     2691     Une valeur enum occupe quatre octets sur disque. La longueur du label texte 
     2692     d'une valeur enum est limité au paramètre <symbol>NAMEDATALEN</symbol> 
     2693     codé en dur dans <productname>PostgreSQL</productname>&nbsp;; dans les 
     2694     constructions standards, cela signifie un maximum de 63 octets. 
     2695    </para> 
     2696 
     2697    <para> 
     2698     Les labels enum sont sensibles à la casse, donc 
     2699     <type>'heureux'</type> n'est pas identique à <type>'HEUREUX'</type>. 
     2700     Les espaces sont aussi significatifs dans les labels. 
    26982701    </para> 
    26992702 
    …… 
    33123315 
    33133316   <para> 
    3314     A bit string value requires 1 byte for each group of 8 bits, plus 
    3315     5 or 8 bytes overhead depending on the length of the string 
    3316     (but long values may be compressed or moved out-of-line, as explained 
    3317     in <xref linkend="datatype-character"/> for character strings). 
     3317    Une valeur pour une chaîne de bit nécessite un octet pour chaque groupe de 
     3318    huit bits, plus cinq ou huit octets d'en-tête suivant la longueur de la 
     3319    chaîne (les valeurs longues peuvent être compressées ou déplacées, comme 
     3320    expliqué dans <xref linkend="datatype-character"/> pour les chaînes de 
     3321    caractères). 
    33183322   </para> 
    33193323  </sect1> 
    33203324 
    33213325  <sect1 id="datatype-uuid"> 
    3322    <title><acronym>UUID</acronym> Type</title> 
     3326   <title>Type <acronym>UUID</acronym></title> 
    33233327 
    33243328   <indexterm zone="datatype-uuid"> 
    …… 
    33273331 
    33283332   <para> 
    3329     The data type <type>uuid</type> stores Universally Unique 
    3330     Identifiers (UUID) as per RFC 4122, ISO/IEC 9834-8:2005, and 
    3331     related standards.  (Some systems refer to this data type as 
    3332     globally unique 
    3333     identifier/GUID<indexterm><primary>GUID</primary></indexterm> 
    3334     instead.)  Such an identifier is a 128-bit quantity that is 
    3335     generated by a suitable algorithm so that it is very unlikely to 
    3336     be generated by anyone else in the known universe using the same 
    3337     algorithm.  Therefore, for distributed systems, these identifiers 
    3338     provide a better uniqueness guarantee than that which can be 
    3339     achieved using sequence generators, which are only unique within a 
    3340     single database. 
    3341    </para> 
    3342  
    3343    <para> 
    3344     A UUID is written as a sequence of lower-case hexadecimal digits, 
    3345     in several groups separated by hyphens, specifically a group of 8 
    3346     digits followed by three groups of 4 digits followed by a group of 
    3347     12 digits, for a total of 32 digits representing the 128 bits.  An 
    3348     example of a UUID in this standard form is: 
     3333    Le type de données <type>uuid</type> stocke des identifiants universels 
     3334    uniques (<acronym>UUID</acronym>, acronyme de <foreignphrase>Universally 
     3335    Unique Identifiers</foreignphrase>) décrits dans les standards RFC 4122, 
     3336    ISO/IEC 9834-8:2005, 
     3337    et d'autres encore. (Certains systèmes font référence à ce type de données 
     3338    en tant qu'identifiant unique global (ou <acronym>GUID</acronym> 
     3339    <indexterm><primary>GUID</primary></indexterm>).) Un identifiant de ce type 
     3340    est une quantité sur 128 bits généré par un algorithme adéquat qui a peu 
     3341    de chances d'être reproduit par quelqu'un d'autre utilisant le même 
     3342    algorithme. Du coup, pour les systèmes distribués, ces identifiants 
     3343    fournissent une meilleure garantie d'unicité que ce que pourrait fournir 
     3344    une séquence, dont la valeur est unique seulement au sein d'une base 
     3345    de données. 
     3346   </para> 
     3347 
     3348   <para> 
     3349    Un <acronym>UUID</acronym> est écrit comme une séquence de chiffres 
     3350    hexadécimaux en minuscule, répartis en différents groupes séparés par 
     3351    un tiret. Plus précisément, il s'agit d'un groupe de huit chiffres 
     3352    suivis de trois groupes de quatre chiffres terminés par un groupe de 
     3353    douze chiffres, ce qui fait un total de 32 chiffres représentant les 
     3354    128 bits. Voici un exemple d'<acronym>UUID</acronym> dans sa forme 
     3355    standard&nbsp;: 
    33493356<programlisting> 
    33503357a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11 
    33513358</programlisting> 
    3352     PostgreSQL also accepts the following alternative forms for input: 
    3353     use of upper-case digits, the standard format surrounded by 
    3354     braces, and omitting the hyphens.  Examples are: 
     3359    PostgreSQL accepte aussi d'autres formes en entrée&nbsp;: utilisation 
     3360    des majuscules, de crochets englobant le nombre, suppression des tirets. 
     3361    Voici quelques exemples&nbsp;: 
    33553362<programlisting> 
    33563363A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11 
    …… 
    33583365a0eebc999c0b4ef8bb6d6bb9bd380a11 
    33593366</programlisting> 
    3360     Output is always in the standard form. 
    3361    </para> 
    3362  
    3363    <para> 
    3364     To generate UUIDs, the contrib module <literal>uuid-ossp</literal> 
    3365     provides functions that implement the standard algorithms. 
    3366     Alternatively, UUIDs could be generated by client applications or 
    3367     other libraries invoked through a server-side function. 
     3367    L'affichage est toujours dans la forme standard. 
     3368   </para> 
     3369 
     3370   <para> 
     3371    Pour générer des <acronym>UUID</acronym>, le module contrib 
     3372    <literal>uuid-ossp</literal> fournit des fonctions qui implémentent 
     3373    les algorithmes standards. Sinon, les <acronym>UUID</acronym> 
     3374    peuvent être générés par des applications clientes ou par d'autres 
     3375    bibliothèques appelées par une fonction serveur. 
    33683376   </para> 
    33693377  </sect1> 
    33703378 
    33713379  <sect1 id="datatype-textsearch"> 
    3372    <title>Full Text Search</title> 
     3380   <title>Recherche plein texte</title> 
    33733381 
    33743382   <variablelist> 
    …… 
    33803388      <para> 
    33813389       <type>tsvector</type> 
    3382        <indexterm><primary>tsvector</primary></indexterm> is a data type 
    3383        that represents a document and is optimized for full text searching. 
    3384        In the simplest case, <type>tsvector</type> is a sorted list of 
    3385        lexemes, so even without indexes full text searches perform better 
    3386        than standard <literal>~</literal> and <literal>LIKE</literal> 
    3387        operations: 
     3390       <indexterm><primary>tsvector</primary></indexterm> est un type de données 
     3391       qui représente un document et est optimisé pour la recherche plein texte. 
     3392       Dans le cas le plus simple, <type>tsvector</type> est une liste triée de 
     3393       lexemes, donc même sans index, les recherches plein texte s'exécutent 
     3394       plus rapidement que les opérations standards <literal>~</literal> et 
     3395       <literal>LIKE</literal>&nbsp;: 
    33883396 
    33893397<programlisting> 
    …… 
    34033411</programlisting> 
    34043412 
    3405        Each lexeme, optionally, can have positional information which is used for 
    3406        <varname>proximity ranking</varname>: 
     3413       En option, chaque lexeme peut avoir des informations de positionnement 
     3414       à utiliser pour améliorer le <varname>score</varname>&nbsp;: 
    34073415 
    34083416<programlisting> 
    …… 
    34133421</programlisting> 
    34143422 
    3415        Each lexeme position also can be labeled as <literal>A</literal>, 
     3423       Chaque position de lexeme peut aussi utiliser un label <literal>A</literal>, 
    34163424       <literal>B</literal>, <literal>C</literal>, <literal>D</literal>, 
    3417        where <literal>D</literal> is the default. These labels can be used to group 
    3418        lexemes into different <emphasis>importance</emphasis> or 
    3419        <emphasis>rankings</emphasis>, for example to reflect document structure. 
    3420        Actual values can be assigned at search time and used during the calculation 
    3421        of the document rank.  This is very useful for controlling search results. 
     3425       avec <literal>D</literal> comme valeur par défaut. Ces labels sont 
     3426       utilisées pour grouper les lexemes de différentes 
     3427       <emphasis>importance</emphasis> ou de <emphasis>scores</emphasis> 
     3428       différents, par exemple pour refléter la structure du document. Des 
     3429       valeurs réelles peuvent être affectées au moment de la recherche et 
     3430       utilisées lors du calcul du score du document. Ceci est très utile pour 
     3431       contrôler les résultats des recherches. 
    34223432      </para> 
    34233433 
    34243434      <para> 
    3425        The concatenation operator, e.g. <literal>tsvector || tsvector</literal>, 
    3426        can "construct" a document from several parts. The order is important if 
    3427        <type>tsvector</type> contains positional information. Of course, 
    3428        it is also possible to build a document using different tables: 
     3435       L'opérateur de concaténation operator, c'est-à-dire <literal>tsvector || 
     3436       tsvector</literal>, peut construire un document à partir de différentes 
     3437       sources. L'ordre est important si <type>tsvector</type> contient des 
     3438       informations de position. Bien sûr, il est aussi possible de construire 
     3439       un document en utilisant différentes tables&nbsp;: 
    34293440 
    34303441<programlisting> 
    …… 
    34523463      <para> 
    34533464       <type>tsquery</type> 
    3454        <indexterm><primary>tsquery</primary></indexterm> is a data type 
    3455        for textual queries which supports the boolean operators 
    3456        <literal>&amp;</literal> (AND), <literal>|</literal> (OR), and 
    3457        parentheses.  A <type>tsquery</type> consists of lexemes (optionally 
    3458        labeled by letters) with boolean operators in between: 
     3465       <indexterm><primary>tsquery</primary></indexterm> est un type de données 
     3466       pour les requêtes de recherche plein texte. Ce type supporte les 
     3467       opérateurs booléens <literal>&amp;</literal> (AND), <literal>|</literal> 
     3468       (OR) et les parenthèses.  Un <type>tsquery</type> consiste en des lexemes 
     3469       (quelque fois avec des labels) entrecoupés d'opérateurs booléens&nbsp;: 
    34593470 
    34603471<programlisting> 
    …… 
    34693480</programlisting> 
    34703481 
    3471        Labels can be used to restrict the search region, which allows the 
    3472        development of different search engines using the same full text index. 
     3482       Les labels sont utilisés pour restreindre la région de la recherche, ce qui 
     3483       permet le développement de différents moteurs de recherche utilisant le 
     3484       même index plein texte. 
    34733485      </para> 
    34743486 
    34753487      <para> 
    3476        <type>tsqueries</type> can be concatenated using <literal>&amp;&amp;</literal> (AND) 
    3477        and <literal>||</literal> (OR) operators: 
     3488       <type>tsqueries</type> peut être concaténé en utilisant les opérateurs 
     3489       <literal>&amp;&amp;</literal> (AND) et <literal>||</literal> (OR)&nbsp;: 
    34783490 
    34793491<programlisting> 
    …… 
    34973509 
    34983510  <sect1 id="datatype-xml"> 
    3499    <title><acronym>XML</acronym> Type</title> 
     3511   <title>Type <acronym>XML</acronym></title> 
    35003512 
    35013513   <indexterm zone="datatype-xml"> 
    …… 
    35043516 
    35053517   <para> 
    3506     The data type <type>xml</type> can be used to store XML data.  Its 
    3507     advantage over storing XML data in a <type>text</type> field is that it 
    3508     checks the input values for well-formedness, and there are support 
    3509     functions to perform type-safe operations on it; see <xref 
    3510     linkend="functions-xml"/>.  Use of this data type requires the 
    3511     installation to have been built with <command>configure  
     3518    Le type de données <type>xml</type> peut être utilisé pour stocker des 
     3519    données de type XML. Son avantage sur le stockage dans un champ de type 
     3520    <type>text</type> est qu'il vérifie que les valeurs en entrée sont bien 
     3521    formées. De plus, il existe des fonctions de support pour réaliser des 
     3522    opérations saines à partir de ce type&nbsp;; voir <xref 
     3523    linkend="functions-xml"/>. L'utilisation de ce type de données requiert 
     3524    que l'installation se soit faire avec <command>configure  
    35123525    --with-libxml</command>. 
    35133526   </para> 
    35143527 
    35153528   <para> 
    3516     The <type>xml</type> type can store well-formed 
    3517     <quote>documents</quote>, as defined by the XML standard, as well 
    3518     as <quote>content</quote> fragments, which are defined by the 
    3519     production <literal>XMLDecl? content</literal> in the XML 
    3520     standard.  Roughly, this means that content fragments can have 
    3521     more than one top-level element or character node.  The expression 
    3522     <literal><replaceable>xmlvalue</replaceable> IS DOCUMENT</literal> 
    3523     can be used to evaluate whether a particular <type>xml</type> 
    3524     value is a full document or only a content fragment. 
     3529    Le type <type>xml</type> peut stocker des <quote>documents</quote> bien 
     3530    formés, suivant la définition du standard XML, ainsi que des fragement 
     3531    de contenu (<quote>content</quote>), qui sont définis par 
     3532    <literal>XMLDecl? content</literal> dans le standard XML. Cela signifie 
     3533    que les fragments de contenu peuvent avoir plus d'un élément racine ou 
     3534    noeud caractère. L'expression 
     3535    <literal><replaceable>valeurxml</replaceable> IS DOCUMENT</literal> 
     3536    peut être utilisé pour évaluer si une valeur <type>xml</type> particulière 
     3537    est un document complet ou seulement un fragement de contenu. 
    35253538   </para> 
    35263539 
    35273540   <sect2> 
    3528     <title>Creating XML Values</title> 
    3529    <para> 
    3530     To produce a value of type <type>xml</type> from character data, 
    3531     use the function 
     3541    <title>Créer des valeurs XML</title> 
     3542   <para> 
     3543    Pour produire une valeur de type <type>xml</type> à partir de données de 
     3544    type caractère, utilisez la fonction 
    35323545    <function>xmlparse</function>:<indexterm><primary>xmlparse</primary></indexterm> 
    35333546<synopsis> 
    35343547XMLPARSE ( { DOCUMENT | CONTENT } <replaceable>value</replaceable>) 
    35353548</synopsis> 
    3536     Examples: 
     3549    Quelques exemples&nbsp;: 
    35373550<programlisting><![CDATA[ 
    35383551XMLPARSE (DOCUMENT '<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter><book>') 
    35393552XMLPARSE (CONTENT 'abc<foo>bar</foo><bar>foo</bar>') 
    35403553]]></programlisting> 
    3541     While this is the only way to convert character strings into XML 
    3542     values according to the SQL standard, the PostgreSQL-specific 
    3543     syntaxes: 
     3554    Bien que cela soit la seule façon de convertir des chaînes de 
     3555    caractère en valeurs XML d'après le standard XML, voici des syntaxes 
     3556    spécifiques à PostgreSQL&nbsp;: 
    35443557<programlisting><![CDATA[ 
    35453558xml '<foo>bar</foo>' 
    35463559'<foo>bar</foo>'::xml 
    35473560]]></programlisting> 
    3548     can also be used. 
    3549    </para> 
    3550  
    3551    <para> 
    3552     The <type>xml</type> type does not validate its input values 
    3553     against a possibly included document type declaration 
     3561   </para> 
     3562 
     3563   <para> 
     3564    Le type <type>xml</type> ne valide pas les valeurs en entrée par rapport 
     3565    à une déclaration de type de document inclue  
    35543566    (DTD).<indexterm><primary>DTD</primary></indexterm> 
    35553567   </para> 
    35563568 
    35573569   <para> 
    3558     The inverse operation, producing character string type values from 
    3559     <type>xml</type>, uses the function 
     3570    L'opération inverse, produisant une chaîne de caractères à partir d'une 
     3571    valeur au type <type>xml</type>, utilise la fonction 
    35603572    <function>xmlserialize</function>:<indexterm><primary>xmlserialize</primary></indexterm> 
    35613573<synopsis> 
    35623574XMLSERIALIZE ( { DOCUMENT | CONTENT } <replaceable>value</replaceable> AS <replaceable>type</replaceable> ) 
    35633575</synopsis> 
    3564     <replaceable>type</replaceable> can be one of 
    3565     <type>character</type>, <type>character varying</type>, or 
    3566     <type>text</type> (or an alias name for those).  Again, according 
    3567     to the SQL standard, this is the only way to convert between type 
    3568     <type>xml</type> and character types, but PostgreSQL also allows 
    3569     you to simply cast the value. 
    3570    </para> 
    3571  
    3572    <para> 
    3573     When character string values are cast to or from type 
    3574     <type>xml</type> without going through <type>XMLPARSE</type> or 
    3575     <type>XMLSERIALIZE</type>, respectively, the choice of 
    3576     <literal>DOCUMENT</literal> versus <literal>CONTENT</literal> is 
    3577     determined by the <quote>XML option</quote> 
    3578     <indexterm><primary>XML option</primary></indexterm> 
    3579     session configuration parameter, which can be set using the 
    3580     standard command 
     3576    <replaceable>type</replaceable> peut être 
     3577    <type>character</type>, <type>character varying</type> ou 
     3578    <type>text</type> (ou un alias de ces derniers). Encore une fois, d'après 
     3579    le standard SQL, c'est le seul moyen de convertir le type 
     3580    <type>xml</type> vers les types caractère mais PostgreSQL autorise aussi 
     3581    la conversion simple de la valeur. 
     3582   </para> 
     3583 
     3584   <para> 
     3585    Lorsque les valeurs des chaînes de caractère sont converties vers ou à 
     3586    partir du type <type>xml</type> sans passer par <type>XMLPARSE</type> ou 
     3587    <type>XMLSERIALIZE</type>, respectivement, le choix de 
     3588    <literal>DOCUMENT</literal> ou de <literal>CONTENT</literal> est 
     3589    déterminé par un paramètre de configuation niveau session, 
     3590    <quote>XML OPTION</quote> 
     3591    <indexterm><primary>XML OPTION</primary></indexterm>, qui peut être 
     3592    configuré par la commande habituelle&nbsp;: 
    35813593<synopsis> 
    35823594SET XML OPTION { DOCUMENT | CONTENT }; 
    35833595</synopsis> 
    3584     or the more PostgreSQL-like syntax 
     3596    ou la syntaxe PostgreSQL&nbsp;: 
    35853597<synopsis> 
    35863598SET xmloption TO { DOCUMENT | CONTENT }; 
    35873599</synopsis> 
    3588     The default is <literal>CONTENT</literal>, so all forms of XML 
    3589     data are allowed. 
     3600    La valeur par défaut est <literal>CONTENT</literal>, donc toutes les formes 
     3601    de données XML sont autorisées. 
    35903602   </para> 
    35913603   </sect2> 
    35923604 
    35933605   <sect2> 
    3594     <title>Encoding Handling</title> 
    3595    <para> 
    3596     Care must be taken when dealing with multiple character encodings 
    3597     on the client, server, and in the XML data passed through them. 
    3598     When using the text mode to pass queries to the server and query 
    3599     results to the client (which is the normal mode), PostgreSQL 
    3600     converts all character data passed between the client and the 
    3601     server and vice versa to the character encoding of the respective 
    3602     end; see <xref linkend="multibyte"/>.  This includes string 
    3603     representations of XML values, such as in the above examples. 
    3604     This would ordinarily mean that encoding declarations contained in 
    3605     XML data might become invalid as the character data is converted 
    3606     to other encodings while travelling between client and server, 
    3607     while the embedded encoding declaration is not changed.  To cope 
    3608     with this behavior, an encoding declaration contained in a 
    3609     character string presented for input to the <type>xml</type> type 
    3610     is <emphasis>ignored</emphasis>, and the content is always assumed 
    3611     to be in the current server encoding.  Consequently, for correct 
    3612     processing, such character strings of XML data must be sent off 
    3613     from the client in the current client encoding.