Bases de la gestion de bases de données avec PostgreSQL

Introduction

Dans ce laboratoire, vous apprendrez les fondamentaux de la gestion de bases de données en utilisant PostgreSQL. Ce laboratoire couvre les opérations essentielles pour la gestion des bases de données, notamment la création de nouvelles bases de données, la liste et la connexion aux bases de données existantes, et la suppression des bases de données lorsqu'elles ne sont plus nécessaires.

Vous commencerez par créer une nouvelle base de données en utilisant la commande createdb et en vérifiant sa création via la commande psql. Ensuite, vous apprendrez à lister toutes les bases de données disponibles et à vous connecter à une base de données spécifique. Enfin, vous explorerez comment supprimer ( drop ) une base de données et afficher les métadonnées de la base de données. Ce laboratoire fournit une introduction pratique aux tâches d'administration de base de données dans PostgreSQL.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 88%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Créer une nouvelle base de données

Dans cette étape, vous apprendrez à créer une nouvelle base de données dans PostgreSQL. La création d'une base de données est la première étape pour organiser et stocker vos données.

Avant de commencer, comprenons ce qu'est une base de données. Une base de données est une collection structurée de données qui est organisée pour un accès, une gestion et une mise à jour faciles. Dans PostgreSQL, une base de données est un conteneur pour les tables, les vues et autres objets de base de données.

Pour créer une nouvelle base de données, vous utiliserez la commande createdb. Cette commande est un wrapper (enveloppe) autour de la commande SQL CREATE DATABASE.

Ouvrez un terminal : Si vous n'en avez pas déjà un ouvert, lancez une fenêtre de terminal.
Créez une nouvelle base de données : Utilisez la commande createdb suivie du nom que vous souhaitez donner à votre base de données. Par exemple, pour créer une base de données nommée mydatabase, exécutez la commande suivante :
```
createdb mydatabase
```
Cette commande créera une nouvelle base de données nommée mydatabase. Si la commande réussit, vous ne verrez aucune sortie.
Vérifiez la création de la base de données : Pour confirmer que la base de données a été créée, vous pouvez lister toutes les bases de données à l'aide de la commande psql. Tout d'abord, connectez-vous à la base de données par défaut postgres :
```
psql -d postgres
```
Vous serez présenté avec l'invite postgres=#.

Listez les bases de données : À l'invite postgres=#, exécutez la commande SQL suivante pour lister toutes les bases de données :

\l

Cette commande affichera une liste des bases de données, y compris celle que vous venez de créer (mydatabase). Vous devriez voir une sortie similaire à ceci :

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

Notez que mydatabase est dans la liste.

Quittez psql : Pour quitter l'invite psql, tapez :
```
\q
```
et appuyez sur Entrée. Vous reviendrez à l'invite de terminal normale.

Vous avez maintenant créé avec succès une nouvelle base de données dans PostgreSQL.

Lister et se connecter aux bases de données

Dans cette étape, vous apprendrez à lister les bases de données disponibles et à vous connecter à une base de données spécifique à l'aide de l'outil en ligne de commande psql.

Ouvrez un terminal : Si vous n'en avez pas déjà un ouvert, lancez une fenêtre de terminal.
Listez les bases de données disponibles : Pour lister toutes les bases de données, vous pouvez utiliser la commande psql avec l'option -l (un 'L' minuscule). Cette option liste toutes les bases de données sur le serveur. Étant donné que vous n'avez pas spécifié de base de données à laquelle vous connecter, psql tentera de se connecter en utilisant votre nom d'utilisateur actuel.
```
psql -l
```
Cette commande affichera une liste des bases de données, ainsi que leurs propriétaires, leurs encodages et d'autres informations. Vous devriez voir une sortie similaire à ceci :
```
                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)
```
Cette sortie affiche les noms des bases de données, leurs propriétaires et d'autres détails. Vous devriez voir la base de données mydatabase que vous avez créée à l'étape précédente.
Connectez-vous à une base de données spécifique : Pour vous connecter à une base de données spécifique, utilisez la commande psql avec l'option -d, suivie du nom de la base de données. Par exemple, pour vous connecter à la base de données mydatabase, exécutez la commande suivante :
```
psql -d mydatabase
```
Si la connexion réussit, vous serez présenté avec l'invite mydatabase=#. Cela indique que vous êtes maintenant connecté à la base de données mydatabase.

Vérifiez la connexion : Pour vérifier que vous êtes connecté à la bonne base de données, vous pouvez exécuter une simple commande SQL, telle que :

SELECT version();

Cette commande affichera la version du serveur PostgreSQL auquel vous êtes connecté. La sortie ressemblera à ceci :

                                                 version
----------------------------------------------------------------------------------------------------------------
 PostgreSQL 14.7 (Debian 14.7-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
(1 row)

Quittez psql : Pour quitter l'invite psql, tapez :
```
\q
```
et appuyez sur Entrée. Vous reviendrez à l'invite de terminal normale.

Vous avez maintenant listé avec succès les bases de données disponibles et vous êtes connecté à une base de données spécifique à l'aide de psql.

Supprimer une base de données

Dans cette étape, vous apprendrez à supprimer (effacer) une base de données dans PostgreSQL. La suppression d'une base de données est une action permanente, il est donc important d'être prudent lors de l'utilisation de cette commande. Toutes les données de la base de données seront perdues.

Ouvrez un terminal : Si vous n'en avez pas déjà un ouvert, lancez une fenêtre de terminal.
Supprimez la base de données : Utilisez la commande dropdb suivie du nom de la base de données que vous souhaitez supprimer. Par exemple, pour supprimer la base de données mydatabase, exécutez la commande suivante :
```
dropdb mydatabase
```
Cette commande supprimera la base de données mydatabase. Si la commande réussit, vous ne verrez aucune sortie.

Important : Avant de supprimer une base de données, assurez-vous que personne n'y est connecté. S'il existe des connexions actives, la commande dropdb peut échouer.
Vérifiez la suppression de la base de données : Pour confirmer que la base de données a été supprimée, vous pouvez lister toutes les bases de données à l'aide de la commande psql. Tout d'abord, connectez-vous à la base de données par défaut postgres :
```
psql -d postgres
```
Vous serez présenté avec l'invite postgres=#.

Listez les bases de données : À l'invite postgres=#, exécutez la commande SQL suivante pour lister toutes les bases de données :

\l

Cette commande affichera une liste des bases de données. Vérifiez que mydatabase n'est plus dans la liste.

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(3 rows)

Si mydatabase n'est pas listée, elle a été supprimée avec succès.

Quittez psql : Pour quitter l'invite psql, tapez :
```
\q
```
et appuyez sur Entrée. Vous reviendrez à l'invite de terminal normale.

Vous avez maintenant supprimé avec succès une base de données dans PostgreSQL. N'oubliez pas d'être prudent lorsque vous supprimez des bases de données, car cette action est irréversible.

Afficher les métadonnées de la base de données

Dans cette étape, vous apprendrez à afficher les métadonnées de la base de données dans PostgreSQL. Les métadonnées sont des "données sur les données" (data about data). Dans le contexte d'une base de données, les métadonnées décrivent la structure et les caractéristiques de la base de données elle-même, y compris des informations sur les tables, les colonnes, les types de données et les contraintes.

Ouvrez un terminal : Si vous n'en avez pas déjà un ouvert, lancez une fenêtre de terminal.
Connectez-vous à la base de données postgres : Puisque nous avons supprimé mydatabase à l'étape précédente, nous allons nous connecter à la base de données par défaut postgres pour explorer les métadonnées.
```
psql -d postgres
```
Vous serez présenté avec l'invite postgres=#.
Listez les tables : Pour lister toutes les tables de la base de données actuellement connectée, vous pouvez utiliser la commande \dt.
```
\dt
```
Étant donné que nous n'avons créé aucune table pour l'instant, la sortie doit être vide ou afficher les tables système. Cela pourrait ressembler à ceci :
```
Did not find any relations.
```
ou
```
             List of relations
 Schema |         Name          | Type  |  Owner
--------+-----------------------+-------+----------
 pg_catalog | pg_aggregate          | table | postgres
 pg_catalog | pg_am               | table | postgres
 pg_catalog | pg_amop             | table | postgres
...
```
La sortie affiche le schéma, le nom, le type et le propriétaire de chaque table.

Décrivez une table : Pour afficher des informations détaillées sur une table spécifique, vous pouvez utiliser la commande \d suivie du nom de la table. Puisque nous n'avons pas de table créée par l'utilisateur, examinons une table système, par exemple, pg_class.

\d pg_class

Cette commande affichera la structure de la table pg_class, y compris les noms de colonnes, les types de données et toutes les contraintes. La sortie sera assez étendue, mais elle fournit un aperçu complet de la définition de la table.

                                     Table "pg_catalog.pg_class"
      Column       |   Type    | Collation | Nullable | Default | Storage  | Stats target | Description
-------------------+-----------+-----------+----------+---------+----------+--------------+-------------
 oid               | oid       |           | not null |         | plain    |              |
 relname           | name      |           | not null |         | plain    |              |
 relnamespace      | oid       |           | not null |         | plain    |              |
 reltype           | oid       |           | not null |         | plain    |              |
 reloftype         | oid       |           | not null |         | plain    |              |
 relowner          | oid       |           | not null |         | plain    |              |
 relam             | oid       |           | not null |         | plain    |              |
 relfilenode       | oid       |           | not null |         | plain    |              |
 reltablespace     | oid       |           | not null |         | plain    |              |
 relpages          | integer   |           | not null |         | plain    |              |
 reltuples         | real      |           | not null |         | plain    |              |
 relallvisible     | boolean   |           | not null |         | plain    |              |
 reltoastrelid     | oid       |           | not null |         | plain    |              |
 relhasindex       | boolean   |           | not null |         | plain    |              |
 relhasrules       | boolean   |           | not null |         | plain    |              |
 relhastriggers    | boolean   |           | not null |         | plain    |              |
 relhassubclass    | boolean   |           | not null |         | plain    |              |
 relrowsecurity    | boolean   |           | not null |         | plain    |              |
 relforcerowsecurity| boolean   |           | not null |         | plain    |              |
 relispopulated    | boolean   |           | not null |         | plain    |              |
 relreplident      | character |           | not null |         | plain    |              |
 relispartition    | boolean   |           | not null |         | plain    |              |
 relrewrite        | oid       |           | not null |         | plain    |              |
 relacl            | aclitem[] |           |          |         | plain    |              |
 reloptions        | text[]    |           |          |         | plain    |              |
 relpartbound      | pg_node_tree |           |          |         | extended |              |
Indexes:
    "pg_class_oid_index" UNIQUE, btree (oid)
    "pg_class_relname_nsp_index" UNIQUE, btree (relname, relnamespace)
Foreign-key constraints:
    "pg_class_relam_fkey" FOREIGN KEY (relam) REFERENCES pg_am(oid)
    "pg_class_relnamespace_fkey" FOREIGN KEY (relnamespace) REFERENCES pg_namespace(oid)
    "pg_class_relowner_fkey" FOREIGN KEY (relowner) REFERENCES pg_authid(oid)
    "pg_class_reltoastrelid_fkey" FOREIGN KEY (reltoastrelid) REFERENCES pg_class(oid)
Referenced by:
    TABLE "pg_statistic_ext" CONSTRAINT "pg_statistic_ext_relid_fkey" FOREIGN KEY (relid) REFERENCES pg_class(oid)
    TABLE "pg_rewrite" CONSTRAINT "pg_rewrite_ev_class_fkey" FOREIGN KEY (ev_class) REFERENCES pg_class(oid)
    TABLE "pg_trigger" CONSTRAINT "pg_trigger_tgrelid_fkey" FOREIGN KEY (tgrelid) REFERENCES pg_class(oid)

Quittez psql : Pour quitter l'invite psql, tapez :
```
\q
```
et appuyez sur Entrée. Vous reviendrez à l'invite de terminal normale.

Vous avez maintenant affiché avec succès les métadonnées de la base de données dans PostgreSQL à l'aide de psql. Cela vous permet de comprendre la structure et les propriétés de vos bases de données et de vos tables.

Résumé

Dans ce lab (laboratoire), vous avez appris les bases de la gestion de base de données dans PostgreSQL, en commençant par la création d'une nouvelle base de données. Le processus implique l'utilisation de la commande createdb suivie du nom de base de données souhaité dans le terminal. Une exécution réussie crée la base de données sans aucune sortie.

Pour vérifier la création, vous vous connectez à la base de données par défaut postgres en utilisant psql -d postgres, puis vous utilisez la commande \l pour lister toutes les bases de données disponibles, confirmant ainsi la présence de la base de données nouvellement créée.