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 MySQL et l'autre est celui qui fait l'objet de ce guide : PostgreSQL. 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 CLEF ÉTRANGÈRE (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. emerge sera la première étape. Dans la section suivante, le processus d'installation par emerge sera décrit, ainsi que la configuration de base.

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 :

# emerge -pv postgresql

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

Voici une liste de ce que les différentes options « build » signifient :

Quand vous aurez terminé la personnalisation de PostgreSQL pour l'adapter à vos besoins spécifiques, passez à l'étape suivante en procédant à l'emerge.

# emerge postgresql
(Sortie abrégée)
>>> /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.

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.

Telle que la dernière sortie d'emerge l'indique, l'environnement initial de PostgreSQL doit être réglé. Toutefois, avant de procéder, une chose doit être prise en considération : Contrairement à MySQL, par exemple, le mot de passe « root » de PostgreSQL est celui de l'utilisateur effectif. Néanmoins, ebuild ne créé que l'utilisateur, pas sont mot de passe. Par conséquent, avant de commencer, le mot de passe pour l'utilisateur PostgreSQL doit être créé :

# passwd postgres
New UNIX password:
Retype new UNIX password:
passwd: password updated successfully

Maintenant que c'est chose faite, la création de l'environnement initial de la base de donnée peut intervenir :

# emerge --config =postgresql-8.0.4


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.
 *

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.

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 :

# /etc/init.d/postgresql start
* Starting PostgreSQL ...                                          [ ok ]

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 :

# rc-update add postgresql default
* postgresql added to runlevel default

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 createdb. Nous passerons également l'option -U pour instaurer l'utilisateur (sans cela c'est l'utilisateur actuel qui est instauré par défaut), ainsi que l'option -W 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 :

$ createdb -U postgres -W test
Password:
CREATE DATABASE

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 dropdb. Nous créerons et utiliserons une nouvelle base de données ultérieurement :

$ dropdb -U postgres -W test
Password:
DROP DATABASE

À 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.

Comme nous l'avons déjà mentionné, il n'est pas souhaitable, dans un environnement multi-utilisateur, de devoir se connecter avec le compte « postgres ». 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 createuser 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 « super-utilisateur » qui pourra ajouter d'autres utilisateurs et administrer la base de données, ainsi qu'un utilisateur standard :

(remplacez chris par le nom d'utilisateur que vous souhaitez utiliser)
$ createuser -a -d -P -E -U postgres -W chris
Enter password for new user:
Enter it again:
Password:
CREATE USER

Très bien, nous avons créé le super-utilisateur. L'option -a de la ligne de commande spécifie que cet utilisateur peut ajouter d'autres utilisateurs. -d signifie que cet utilisateur peut créer des bases de données. -P permet de saisir un mot de passe pour l'utilisateur et -E 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 :

(remplacez chris par l'utilisateur que vous venez de créer)
$ createuser -A -D -P -E -U chris -W utilisateurTest
Enter password for new user:
Enter it again:
Password:
CREATE USER

Parfait ! Notre nouvel utilisateur a été créé par le super-utilisateur que nous avions préalablement créé. Les options -A et -D ont l'effet inverse de -a et -d : 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.

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 -O à la commande createdb. Nous commencerons par créer, avec notre super-utilisateur, une nouvelle base de données, MyDB, qui appartiendra à l'utilisateur test précédent :

$ createdb -O utilisateurTest -U chris -W MyDB
Password:
CREATE DATABASE

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 psql. 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 :

$ psql -U utilisateurTest -W MyDB
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=>

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 psql (le programme client).

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 :

À l'exception de \c[onnect], 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 CREATE TABLE. Nous créerons une table d'éléments. Ils contiendront un identifiant de produit, une description et un prix :

MyDB=> CREATE TABLE produits (
MyDB(>   identifiant_produit SERIAL,
MyDB(>   description TEXT,
MyDB(>   prix DECIMAL
MyDB(> );
NOTICE:  CREATE TABLE will create implicit sequence "products_product_id_seq"
for serial column "products.product_id"
CREATE TABLE

Vous pouvez ignorer cette « NOTICE », elle est parfaitement bénigne. La dernière ligne de la fonction CREATE TABLE semble indiquer que la commande s'est déroulée correctement. Vérifions malgré tout, avec la commande \d, que la table a effectivement été créée.

MyDB=> \d produits
                                 Table "public.produits"
   Column    |  Type   |                            Modifiers
-------------+---------+------------------------------------------------------------------
 identifiant_produit  | integer | not null default nextval('public.produits_identifiant_produit_seq'::text)
 description | text    |
 prix       | numeric |

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.

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 : INSERT :

INSERT INTO [nom_table] (colonne1,colonne2,colonne3) VALUES(valeur1,valeur2,valeur3)

Le nom_table 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 doit être le même. Poursuivons et insérons un élément dans la table :

MyDB=> INSERT INTO produits (description,prix) VALUES('Un produit test', 12.00);
INSERT 17273 1

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 PostgreSQL manual 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 COPY 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 :

2,viande,6.79
3,soupe,0.69
4,limonade,1.79

Nous allons maintenant utiliser la commande COPY pour alimenter la table :

MyDB=> COPY produits FROM STDIN WITH DELIMITER AS ',';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 2,viande,6.79
>> 3,soupe,0.69
>> 4,limonade,1.79
>> \.

Malheureusement, cette instruction ne retourne pas les mêmes informations sur le statut que l'instruction INSERT INTO. 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.

Cette section traitera de l'usage de l'instruction SELECT qui permet de voir les données dans nos tables. Le format basique de SELECT ressemble à ça :

SELECT (colonne1,colonne2|*) FROM (table) [WHERE (conditions)]

Il y a deux moyens pour sélectionner les colonnes. Le premier est d'utiliser * 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 SELECT avec * pour spécifier toutes les colonnes :

MyDB=> SELECT * FROM produits;
 identifiant_produit |  description   | prix
------------+----------------+-------
          1 | Un produit test | 12.00
          2 | viande          |  6.79
          3 | soupe           |  0.69
          4 | limonade        |  1.79
(4 rows)

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 « colonnes particulières » de SELECT :

MyDB=> SELECT description,prix FROM produits;
  description   | prix
----------------+-------
 Un produit test | 12.00
 viande          |  6.79
 soupe           |  0.69
 limonade        |  1.79
(4 rows)

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 WHERE vient à notre secours :

MyDB=> SELECT description,prix FROM produits WHERE prix > 2.00;
  description   | prix
----------------+-------
 Un produit test | 12.00
 viande          |  6.79
(2 rows)

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.

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 à chriswhite@gentoo.org. Pour une documentation plus détaillée, veuillez consulter le PostgreSQL website.