Gentoo Logo

Guide PostgreSQL

Table des matières :

1.  Introduction

Introduction à PostgreSQL

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.

Installation de PostgreSQL

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 :

Exemple de code 1.1 : Vérification des options USE de PostgreSQL

# 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 +nls +pam +perl -pg-intdatetime +python +readline (-selinux) +ssl -tcl +xml +zlib 0 kB

Voici une liste qui explique ce que signifient les différentes options USE :

Option USE Signification
doc Cette option active ou désactive l'installation de la documentation en sus des pages man standard. Vous pouvez désactiver cette option si vous manquez d'espace ou si vous avez accès à cette documentation par d'autres méthodes (en ligne, etc.).
kerberos Avec cette option activée, l'administrateur a la possibilité d'utiliser kerberos pour l'authentification des utilisateurs/services d'une base de données.
nls Si cette option est activée, PostgreSQL peut utiliser des chaînes de caractères traduites pour les utilisateurs non anglophones.
pam 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 PAM (Pluggable Authentication Module).
perl Si cette option est activée, les liaisons (bindings) pour perl seront construites.
pg-intdatetime Si cette option est activée, PostgreSQL supportera le type de donnée « date » en 64 bit.
python Si cette option est activée, PostgreSQL sera construit avec les liaisons (bindings) python.
readline Si cette option est activée, PostgreSQL supportera l'édition des commandes en se conformant au style readline. Cela inclut l'historique des commandes et isearch (recherche dans l'historique).
selinux Si cette option est activée, une politique selinux pour PostgreSQL sera installée.
ssl Si cette option est activée, PostgreSQL utilisera la librairie OpenSSL pour chiffrer le trafic entre les clients et serveurs PostreSQL.
tcl Si cette option est activée, les liaisons (bindings) tcl pour PostgreSQL seront construites.
xml Si cette option est activée, le support du style XPATH de XML sera construit. Vous trouverez ici des informations supplémentaires sur le support du XML avec PostgreSQL : PostgreSQL and XML (en anglais).
zlib Cette option n'est pas directement utilisée par PostgreSQL, mais par pg_dump pour compresser les images des données (dumps) qu'il produit.

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

Exemple de code 1.2 : Installer PostgreSQL

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

2.  Configuration de PostgreSQL

Réglage de l'environnement initial de PostgreSQL

Telle que la dernière sortie d'emerge l'a indiqué, l'environnement initial de PostgreSQL doit être configuré. 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 son mot de passe. Par conséquent, avant de commencer, le mot de passe pour l'utilisateur PostgreSQL doit être créé :

Exemple de code 2.1 : Créer le mot de passe

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

Maintenant que c'est chose faite, nous pouvons passer à la création de l'environnement initial de la base de données :

Exemple de code 2.2 : Configurer l'environnement de la base de données avec emerge --config

# 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 initialisé. La section suivante concernera la vérification de l'installation et l'ajout de l'accès à la base de données par les utilisateurs.

Réglage de la base de données PostgreSQL

Maintenant que PostgreSQL est en place, il serait bon, à ce stade, de vérifier l'installation. Premièrement, assurez-vous que le service démarre correctement :

Exemple de code 2.3 : Démarrage du service PostgreSQL

# /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 :

Exemple de code 2.4 : Ajout au niveau d'exécution par défaut

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

Exemple de code 2.5 : Création d'une base de données avec createdb

$ 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 les tâches élémentaires. Poursuivons et supprimons (drop) cette base de données à l'aide de la commande dropdb :

Exemple de code 2.6 : Suppression d'une base de données avec dropdb

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

Configuration 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, nous pouvons utiliser la commande createuser. 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 :

Exemple de code 2.7 : Création du super-utilisateur

(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 chiffrer celui-ci afin de sécuriser le compte. Nous allons maintenant tester les permissions de ce nouvel utilisateur en créant notre utilisateur standard :

Exemple de code 2.8 : Création de l'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. Le prochain chapitre abordera l'utilisation de cette base de données.

3.  Utilisation de PostgreSQL

Configuration des permissions

À présent, 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 :

Exemple de code 3.1 : Création de la base de données MyDB

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

Exemple de code 3.2 : Se connecter à la base de données MyDB en tant qu'utilisateurTest

$ 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).

Commandes PostgreSQL de base et création d'une table

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 :

Commande Usage Équivalent MySQL
\c[onnect] [DBNAME|- [USER]] Connexion à une autre base de données USE DATABASE
\q Sortie du client psql quit
\i FICHIER Exécution des commandes contenues dans FICHIER source FILE
\o [FICHIER] Envoi des résultats de la requête dans FICHIER INTO OUTFILE, mais cela fonctionne pour tout (pas uniquement pour SELECT)
\d [NOM] Description d'une base de données ou d'une table (ainsi que d'autres éléments) DESC(RIBE)
\db [MOTIF] Liste les tables disponibles qui correspondent au MOTIF (toutes si aucun motif n'est spécifié) SHOW TABLES

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

Exemple de code 3.3 : Création de la table produits

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.

Exemple de code 3.4 : Vérification de la table nouvellement 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.

Insérer des 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 :

Exemple de code 3.5 : Syntaxe de INSERT

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

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

Important : Pour avoir travaillé longtemps avec des bases de données, je recommande de spécifier les instructions INSERT exactement comme nous venons de le faire. Les développeurs font souvent l'erreur d'utiliser INSERT INTO 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 toujours spécifier les colonnes à moins que vous ne soyez sûrs à 300% que vous n'en ajouterez jamais.

Exemple de code 3.6 : Insertion de données 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 où 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 CSV (valeurs séparées par des virgules), qui contient les identifiants des produits, leurs descriptions et leurs prix. Le fichier ressemble à ça :

Exemple de code 3.7 : produits.csv

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

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

Important : Nous utilisons la commande COPY FROM STDIN 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é).

Exemple de code 3.8 : Utilisation de COPY pour alimenter la table produits

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.

Utilisation de requêtes PostgreSQL

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 :

Exemple de code 3.9 : Syntaxe de SELECT

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

Exemple de code 3.10 : Visualiser la table produits

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 :

Exemple de code 3.11 : Visualiser des colonnes particulières de la table produits

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 :

Exemple de code 3.12 : Visualiser des éléments particuliers de la table produits

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.

Conclusion

Ceci conclut le guide PostgreSQL. Un grand merci à Masatomo Nakano, qui assurait le suivi de Gentoo PostgreSQL, qui m'a été d'une grande aide. Toute suggestion concernant ce guide devra être envoyée à Chris White. Pour une documentation plus détaillée, veuillez consulter le site officiel de PostgreSQL.



Imprimer

Dernière mise à jour le 25 avril 2007

La version originale de cette traduction n'est plus maintenue

Résumé : 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.

Chris White
Auteur

Xavier Neys
Correcteur

tutux
Traducteur

Donate to support our development efforts.

Copyright 2001-2014 Gentoo Foundation, Inc. Questions, Comments? Contact us.