Attachment 86405 Details for Bug 132638 – postgres-howto.xml translated to french

postgres-howto.xml translated to french

postgres-howto.xml (text/plain), 26.43 KB, created by alexandre on 2006-05-07 20:01:09 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: alexandre

Created: 2006-05-07 20:01:09 UTC

Size: 26.43 KB

patch

obsolete

><?xml version="1.0" encoding="UTF-8"?>
><!DOCTYPE guide SYSTEM "/dtd/guide.dtd">
>
>
><guide link="/doc/fr/postgres-howto.xml" lang="fr">
><title>Guide PostgreSQL</title>
>
><author title="Author">
>  <mail link="chriswhite@gentoo.org">Chris White</mail>
></author>
><author title="Editor">
>  <mail link="neysx@gentoo.org">Xavier Neys</mail>
></author>
><author title="Traducteur">tutux</author>
>
><abstract>
>L'objectif de ce guide est de prÃ©senter une installation rudimentaire de PostgreSQL. L'installation dÃ©crite ici devrait Ãªtre suffisante pour un usage standard d'application web ou tout autre programme fournissant un support PostgreSQL.
></abstract>
>
>
>
><license/>
>
><version>1.0</version>
><date>2006-05-07</date>
>
><chapter>
><title>Introduction</title>
><section>
><title>Introduction Ã  PostgreSQL</title>
><body>
>
><p>
>Si vous demandez Ã  un dÃ©veloppeur quel SystÃ¨me de Gestion de Base de DonnÃ©es (SGBD) utiliser, il y a de fortes chances qu'il vous parle de deux SGBD majeurs. L'un est <c>MySQL</c> et l'autre est celui qui fait l'objet de ce guide&#160;: <c>PostgreSQL</c>. Les avantages de l'un par rapport Ã  l'autre ont dÃ©jÃ  fait l'objet de longs dÃ©bats, nÃ©anmoins, il est juste de dire que PostgreSQL implÃ©mente plus strictement que MySQL une rÃ©elle structure de base de donnÃ©es relationnelle. La plupart des fonctionnalitÃ©s de base, telles que la <b>CLEF ÃTRANGÃRE</b> (FOREIGN KEY) n'ont Ã©tÃ© ajoutÃ©es Ã  MySQL qu'Ã  partir de sa version 5. Quoi qu'il en soit, dans ce document nous supposons que vous avez dÃ©jÃ  portÃ© votre choix sur PostgreSQL. <c>emerge</c> sera la premiÃ¨re Ã©tape. Dans la section suivante, le processus d'installation par emerge sera dÃ©crit, ainsi que la configuration de base.
></p>
>
></body>
></section>
><section>
><title>Installation de PostgreSQL</title>
><body>
>
><p>
>Pour commencer, nous devons procÃ©der Ã  l'installation du paquet PostgreSQL. Pour ce faire, exÃ©cutez le code suivant, afin de vous assurer que les options sont correctement rÃ©glÃ©es&#160;:
></p>
>
><pre caption="VÃ©rification des options Â«&#160;build&#160;Â» de PostgreSQL">
># <i>emerge -pv postgresql</i>
>
>These are the packages that I would merge, in order:
>
>Calculating dependencies ...done!
>[ebuild  N    ] dev-db/postgresql-8.0.4  -doc -kerberos +libg++ +nls +pam +perl
>-pg-hier -pg-intdatetime +python +readline (-selinux) +ssl -tcltk +xml2 +zlib 0 kB
></pre>
>
><p>
>Voici une liste de ce que les diffÃ©rentes options Â«&#160;build&#160;Â» signifient&#160;:
></p>
>
><table>
><tr>
>  <th>USE Flag</th>
>  <th>Signifie</th>
></tr>
><tr>
>  <ti>doc</ti>
>  <ti>
>Ce USE flag active ou dÃ©sactive l'installation de la documentation en sus des pages man standard. La seule raison valable de dÃ©sactiver cette option est le manque d'espace ou si vous avez accÃ¨s Ã  cette documentation par d'autres mÃ©thodes (en ligne, etc.)
>  </ti>
></tr>
><tr>
>  <ti>kerberos</ti>
>  <ti>
>Avec cette option activÃ©e, l'administrateur a la possibilitÃ© d'utiliser <c>kerberos</c> pour l'authentification des utilisateurs/services d'une base de donnÃ©es.
>  </ti>
></tr>
><tr>
>  <ti>libg++</ti>
>  <ti>
>Si cette option est activÃ©e, les ligatures (bindings) C++ pour PostgreSQL seront construites. Cela crÃ©era libpq++ dont les programmes C++ se serviront pour la liaison.
>  </ti>
></tr>
><tr>
>  <ti>nls</ti>
>  <ti>
>Si cette option est activÃ©e, PostgreSQL peut utiliser des chaÃ®nes de caractÃ¨res traduites pour les utilisateurs non anglophones.
>  </ti>
></tr>
><tr>
>  <ti>pam</ti>
>  <ti>
>Si cette option est activÃ©e, et que l'administrateur configure le fichier de configuration de PostgreSQL correctement, les utilisateurs/services pourront se connecter Ã  une base de donnÃ©es PostgreSQL en utilisant <c>PAM</c> (Pluggable Authentication Module - Module d'authentification Â«&#160;grefable&#160;Â»).
>  </ti>
></tr>
><tr>
>  <ti>perl</ti>
>  <ti>
>      Si cette option est activÃ©e, les ligatures (bindings) pour <c>perl</c> seront construites.
>  </ti>
></tr>
><tr>
>  <ti>pg-hier</ti>
>  <ti>
>Si cette option est activÃ©e, un correctif sera appliquÃ© pour permettre les requÃªtes hiÃ©rarchiques, telles que celles que l'on peut voir avec l'instruction <c>CONNECT</c> des serveurs de base de donnÃ©es <c>Oracle</c>. Des informations supplÃ©mentaires sur les requÃªtes hiÃ©rarchiques peuvent se trouver ici&#160;: <uri
>    link="http://www.lc.leidenuniv.nl/awcourse/oracle/server.920/a96540/
>    queries4a. htm">Oracle Reference Guide</uri> (en anglais).
>  </ti>
></tr>
><tr>
>  <ti>pg-intdatetime</ti>
>  <ti>
>Si cette option est activÃ©e, PostgreSQL supportera le type de donnÃ©e Â«&#160;date&#160;Â» en 64 bit.
>  </ti>
></tr>
><tr>
>  <ti>python</ti>
>  <ti>
>Si cette option est activÃ©e, PostgreSQL sera construit avec les ligatures (bindings) <c>python</c>.
>  </ti>
></tr>
><tr>
>  <ti>readline</ti>
>  <ti>
>Si cette option est activÃ©e, PostgreSQL supportera l'Ã©dition des commandes en se conformant au style <c>readline</c>. Cela inclut l'historique des commandes et isearch.
>  </ti>
></tr>
><tr>
>  <ti>selinux</ti>
>  <ti>
>Si cette option est activÃ©e, une politique <c>selinux</c> pour PostgreSQL sera installÃ©e.
>  </ti>
></tr>
><tr>
>  <ti>ssl</ti>
>  <ti>
>Si cette option est activÃ©e, PostgreSQL utilisera la librairie <c>OpenSSL</c> pour crypter le traffic entre les clients et serveurs PostreSQL.
>  </ti>
></tr>
><tr>
>  <ti>tcltk</ti>
>  <ti>
>Si cette option est activÃ©e, les ligatures (bindings) <c>tcl/tk</c> pour PostgreSQL seront construites.
>  </ti>
></tr>
><tr>
>  <ti>xml2</ti>
>  <ti>
>Si cette option est activÃ©e, le support du style <c>XPATH</c> de xml sera construit.
>Des informations supplÃ©mentaires sur le support de xml avec PostgreSQL peut se trouver ici&#160;:
>     <uri link="http://www.throwingbeans.org/tech/postgresql_and_xml.html">
>    PostgreSQL and XML</uri> (en anglais).
>  </ti>
></tr>
><tr>
>  <ti>zlib</ti>
>  <ti>
>Cette option n'est pas directement utilisÃ©e par PostgreSQL, mais par <c>pg_dump</c> pour compresser les clichÃ©s (dumps) qu'il produit.
>  </ti>
></tr>
></table>
>
><note>
>L'auteur du patch <c>pg-hier</c> ne travaille plus sur ce patch, et il sera probablement retirÃ© des versions ultÃ©rieures.
></note>
>
><p>
>Quand vous aurez terminÃ© la personnalisation de PostgreSQL pour l'adapter Ã  vos besoins spÃ©cifiques, passez Ã  l'Ã©tape suivante en procÃ©dant Ã  l'<c>emerge</c>.
></p>
>
><pre caption="Emerge-ing PostgreSQL">
># <i>emerge postgresql</i>
><comment>(Sortie abrÃ©gÃ©e)</comment>
>>>> /usr/lib/libecpg.so.5 -> libecpg.so.5.0
>>>> /usr/bin/postmaster -> postgres
> * Make sure the postgres user in /etc/passwd has an account setup with /bin/bash as the shell
> *
> * Execute the following command
> * emerge --config =postgresql-8.0.4
> * to setup the initial database environment.
> *
>>>> Regenerating /etc/ld.so.cache...
>>>> dev-db/postgresql-8.0.4 merged.
></pre>
>
><p>
>Telle que la sortie de einfo l'indique, il reste quelques rÃ©glages post-installation Ã  faire. Le chapitre suivant s'intÃ©ressera Ã  la configuration de PostgreSQL proprement dite.
></p>
>
></body>
></section>
></chapter>
><chapter>
><title>Configuration de PostgreSQL</title>
><section>
><title>RÃ©glage de l'environnement initial de PostgreSQL</title>
><body>
>
><p>
>Telle que la derniÃ¨re sortie d'<c>emerge</c> l'indique, l'environnement initial de PostgreSQL doit Ãªtre rÃ©glÃ©. Toutefois, avant de procÃ©der, une chose doit Ãªtre prise en considÃ©ration&#160;: Contrairement Ã  MySQL, par exemple, le mot de passe Â«&#160;root&#160;Â» de PostgreSQL est celui de l'utilisateur effectif. NÃ©anmoins, ebuild ne crÃ©Ã© que l'utilisateur, <c>pas</c> sont mot de passe. Par consÃ©quent, avant de commencer, le mot de passe pour l'utilisateur PostgreSQL doit Ãªtre crÃ©Ã©&#160;:
></p>
>
><pre caption="CrÃ©er le mot de passe">
># <i>passwd postgres</i>
>New UNIX password:
>Retype new UNIX password:
>passwd: password updated successfully
></pre>
>
><p>
>Maintenant que c'est chose faite, la crÃ©ation de l'environnement initial de la base de donnÃ©e peut intervenir&#160;:
></p>
>
><pre caption="Configurer l'environnement de la base de donnÃ©es avec emerge --config">
># <i>emerge --config =postgresql-8.0.4</i>
>
>
>Configuring pkg...
>
> * Creating the data directory ...
> * Initializing the database ...
>The files belonging to this database system will be owned by user "postgres".
>This user must also own the server process.
>
>The database cluster will be initialized with locale C.
>
>fixing permissions on existing directory /var/lib/postgresql/data ... ok
>creating directory /var/lib/postgresql/data/global ... ok
>creating directory /var/lib/postgresql/data/pg_xlog ... ok
>creating directory /var/lib/postgresql/data/pg_xlog/archive_status ... ok
>creating directory /var/lib/postgresql/data/pg_clog ... ok
>creating directory /var/lib/postgresql/data/pg_subtrans ... ok
>creating directory /var/lib/postgresql/data/base ... ok
>creating directory /var/lib/postgresql/data/base/1 ... ok
>creating directory /var/lib/postgresql/data/pg_tblspc ... ok
>selecting default max_connections ... 100
>selecting default shared_buffers ... 1000
>creating configuration files ... ok
>creating template1 database in /var/lib/postgresql/data/base/1 ... ok
>initializing pg_shadow ... ok
>enabling unlimited row size for system tables ... ok
>initializing pg_depend ... ok
>creating system views ... ok
>loading pg_description ... ok
>creating conversions ... ok
>setting privileges on built-in objects ... ok
>creating information schema ... ok
>vacuuming database template1 ... ok
>copying template1 to template0 ... ok
>
>WARNING: enabling "trust" authentication for local connections
>You can change this by editing pg_hba.conf or using the -A option the
>next time you run initdb.
>
>Success. You can now start the database server using:
>
>    /usr/bin/postmaster -D /var/lib/postgresql/data
>or
>    /usr/bin/pg_ctl -D /var/lib/postgresql/data -l logfile start
>
> *
> * You can use /etc/init.d/postgresql script to run PostgreSQL instead of pg_ctl.
> *
></pre>
>
><p>
>L'environnement initial de la base de donnÃ©es est maintenant rÃ©glÃ©. La section suivante concernera la vÃ©rification de l'installation et l'ajout d'accÃ¨s Ã  la base de donnÃ©es par des utilisateurs.
></p>
>
></body>
></section>
><section>
><title>RÃ©glage de la base de donnÃ©es PostgreSQL</title>
><body>
>
><p>
>Maintenant que PostgreSQL est rÃ©glÃ© il serait bon, Ã  ce stade, de vÃ©rifier l'installation. PremiÃ¨rement, assurez-vous que le service dÃ©marre correctement&#160;:
></p>
>
><pre caption="DÃ©marrage du service PostgreSQL">
># <i>/etc/init.d/postgresql start</i>
>* Starting PostgreSQL ...                                          [ ok ]
></pre>
>
><p>
>AprÃ¨s confirmation du dÃ©marrage, il serait Ã©galement indiquÃ© de l'ajouter au niveau d'exÃ©cution (run level) par dÃ©faut afin qu'il dÃ©marre Ã  l'amorÃ§age du systÃ¨me&#160;:
></p>
>
><pre caption="Ajout au niveau d'exÃ©cution par dÃ©faut">
># <i>rc-update add postgresql default</i>
>* postgresql added to runlevel default
></pre>
>
><p>
>Maintenant que le service a Ã©tÃ© dÃ©marrÃ©, il est temps d'essayer de crÃ©er une base de donnÃ©es test. Pour commencer, crÃ©ons une base de donnÃ©es test en utilisant la commande <c>createdb</c>. Nous passerons Ã©galement l'option <c>-U</c> pour instaurer l'utilisateur (sans cela c'est l'utilisateur actuel qui est instaurÃ© par dÃ©faut), ainsi que l'option <c>-W</c> pour invoquer le mot de passe que nous avons prÃ©cÃ©demment crÃ©Ã©. Enfin, nous donnons un nom Ã  la base de donnÃ©es que nous voulons crÃ©er&#160;:
></p>
>
><pre caption="Creation d'une base de donnÃ©es avec createdb">
>$ <i>createdb -U postgres -W test</i>
>Password:
>CREATE DATABASE
></pre>
>
><p>
>La base de donnÃ©es a Ã©tÃ© crÃ©Ã©e avec succÃ¨s, et nous sommes assurÃ©s que la base de donnÃ©es accomplit des tÃ¢ches Ã©lÃ©mentaires. Poursuivons et supprimons (drop) cette base de donnÃ©es Ã  l'aide de la commande <c>dropdb</c>. Nous crÃ©erons et utiliserons une nouvelle base de donnÃ©es ultÃ©rieurement&#160;:
></p>
>
><pre caption="Suppression d'une base de donnÃ©es avec dropdb">
>$ <i>dropdb -U postgres -W test</i>
>Password:
>DROP DATABASE
></pre>
>
><p>
>Ã ce stade, il n'y a que l'utilisateur postgres qui puisse exÃ©cuter des commandes. Ãa n'est Ã©videmment pas la configuration que nous voulons dans un environnement multi-utilisateurs. La section suivante concerne la gestion des comptes utilisateurs.
></p>
>
></body>
></section>
><section>
><title>Configuration des comptes utilisateurs</title>
><body>
>
><p>
>Comme nous l'avons dÃ©jÃ  mentionnÃ©, il n'est pas souhaitable, dans un environnement multi-utilisateur, de devoir se connecter avec le compte Â«&#160;postgres&#160;Â». Dans la plupart des cas, il y aura plusieurs utilisateurs et services qui accÃ©deront au serveur, et chacun d'eux requiert des permissions diffÃ©rentes. Pour gÃ©rer cela, la commande <c>createuser</c> peut Ãªtre utilisÃ©e. Cette commande est une alternative Ã  l'exÃ©cution de plusieurs requÃªtes SQL, et du point de vue de l'administrateur, elle est bien plus flexible. Poursuivons et crÃ©ons deux utilisateurs, un Â«&#160;super-utilisateur&#160;Â» qui pourra ajouter d'autres utilisateurs et administrer la base de donnÃ©es, ainsi qu'un utilisateur standard&#160;:
></p>
>
><pre caption="CrÃ©ation du super-utilisateur">
><comment>(remplacez chris par le nom d'utilisateur que vous souhaitez utiliser)</comment>
>$ <i>createuser -a -d -P -E -U postgres -W chris</i>
>Enter password for new user:
>Enter it again:
>Password:
>CREATE USER
></pre>
>
><p>
>TrÃ¨s bien, nous avons crÃ©Ã© le super-utilisateur. L'option <c>-a</c> de la ligne de commande spÃ©cifie que cet utilisateur peut ajouter d'autres utilisateurs. <c>-d</c> signifie que cet utilisateur peut crÃ©er des bases de donnÃ©es. <c>-P</c> permet de saisir un mot de passe pour l'utilisateur et <c>-E</c> permet de le crypter afin de sÃ©curiser le compte. Nous allons maintenant tester les permissions de ce nouvel utilisateur en crÃ©ant notre utilisateur standard&#160;:
></p>
>
><pre caption="CrÃ©ation de l'utilisateur standard">
><comment>(remplacez chris par l'utilisateur que vous venez de crÃ©er)</comment>
>$ <i>createuser -A -D -P -E -U chris -W utilisateurTest</i>
>Enter password for new user:
>Enter it again:
>Password:
>CREATE USER
></pre>
>
><p>
>Parfait ! Notre nouvel utilisateur a Ã©tÃ© crÃ©Ã© par le super-utilisateur que nous avions prÃ©alablement crÃ©Ã©. Les options <c>-A</c> et <c>-D</c> ont l'effet inverse de <c>-a</c> et <c>-d</c>&#160;: elles empÃªchent l'utilisateur de crÃ©er d'autres utilisateurs et bases de donnÃ©es. Nous avons maintenant des utilisateurs avec qui travailler et une base de donnÃ©es nouvellement crÃ©Ã©e, et le prochain chapitre abordera l'utilisation de cette base de donnÃ©es.
></p>
>
></body>
></section>
></chapter>
><chapter>
><title>Utilisation de PostgreSQL</title>
><section>
><title>Configuration des permissions</title>
><body>
>
><p>
>Avec notre base de donnÃ©es nouvellement crÃ©Ã©e, il y a un utilisateur qui peut crÃ©er des bases de donnÃ©es et ajouter de nouveaux utilisateur, ainsi que l'utilisateur principal postgres qui peut tout faire. Le dernier utilisateur que nous avons crÃ©Ã© peut se connecter au serveur, et c'est Ã  peu prÃ¨s tout. En gÃ©nÃ©ral, les utilisateurs ont besoin de pouvoir insÃ©rer et extraire des donnÃ©es, et dans certains cas, de pouvoir exÃ©cuter un certain nombre d'autres tÃ¢ches. Donc, pour que ce nouvel utilisateur puisse faire quoi que ce soit, il doit Ãªtre configurÃ© avec les permissions adÃ©quates. Cela peut se faire facilement en passant le paramÃ¨tre <c>-O</c> Ã  la commande <c>createdb</c>. Nous commencerons par crÃ©er, avec notre super-utilisateur, une nouvelle base de donnÃ©es, <b>MyDB</b>, qui appartiendra Ã  l'utilisateur test prÃ©cÃ©dent&#160;:
></p>
>
><pre caption="CrÃ©ation de la base de donnÃ©es MyDB">
>$ <i>createdb -O utilisateurTest -U chris -W MyDB</i>
>Password:
>CREATE DATABASE
></pre>
>
><p>
>    TrÃ¨s bien, nous avons maintenant une nouvelle base de donnÃ©es MyDB, ainsi qu'un utilisateur utilisateurTest qui peut y accÃ©der. Pour s'en assurer, nous allons nous connecter Ã  la nouvelle base de donnÃ©es MyDB en tant que utilisateurTest. Nous allons faire cela avec le programme <c>psql</c>. C'est ce programme qui est utilisÃ© pour se connecter Ã  une base de donnÃ©es PostgreSQL en ligne de commande. Connectez-vous donc Ã  cette nouvelle base de donnÃ©es de cette maniÃ¨re&#160;:
></p>
>
><pre caption="Se connecter Ã  la base de donnÃ©es MyDB en tant que utilisateurTest">
>$ <i>psql -U utilisateurTest -W MyDB</i>
>Password:
>Welcome to psql 8.0.4, the PostgreSQL interactive terminal.
>
>Type:  \copyright for distribution terms
>       \h for help with SQL commands
>       \? for help with psql commands
>       \g or terminate with semicolon to execute query
>       \q to quit
>
>MyDB=&gt;
></pre>
>
><p>
>utilisateurTest est maintenant connectÃ© Ã  la base de donnÃ©es, et peut commencer Ã  exÃ©cuter quelques commandes. Pour s'accoutumer Ã  l'utilisation de PostgreSQL, la section suivante prÃ©sentera quelques commandes de base pour naviguer dans <c>psql</c> (le programme client).
></p>
>
></body>
></section>
><section>
><title>Commandes PostgreSQL de base et crÃ©ation d'une table</title>
><body>
>
><p>
>Ceux qui sont habituÃ©s Ã  MySQL devraient dÃ©finitivement lire ceci. C'est lÃ  que PostgreSQL diffÃ¨re sensiblement dans la maniÃ¨re d'exÃ©cuter les commandes. Pour commencer, voici une liste de quelques commandes qui seront abordÃ©es&#160;:
></p>
>
><table>
><tr>
>  <th>Commande</th>
>  <th>Usage</th>
>  <th>Ãquivalent MySQL</th>
></tr>
><tr>
>  <ti>\c[onnect] [DBNAME|- [USER]]</ti>
>  <ti>Connexion Ã  une autre base de donnÃ©es</ti>
>  <ti>USE DATABASE</ti>
></tr>
><tr>
>  <ti>\q</ti>
>  <ti>Sortie du client <c>psql</c></ti>
>  <ti>quit</ti>
></tr>
><tr>
>  <ti>\i FICHIER</ti>
>  <ti>ExÃ©cution des commandes contenues dans <c>FICHIER</c></ti>
>  <ti>source FILE</ti>
></tr>
><tr>
>  <ti>\o [FICHIER]</ti>
>  <ti>Envoi des rÃ©sultats de la requÃªte dans <c>FICHIER</c></ti>
>  <ti>INTO OUTFILE, but outputs everything (not just SELECTS)</ti>
></tr>
><tr>
>  <ti>\d [NOM]</ti>
>  <ti>Description d'une base de donnÃ©es ou d'une table (ainsi que d'autres Ã©lÃ©ments)</ti>
>  <ti>DESC(RIBE)</ti>
></tr>
><tr>
>  <ti>\db [MOTIF]</ti>
>  <ti>
>    Liste les tables disponibles qui correspondent au <c>MOTIF</c> (toutes si aucun motif n'est spÃ©cifiÃ©)
>  </ti>
>  <ti>SHOW TABLES</ti>
></tr>
></table>
>
><p>
>Ã l'exception de <c>\c[onnect]</c>, toutes les commandes listÃ©es seront utilisÃ©es ultÃ©rieurement dans cette section. Notre base de donnÃ©es est vide. Il nous faut donc insÃ©rer quelques donnÃ©es. Cependant, la premiÃ¨re Ã©tape est de les insÃ©rer dans une table. A ce stade, il n'y a aucune table dans notre base de donnÃ©es, nous devons donc en crÃ©er une. Cela se fait avec la commande <c>CREATE TABLE</c>. Nous crÃ©erons une table d'Ã©lÃ©ments. Ils contiendront un identifiant de produit, une description et un prix&#160;:
></p>
>
><pre caption="CrÃ©ation de la table produits">
>MyDB=> CREATE TABLE produits (
>MyDB(&gt;   identifiant_produit SERIAL,
>MyDB(&gt;   description TEXT,
>MyDB(&gt;   prix DECIMAL
>MyDB(&gt; );
>NOTICE:  CREATE TABLE will create implicit sequence "products_product_id_seq"
>for serial column "products.product_id"
>CREATE TABLE
></pre>
>
><p>
>Vous pouvez ignorer cette Â«&#160;NOTICE&#160;Â», elle est parfaitement bÃ©nigne. La derniÃ¨re ligne de la fonction <c>CREATE TABLE</c> semble indiquer que la commande s'est dÃ©roulÃ©e correctement. VÃ©rifions malgrÃ© tout, avec la commande <c>\d</c>, que la table a effectivement Ã©tÃ© crÃ©Ã©e.
></p>
>
><pre caption="VÃ©rification de la table nouvellement crÃ©Ã©e">
>MyDB=&gt; <i>\d produits</i>
>                                 Table "public.produits"
>   Column    |  Type   |                            Modifiers
>-------------+---------+------------------------------------------------------------------
> identifiant_produit  | integer | not null default nextval('public.produits_identifiant_produit_seq'::text)
> description | text    |
> prix       | numeric |
></pre>
>
><p>
>La table a, en effet, Ã©tÃ© crÃ©Ã©e. Maintenant que la table est crÃ©Ã©e, nous pouvons y ajouter des donnÃ©es. La section suivante traite de l'ajout de donnÃ©es dans la base de donnÃ©es.
></p>
>
></body>
></section>
><section>
><title>InsÃ©rer des donnÃ©es dans la base de donnÃ©es</title>
><body>
>
><p>
>Cette section prÃ©sentera deux faÃ§ons d'ajouter des donnÃ©es dans la table nouvellement crÃ©Ã©e. Pour commencer, intÃ©ressons nous Ã  la commande la plus Ã©lÃ©mentaire&#160;: <c>INSERT</c>&#160;:
></p>
>
><pre caption="Syntaxe de INSERT">
>INSERT INTO [nom_table] (colonne1,colonne2,colonne3) VALUES(valeur1,valeur2,valeur3)
></pre>
>
><p>
>Le <c>nom_table</c> correspond au nom de la table dans laquelle nous insÃ©rons les donnÃ©es.  (colonne1,colonne2,colonne3) permet de spÃ©cifier dans quelles colonnes nous voulons insÃ©rer les valeurs. VALUES(valeur1,valeur2,valeur3) est la liste des valeurs. Les valeurs sont insÃ©rÃ©es dans le mÃªme ordre que les colonnes (colonne1 reÃ§oit la valeur1, colonne2 reÃ§oit la valeur2, colonne3 reÃ§oit la valeur3). Le nombre de colonnes et de valeurs <e>doit</e> Ãªtre le mÃªme. Poursuivons et insÃ©rons un Ã©lÃ©ment dans la table&#160;:
></p>
>
><impo>
>Pour avoir travaillÃ© longtemps avec des bases de donnÃ©es, je recommande de spÃ©cifier les instructions <c>INSERT</c> exactement comme nous venons de le faire. Les dÃ©veloppeurs font souvent l'erreur d'utiliser <c>INSERT INTO</c> sans spÃ©cifier les colonnes. Ãa n'est pas rentable, car si une nouvelle colonne est ajoutÃ©e Ã  la table et que la position de la colonne ne correspond plus Ã  la valeur qu'on souhaite y ajouter, cela causera de sÃ©rieux problÃ¨mes. Vous devriez <c>toujours</c> spÃ©cifier les colonnes Ã  moins que vous ne soyez sÃ»rs Ã  300% que vous n'en ajouterez jamais.
></impo>
>
><pre caption="Insertion de donnÃ©es dans la table">
>MyDB=&gt; <i>INSERT INTO produits (description,prix) VALUES('Un produit test', 12.00);</i>
>INSERT 17273 1
></pre>
>
><p>
>La derniÃ¨re ligne appelle quelques explications. Le retour d'une commande d'insertion est composÃ©e d'un OID (Identifiant d'Objet) et du nombre d'Ã©lÃ©ments (ou lignes) insÃ©rÃ©s. Les OID dÃ©passent un peu le cadre de ce guide et le <uri link="http://www.postgresql.org/docs/8.1/static/datatype-oid.html">PostgreSQL manual</uri> fournit de bonnes informations les concernant. Maintenant, dans le cas ou vous avez 20'000 produits, ces instructions d'insertion pourraient devenir lÃ©gÃ¨rement fastidieuses. Ne dÃ©sespÃ©rez pas ! La commande <c>COPY</c> peut Ãªtre utilisÃ©e pour insÃ©rer des donnÃ©es dans une table Ã  partir d'un fichier ou de l'entrÃ©e standard (stdin). Dans cet exemple, nous supposerons que vous avez un fichier cvs (valeurs sÃ©parÃ©es par des virgules), qui contient les identifiants des produits, leurs descriptions et leurs prix. Le fichier ressemble Ã  Ã§a&#160;:
></p>
>
><pre caption="produits.csv">
>2,viande,6.79
>3,soupe,0.69
>4,limonade,1.79
></pre>
>
><p>
>Nous allons maintenant utiliser la commande <c>COPY</c> pour alimenter la table&#160;:
></p>
>
><impo>
>Nous utilisons la commande <c>COPY FROM STDIN</c> parce que l'insertion de donnÃ©es Ã  partir d'un fichier n'est possible que pour l'utilisateur postgres (pour d'Ã©videntes raisons de sÃ©curitÃ©).
></impo>
>
><pre caption="Utilisation de COPY pour alimenter la table produits">
>MyDB=&gt; <i>COPY produits FROM STDIN WITH DELIMITER AS ',';</i>
>Enter data to be copied followed by a newline.
>End with a backslash and a period on a line by itself.
>>> <i>2,viande,6.79</i>
>>> <i>3,soupe,0.69</i>
>>> <i>4,limonade,1.79</i>
>>> <i>\.</i>
></pre>
>
><p>
>Malheureusement, cette instruction ne retourne pas les mÃªmes informations sur le statut que l'instruction <c>INSERT INTO</c>. Comment savoir si les donnÃ©es ont Ã©tÃ© insÃ©rÃ©es ? La section suivante traitera de l'exÃ©cution de requÃªtes pour vÃ©rifier nos donnÃ©es.
></p>
>
></body>
></section>
><section>
><title>Utilisation de requÃªtes PostgreSQL</title>
><body>
>
><p>
>Cette section traitera de l'usage de l'instruction <c>SELECT</c> qui permet de voir les donnÃ©es dans nos tables. Le format basique de <c>SELECT</c> ressemble Ã  Ã§a&#160;:
></p>
>
><pre caption="Syntaxe de SELECT">
>SELECT (colonne1,colonne2|*) FROM (table) [WHERE (conditions)]
></pre>
>
><p>
>Il y a deux moyens pour sÃ©lectionner les colonnes. Le premier est d'utiliser <c>*</c> pour sÃ©lectionner toutes les colonnes, et le deuxiÃ¨me est de spÃ©cifier la liste des colonnes que vous souhaitez voir. Le deuxiÃ¨me est plutÃ´t pratique quand vous voulez trouver une colonne particuliÃ¨re parmi une longue liste de colonnes. CommenÃ§ons par utiliser <c>SELECT</c> avec <c>*</c> pour spÃ©cifier toutes les colonnes&#160;:
></p>
>
><pre caption="Visualiser la table produits">
>MyDB=&gt; <i>SELECT * FROM produits;</i>
> identifiant_produit |  description   | prix
>------------+----------------+-------
>          1 | Un produit test | 12.00
>          2 | viande          |  6.79
>          3 | soupe           |  0.69
>          4 | limonade        |  1.79
>(4 rows)
></pre>
>
><p>
>Comme on peut le voir, toutes les donnÃ©es que nous avons insÃ©rÃ© plus tÃ´t sont effectivement dans la table. Maintenant, admettons que nous ne souhaitons voir que la description et le prix, et que nous nous dÃ©sintÃ©ressons de l'identifiant du produit. Dans ce cas, nous utiliserons la forme Â«&#160;colonnes particuliÃ¨res&#160;Â» de SELECT&#160;:
></p>
>
><pre caption="Visualiser des colonnes particuliÃ¨res de la table produits">
>MyDB=&gt; <i>SELECT description,prix FROM produits;</i>
>  description   | prix
>----------------+-------
> Un produit test | 12.00
> viande          |  6.79
> soupe           |  0.69
> limonade        |  1.79
>(4 rows)
></pre>
>
><p>
>Nous avons maintenant uniquement le produit et le prix, ce qui nous permet de nous concentrer sur les donnÃ©es importantes. Imaginons maintenant que nous ne souhaitons voir que les Ã©lÃ©ments dont le prix est supÃ©rieur Ã  2 euros. C'est ici que la clause <c>WHERE</c> vient Ã  notre secours&#160;:
></p>
>
><pre caption="Visualiser des Ã©lÃ©ments particuliers de la table produits">
>MyDB=&gt; <i>SELECT description,prix FROM produits WHERE prix > 2.00;</i>
>  description   | prix
>----------------+-------
> Un produit test | 12.00
> viande          |  6.79
>(2 rows)
></pre>
>
><p>
>Une liste des produits dont le prix est supÃ©rieur Ã  2 euros est maintenant affichÃ©e, ce qui affine encore notre sÃ©lection. Ces formes de requÃªtes d'informations sont trÃ¨s puissantes et peuvent aider Ã  crÃ©er des rapports extrÃªmement utiles.
></p>
>
></body>
></section>
><section>
><title>Conclusion</title>
><body>
>
><p>
>Ceci conclut le guide PostgreSQL. Un grand merci Ã  Masatomo Nakano, qui assure le suivit de Gentoo PostgreSQL, qui m'a Ã©tÃ© d'une grande aide. Toute suggestion concernant ce guide devra Ãªtre envoyÃ©e Ã  <mail>chriswhite@gentoo.org</mail>. Pour une documentation plus dÃ©taillÃ©e, veuillez consulter le <uri link="http://www.postgresql.org">PostgreSQL website</uri>.
></p>
>
></body>
></section>
></chapter>
></guide>

Actions: View

Attachments on bug 132638: 86405