Admin DB

Filières : Licence 3 – RIT
ADMINISTRATION DE BASES DE DONNÉES
M. KONATE Ibrahima
1
SOMMAIRE
1. Introduction ....................................................................................................................................... 3
1.1 Installation et configuration de POSTGRESQL ........................................................................... 3
1.2 PostgreSQL ................................................................................................................................ 3
2. Gestion de bases de données............................................................................................................ 3
2.1 Création de bases de données .................................................................................................. 3
2.2 Modification de la base de données ....................................................................................... 10
2.3 Renommage de la base de données........................................................................................ 14
2.4 Suppression de la base de données ........................................................................................ 15
2.5 Copie d’une base de données ................................................................................................. 18
2.6 Obtenir la taille des objets de la base des données ...................................................................... 21
3. Gestion des schémas (Schema) ....................................................................................................... 27
3.1 Schéma .......................................................................................................................................... 27
3.2 Création d’un Schéma ................................................................................................................... 33
3.3 Modification d’un Schéma............................................................................................................. 36
3.4 Suppression d’un Schéma ............................................................................................................. 39
4. Gestion des tablespaces ...................................................................................................................... 43
4.1 Création des tablespaces ............................................................................................................... 43
5. Rôles et Privilèges ................................................................................................................................ 49
5.1 Création d’un rôle .......................................................................................................................... 49
5.2 Octroyer des privilèges .................................................................................................................. 54
5.3 Retirer des privilèges ..................................................................................................................... 57
5.4 Modification d’un rôle ................................................................................................................... 59
5.5 Suppression d’un rôle .................................................................................................................... 63
5.6 Groupe de rôle............................................................................................................................... 67
5.7 Liste des rôles ................................................................................................................................ 72
6. Sauvegarde & Restauration ................................................................................................................. 74
6.1 Sauvegarde de la base de données ............................................................................................... 74
6.2 Restauration de la base de données ............................................................................................. 77
7. Conseils pour bien administrer la base de données............................................................................ 79
2
1. Introduction
Dans ce cours nous allons utiliser le système de gestion de base

de données POSTGRESQL.
1.1 Installation et configuration de POSTGRESQL
Par séance de travail
1.2 PostgreSQL
PostgreSQL est un puissant système de gestion de base de données

relationnelle open source avec plus de 35 ans de développement
actif qui lui a valu une solide réputation de fiabilité, de
robustesse des fonctionnalités et de performance.
Il y a une mine d’informations décrivant comment installer et
utiliser PostgreSQL à travers la documentation officielle. La
communauté open source offre de nombreux endroits utiles pour se
familiariser avec PostgreSQL, découvrir son fonctionnement et
trouver des opportunités de carrière.
2. Gestion de bases de données

2.1 Création de bases de données
L’instruction CREATE DATABASE vous permet de créer une nouvelle

base de données PostgreSQL.
Voici la syntaxe de l’instruction CREATE DATABASE :
3
CREATE DATABASE database_name
WITH
[OWNER = role_name]
[TEMPLATE = template]
[ENCODING = encoding]
[LC_COLLATE = collate]
[LC_CTYPE = ctype]
[TABLESPACE = tablespace_name]
[ALLOW_CONNECTIONS = true | false]
[CONNECTION LIMIT = max_concurrent_connection]
[IS_TEMPLATE = true | false ]
Pour exécuter l’instruction CREATE DATABASE, vous devez avoir un

rôle super utilisateur ou un privilège CREATEDB spécial.
Pour créer une nouvelle base de données :
Tout d’abord, spécifiez le nom de la nouvelle base de données
après les mots-clés CREATE DATABASE. Le nom de la base de données
doit être unique dans le serveur de base de données PostgreSQL.
Si vous essayez de créer une base de données dont le nom existe
déjà, PostgreSQL émettra une erreur.
Ensuite, spécifiez un ou plusieurs paramètres pour la nouvelle
base de données.
Explication des paramètres :

OWNER
Attribuez un rôle qui sera le propriétaire de la base de données.
Si vous omettez l’option OWNER, le propriétaire de la base de
données est le rôle que vous utilisez pour exécuter l’instruction
CREATE DATABASE.
TEMPLATE
Spécifiez la base de données modèle à partir de laquelle la
nouvelle base de données est créée. Par défaut, PostgreSQL
4
utilise la base de données template1 comme base de modèles si
vous ne spécifiez pas explicitement la base de données modèle.
ENCODING
Déterminez l’encodage du jeu de caractères dans la nouvelle base
de données.
LC_COLLATE
Spécifier l’ordre de collationnement (LC_COLLATE) que la nouvelle
base utilisera. Ce paramètre affecte l’ordre de tri de la chaîne
dans les requêtes qui contiennent la clause ORDER BY. Par défaut,
il s’agit du LC_COLLATE de la base modèle.
LC_CTYPE
Précisez la classification des caractères que la nouvelle base de
données utilisera. Elle influe sur la classification des
caractères, p. ex., inférieur, supérieur et numérique. Il est par
défaut LC_CTYPE de la base modèle
TABLESPACE
Spécifiez le nom du tablespace pour la nouvelle base de données.
La valeur par défaut est le tablespace de la base modèle.
CONNECTION LIMIT
Spécifiez le nombre maximum de connexions simultanées à la
nouvelle base de données. La valeur par défaut est -1 soit
illimitée. Ce paramètre est utile dans les environnements
d’hébergement partagé où vous pouvez configurer le maximum de
connexions simultanées pour une base de données particulière.
ALLOW_CONNECTIONS
Le paramètre allow_connections est une valeur booléenne. S’il est
faux, vous ne pouvez pas vous connecter à la base de données.
IS_TEMPLATE
Si le IS_TEMPLATE est vrai, tout utilisateur disposant du
privilège CREATEDB peut le cloner. Si faux, seuls les super
utilisateurs ou le propriétaire de la base de données peuvent le
cloner.
a) Créer une base de données avec les paramètres par défaut
Tout d’abord, connectez-vous à PostgreSQL en utilisant n’importe
quel outil client.
5
Deuxièmement, exécutez l’instruction suivante dans une nouvelle
base de données avec les paramètres par défaut :
CREATE DATABASE sales;
PostgreSQL a créé une nouvelle base de données nommée sales qui a

des paramètres par défaut à partir de la base de modèles par
défaut (template1).
Troisièmement, si vous utilisez l’outil client psql, vous pouvez
afficher toutes les bases de données du serveur de base de
données PostgreSQL actuel en utilisant la commande \l :
\l
b) Créer une base de données avec certains paramètres

L’exemple suivant utilise l’instruction CREATE DATABASE pour
créer une base de données nommée hr avec certains paramètres :
CREATE DATABASE hr
WITH
ENCODING = 'UTF8'
OWNER = hr
CONNECTION LIMIT = 100;
Dans cet exemple, nous avons créé la base de données hr avec

l’encodage UTF8, le propriétaire est hr et le nombre de
connexions simultanées à la base de données est de 100.
c) Création d’une nouvelle base de données avec pgAdmin

L’outil pgAdmin vous offre une interface intuitive pour créer une
nouvelle base de données.
Tout d’abord, connectez-vous au serveur de base de données

PostgreSQL en utilisant pgAdmin.
6
Ensuite, cliquez avec le bouton droit sur le nœud Bases de
données et sélectionnez Créer > Base de données… élément de menu
Une boîte de dialogue s’affiche pour vous permettre d’entrer des

informations détaillées dans la nouvelle base de données.
Troisièmement, entrez le nom de la base de données et
sélectionnez un propriétaire dans l’onglet général.
Dans cet exemple, nous avons entré sampledb comme nom de la

nouvelle base de données et postgres comme propriétaire.
7
Quatrièmement, sélectionnez l’onglet Définition pour définir les
propriétés de la base de données :
Dans l’onglet Définition, vous pouvez sélectionner l’encodage,

choisir un modèle, un tablespace, une collation, un type de
caractère et une limite de connexion.
L’onglet Sécurité vous permet de définir des étiquettes de
sécurité et d’attribuer des privilèges. L’onglet Privilèges vous
permet d’attribuer des privilèges à un rôle.
Cinquièmement, cliquez sur l’onglet SQL pour afficher
l’instruction SQL générée qui s’exécutera.
8
Enfin, cliquez sur le bouton Enregistrer pour créer la base de
données sampledb. Vous verrez la base de données sampledb dans la
liste :
9
Résumé :
Utilisez l’instruction CREATE DATABASE pour créer une nouvelle
base de données.
2.2 Modification de la base de données
L’instruction ALTER DATABASE vous permet d’effectuer l’action

suivante sur la base :
• Modifier les attributs de la base de données

• Renommer la base de données
• Changer le propriétaire de la base
• Modifier le tablespace par défaut d’une base de données
• Modifier la valeur par défaut de la session pour une
variable de configuration d’exécution pour une base de
données
a) Modification des attributs d’une base de données
Pour modifier les attributs d’une base de données, vous utilisez
la syntaxe suivante de ALTER TABLE :
ALTER DATABASE name WITH option;
Cette option peut être :
10
• IS_TEMPLATE
• CONNECTION LIMIT
• ALLOW_CONNECTIONS
Notez que seuls les super utilisateurs ou les propriétaires de
bases de données peuvent modifier ces paramètres.
b) Renommer la base de données

La déclaration suivante ALTER DATABASE RENAME TO renomme une base
de données :
ALTER DATABASE database_name
RENAME TO new_name;
Il n’est pas possible de renommer la base de données actuelle.

Vous devez donc vous connecter à une autre base de données et la
renommer à partir de cette base.
Seuls les super utilisateurs et les propriétaires de base de
données disposant du privilège CREATEDB peuvent renommer la base
de données.
c) Changer de propriétaire de la base
La déclaration suivante ALTER DATABASE change le propriétaire
d’une base de données pour la nouvelle :
OWNER TO new_owner | current_user | session_user;
Les utilisateurs suivants peuvent modifier la réponse de la base

de données :
• Le propriétaire de la base de données avec le privilège

CREATEDB et un membre direct ou indirect du nouveau
propriétaire de rôle.
• Les super utilisateurs
d) Modifier le tablespace par défaut d’une base de données
La déclaration suivante modifie tablespace par défaut de la base
de données :
11
SET TABLESPACE new_tablespace;
La syntaxe déplace physiquement les tables et les index de

l’ancien tablespace vers le nouveau.
Pour définir le nouveau tablespace, le tablespace doit être vide
et il y a une connexion à la base de données.
Les super utilisateurs et le propriétaire de la base de données
peuvent modifier le tablespace par défaut de la base de données
e) Modifier les valeurs par défaut des variables de configuration
d’exécution
Chaque fois que vous vous connectez à une base de données,
PostgreSQL charge les variables de configuration du fichier
postgresql.conf et utilise ces variables par défaut.
Pour surcharger ces paramètres pour une base de données
particulière, vous utilisez l’instruction ALTER DATABASE SET
comme suit :
SET configuration_parameter = value;
Dans les sessions suivantes, PostgreSQL surchargera les

paramètres du fichier postgresql.conf.
Seuls les super utilisateurs ou propriétaires de base de données
peuvent modifier la configuration par défaut de la session pour
une configuration d’exécution de la base de données.
Exemples de PostgreSQL ALTER DATABASE

Tout d’abord, connectez-vous à PostgreSQL en utilisant
l’utilisateur postgres et créez une nouvelle base de données
nommée testdb2 pour la démonstration.
CREATE DATABASE testdb2;
Deuxièmement, renommez testdb2 en testhrdb en utilisant

l’instruction suivante :
ALTER DATABASE testdb2
RENAME TO testhrdb;
12
Troisièmement, exécutez l’instruction suivante pour changer le
propriétaire de la base de données testhrdb de postgresto hr, en
supposant que le rôle hr existe déjà.
ALTER DATABASE testhrdb
OWNER TO hr;
Si le rôle des hr n’existe pas, vous pouvez le créer en utilisant

la syntaxe CREATE ROLE :
CREATE ROLE hr
LOGIN
CREATEDB
PASSWORD 'securePa$$1';
Quatrièmement, changer le tablespace par défaut de testhrdb de

pg_default à hr_default, en supposant que le tablespace
hr_default existe déjà.
ALTER DATABASE testhrdb
SET TABLESPACE hr_default;
Si le tablespace hr_default n’existe pas, vous pouvez le créer en

utilisant l’instruction suivante :
CREATE TABLESPACE hr_default
OWNER hr
LOCATION 'C:\\sampledb\\hr';
Cinquièmement, définissez la variable de configuration

escape_string_warning à off en utilisant l’instruction suivante :
ALTER DATABASE testhrdb SET escape_string_warning = off;
Dans cette partie, vous avez appris à utiliser l’instruction

PostgreSQL ALTER DATABASE.
13
2.3 Renommage de la base de données
Pour renommer une base de données PostgreSQL, procédez comme
suit :
Déconnectez-vous de la base de données que vous souhaitez
renommer et connectez-vous à une autre base de données.
Vérifiez et terminez toutes les connexions actives à la base de
données que vous souhaitez renommer.
Utilisez l’instruction ALTER DATABASE pour renommer la base de
données.
Prenons un exemple de renommage d’une base de données.
L’instruction suivante crée une nouvelle base de données appelée
db :
CREATE DATABASE db;
Pour renommer la base de données en newdb, procédez comme suit :

Tout d’abord, déconnectez-vous de la base de données que vous
souhaitez renommer et connectez-vous à une autre base de données,
par exemple, postgres. Si vous utilisez l’outil psql, vous pouvez
utiliser la commande suivante pour vous connecter à la base de
données postgres :
db=# \connect postgres
En vous connectant à la base de données postgres, vous êtes

automatiquement déconnecté de la base de données db.
Ensuite, vérifiez toutes les connexions actives à la base de
données en utilisant la requête suivante :
SELECT * FROM pg_stat_activity WHERE datname = 'db';
La requête a produit le résultat suivant : (voir la console)

Comme vous pouvez le voir clairement à partir de la sortie, il
n’y a qu’une connexion à la base de données db.
Il se peut que la base de données, que vous souhaitez renommer,
ait de nombreuses connexions actives. Dans ce cas, vous devez
informer les utilisateurs respectifs ainsi que les propriétaires
de l’application avant de mettre fin aux connexions pour éviter
la perte de données.
14
Puis, terminez toutes les connexions à la base de données db en
utilisant l’instruction suivante :
SELECT
pg_terminate_backend (pid)
FROM
pg_stat_activity
WHERE
datname = 'db';
Ensuite, renommez la base de données en newdb en utilisant

l’instruction ALTER DATABASE RENAME TO comme suit :
ALTER DATABASE db RENAME TO newdb;
Enfin, si votre base de données est utilisée par des

applications, vous devez modifier les chaînes de connexion.
Dans cette partie, vous avez appris comment renommer une base de
données PostgreSQL en une nouvelle en utilisant l’instruction
ALTER DATABASE RENAME TO.
2.4 Suppression de la base de données
Une fois qu’une base de données n’est plus nécessaire, vous
pouvez la supprimer en utilisant l’instruction DROP DATABASE.
Ce qui suit illustre la syntaxe de l’instruction DROP DATABASE :
DROP DATABASE [IF EXISTS] database_name;
Pour supprimer une base de données :

Spécifiez le nom de la base de données à supprimer après la
clause DROP DATABASE.
Utilisez IF EXISTS pour empêcher une erreur de supprimer une base
de données inexistante. PostgreSQL émettra plutôt un avis.
La commande DROP DATABASE supprime définitivement les entrées de
catalogue et le répertoire de données. Cette action ne peut pas
être annulée, vous devez donc l’utiliser avec prudence.
15
Seuls les super utilisateurs et le propriétaire de la base de
données peuvent exécuter l’instruction DROP DATABASE. En outre,
vous ne pouvez pas exécuter l’instruction DROP DATABASE si la
base de données a toujours des connexions actives. Dans ce cas,
vous devez vous déconnecter de la base de données et vous
connecter à une autre base de données, par exemple, postgres pour
exécuter l’instruction DROP DATABASE.
PostgreSQL fournit également un utilitaire nommé dropdbqui vous
permet de supprimer une base de données. Le programme dropdb
exécute l’instruction DROP DATABASE en coulisses.
a) Supprimer une base de données ayant des connexions actives

Pour supprimer la base de données qui a des connexions actives,
vous pouvez suivre ces étapes :
Tout d’abord, trouvez les activités associées à la base de
données en interrogeant la vue pg_stat_activity :
SELECT *
FROM pg_stat_activity
WHERE datname = '<database_name>';
Deuxièmement, mettre fin aux connexions actives en émettant la

requête suivante :
SELECT pg_terminate_backend (pid)
WHERE pg_stat_activity.datname = '<database_name>';
Remarque :
Notez que si vous utilisez PostgreSQL version 9.1 ou antérieure,
utilisez la procpidcolumn à la place de la pidcolumn car
PostgreSQL a changé procidcolumn en pidcolumn depuis la version
9.2
Troisièmement, exécutez l’instruction DROP DATABASE :
DROP DATABASE <database_name>;
16
Exemples de base de données PostgreSQL DROP :
Nous utiliserons les bases de données créées dans la partie
PostgreSQL create database pour la démonstration.
Si vous n’avez pas encore créé cette base de données, vous pouvez
utiliser les instructions CREATE DATABASE suivantes pour les
créer :
CREATE DATABASE hrdb;
CREATE DATABASE testdb1;
a) Supprimer une base de données sans connexion active

Pour supprimer la base hrdbdatabase, utilisez le propriétaire
hrdb pour vous connecter à une base de données autre que la base
de données hrdb par ex., postgres et exécuter la syntaxe
suivante :
DROP DATABASE hrdb;
PostgreSQL a supprimé la base hrdb.

b) Supprimer une base de données ayant des connexions actives
La déclaration suivante supprime la base de données testdb1 :
DROP DATABASE testdb1;
Cependant, PostgreSQL a émis une erreur comme suit :
ERROR: database "testdb1" is being accessed by other users
SQL state: 55006
Detail: There is 1 other session using the database.
Pour supprimer la base de données testdb1, vous devez mettre fin

à la connexion active et supprimer la base de données.
Tout d’abord, interroger la vue pg_stat_activity pour trouver les
activités qui se déroulent dans la base de données testdb1 :
17
SELECT *
WHERE datname = 'testdb1';
La base de données testdb1 a une connexion à partir de localhost

par conséquent, il est sûr de mettre fin à cette connexion et de
supprimer la base de données.
Deuxièmement, Mettez fin à la connexion de la base de données
testdb1 en utilisant la déclaration suivante :
SELECT
pg_terminate_backend (pg_stat_activity.pid)
FROM
pg_stat_activity
WHERE
pg_stat_activity.datname = 'testdb1';
Troisièmement, lancer la commande DROP DATABASE pour supprimer la

base de données testdb1 :
DROP DATABASE testdb1;
PostgreSQL supprime le testdb1 de façon permanente.

PostgreSQL DROP DATABASE pour supprimer une base de données. En
outre, vous avez également appris comment supprimer une base de
données ayant des connexions actives.
2.5 Copie d’une base de données
18
Parfois, vous souhaitez copier une base de données PostgreSQL
dans un serveur de base de données à des fins de test.
PostgreSQL permet de le faire facilement via l’instruction CREATE
DATABASE comme suit :
CREATE DATABASE targetdb WITH TEMPLATE sourcedb;
Cette instruction copie le fichier source vers la base de données

targetdb. Par exemple, pour copier la base de données
d’échantillons dvdrental dans la base de données dvdrental_test,
vous utilisez la déclaration suivante :
CREATE DATABASE dvdrental_test WITH TEMPLATE dvdrental;
Selon la taille de la base de données source, la copie peut
prendre un certain temps.
Si la base de données dvdrental a des connexions actives, vous
obtiendrez l’erreur suivante :
ERROR: source database "dvdrental" is being accessed by other users
DETAIL: There is 1 other session using the database.
La requête suivante retourne les connexions actives :
SELECT pid, usename, client_addr FROM pg_stat_activity WHERE datname ='dvdrental';
19
Pour detruire les connexions actives à la base de données
dvdrental, vous utilisez la requête suivante :
SELECT pg_terminate_backend (pid) FROM pg_stat_activity WHERE datname = 'dvdrental';
Ensuite, vous pouvez exécuter à nouveau l’instruction CREATE

TABLE WITH TEMPLATE pour copier la base de données dvdrental dans
dvdrental_test.
PostgreSQL copie la base de données d’un serveur à un autre
Il existe plusieurs façons de copier une base de données entre
les serveurs de base de données PostgreSQL.
Si la taille de la base de données source est grande et que la
connexion entre les serveurs de base de données est lente, vous
pouvez vider la base de données source dans un fichier, copier le
fichier sur le serveur distant et le restaurer :
Tout d’abord, vider la base de données source dans un fichier.
pg_dump -U postgres -d sourcedb -f sourcedb.sql
Deuxièmement, copiez le fichier dump sur le serveur distant.

Troisièmement, créer une nouvelle base de données dans le serveur
distant :
CREATE DATABASE targetdb;
Enfin, restaurer le fichier dump sur le serveur distant :
psql -U postgres -d targetdb -f sourcedb.sql
Exemple de copie de la base de données dvdrental

Les étapes suivantes illustrent comment copier la base de données
dvdrental du serveur local vers le serveur distant.
Tout d’abord, videz la base de données dvdrental dans un fichier
dump, par exemple, dvdrental.sql :
pg_dump -U postgres -O dvdrental -f dvdrental.sql
20
Deuxièmement, copiez le fichier dump sur le serveur distant.
Troisièmement, créer la base de données dvdrental sur le serveur
distant :
CREATE DATABASE dvdrental;
Quatrièmement, restaurez le fichier dump dvdrental.sql dans le

serveur distant :
psql -U postgres -d dvdrental -f dvdrental.sql
Dans le cas où la connexion entre les serveurs est rapide et la

taille de la base de données n’est pas grande, vous pouvez
utiliser la commande suivante :
pg_dump -C -h local -U localuser sourcedb | psql -h remote -U remoteuser targetdb
Par exemple, pour copier la base de données dvdrental du serveur

localhost vers le serveur distant, procédez comme suit :
pg_dump -C -h localhost -U postgres dvdrental | psql -h remote -U postgres dvdrental
Dans cette partie, vous avez appris à copier une base de données
PostgreSQL dans un serveur de base de données, ou d’un serveur de
base de données à un autre.
2.6 Obtenir la taille des objets de la base des données
select pg_relation_size('actor');
La fonction pg_relation_size() renvoie la taille d’une table

spécifique en octets :
pg_relation_size
------------------
16384
21
Pour rendre le résultat plus lisible, vous utilisez la fonction
pg_size_pretty(). La fonction pg_size_pretty() prend le résultat
d’une autre fonction et la formate en utilisant des octets, kB,
MB, GB ou TB selon le cas. Par exemple :
SELECT pg_size_pretty (pg_relation_size('actor'));
La sortie suivante est en kB
pg_size_pretty
----------------
16 kB
(1 row)
La fonction pg_relation_size() renvoie la taille de la table

uniquement, sans index inclus ni objets supplémentaires.
Pour obtenir la taille totale d’une table, utilisez la fonction
pg_total_relation_size(). Par exemple, pour obtenir la taille
totale de la table d’acteur, vous utilisez l’instruction suivante :
SELECT
pg_size_pretty (
pg_total_relation_size ('actor')
);
Voici les résultats obtenus :

pg_size_pretty
----------------
72 kB
(1 row)
Vous pouvez utiliser la fonction pg_total_relation_size() pour

trouver la taille des plus grandes tables, y compris les index.
22
Par exemple, la requête suivante retourne les 5 plus grandes tables
de la base de données dvdrental :
SELECT
relname AS "relation",
pg_size_pretty (
pg_total_relation_size (C .oid)
) AS "total_size"
FROM
pg_class C
LEFT JOIN pg_namespace N ON (N.oid = C .relnamespace)
WHERE
nspname NOT IN (
'pg_catalog',
'information_schema'
AND C .relkind <> 'i'
AND nspname !~ '^pg_toast'
ORDER BY
pg_total_relation_size (C .oid) DESC
LIMIT 5;
23
Voici la sortie :
relation | total_size
------------+------------
rental | 2472 kB
payment | 2232 kB
film | 688 kB
film_actor | 536 kB
inventory | 464 kB
(5 rows)
Taille de la base de données PostgreSQL

Pour obtenir la taille de toute la base de données, utilisez la
fonction pg_database_size(). Par exemple, la syntaxe suivante
renvoie la taille de la base de données dvdrental :
SELECT pg_size_pretty (pg_database_size ('dvdrental') );
La syntaxe renvoie le résultat suivant :
pg_size_pretty
----------------
15 MB
(1 row)
Pour obtenir la taille de chaque base de données sur le serveur de

base de données actuel, vous utilisez la déclaration suivante :
SELECT
pg_database.datname,
pg_size_pretty(pg_database_size(pg_database.datname)) AS size
FROM pg_database;
24
datname | size
----------------+---------
postgres | 7055 kB
template1 | 7055 kB
template0 | 6945 kB
dvdrental | 15 MB
Taille de l’index PostgreSQL

Pour obtenir la taille totale de tous les index attachés à une
table, vous utilisez la fonction pg_indexes_size().
La fonction pg_indexes_size() accepte le nom de l’OID ou de la
table comme argument et retourne l’espace disque total utilisé par
tous les index attachés à cette table.
Par exemple, pour obtenir la taille totale de tous les index
attachés à la table de film, vous utilisez la déclaration
suivante :
SELECT pg_size_pretty (pg_indexes_size('actor'));
Voici la sortie :
pg_size_pretty
----------------
32 kB
(1 row)
Taille du tablespace PostgreSQL

Pour obtenir la taille d’un tablespace, utilisez la fonction
pg_tablespace_size(). La fonction pg_tablespace_size() accepte un
nom du tablespace et renvoie la taille en octets.
La syntaxe suivante renvoie la taille du tablespace pg_default :
SELECT
pg_size_pretty (
pg_tablespace_size ('pg_default')
);
25
La syntaxe renvoie le résultat suivant :
pg_size_pretty
----------------
43 MB
(1 row)
Taille de la valeur PostgreSQL

Pour trouver l’espace nécessaire pour stocker une valeur
spécifique, utilisez la fonction pg_column_size(), par exemple :
select pg_column_size(5::smallint);
pg_column_size
----------------
(1 row)
select pg_column_size(5::int);
pg_column_size
----------------
(1 row)
select pg_column_size(5::bigint);
pg_column_size
----------------
(1 row)
Dans cette partie, vous avez appris diverses fonctions pratiques

pour obtenir la taille d’une base de données, une table, des index,
un tablespace et une valeur.
26
3. Gestion des schémas (Schema)
3.1 Schéma
Dans PostgreSQL, un schéma est un espace de noms qui contient des

objets de base de données nommés tels que tables, vues, index,
types de données, fonctions, procédures stockées et opérateurs.
Pour accéder à un objet dans un schéma, vous devez le qualifier
en utilisant la syntaxe suivante :
schema_name.object_name
Une base de données peut contenir un ou plusieurs schémas et

chaque schéma appartient à une seule base de données. Deux
schémas peuvent avoir des objets différents qui partagent le même
nom.
Par exemple, vous pouvez avoir le schéma des ventes qui a la
table du personnel et le schéma public qui a également la table
du personnel. Lorsque vous faites référence à la table du
personnel, vous devez la qualifier comme suit :
public.staff
Ou :
sales.staff
Pourquoi utiliser des schémas

Il y a certains scénarios que vous souhaitez utiliser :
Les schémas vous permettent d’organiser des objets de base de
données par exemple, des tables en groupes logiques pour les
rendre plus gérables.
Les schémas permettent à plusieurs utilisateurs d’utiliser une
base de données sans interférer les uns avec les autres.
Le schéma public
PostgreSQL crée automatiquement un schéma appelé public pour
chaque nouvelle base de données. Quel que soit l’objet que vous
27
créez sans spécifier le nom du schéma, PostgreSQL le placera dans
ce schéma public. Par conséquent, les syntaxes suivantes sont
équivalentes :
CREATE TABLE table_name(
...
);
Et
CREATE TABLE public.table_name(
...
);
Le chemin de recherche du schéma

En pratique, vous vous référerez à une table sans son nom de
schéma, par exemple, table de personnel au lieu d’un nom
entièrement qualifié comme table de vente.staff.
Lorsque vous référencez une table en utilisant seulement son nom,
PostgreSQL recherche la table en utilisant le chemin de recherche
de schéma, qui est une liste de schémas à rechercher.
PostgreSQL accédera à la première table correspondante dans le
chemin de recherche de schéma. S’il n’y a pas de correspondance,
il retournera une erreur, même le nom existe dans un autre schéma
de la base de données.
Le premier schéma du chemin de recherche est appelé schéma
courant. Notez que lorsque vous créez un nouvel objet sans
spécifier explicitement un nom de schéma, PostgreSQL utilisera
également le schéma courant pour le nouvel objet.
La fonction current_schema() renvoie le schéma actuel :
SELECT current_schema();
Voici la sortie :
28
current_schema
----------------
public
(1 row)
C’est pourquoi PostgreSQL utilise public pour chaque nouvel objet

que vous créez.
Pour afficher le chemin de recherche actuel, utilisez la commande
SHOW dans l’outil psql :
SHOW search_path;
Le résultat est le suivant :

search_path
-----------------
"$user", public
(1 row)
Dans cette sortie :

Le "$user" spécifie que le premier schéma que PostgreSQL
utilisera pour rechercher l’objet, qui a le même nom que
l’utilisateur courant. Par exemple, si vous utilisez
l’utilisateur postgres pour vous connecter et accéder à la table
de portée. PostgreSQL recherchera la table de portée dans le
schéma postgres. S’il ne peut pas trouver un objet comme ça, il
continue à chercher l’objet dans le schéma public.
Le deuxième élément renvoie au schéma public que nous avons déjà
vu.
Pour créer un nouveau schéma, vous utilisez l’instruction CREATE
SCHEMA :
CREATE SCHEMA sales;
Pour ajouter le nouveau schéma au chemin de recherche, utilisez

la commande suivante :
SET search_path TO sales, public;
29
Maintenant, si vous créez une nouvelle table nommée staff sans
spécifier le nom du schéma, PostgreSQL mettra cette table dans le
schéma de vente :
CREATE TABLE staff(
staff_id SERIAL PRIMARY KEY,
first_name VARCHAR(45) NOT NULL,
last_name VARCHAR(45) NOT NULL,
email VARCHAR(100) NOT NULL UNIQUE
);
La photo suivante montre le nouveau schéma des ventes et la table

du personnel qui appartient au schéma des ventes :
30
Pour accéder à la table du personnel dans le schéma de vente,
vous pouvez utiliser l’un des syntaxes suivantes :
SELECT * FROM staff;
Ou :
SELECT * FROM sales.staff;
31
Le schéma public est le deuxième élément du chemin de recherche,
donc pour accéder à la table de portée dans le schéma public,
vous devez qualifier le nom de la table comme suit :
SELECT * FROM public.staff;
Si vous utilisez la commande suivante, vous devrez explicitement

faire référence aux objets dans le schéma public en utilisant un
nom entièrement qualifié :
SET search_path TO public;
Le schéma public n’est pas un schéma spécial, donc vous pouvez le

laisser tomber aussi.
Schémas et privilèges de PostgreSQL
Les utilisateurs ne peuvent accéder aux objets que dans les
schémas qu’ils possèdent. Cela signifie qu’ils ne peuvent accéder
à aucun objet dans les schémas qui ne leur appartiennent pas.
Pour permettre aux utilisateurs d’accéder aux objets du schéma
qu’ils ne possèdent pas, vous devez accorder le privilège USAGE
du schéma aux utilisateurs :
GRANT USAGE ON SCHEMA schema_name
TO role_name;
Pour permettre aux utilisateurs de créer des objets dans le

schéma qu’ils ne possèdent pas, vous devez leur accorder le
privilège CREATE du schéma :
GRANT CREATE ON SCHEMA schema_name
TO user_name;
32
Notez que, par défaut, chaque utilisateur a le CREATE et USAGE
sur le schéma public.
Opérations de schéma PostgreSQL
Pour créer un nouveau schéma, vous utilisez l’instruction CREATE
SCHEMA.
Pour renommer un schéma ou changer son propriétaire, vous
utilisez l’instruction ALTER SCHEMA.
Pour supprimer un schéma, vous utilisez l’instruction DROP
SCHEMA.
Dans cette partie, vous avez appris comment PostgreSQL utilise le
chemin de recherche pour résoudre les noms d’objets.
3.2 Création d’un Schéma
L’instruction CREATE SCHEMA vous permet de créer un nouveau

schéma dans la base de données actuelle.
Ce qui suit illustre la syntaxe de l’instruction CREATE SCHEMA :
CREATE SCHEMA [IF NOT EXISTS] schema_name;
Dans cette syntaxe :

Tout d’abord, spécifiez le nom du schéma après les mots-clés
CREATE SCHEMA. Le nom du schéma doit être unique dans la base de
données courante.
Deuxièmement, utilisez optionnellement IF NOT EXISTS pour créer
conditionnellement le nouveau schéma uniquement s’il n’existe
pas. Essayer de créer un nouveau schéma qui existe déjà sans
utiliser l’option IF NOT EXISTS entraînera une erreur.
NB :
Notez que pour exécuter l’instruction CREATE SCHEMA, vous devez
avoir le privilège CREATE dans la base de données courante.
Vous pouvez également créer un schéma pour un utilisateur :
33
CREATE SCHEMA [IF NOT EXISTS] AUTHORIZATION username;
Dans ce cas, le schéma aura le même nom que le nom d’utilisateur;

PostgreSQL vous permet également de créer un schéma et une liste
d’objets tels que des tables et des vues en utilisant une seule
instruction comme suit :
CREATE SCHEMA schema_name
CREATE TABLE table_name1 (...)
CREATE TABLE table_name2 (...)
CREATE VIEW view_name1
SELECT select_list FROM table_name1;
Notez que chaque sous-commande ne se termine pas par un point-

virgule (;).
PostgreSQL CREATE SCHEMA examples
Prenons quelques exemples d’utilisation de l’instruction CREATE
SCHEMA pour mieux comprendre.
a) Utiliser CREATE SCHEMA pour créer un nouvel exemple de schéma
La commande suivante utilise la commande CREATE SCHEMA pour créer
un nouveau schéma nommé marketing :
CREATE SCHEMA marketing;
Le relevé suivant renvoie tous les schémas de la base de données

courante :
SELECT * FROM pg_catalog.pg_namespace ORDER BY nspname;
Cette image montre la sortie :
34
b) Utiliser CREATE SCHEMA pour créer un schéma pour un exemple
utilisateur
Tout d’abord, créez un nouveau rôle avec le nom john :
CREATE ROLE john
LOGIN
PASSWORD 'Postgr@s321!'; LOGIN
PASSWORD 'Postgr@s321!';
Deuxièmement, créer un schéma pour john :
CREATE SCHEMA AUTHORIZATION john;
Troisièmement, créer un nouveau schéma appelé doe qui sera détenu

par john :
CREATE SCHEMA IF NOT EXISTS doe AUTHORIZATION john;
c) Utiliser CREATE SCHEMA pour créer un schéma et son exemple

d’objets
L’exemple suivant utilise l’instruction CREATE SCHEMA pour créer
un nouveau schéma nommé scm. Il crée également une table nommée
deliveries et une vue nommée delivery_due_list qui appartient au
schéma scm :
35
CREATE SCHEMA scm
CREATE TABLE deliveries(
id SERIAL NOT NULL,
customer_id INT NOT NULL,
ship_date DATE NOT NULL
CREATE VIEW delivery_due_list AS
SELECT ID, ship_date
FROM deliveries
WHERE ship_date <= CURRENT_DATE;

PostgreSQL CREATE SCHEMA pour créer un nouveau schéma dans une
base de données.
3.3 Modification d’un Schéma
L’instruction ALTER SCHEMA vous permet de modifier la définition

d’un schéma. Par exemple, vous pouvez renommer un schéma comme
suit :
ALTER SCHEMA schema_name RENAME TO new_name;
Tout d’abord, spécifiez le nom du schéma que vous souhaitez

renommer après les mots-clés ALTER SCHEMA.
Deuxièmement, spécifiez le nouveau nom du schéma après les mots-
clés RENAME TO.
Notez que pour exécuter cette instruction, vous devez être le
propriétaire du schéma et vous devez avoir le privilège CREATE
pour la base de données.
En plus de renommer un schéma, ALTER SCHEMA vous permet également

de changer le propriétaire d’un schéma pour le nouveau comme
indiqué dans l’instruction suivante :
ALTER SCHEMA schema_name
OWNER TO { new_owner | CURRENT_USER | SESSION_USER};
36
Tout d’abord, spécifiez le nom du schéma auquel vous voulez
changer le propriétaire dans la clause ALTER SCHEMA.
Deuxièmement, précisez le nouveau propriétaire dans la clause
OWNER TO.
Exemples d’instructions PostgreSQL ALTER SCHEMA
Prenons quelques exemples d’utilisation de l’instruction ALTER
SCHEMA pour mieux comprendre.
Notez que les exemples de la partie suivante sont basés sur le

schéma que nous avons créé dans le cours sur CREATE SCHEMA.
a) Utilisation de l’instruction ALTER SCHEMA pour renommer un

exemple de schéma
Cet exemple utilise l’instruction ALTER SCHEMA pour renommer le
schema doe en finance :
dessin
ALTER SCHEMA doe RENAME TO finance;
De même, l’exemple suivant renomme le schéma john en

comptabilité :
ALTER SCHEMA john RENAME TO accounting;
b) Utiliser l’instruction ALTER SCHEMA pour changer le

propriétaire d’un exemple de schéma
L’exemple suivant utilise l’instruction ALTER SCHEMA pour changer
le propriétaire de la comptabilité de schéma de john à postgres :
ALTER SCHEMA finance OWNER TO postgres;
Voici l’instruction pour interroger le schéma créé par

l’utilisateur :
37
SELECT *
FROM
pg_catalog.pg_namespace
WHERE
nspacl is NULL AND
nspname NOT LIKE 'pg_%'
ORDER BY
nspname;
Le resultat :
Comme vous pouvez le voir clairement sur la sortie, le schéma

financier est maintenant la propriété du propriétaire avec id 10,
qui est postgres.
De même, cet état change le propriétaire du schéma comptable en
postgres :
ALTER SCHEMA accounting OWNER TO postgres;

PostgreSQL ALTER SCHEMA pour renommer un schéma ou changer le
propriétaire d’un schéma en un nouveau.
38
3.4 Suppression d’un Schéma
Le DROP SCHEMA supprime un schéma et tous ses objets d’une base
de données. Ce qui suit illustre la syntaxe de l’instruction DROP
SCHEMA :
dessin
DROP SCHEMA [IF EXISTS] schema_name
[ CASCADE | RESTRICT ];

Tout d’abord, spécifiez le nom du schéma dont vous voulez
supprimer après les mots-clés DROP SCHEMA.
Deuxièmement, utilisez l’option IF EXISTS pour supprimer le
schéma conditionnellement uniquement s’il existe.
Troisièmement, utilisez CASCADE pour supprimer schema et tous ses
objets, et à son tour, tous les objets qui dépendent de ces
objets. Si vous voulez supprimer schema seulement quand il est
vide, vous pouvez utiliser l’option RESTRICT. Par défaut, DROP
SCHEMA utilise l’option RESTRICT.
Pour exécuter l’instruction DROP SCHEMA, vous devez être le
propriétaire du schéma que vous voulez déposer ou un super
utilisateur.
PostgreSQL vous permet de supprimer plusieurs schémas en même
temps en utilisant une seule instruction DROP SCHEMA :
DROP SCHEMA [IF EXISTS] schema_name1 [,schema_name2,...]
[CASCADE | RESTRICT];
Exemples d’instructions PostgreSQL DROP SCHEMA

Notez que les exemples suivants utilisent des schémas créés dans
le cours CREATE SCHEMA avec quelques modifications dans le cours
ALTER SCHEMA.
39
a) Utiliser l’instruction DROP SCHEMA pour supprimer un exemple
de schéma vide
Cet exemple utilise l’instruction DROP SCHEMA pour supprimer le
schéma comptable :
DROP SCHEMA IF EXISTS accounting;

Pour actualiser les schémas dans la liste, cliquez avec le bouton
droit sur le nœud Schemas et sélectionnez l’élément de menu
Actualiser :
40
b) Utilisation de l’instruction DROP SCHEMA pour supprimer des
exemples de schémas multiples
L’exemple suivant utilise l’instruction DROP SCHEMA pour
supprimer plusieurs schémas finance et marketing en utilisant une
seule instruction :
DROP SCHEMA IF EXISTS finance, marketing;
c) Utiliser l’instruction DROP SCHEMA pour supprimer un exemple

de schéma non vide
41
Cette instruction supprime le schéma scm :
DROP dessin
SCHEMA scm;
Voici les messages :
ERROR: cannot drop schema scm because other objects
depend on it
DETAIL: table scm.deliveries depends on schema scm
view scm.delivery_due_list depends on schema scm
HINT: Use DROP ... CASCADE to drop the dependent objects
too.
SQL state: 2BP01
Donc, si le schéma n’est pas vide et que vous voulez supprimer le

schéma et ses objets, vous devez utiliser l’option CASCADE :
DROP SCHEMA scm CASCADE;
De même, vous pouvez supprimer le schéma de vente et ses objets

en utilisant la déclaration suivante:
capture
DROP SCHEMAde dessin
sales CASCADE;
42
Dans cette partie, vous avez appris à utiliser la syntaxe
PostgreSQL DROP SCHEMA
4. Gestion des tablespaces
4.1 Création des tablespaces
Un tablespace est un emplacement sur le disque où PostgreSQL

stocke des fichiers de données contenant des objets de base de
données, par exemple, des index et des tables.
PostgreSQL utilise un tablespace pour mapper un nom logique à un
emplacement physique sur le disque.
PostgreSQL est livré avec deux tablespaces par défaut:
pg_default tablespace stocke les données utilisateur.
pg_global tablespace stocke les données globales.
Les tablespaces vous permettent de contrôler la disposition du
disque de PostgreSQL. Il y a deux avantages principaux à utiliser
les tablespaces:
Tout d’abord, si une partition sur laquelle le cluster a été
initialisé est vide, vous pouvez créer un nouveau tablespace sur
une partition différente et l’utiliser jusqu’à ce que vous
reconfiguriez le système.
Deuxièmement, vous pouvez utiliser les statistiques pour
optimiser les performances de la base de données. Par exemple,
vous pouvez placer les index d’accès fréquents ou les tables sur
des appareils qui fonctionnent très rapidement, par exemple, les
43
appareils à semi-conducteurs, et mettre les tables contenant des
données d’archive qui est rarement utilisé sur des appareils plus
lents.
PostgreSQL CREATE TABLESPACE
Pour créer de nouveaux tablespaces, utilisez l’instruction CREATE
TABLESPACE comme suit :
CREATE TABLESPACE tablespace_name

OWNER user_name
LOCATION directory_path;
Le nom du tablespace ne doit pas commencer par pg_, car ces noms
sont réservés aux tablespaces du système.
Par défaut, l’utilisateur qui exécute CREATE TABLESPACE est le
propriétaire du tablespace. Pour affecter un autre utilisateur
comme propriétaire du tablespace, vous le spécifiez après le mot-
clé OWNER.
Le directory_path est le chemin absolu vers un répertoire vide
utilisé pour l’espace de table. Les utilisateurs du système
PostgreSQL doivent posséder ce répertoire pour pouvoir y lire et
y écrire des données.
Une fois qu’un tablespace est créé, vous pouvez le spécifier dans
les instructions CREATE DATABASE, CREATE TABLE et CREATE INDEX
pour stocker les fichiers de données des objets dans le
tablespace.
PostgreSQL CREATE TABLE examples
L’instruction suivante utilise CREATE TABLESPACE pour créer un
nouvel espace appelé ts_primary avec l’emplacement physique c :
pgdata primary.
CREATE TABLESPACE ts_primary

LOCATION 'c:\pgdata\primary';
Notez que cette instruction utilise les barres obliques de style

Unix pour le chemin du répertoire. Et c:\pgdata\primary doit
exister avant d’exécuter la commande.
44
Pour lister tous les tablespaces dans le serveur de base de
données PostgreSQL actuel, vous utilisez la commande db :
\db
Résultat :
List of tablespaces
Name | Owner | Location
------------+----------+-------------------
pg_default | postgres |
pg_global | postgres |
ts_primary | postgres | c:\pgdata\primary
(4 rows)
La commande db+ affiche plus d’informations telles que la taille

et les droits d’accès :
List of tablespaces
Name | Owner | Location | Access privileges |
Options | Size | Description
------------+----------+-------------------+-------------------+-
--------+---------+-------------
pg_default | postgres | | |
| 124 MB |
pg_global | postgres | | |
| 625 kB |
La syntaxe suivante crée la base de données logistiques qui
ts_primary
utilise | postgrests_primary
le tablespace | c:\pgdata\primary
: | |
| 0 bytes |
(4 rows)DATABASE logistics TABLESPACE ts_primary;
CREATE
La clause TABLESPACE indique le tablespace que la base de données
logistique utilisera pour stocker les données.
L’instruction suivante crée une nouvelle table appelée livraisons
et insère une ligne dans la table :
CREATE TABLE deliveries (
delivery_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
order_date DATE,
customer_id INT
);
INSERT INTO deliveries(order_date, customer_id)

VALUES('2020-08-01',1);
45
Comme le tablespace ts_primary contient des données, vous pouvez
afficher ses informations en utilisant la commande suivante dans
psql :
\db+ ts_primary
Resultat :
Name | Owner | Location | Access privileges |

Options | Size | Description
------------+----------+-------------------+-------------------+-
--------+---------+-------------
ts_primary | postgres | c:\pgdata\primary | |
| 8033 kB |
(1 row)
Résumé
Un tablespace est un emplacement sur le périphérique de stockage
où PostgreSQL stocke les fichiers de données.
Utilisez l’instruction CREATE TABLESAPCE pour créer un nouvel
espace de table.
4.2 Modification d’un tablespace

Une fois qu’un tablespace est créé, vous pouvez modifier sa
définition en utilisant ALTER TABLESPACE comme indiqué ci-
dessous :
ALTER TABLESPACE tablespace_name action;
L’action peut être :

- Renommer le tablespace
- Changer de propriétaire
Définissez les paramètres de l’espace de table.
Pour renommer le tablespace, utilisez l’instruction ALTER
TABLESPACE RENAME TO :
46
ALTER TABLESPACE tablespace_name RENAME TO new_name;
Pour changer le propriétaire du tablespace, vous utilisez

l’instruction ALTER TABLESPACE OWNER TO :
ALTER TABLESPACE tablespace_name OWNER TO new_owner;
La déclaration suivante modifie les paramètres d’un tablespace :
ALTER TABLESPACE tablespace_name

SET parameter_name = value;
Seuls les super utilisateurs ou les propriétaires de tablespace

peuvent exécuter l’instruction ALTER TABLESPACE.
Exemples PostgreSQL ALTER TABLESPACE
La déclaration suivante renomme dvdrental tablespace en
dvdrental_raid :
ALTER TABLESPACE dvdrental RENAME TO dvdrental_raid;

La déclaration suivante change le propriétaire du dvdrental_raid
de postgresto hr :
ALTER TABLESPACE dvdrental_raid OWNER to hr;
Résumé :
- Utilisez l’instruction ALTER TABLESPACE RENAME TO pour renommer
un tablespace.
- Utilisez ALTER TABLESPACE OWNER TO pour changer le propriétaire
d’un tablespace.
- Utilisez ALTER TABLESPACE SET pour définir les paramètres d’un
tablespace.
4.3 Suppression d’un tablespace
L’instruction DROP TABLESPACE supprime un tablespace de la base

de données actuelle :
47
DROP TABLESPACE [IF EXISTS] tablespace_name;
Dans cette syntaxe, vous spécifiez le nom du tablespace que vous
souhaitez supprimer après les mots-clés DROP TABLESPACE.
Vous utilisez l’option IF EXISTS pour demander à PostgreSQL
d’émettre un avis au lieu d’une erreur lorsque le tablespace
n’existe pas.
Seuls les propriétaires de tablespace ou les superutilisateurs
peuvent exécuter l’instruction DROP TABLESPACE pour supprimer le
tablespace.
Exemple PostgreSQL DROP TABLESPACE
Tout d’abord, créez un nouveau tablespace nommé demo et mappez-le
au répertoire c : data demo.
CREATEdessin
TABLESPACE demo LOCATION 'c:/data/demo';
Deuxièmement, créer une nouvelle base de données nommée dbdemo et
définir son tablespace pour la démonstration :
CREATE DATABASE dbdemo

TABLESPACE = demo;
Troisièmement, créer une nouvelle table nommée test la dbdemo et
modifier son tablespace à demo:
CREATE TABLE test (

ID serial PRIMARY KEY,
title VARCHAR (255) NOT NULL
) TABLESPACE demo;TABLESPACE = demo;
La déclaration suivante renvoie tous les objets dans le

tablespace de demo :
SELECT
ts.spcname,
cl.relname
FROM
pg_class cl
JOIN pg_tablespace ts
ON cl.reltablespace = ts.oid
WHERE
ts.spcname = 'demo';
48
Quatrièmement, essayez de supprimer l’espace de demo:
DROP TABLESPACE demo;
PostgreSQL émet une erreur :

dessin
[Err] ERROR: tablespace "demo" is not empty
Parce que le tablespace de démonstration n’est pas vide, il ne

peut pas être abandonné.
Cinquièmement, connectez-vous à la base de données postgres et
supprimez la base de données dbdemo:
DROP DATABASE dbdemo;
Au lieu de supprimer la base de données, vous pouvez la déplacer

vers un autre tablespace, par exemple, pg_default en utilisant
l’instruction ALTER TABLE comme suit :
ALTER DATABASE dbdemo SET TABLESPACE = pg_default;

Sixièmement, supprimez à nouveau le tablespace de demo:
DROP TABLESPACE demo;
Cela a fonctionné. Le tablespace demo a été supprimé avec succès.

PostgreSQL DROP TABLESPACE pour supprimer un tablespace.
5. Rôles et Privilèges
5.1 Création d’un rôle
PostgreSQL utilise des rôles pour représenter les comptes

utilisateurs. Il n’utilise pas le concept utilisateur comme les
autres systèmes de base de données.
49
Typiquement, les rôles qui se connectent sont appelés rôles de
connexion. Ils sont équivalents aux utilisateurs dans d’autres
systèmes de base de données.
Lorsque les rôles contiennent d’autres rôles, ce sont des groupes
de rôle.
PostgreSQL CREATE ROLE
Pour créer un nouveau rôle, utilisez la syntaxe CREATE ROLE comme
suit :
CREATE ROLE role_name;
Lorsque vous créez un rôle, il est valide dans toutes les bases
de données du serveur de base de données (ou cluster).
L’instruction suivante utilise l’instruction CREATE ROLE pour
créer un nouveau rôle appelé bob :
CREATE ROLE bob;
Pour obtenir tous les rôles du serveur de base de données

PostgreSQL actuel, vous pouvez les interroger à partir du
catalogue système pg_roles comme suit :
SELECT rolname FROM pg_roles;
50
rolname
---------------------------
pg_monitor
pg_read_all_settings
pg_read_all_stats
pg_stat_scan_tables
pg_read_server_files
pg_write_server_files
pg_execute_server_program
pg_signal_backend
postgres
bob
Noter que les rôles qui commencent par pg_ sont des rôles
système.
Si vous utilisez l’outil psql, vous pouvez utiliser la commande
du pour lister tous les rôles existants dans le serveur de base
de données PostgreSQL actuel.
\du
Résultat :
List of roles
Role name | Attributes
| Member of
-----------+-----------------------------------------------------
-------+-----------
bob | Cannot login
| {}
postgres | Superuser, Create role, Create DB, Replication,
Bypass RLS | {}
Comme vous pouvez le voir clairement à partir de la sortie, le

rôle bob ne peut pas se connecter.
Pour permettre au rôle bob de se connecter au serveur de base de
données PostgreSQL, vous devez y ajouter l’attribut LOGIN.
Attributs de rôle
Les attributs d’un rôle définissent les privilèges de ce rôle, y
compris l’ouverture de session, le super utilisateur, la création
de base de données, la création de rôle, le mot de passe, etc.
CREATE ROLE name WITH option;
51
Dans cette syntaxe, le mot-clé WITH est optionnel. Et l’option
peut être un ou plusieurs attributs, y compris SUPER, CREATEDB,
CREATEROLE, etc.
a) Créer des rôles de connexion
Par exemple, l’instruction suivante crée un rôle appelé alice qui
a le privilège de connexion et un mot de passe initial :
CREATE ROLE alice

LOGIN
PASSWORD 'securePass1';
Notez que vous placez le mot de passe entre guillemets simples

(').
Maintenant, vous pouvez utiliser le rôle alice pour vous
connecter au serveur de base de données PostgreSQL en utilisant
l’outil client psql :
psql -U alice -W postgres
Il vous demandera un mot de passe. Vous devez entrer le mot de

passe que vous avez entré dans la syntaxe CREATE ROLE.
b) Créer des rôles de super utilisateur
L’instruction suivante crée un rôle appelé john qui a l’attribut
superuser.
CREATE ROLE john

SUPERUSER
LOGIN
Le super utilisateur peut outrepasser toutes les restrictions
d’accès dans la base de données. Par conséquent, vous ne devriez
créer ce rôle qu’au besoin.
Notez que vous devez être un super utilisateur afin de créer un
autre rôle super utilisateur.
c) Créer des rôles qui peuvent créer des bases de données
Si vous voulez créer des rôles qui ont le droit de création de
base de données, vous utilisez l’attribut CREATEDB :
52
CREATE ROLE dba
CREATEDB
LOGIN
PASSWORD 'Abcd1234';
d) Créer des rôles avec une période de validité

Pour définir une date et une heure après lesquelles le mot de
passe du rôle n’est plus valide, vous utilisez l’attribut valid
until :
VALID UNTIL 'timestamp'
Par exemple, l’instruction suivante crée un rôle dev_api avec un

mot de passe valide jusqu’à la fin de 2029 :
CREATE ROLE dev_api WITH
LOGIN
PASSWORD 'securePass1'
VALID UNTIL '2030-01-01';
Après une seconde coche en 2030, le mot de passe dev_api n’est

plus valide.
e) Créer des rôles avec une limite de connexion
Pour spécifier le nombre de connexions simultanées qu’un rôle
peut faire, vous utilisez l’attribut CONNECTION LIMIT :
CONNECTION LIMIT connection_count
Ce qui suit crée un nouveau rôle appelé api qui peut faire 1000
connexions concurent :
CREATE ROLE api

LOGIN
PASSWORD 'securePass1'
CONNECTION LIMIT 1000;
La commande psql suivante montre tous les rôles que nous avons
créés jusqu’à présent :
\du
53
List of roles
| Member of
-----------+-----------------------------------------------------
-------+-----------
alice |
| {}
api | 1000 connections
| {}
bob | Cannot login
| {}
dba | Create DB
| {}
john | Superuser
| {}
Bypass RLS | {}
Résumé :
PostgreSQL utilise des rôles pour représenter les comptes
utilisateurs. Un rôle qui peut se connecter est équivalent à un
compte utilisateur dans d’autres systèmes de base de données.
Utilisez les attributs de rôle pour spécifier les privilèges des
rôles, par exemple, LOGIN permet au rôle de se connecter,
CREATEDB permet au rôle de créer une nouvelle base de données,
SUPERUSER permet au rôle d’avoir tous les privilèges.
5.2 Octroyer des privilèges
Après avoir créé un rôle avec l’attribut LOGIN, le rôle peut se

connecter au serveur de base de données PostgreSQL. Cependant, il
ne peut rien faire aux objets de la base de données comme les
tables, les vues, les fonctions, etc.
Par exemple, le rôle de l’utilisateur ne peut pas sélectionner
des données dans une table ou exécuter une fonction spécifique.
Pour permettre au rôle utilisateur d’interagir avec les objets de
la base de données, vous devez accorder les privilèges sur les
objets de la base de données au rôle utilisateur en utilisant
l’instruction GRANT.
Ce qui suit montre la forme simple de syntaxe GRANT qui accorde
un ou plusieurs privilèges sur une table à un rôle :
GRANT privilege_list | ALL

ON table_name
TO role_name;
54
Tout d’abord, spécifiez la privilege_list qui peut être SELECT,
INSERT, UPDATE, DELETE, TRUNCATE, etc. Vous utilisez l’option ALL
pour accorder tous les privilèges d’une table au rôle.
Deuxièmement, spécifiez le nom de la table après le mot-clé ON.
Troisièmement, spécifiez le nom du rôle auquel vous souhaitez
accorder des privilèges.
Exemples de déclarations PostgreSQL GRANT
Tout d’abord, utilisez l’utilisateur postgres pour vous connecter
au serveur de base de données PostgreSQL en utilisant n’importe
quel outil client de votre choix.
Deuxièmement, créer un nouveau rôle d’utilisateur appelé joe qui
peut se connecter au serveur de base de données PostgreSQL :
create role joe

login
password 'Abcd1234';
Troisièmement, créer une nouvelle table appelée candidats :

create table candidates (
candidate_id int generated always as identity,
first_name varchar(100) not null,
last_name varchar(100) not null,
email varchar(255) not null unique,
phone varchar(25) not null,
primary key(candidate_id)
);
Quatrièmement, utilisez le rôle joe pour vous connecter au

serveur de base de données PostgreSQL dans une session séparée.
Cinquièmement, tenter de sélectionner des données à partir de la
table des candidats à partir de la séance des joe :
SELECT * FROM candidates;

PostgreSQL a émis une erreur :
ERROR: permission denied for table candidates
55
Pour accorder le privilège SELECT sur la table des candidats au
responsable du rôle, vous exécutez la syntaxe GRANT dans la
session postgres :
GRANT SELECT ON candidates TO joe;
Sixièmement, exécutez l’instruction SELECT de la session du joe :
SELECT * FROM candidates;
PostgreSQL retourne un résultat vide au lieu d’une erreur.

Septièmement, exécuter la déclaration INSERT suivante :
INSERT INTO candidates(first_name, last_name, email, phone)
VALUES('Joe','Com','joe.com@example.com','408-111-2222');
PostgreSQL a émis l’erreur suivante parce que joe n’a pas le

privilège INSERT sur la table des candidats :
ERROR: permission denied for table candidates

Huitièmement, accordez les privilèges INSÉRER, METTRE À JOUR et
SUPPRIMER sur la table des candidats au responsable du rôle :
GRANT INSERT, UPDATE, DELETE

ON candidates
TO joe;
Neuvièmement, exécuter de nouveau la syntaxe INSERT de joe :
INSERT INTO candidates(first_name, last_name, email, phone)

VALUES('Joe','Com','joe.com@example.com','408-111-2222');
Maintenant, joe peut insérer des données dans la table des

candidats. En outre, il peut mettre à jour ou supprimer des
données de la table.
Plus d’exemples de GRANT PostgreSQL
Prenons d’autres exemples de l’utilisation de la déclaration
GRANT.
56
Accorder tous les privilèges sur une table à un rôle
La déclaration suivante accorde tous les privilèges sur la table
des candidats au joe de rôle :
GRANT ALL
ON candidates
TO joe;
Accorder tous les privilèges sur toutes les tables d’un schéma à
un rôle
La déclaration suivante accorde tous les privilèges sur toutes
les tables dans le schéma public de la base d’échantillons
dvdrental au rôle joe :
GRANT ALL
ON ALL TABLES
IN SCHEMA "public"
TO joe;
Attribuer SELECT à tous les tableaux
Parfois, vous voulez créer un rôle readonly qui ne peut
sélectionner les données de toutes les tables dans un schéma
spécifié.
Pour ce faire, vous pouvez accorder le privilège SELECT sur
toutes les tables du schéma public comme ceci :
GRANT SELECT
ON ALL TABLES
IN SCHEMA "public"
TO reader;
Jusqu’à présent, vous avez appris à accorder des privilèges sur
les tables. Pour accorder des privilèges sur d’autres objets,
consultez la syntaxe de l’instruction GRANT.
Résumé :
Utilisez l’instruction GRANT pour accorder des privilèges sur des
objets de base de données à un rôle.
5.3 Retirer des privilèges
57
L’instruction REVOKE révoque les privilèges précédemment accordés
sur les objets de base de données d’un rôle.
Ce qui suit montre la syntaxe de l’instruction REVOKE qui révoque
les privilèges sur une ou plusieurs tables d’un rôle :
REVOKE privilege | ALL

ON TABLE table_name | ALL TABLES IN SCHEMA schema_name
FROM role_name;

Tout d’abord, spécifiez le ou les privilèges que vous souhaitez
révoquer. Vous utilisez l’option TOUT pour révoquer tous les
privilèges.
Deuxièmement, spécifiez le nom de la table après le mot-clé ON.
Vous utilisez ALL TABLES pour révoquer les privilèges spécifiés
de toutes les tables dans un schéma.
Troisièmement, spécifiez le nom du rôle à partir duquel vous
souhaitez révoquer les privilèges.
Exemple d’instruction PostgreSQL REVOKE
Prenons un exemple d’utilisation du relevé REVOKE.
Étape 1. Créer un rôle et accorder des privilèges

Tout d’abord, utilisez l’utilisateur postgres pour vous connecter
à la base d’échantillons dvdrental :
psql -U postgres -d dvdrental

Ensuite, créez un nouveau rôle appelé jim avec les attributs
LOGIN et PASSWORD :
CREATE ROLE jim

LOGIN
Troisièmement, accorder tous les privilèges sur la table de

cinéma au rôle jim:
GRANT ALL
ON film
TO jim;
58
Enfin, accordez le privilège SELECT sur la table des acteurs au
rôle jim:
GRANT SELECT
ON actor
TO jim;
Étape 2. Révoquer les privilèges d’un rôle

Pour révoquer le privilège SELECT sur la table d’acteur du rôle
jim, vous utilisez la déclaration suivante :
REVOKE SELECT
ON actor
FROM jim;
Pour révoquer tous les privilèges de la table de film du rôle

jim, vous utilisez l’instruction REVOKE avec l’option ALL comme
ceci :
REVOKE ALL
ON film
FROM jim;
Révoquer les privilèges sur d’autres objets de base de données

Pour révoquer les privilèges d’autres objets de base de données
tels que les séquences, les fonctions, les procédures stockées,
les schémas, les bases de données, vérifiez l’instruction REVOKE.
Résumé
Utilisez l’instruction PostgreSQL REVOKE pour révoquer les
privilèges précédemment accordés sur les objets de base de
données d’un rôle.
5.4 Modification d’un rôle
Pour modifier les attributs d’un rôle, vous utilisez la syntaxe

suivante ALTER ROLE :
59
ALTER ROLE role_name [WITH] option;
L’option peut être :

SUPERUSER | NOSUPERUSER – Déterminez si le poste est un super
utilisateur ou non.
CREATEDB | NOCREATEDB – permet au rôle de créer de nouvelles
bases de données.
CREATEROLE | NOCREATEROLE – permet au rôle de créer ou de changer
des rôles.
INHERIT | NOINHERIT – déterminer si le rôle d’hériter des
privilèges des rôles dont il est membre.
CONNEXION | NOLOGIN – permet au rôle d’ouvrir une session.
REPLICATION | NOREPLICATION – déterminer si le rôle est un rôle
de réplication.
BYPASSRLS | NOBYPASSRLS – Déterminer si le rôle doit contourner
une politique de sécurité au niveau de la ligne.
LIMITE DE CONNEXION – spécifiez le nombre de connexions
simultanées qu’un rôle peut faire, -1 signifie illimité.
PASSWORD 'password' | PASSWORD NULL – Changer le mot de passe du
rôle.
VALID UNTIL 'timestamp' – Définit la date et l’heure après
lesquelles le mot de passe du rôle n’est plus valide.
Les règles suivantes sont appliquées :
Les superutilisateurs peuvent modifier n’importe lequel de ces

attributs pour n’importe quel rôle.
Les rôles qui ont l’attribut CREATEROLE peuvent changer n’importe
lequel de ces attributs pour les rôles non superposés et sans
réplication.
Les rôles ordinaux peuvent seulement changer leurs mots de passe.
Tout d’abord, connectez-vous à PostgreSQL en utilisant le rôle
postgres.
60
Deuxièmement, créez un nouveau rôle appelé calf à l’aide de la
syntaxe CREATE ROLE :
create role calf login password 'securePwd1';
Le rôle calf peut se connecter avec un mot de passe.

Parce que postgres est un superutilisateur, il peut changer le
rôle de calf pour être un superutilisateur:
alter role calf superuser;
Pour afficher le rôle calf dans le programme interactif psql,

vous utilisez la commande du:
\du calf
Résultat :
List of roles
Role name | Attributes | Member of
-----------+------------+-----------
calf | Superuser | {}
La déclaration suivante définit le mot de passe du rôle calf

jusqu’à la fin de 2050:
alter role calf valid until '2050-01-01';
Utilisez la commande du pour voir l’effet :

Résultat
\du calf:
List of roles
Role name | Attributes | Member
of
-----------+---------------------------------------------+-------
----
calf | Superuser +| {}
Utilisation|de PostgreSQL
Password ALTER
valid ROLE
until pour renommer
2050-01-01 les rôles
00:00:00-08 |
61
Pour changer le nom d’un rôle, vous utilisez la syntaxe suivante
ALTER ROLE :
ALTER ROLE role_name TO new_name;
Dans cette syntaxe, vous spécifiez le nom du rôle après les mots-
clés ALTER ROLE et le nouveau nom du rôle après le mot-clé TO.
Un super utilisateur peut renommer n’importe quel rôle. Un rôle
avec le privilège CREATEROLE peut renommer les rôles sans super
utilisateur.
Si vous utilisez un rôle pour vous connecter au serveur de base
de données PostgreSQL et le renommer dans la session courante,
vous obtiendrez une erreur :
ERROR: session user cannot be renamed
Dans ce cas, vous devez vous connecter au serveur de base de

données PostgreSQL en utilisant un rôle différent pour renommer
ce rôle.
Vous exécutez l’instruction suivante de la session postgres pour
renommer le rôle veau en elephant :
ALTER ROLE calf RENAME TO elephant;
Utilisation de PostgreSQL ALTER ROLE pour modifier la session par

défaut d’un rôle pour une variable de configuration
L’instruction ALTER ROLE suivante modifie la session par défaut
du rôle pour une variable de configuration :
ALTER ROLE role_name | CURRENT_USER | SESSION_USER | ALL

[IN DATABASE database_name]
SET configuration_param = { value | DEFAULT }

Tout d’abord, spécifiez le nom du rôle que vous souhaitez
modifier par défaut dans la session du rôle, ou utilisez
CURRENT_USER ou SESSION_USER. Vous utilisez l’option ALL pour
modifier les paramètres de tous les rôles.
62
Deuxièmement, spécifiez un nom de base de données après le mot-
clé IN DATABASE pour le modifier uniquement pour les sessions de
la base de données nommée. Si vous omettez la clause IN DATABASE,
la modification sera appliquée à toutes les bases de données.
Troisièmement, spécifiez le paramètre de configuration et la
nouvelle valeur dans la clause SET.
Les super-utilisateurs peuvent modifier les valeurs par défaut de
n’importe quel rôle. Les rôles avec l’attribut CREATEROLE peuvent
définir les valeurs par défaut pour les rôles non superposés. Les
rôles ordinaires ne peuvent être définis que par défaut. Seuls
les superutilisateurs peuvent modifier un paramètre pour tous les
rôles dans toutes les bases de données.
L’exemple suivant utilise ALTER ROLE pour donner à l’éléphant de

rôle un paramètre non défaillant spécifique à la base de données
du paramètre client_min_messages :
ALTER ROLE elephant

IN DATABASE dvdrental
SET client_min_messages = NOTICE;
Résumé :
Utilisez l’option ALTER ROLE role_name pour modifier les
attributs d’un rôle.
Utilisez ALTER ROLE role_name RENAME TO new_role pour renommer un
rôle.
Utilisez la syntaxe ALTER ROLE role_name SET param=value pour
modifier la valeur par défaut de session d’un rôle pour une
variable de configuration.
5.5 Suppression d’un rôle
Pour supprimer un rôle spécifique, utilisez l’instruction DROP

ROLE :
DROP ROLE [IF EXISTS] target_role;
63
Spécifiez le nom du rôle que vous souhaitez supprimer après les
mots-clés DROP ROLE.
Utilisez l’option IF EXISTS si vous voulez que PostgreSQL émette
un avis au lieu d’une erreur lorsque vous supprimez un rôle qui
n’existe pas.
Pour supprimer un rôle de super utilisateur, vous devez être un
super utilisateur. Pour supprimer des rôles non superposés, vous
devez avoir le privilège CREATEROLE.
Lorsque vous supprimez un rôle référencé dans une base de
données, PostgreSQL génère une erreur. Dans ce cas, vous devez
suivre deux étapes :
Tout d’abord, supprimez les objets de base de données appartenant
au rôle en utilisant l’état DROP OWNED ou réaffectez la propriété
des objets de base de données à un autre rôle REASSIGN OWNED.
Deuxièmement, révoquer toute autorisation accordée au rôle.
L’état REASSIGN OWNED réaffecte la propriété de tous les objets
dépendants d’un rôle cible à un autre rôle. Comme l’instruction
REASSIGN OWNED ne peut accéder qu’aux objets de la base de
données courante, vous devez exécuter cette instruction dans
chaque base de données qui contient des objets appartenant au
rôle cible.
Après avoir transféré les propriétés des objets à un autre rôle,

vous devez supprimer tous les objets restants appartenant au rôle
cible en exécutant l’instruction DROP OWNED dans chaque base de
données qui contient des objets appartenant au rôle cible.
En d’autres termes, vous devez exécuter les instructions
suivantes dans l’ordre pour supprimer un rôle :
-- execute these statements in the database that contains
-- the object owned by the target role
REASSIGN OWNED BY target_role TO another_role;
DROP OWNED
Voyons BY target_role;
l’exemple suivant.
-- dropde
Exemple the role
DROP ROLE PostgreSQL
DROP ROLE target_role;
Dans cet exemple :
64
Tout d’abord, nous allons créer un nouveau rôle appelé alice et
utiliser ce rôle pour créer une table nommée clients.
Ensuite, nous allons vous montrer étape par étape comment
supprimer le rôle alice du serveur de base de données PostgreSQL.
Nous utiliserons l’outil psql. Cependant, vous pouvez utiliser
n’importe quel outil client de votre choix.
Étape 1. Définir un nouveau rôle et une nouvelle base de données
Tout d’abord, connectez-vous à PostgreSQL en utilisant le rôle
postgres :
dessin
psql -U postgres
Deuxièmement, créer un nouveau rôle appelé alice:
dessin create role alice with login password 'Abcd1234';
postgres=#
Troisièmement, accordez à alice le privilège créé :
Dessin alter role alice createdb;
postgres=#
Quatrièmement, créer une nouvelle base de données appelée
ventes :
dessin
postgres=# create database sales;
Quitter la session en cours :
dessin
postgres=# \q
Étape 2. Utilisation du nouveau rôle pour créer des objets de
base de données
PostgreSQL en utilisant le rôle alice:
dessin
psql -U alice -W sales
Deuxièmement, créer une nouvelle table dans la base de données
des ventes :
create table customers(

customer_id int generated always as identity,
customer_name varchar(150) not null,
primary key(customer_id)
);
Troisièmement, afficher la liste des tables dans la base de

données des ventes :
65
sales=> \dt
List of relations
dessin
Schema | Name | Type | Owner
--------+-----------+-------+-------
public | customers | table | alice
(1 row)
Enfin, quittez la session en cours :

dessin \q
postgres=#
Étape 3. Supprimer le rôle alice
PostgreSQL en utilisant le rôle postgres :
dessin
psql -U postgres
Deuxièmement, essayer de supprimer le rôle d’Alice:
dessin
drop role alice;
ERROR: role "alice" cannot be dropped because some objects
depend on it
DETAIL: 2a objects
PostgreSQL in database
émis l’erreur sales
suivante :
Error:
ERROR: role "alice" cannot be dropped because some objects

Le rôle
depend onalice
it ne peut pas être abandonné parce qu’il a des objets
DETAIL: 2 objects in database sales
dépendants.
Troisièmement, passez à la base de données des ventes :
dessin \c sales
postgres=#
Quatrièmement, réaffecter les objets d’Alice à postgres :
dessin
sales=# reassign owned by alice to postgres;
Cinquièmement, supprimer les objets appartenant à Alice :
dessin drop owned by alice;
sales=#
Sixièmement, supprimer le rôle d’Alice :
dessin drop role alice;
sales=#
Septièmement, énumérez les rôles actuels :
dessin
sales=#\du
Vous verrez que le rôle d’Alice a été supprimé.
Enfin, quittez la session en cours :
66
dessin
sales=#\q
Résumé :
Utilisez l’instruction PostgreSQL DROP ROLE pour supprimer un
rôle spécifié.
Si un rôle a des objets dépendants, utilisez les instructions
REASSIGN OWNED et DROP OWNED pour supprimer les objets dépendants
du rôle avant d’exécuter l’instruction DROP ROLE.
5.6 Groupe de rôle
Il est plus facile de gérer les rôles en tant que groupe afin que
vous puissiez accorder ou révoquer les privilèges d’un groupe
dans son ensemble au lieu de le faire sur un rôle individuel.
En règle générale, vous créez un rôle qui représente un groupe,
puis vous attribuez des rôles individuels aux membres du groupe.
Par convention, un rôle de groupe n’a pas le privilège LOGIN.
Cela signifie que vous ne pourrez pas utiliser le rôle de groupe
pour vous connecter à PostgreSQL.
Pour créer un rôle de groupe, utilisez la syntaxe CREATE ROLE
comme suit :
CREATE ROLE group_role_name;

Par exemple, la syntaxe suivante crée un groupe de role ventes :
CREATE ROLE sales;
Lorsque vous utilisez la commande \du dans l’outil psql, vous
verrez que les rôles de groupe sont listés avec les rôles
utilisateur :
67
List of roles
| Member of
-----------+-----------------------------------------------------
-------+-----------
alice |
| {}
| {}
bob | Cannot login
| {}
dba | Create DB
| {}
john | Superuser
| {}
Bypass RLS | {}
sales | Cannot login
| {}
Pour ajouter un rôle à un rôle de groupe, vous utilisez la

syntaxe suivante de GRANT :
GRANT group_role to user_role;

Par exemple, la syntaxe suivante ajoute le rôle alice au groupe
de rôles ventes :
GRANT sales TO alice;
Si vous lancez encore la commande \du , vous verrez qu’Alice est

maintenant membre des ventes :
\du
68
List of roles
| Member of
-----------+-----------------------------------------------------
-------+-----------
alice |
| {sales}
| {}
bob | Cannot login
| {}
dba | Create DB
| {}
john | Superuser
| {}
Bypass RLS | {}
sales | Cannot login
| {}
Pour supprimer un rôle utilisateur d’un rôle de groupe, vous

utilisez l’instruction REVOKE :
REVOKE group_role FROM user_role;
Par exemple, utilisé la syntaxe REVOKE pour supprimer le rôle

alice du groupe des ventes :
REVOKE sales FROM alice;
Notez que PostgreSQL ne vous permet pas d’avoir des boucles

d’adhésion circulaires, dans lesquelles un rôle est le membre
d’un autre rôle et vice versa.
Exemple d’adhésion au rôle PostgreSQL
Un rôle peut utiliser les privilèges du rôle de groupe de la
manière suivante :
Tout d’abord, un rôle avec l’attribut INHERIT aura
automatiquement les privilèges des rôles de groupe dont il est
membre, y compris les privilèges hérités par ce rôle.
Deuxièmement, un rôle peut utiliser la syntaxe SET ROLE pour
devenir temporairement le rôle de groupe. Le rôle aura les
privilèges du rôle de groupe plutôt que son rôle de connexion
initial. En outre, les objets créés par le rôle sont détenus par
le rôle de groupe, pas le rôle de connexion.
69
Étape 1. Établir une base de données et des tableaux
a) Connectez-vous à PostgreSQL en utilisant la base de données
postgres.
b) Créer une nouvelle base de données appelée corp :
create database corp;

c) Passer à la base de données corp:
\c corp
4) Créer la table des contacts :
create table contacts(
id int generated always as identity primary key,
name varchar(255) not null,
phone varchar(255) not null
);
5) Créer la table des prévisions :
create table forecasts(

year int,
month int,
amount numeric
);
Étape 2. Établissement des rôles et des rôles de groupe

a) Créer un rôle jane qui peut se connecter avec un mot de passe
et hériter de tous les privilèges des rôles de groupe dont elle
est membre :
create role jane inherit login password 'securePass1';
b) Accordez à Jane le choix de SELECT sur la table des

prévisions :
grant select on forecasts to jane;

c) Utilisez la commande \z pour vérifier la table d’attribution :
\z
d) Créer le rôle du groupe marketing :
create role marketing noinherit;
70
e) Créer le rôle du groupe planning :
create role planning noinherit;
f) Accorder tous les privilèges sur la table de contacts au
marketing :
grant all on contacts to marketing;

g) Accorder tous les privilèges de la table des prévisions à la
planification :
grant all on forecasts to planning;

h) Ajouter Jane comme membre du marketing
grant marketing to jane;
i) Ajouter la planification en tant que membre du marketing
grant marketing to planning;

Étape 3. Utilisation des rôles
a) Si vous vous connectez à PostgreSQL en utilisant le rôle Jane,
vous aurez des privilèges directement accordés à Jane plus tous
les privilèges accordés au marketing parce que Jane hérite des
privilèges du marketing :
psql -U jane -d corp
b) Il vous demandera le mot de passe de la dame.

c) Jane peut sélectionner des données dans la table des
prévisions :
dcorp=> select * from forecasts;

d) Et insérer une ligne dans la table des contacts :
corp=> insert into contacts(name, phone) values('Jone Doe','408-

102-3459');
e) Cependant, Jane ne peut pas insérer une ligne dans la table

des prévisions :
corp=> insert into forecasts(year, month, amount)
values(2020,1,1000);
ERROR: permission denied for table forecasts
71
f) Après avoir exécuté la syntaxe SET ROLE suivante :
corp=> set role planning;
g) Le rôle de Jane sera accordé à la planification, et non pas à

ceux qui ont été accordés directement à Jane ou indirectement au
marketing.
h) Jane peut maintenant insérer une ligne dans la table des
prévisions :
corp=> insert into forecasts(year, month, amount)

values(2020,1,1000);
i) Si Jane tente de sélectionner des données dans la table des

contacts, elle échouera parce que la planification des rôles n’a
aucun privilège sur la table des contacts :
corp=> select * from contacts;

ERROR: permission denied for table contacts values(2020,1,1000);
Pour restaurer les privilèges originaux de Jane, vous utilisez

l’instruction RESET ROLE :
RESET ROLE;
Résumé :
Gérer les privilèges sur les rôles de groupe au lieu des rôles
individuels.
Les rôles avec l’attribut INHERIT prennent tous les privilèges
des rôles de groupe dont ils sont membres.
5.7 Liste des rôles

PostgreSQL en utilisant l’utilisateur postgres:
$ psql -U postgres
Il vous demandera un mot de passe :
72
Password:
Une fois que vous aurez entré le mot de passe de l’utilisateur

postgres, vous verrez l’invite de commande suivante :
postgres=#
Deuxièmement, utilisez \du pour lister tous les comptes

utilisateurs (ou rôles) du serveur de base de données PostgreSQL
actuel :
postgres=# \du
Si vous souhaitez afficher plus d’informations, vous pouvez

utiliser la commande \du+ :
postgres=#\du+
La commande \du+ ajoute une colonne supplémentaire appelée

description.
Liste des utilisateurs utilisant l’instruction SQL
La déclaration suivante renvoie tous les utilisateurs du serveur
de base de données actuel en interrogeant les données du
catalogue pg_catalog.pg_user :
SELECT usename AS role_name,

CASE
WHEN usesuper AND usecreatedb THEN
CAST('superuser, create database' AS pg_catalog.text)
WHEN usesuper THEN
CAST('superuser' AS pg_catalog.text)
WHEN usecreatedb THEN
CAST('create database' AS pg_catalog.text)
ELSE
CAST('' AS pg_catalog.text)
END role_attributes
FROM pg_catalog.pg_user
ORDER BY role_name desc;
73
Résumé :
Utilisez la commande \du ou \du+ psql pour lister tous les
utilisateurs du serveur de base de données actuel.
Utilisez l’instruction SELECT pour rechercher les informations
utilisateur dans le catalogue pg_catalog.pg_user.
6. Sauvegarde & Restauration

6.1 Sauvegarde de la base de données
La sauvegarde des bases de données est l’une des tâches les plus
critiques dans l’administration des bases de données. Avant de
sauvegarder les bases de données, vous devriez considérer les
types de sauvegardes suivants:
- Bases de données complètes ou partielles
- Données et structures, ou seulement structures
- Récupération ponctuelle
- Rétablir le rendement
PostgreSQL est livré avec pg_dump et pg_dumpall tools qui vous
aident à sauvegarder les bases de données facilement et
efficacement.
Pour ceux qui veulent voir la commande de sauvegarde des bases de
données rapidement, voici:
pg_dump -U username -W -F t database_name > c:\backup_file.tar
Dans la section suivante, vous apprendrez étape par étape comment

sauvegarder une base de données, toutes les bases de données et
seulement les objets de base de données.
Sauvegarde d’une base de données
Pour sauvegarder une base de données, vous pouvez utiliser
l’outil pg_dump. pg_dump décharge le contenu de tous les objets
de la base de données dans un seul fichier.
Tout d’abord, naviguez vers le dossier PostgreSQL bin :
C:\>cd C:\Program Files\PostgreSQL\12\bin
74
Ensuite, exécutez le programme pg_dump et utilisez les options
suivantes pour sauvegarder la base de données dvdrental dans le
fichier dvdrental.tar du dossier c:\pgbackup\.
pg_dump -U postgres -W -F t dvdrental > c:\pgbackup\dvdrental.tar
Examinons les options plus en détail.

-U postgres : spécifie l’utilisateur à connecter au serveur de
base de données PostgreSQL. Nous avons utilisé les postgres dans
cet exemple.
-W : force pg_dump à demander le mot de passe avant de se
connecter au serveur de base de données PostgreSQL. Après avoir
appuyé sur entrée, pg_dump vous demandera le mot de passe de
l’utilisateur postgres.
-F : spécifie le format de fichier de sortie qui peut être l’un
des suivants :
c : format de fichier d’archive personnalisé
d : répertoire-format archive
t : tar
p : fichier de script SQL en texte clair).
Dans cet exemple, nous utilisons -F t pour spécifier le fichier
de sortie comme fichier tar.
dvdrental : est le nom de la base de données que vous souhaitez
sauvegarder.
> c:\pgbackup\dvdrental.tar est le chemin du fichier de
sauvegarde de sortie.
Sauvegarde de toutes les bases de données
Pour sauvegarder toutes les bases de données, vous pouvez
exécuter la commande pg_dump individuelle ci-dessus de manière
séquentielle ou parallèle si vous voulez accélérer le processus
de sauvegarde.
Tout d’abord, depuis psql, utilisez la liste de commandes pour
lister toutes les bases de données disponibles dans votre cluster
Deuxièmement, sauvegardez chaque base de données individuelle en
utilisant le programme pg_dump comme décrit dans la section ci-
dessus.
75
En plus du programme pg_dump, PostgreSQL vous fournit également
l’outil pg_dumpall qui vous permet de sauvegarder toutes les
bases de données à la fois. Toutefois, il n’est pas recommandé
d’utiliser cet outil pour les raisons suivantes :
Le programme pg_dumpall exporte toutes les bases de données,
l’une après l’autre, dans un seul fichier de script, ce qui vous
empêche d’effectuer la restauration parallèle. Si vous
sauvegardez toutes les bases de données de cette façon, le
processus de restauration prendra plus de temps.
Le traitement du dumping de toutes les bases de données prend
plus de temps qu’individuellement, de sorte que vous ne savez pas
quel dump de chaque base de données se rapporte à un moment
précis dans le temps.
Si vous avez une bonne raison d’utiliser pg_dumpall pour
sauvegarder toutes les bases de données, voici la commande :
pg_dumpall -U postgres > c:\pgbackup\all.sql
Les options du programme pg_dumpall sont similaires aux options

du programme pg_dump. Cette commande omet l’option -W pour éviter
de taper le mot de passe pour chaque base de données.
Sauvegarde des définitions des objets de la base de données
Parfois, vous voulez sauvegarder uniquement les définitions
d’objets de base de données, pas les données Ceci est utile dans
la phase de test, que vous ne voulez pas déplacer les données de
test vers le système en direct.
Pour sauvegarder des objets dans toutes les bases de données, y
compris les rôles, les tablespaces, les bases de données, les
schémas, les tables, les index, les déclencheurs, les fonctions,
les contraintes, les vues, les propriétés et les privilèges, vous
utilisez la commande suivante :
pg_dumpall --schema-only > c:\pgdump\definitiononly.sql
Si vous souhaitez sauvegarder la définition des rôles uniquement,

utilisez la commande suivante :
pg_dumpall --roles-only > c:\pgdump\allroles.sql
76
Pour sauvegarder la définition des tablespaces, utiliser la
commande suivante :
pg_dumpall --tablespaces-only > c:\pgdump\allroles.sql
6.2 Restauration de la base de données
Avant de restaurer une base de données, vous devez mettre fin à

toutes les connexions à cette base de données et préparer le
fichier de sauvegarde. Dans PostgreSQL, vous pouvez restaurer une
base de données de deux façons :
Utiliser psql pour restaurer le fichier de script SQL généré par
les outils pg_dump et pg_dumpall.
Utiliser pg_restore pour restaurer le fichier tar et le format de
répertoire créés par l’outil pg_dump.
Comment restaurer des bases de données en utilisant psql
L’outil psql vous permet de restaurer le fichier de script SQL
généré par pg_dump, pg_dumpall ou tout autre outil générant des
fichiers sauvegardés compatibles. En utilisant l’outil psql, vous
pouvez exécuter l’intégralité du script dans le fichier dump.
Pour restaurer une sauvegarde complète et ignorer toute erreur
survenue pendant le processus de restauration, utilisez la
commande suivante :
psql -U username -f backupfile.sql
Si vous souhaitez arrêter la restauration d’une base en cas

d’erreur, vous ajoutez l’option --set ON_ERROR_STOP=on :
psql -U username --set ON_ERROR_STOP=on -f backupfile
Si vous sauvegardez des objets dans une base de données

particulière, vous pouvez les restaurer en utilisant la commande
suivante :
psql -U username -d database_name -f objects.sql
Restauration des bases de données à l’aide de pg_restore
77
Outre l’outil psql, vous pouvez utiliser le programme pg_restore
pour restaurer les bases de données sauvegardées par les outils
pg_dump ou pg_dumpall. Avec le programme pg_restore, vous avez
différentes options pour restaurer les bases de données, par
exemple :
Le pg_restore permet d’effectuer des restaurations parallèles en
utilisant l’option -j pour spécifier le nombre de threads à
restaurer. Chaque thread restaure une table séparée
simultanément, ce qui accélère considérablement le processus.
Actuellement, pg_restore supporte cette option pour le seul
format de fichier personnalisé.
Le pg_restore vous permet également de restaurer des objets de
base de données spécifiques dans un fichier de sauvegarde qui
contient la base de données complète.
La pg_restore peut prendre une base de données sauvegardée dans
l’ancienne version et la restaurer dans la version plus récente.
Créons une nouvelle base de données nommée newdvdrental pour
pratiquer avec l’outil pg_restore.
CREATE DATABASE newdvdrental;
Vous pouvez restaurer le fichier de la base de données dvdrental

au format de fichier tar généré par l’outil pg_dump dans le cours
de base de données de sauvegarde PostgreSQL en utilisant la
commande suivante :
pg_restore --dbname=newdvdrental --verbose

c:\pgbackup\dvdrental.tar
Si vous restaurez la base de données, qui est la même que celle

que vous avez sauvegardée, vous pouvez utiliser la commande
suivante :
pg_restore --dbname=dvdrental --create --verbose

Depuis PostgreSQL 9.2, vous pouvez utiliser l’option --section

pour restaurer uniquement la structure de la table. Cela vous
permet d’utiliser la nouvelle base de données comme modèle pour
créer d’autres bases de données.
78
Tout d’abord, créez une nouvelle base de données nommée
dvdrental_tpl.
CREATE DATABASE dvdrental_tpl;
Ensuite, restaurez la structure de la table à partir du fichier

de sauvegarde dvdrental.tar en utilisant la commande suivante :
>pg_restore --dbname=dvdrental_tpl --section=pre-data

7. Conseils pour bien administrer la base de données
- Lancement du service via DOS :
pg_ctl -D "C:\Program Files\PostgreSQL\12\data" restart
- Se connecter à la base de données :
psql -U postgres
- Modifier le mot de passe d’un utilisateur :
postgres=# ALTER USER postgres WITH PASSWORD 'new_password';
- Se connecter à une base de données
postgres=# \c dvdrental
- Decrire une table

-
postgres=# \c table_name
79
SELECT
table_name,
column_name,
data_type
FROM
information_schema.columns
WHERE
table_name = 'city';
- Voir les bases de données
postgres=# \l or \l+
SELECT datname FROM pg_database;
- Voir les tables d’une base de données
postgres=# \dt or \dt+
SELECT *
FROM pg_catalog.pg_tables
WHERE schemaname != 'pg_catalog' AND
schemaname != 'information_schema';
- Voir les Schémas disponibles
postgres=# \dn
- Liste des Rôles

postgres=# \du
- Voir la version de PostgreSQL
SELECT version();
80

Admin DB

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Admin DB

Transféré par

Droits d'auteur :

Formats disponibles

Filières : Licence 3 – RIT

ADMINISTRATION DE BASES DE DONNÉES

Dans ce cours nous allons utiliser le système de gestion de base

1.1 Installation et configuration de POSTGRESQL

Par séance de travail

PostgreSQL est un puissant système de gestion de base de données

2. Gestion de bases de données

L’instruction CREATE DATABASE vous permet de créer une nouvelle

[ALLOW_CONNECTIONS = true | false]

[CONNECTION LIMIT = max_concurrent_connection]

[IS_TEMPLATE = true | false ]

Pour exécuter l’instruction CREATE DATABASE, vous devez avoir un

Explication des paramètres :

CREATE DATABASE sales;

PostgreSQL a créé une nouvelle base de données nommée sales qui a

b) Créer une base de données avec certains paramètres

CONNECTION LIMIT = 100;

Dans cet exemple, nous avons créé la base de données hr avec

c) Création d’une nouvelle base de données avec pgAdmin

Tout d’abord, connectez-vous au serveur de base de données

Une boîte de dialogue s’affiche pour vous permettre d’entrer des

Dans cet exemple, nous avons entré sampledb comme nom de la

Dans l’onglet Définition, vous pouvez sélectionner l’encodage,

2.2 Modification de la base de données

L’instruction ALTER DATABASE vous permet d’effectuer l’action

• Modifier les attributs de la base de données

ALTER DATABASE name WITH option;

Cette option peut être :

b) Renommer la base de données

Il n’est pas possible de renommer la base de données actuelle.

ALTER DATABASE database_name

OWNER TO new_owner | current_user | session_user;

Les utilisateurs suivants peuvent modifier la réponse de la base

• Le propriétaire de la base de données avec le privilège

SET TABLESPACE new_tablespace;

La syntaxe déplace physiquement les tables et les index de

SET configuration_parameter = value;

Dans les sessions suivantes, PostgreSQL surchargera les

Exemples de PostgreSQL ALTER DATABASE

Deuxièmement, renommez testdb2 en testhrdb en utilisant

ALTER DATABASE testdb2

Si le rôle des hr n’existe pas, vous pouvez le créer en utilisant

Quatrièmement, changer le tablespace par défaut de testhrdb de

ALTER DATABASE testhrdb

SET TABLESPACE hr_default;

Si le tablespace hr_default n’existe pas, vous pouvez le créer en

CREATE TABLESPACE hr_default

Cinquièmement, définissez la variable de configuration

ALTER DATABASE testhrdb SET escape_string_warning = off;

Dans cette partie, vous avez appris à utiliser l’instruction

CREATE DATABASE db;

Pour renommer la base de données en newdb, procédez comme suit :

En vous connectant à la base de données postgres, vous êtes

SELECT * FROM pg_stat_activity WHERE datname = 'db';

La requête a produit le résultat suivant : (voir la console)

Ensuite, renommez la base de données en newdb en utilisant

ALTER DATABASE db RENAME TO newdb;

Enfin, si votre base de données est utilisée par des

DROP DATABASE [IF EXISTS] database_name;

Pour supprimer une base de données :

a) Supprimer une base de données ayant des connexions actives

WHERE datname = '<database_name>';

Deuxièmement, mettre fin aux connexions actives en émettant la