PostgreSQL
 sql >> Base de données >  >> RDS >> PostgreSQL

Comment créer et supprimer des bases de données et des tables dans PostgreSQL


Introduction

PostgreSQL et d'autres systèmes de gestion de bases de données relationnelles utilisent des bases de données et tableaux structurer et organiser leurs données. On peut revoir rapidement la définition de ces deux termes :

  • bases de données : séparer différents ensembles de structures et de données les uns des autres
  • tableaux : définir la structure des données et stocker les valeurs de données réelles dans les bases de données

Dans PostgreSQL, il existe également un objet intermédiaire entre les bases de données et les tables appelé schéma :

  • schéma : un espace de noms dans une base de données qui contient des tables, des index, des vues et d'autres éléments.

Ce guide ne traitera pas directement du concept de schéma de PostgreSQL, mais il est bon de savoir qu'il existe.

Au lieu de cela, nous nous concentrerons sur la façon de créer et de détruire des bases de données et des tables PostgreSQL. Les exemples utiliseront principalement SQL, mais vers la fin, nous vous montrerons comment effectuer quelques-unes de ces tâches à l'aide de la ligne de commande. Ces alternatives utilisent des outils inclus dans l'installation standard de PostgreSQL qui sont disponibles si vous disposez d'un accès administratif à l'hôte PostgreSQL.

Certaines des instructions couvertes dans ce guide, en particulier le PostgreSQL CREATE TABLE , ont de nombreuses options supplémentaires qui sortaient du cadre de cet article. Si vous souhaitez des informations supplémentaires, découvrez-en plus en consultant la documentation officielle de PostgreSQL.



Prérequis

Pour suivre ce guide, vous devrez vous connecter à une instance PostgreSQL avec un utilisateur disposant de privilèges administratifs en utilisant le psql client en ligne de commande. Votre instance PostgreSQL peut être installée localement, à distance ou provisionnée par un fournisseur.

Plus précisément, votre utilisateur PostgreSQL aura besoin du CREATE DB privilège ou être un Superuser , que vous pouvez vérifier avec le \du méta-commande dans psql :

\du
 
                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

Le postgres le superutilisateur, qui est créé automatiquement lors de l'installation, possède les privilèges requis, mais vous pouvez utiliser n'importe quel utilisateur avec le Create DB privilège.



Créer une nouvelle base de données

Une fois que vous êtes connecté à votre instance PostgreSQL en utilisant psql ou tout autre client SQL, vous pouvez créer une base de données en utilisant SQL.

La syntaxe de base pour créer une base de données est :

CREATE DATABASE db_name;

Cela créera une base de données appelée db_name sur le serveur actuel avec l'utilisateur actuel défini comme propriétaire de la nouvelle base de données à l'aide des paramètres de base de données par défaut. Vous pouvez afficher les propriétés du template1 par défaut modèle utilisant le psql suivant méta-commande :

\l template1
 
                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres(1 row)

Vous pouvez ajouter des paramètres supplémentaires pour modifier la façon dont votre base de données est créée. Voici quelques options courantes :

  • ENCODAGE : définit le codage des caractères pour la base de données.
  • LC_COLLATE : définit le classement , ou tri, ordre pour la base de données. Il s'agit d'une option de localisation qui détermine la façon dont les articles sont organisés lorsqu'ils sont commandés.
  • LC_CTYPE : définit la classification des caractères pour la nouvelle base de données. Il s'agit d'une option de localisation qui affecte les caractères considérés comme majuscules, minuscules et chiffres.

Ceux-ci peuvent aider à garantir que la base de données peut stocker des données dans les formats que vous prévoyez de prendre en charge et avec les préférences de localisation de votre projet.

Par exemple, pour vous assurer que votre base de données est créée avec le support Unicode et pour remplacer les propres paramètres régionaux du serveur pour utiliser la localisation en anglais américain (tout cela correspond aux valeurs du template1 ci-dessus, donc aucun changement ne se produira réellement), vous pouvez taper :

CREATE DATABASE db_name  ENCODING 'UTF8'  LC_COLLATE 'en_US.UTF-8'  LC_CTYPE 'en_US.UTF-8';

Pour suivre les exemples de ce guide, créez une base de données appelée school en utilisant les paramètres régionaux par défaut de votre instance et l'encodage de caractères UTF8 :

CREATE DATABASE school ENCODING 'UTF8';

Cela créera votre nouvelle base de données en utilisant les spécifications que vous avez fournies.



Liste des bases de données existantes

Pour déterminer quelles bases de données sont actuellement disponibles sur votre serveur ou votre cluster, vous pouvez utiliser l'instruction SQL suivante :

SELECT datname FROM pg_database;

Cela listera chacune des bases de données actuellement définies dans l'environnement :

  datname----------- _dodb template1 template0 defaultdb school(5 rows)

Comme mentionné précédemment, si vous êtes connecté en utilisant le psql client, vous pouvez également obtenir ces informations \l méta-commande :

\l

Cela affichera les noms de base de données disponibles ainsi que leurs propriétaires, encodage, paramètres régionaux et privilèges :

                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)

L'school base de données que nous avons créée est affichée parmi les autres bases de données du système. C'est un bon moyen d'avoir une vue d'ensemble des bases de données de votre serveur ou cluster.



Créer des tables dans des bases de données

Après avoir créé une ou plusieurs bases de données, vous pouvez commencer à définir des tables pour stocker vos données. Les tables se composent d'un nom et d'un schéma défini qui détermine les champs et les types de données que chaque enregistrement doit contenir.


PostgreSQL CREATE TABLE syntaxe

Vous pouvez créer des tables en utilisant le CREATE TABLE déclaration. Une syntaxe de base simplifiée pour la commande ressemble à ceci :

CREATE TABLE table_name (    column_name TYPE [column_constraint],    [table_constraint,]);

Les composants de la syntaxe ci-dessus incluent les éléments suivants :

  • CREATE TABLE table_name :L'instruction de création de base qui signale que vous souhaitez définir une table. Le table_name l'espace réservé doit être remplacé par le nom de la table que vous souhaitez utiliser.
  • column_name TYPE :Définit une colonne de base dans le tableau. Le column_name placeholder doit être remplacé par le nom que vous souhaitez utiliser pour votre colonne. Le TYPE spécifie le type de données PostgreSQL pour la colonne. Les données stockées dans la table doivent être conformes à la structure de colonne et aux types de données de colonne pour être acceptées.
  • column_constraint :les contraintes de colonne sont des contraintes facultatives pour ajouter des restrictions supplémentaires sur les données pouvant être stockées dans la colonne. Par exemple, vous pouvez exiger que les entrées ne soient pas des entiers nuls, uniques ou positifs.
  • table_constraints :Les contraintes de table sont similaires aux contraintes de colonne mais impliquent l'interaction de plusieurs colonnes. Par exemple, vous pourriez avoir une contrainte de table qui vérifie qu'un DATE_OF_BIRTH est avant DATE_OF_DEATH dans un tableau.


Créer des tables de manière conditionnelle avec le IF NOT EXISTS clause

Par défaut, si vous essayez de créer une table dans PostgreSQL qui existe déjà dans la base de données, une erreur se produira. Pour contourner ce problème dans les cas où vous souhaitez créer une table si elle n'est pas présente, mais continuez simplement si elle existe déjà, vous pouvez utiliser le IF NOT EXISTS clause. Le IF NOT EXISTS qualificateur facultatif qui indique à PostgreSQL d'ignorer l'instruction si la base de données existe déjà.

Pour utiliser le IF NOT EXISTS clause, insérez-la dans la commande après CREATE TABLE syntaxe et avant le nom de la table :

CREATE TABLE IF NOT EXISTS table_name (    column_name TYPE [column_constraint],    [table_constraint,]);

Cette variante tentera de créer la table. Si une table portant ce nom existe déjà dans la base de données spécifiée, PostgreSQL lancera un avertissement indiquant que le nom de la table a déjà été pris au lieu d'échouer avec une erreur.



Comment créer des tables dans PostgreSQL

La syntaxe ci-dessus est suffisante pour créer des tables de base. Par exemple, nous allons créer deux tables dans notre school base de données. Une table s'appellera supplies et l'autre s'appellera teachers :

Dans les supplies table, nous voulons avoir les champs suivants :

  • Identifiant : Un identifiant unique pour chaque type de fournitures scolaires.
  • Nom : Le nom d'un élément scolaire spécifique.
  • Description : Une courte description de l'article.
  • Fabricant : Le nom du fabricant de l'article.
  • Couleur : La couleur de l'article.
  • Inventaire : Le nombre d'articles que nous avons pour un certain type de fournitures scolaires. Cela ne doit jamais être inférieur à 0.

Nous pouvons créer les supplies table avec les qualités ci-dessus en utilisant le SQL suivant.

Tout d'abord, changez pour school base de données que vous avez créée avec psql en tapant :

\c school

Cela changera la base de données que nos futures commandes cibleront. Votre invite devrait changer pour refléter la base de données.

Ensuite, créez les supplies tableau avec l'instruction suivante :

CREATE TABLE supplies (  id INT PRIMARY KEY,  name VARCHAR,  description VARCHAR,  manufacturer VARCHAR,  color VARCHAR,  inventory int CHECK (inventory > 0));

Cela créera les supplies table au sein de l'school base de données. La PRIMARY KEY La contrainte de colonne est une contrainte spéciale utilisée pour indiquer les colonnes qui peuvent identifier de manière unique les enregistrements dans la table. Ainsi, la contrainte spécifie que la colonne ne peut pas être nulle et doit être unique. PostgreSQL crée des index pour les colonnes de clé primaire afin d'augmenter la vitesse d'interrogation.

Vérifiez que la nouvelle table est présente en tapant :

\dt
 
          List of relations Schema |   Name   | Type  |  Owner  --------+----------+-------+--------- public | supplies | table | doadmin(1 row)

Vérifiez que le schéma reflète la conception prévue en saisissant :

\d supplies
 
                      Table "public.supplies"    Column    |       Type        | Collation | Nullable | Default--------------+-------------------+-----------+----------+--------- id           | integer           |           | not null | name         | character varying |           |          | description  | character varying |           |          | manufacturer | character varying |           |          | color        | character varying |           |          | inventory    | integer           |           |          |Indexes:    "supplies_pkey" PRIMARY KEY, btree (id)Check constraints:    "supplies_inventory_check" CHECK (inventory > 0)

Nous pouvons voir chacune des colonnes et des types de données que nous avons spécifiés. La contrainte de colonne que nous avons définie pour le inventory colonne est répertoriée vers la fin.

Ensuite, nous allons créer un teachers table. Dans ce tableau, les colonnes suivantes doivent être présentes :

  • Identifiant d'employé  :Un numéro d'identification d'employé unique.
  • Prénom :Le prénom de l'enseignant.
  • Nom de famille :Nom de famille de l'enseignant.
  • Objet  :La matière que l'enseignant est engagé pour enseigner.
  • Niveau scolaire  :le niveau scolaire des élèves pour lesquels l'enseignant est embauché.

Créer les teachers table avec le schéma ci-dessus avec le SQL suivant :

CREATE TABLE teachers (  id INT PRIMARY KEY,  first_name VARCHAR,  last_name VARCHAR,  subject VARCHAR,  grade_level int);


Comment créer des tables avec des clés primaires et des clés étrangères

Vous pouvez trouver des informations sur la création de tables avec des clés primaires et étrangères dans certains de nos autres guides PostgreSQL. Les clés primaires et les clés étrangères sont les deux types de contraintes de base de données dans PostgreSQL.

Une clé primaire est une colonne ou une colonne spéciale dont l'unicité est garantie sur les lignes d'une même table. Toutes les clés primaires peuvent être utilisées pour identifier de manière unique une ligne spécifique. Les clés primaires garantissent non seulement que chaque ligne a une valeur unique pour les colonnes de clé primaire, elles garantissent également qu'aucune ligne ne contient NULL valeurs pour cette colonne. Souvent, la clé primaire dans PostgreSQL utilise le format suivant pour spécifier une clé primaire incrémentielle automatiquement attribuée :id SERIAL PRIMARY KEY .

Les clés étrangères sont un moyen de s'assurer qu'une ou plusieurs colonnes d'une table correspondent aux valeurs contenues dans une autre table. Cela permet d'assurer l'intégrité référentielle entre les tables.




Comment afficher les tables dans PostgreSQL

Dans PostgreSQL, vous pouvez répertorier les tables de différentes manières en fonction des informations que vous recherchez.

Si vous souhaitez voir quelles tables sont disponibles dans votre base de données, vous pouvez utiliser le \dt méta-commande incluse avec le psql client pour lister toutes les tables, comme nous l'avons démontré ci-dessus :

\dt
 
          List of relations Schema |   Name   | Type  |  Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)

Vous pouvez également vérifier que le schéma de la table correspond à vos spécifications :

\d teachers
 
                     Table "public.teachers"   Column    |       Type        | Collation | Nullable | Default-------------+-------------------+-----------+----------+--------- id          | integer           |           | not null | first_name  | character varying |           |          | last_name   | character varying |           |          | subject     | character varying |           |          | grade_level | integer           |           |          |Indexes:    "teachers_pkey" PRIMARY KEY, btree (id)

Les teachers table semble correspondre à notre définition.



Modifier les tables

Si vous avez besoin de changer le schéma d'une table existante dans PostgreSQL, vous pouvez utiliser le ALTER TABLE commande. Le ALTER TABLE La commande est très similaire à la commande CREATE TABLE commande, mais fonctionne sur une table existante.


Modifier la syntaxe du tableau

La syntaxe de base pour modifier les tables dans PostgreSQL ressemble à ceci :

ALTER TABLE <table_name> <change_command> <change_parameters>

Le <change_command> indique le type exact de modification que vous souhaitez apporter, qu'il s'agisse de définir différentes options sur la table, d'ajouter ou de supprimer des colonnes ou de modifier des types ou des contraintes. Le <change_parameters> une partie de la commande contient toute information supplémentaire dont PostgreSQL a besoin pour effectuer la modification.



Ajouter des colonnes aux tableaux

Vous pouvez ajouter une colonne à une table PostgreSQL avec le ADD COLUMN changer de commande. Les paramètres de modification incluront le nom de la colonne, le type et les options, tout comme vous les spécifiez dans le CREATE TABLE commande.

Par exemple, pour ajouter une colonne appelée missing_column du text tapez dans une table appelée some_table , vous taperiez :

ALTER TABLE some_table ADD COLUMN missing_column text;


Supprimer des colonnes des tableaux

Si, à la place, vous souhaitez supprimer une colonne existante, vous pouvez utiliser le DROP COLUMN commande à la place. Vous devez spécifier le nom de la colonne que vous souhaitez supprimer en tant que paramètre de modification :

ALTER TABLE some_table DROP COLUMN useless_column;


Changer le type de données d'une colonne

Pour changer le type de données que PostgreSQL utilise pour une colonne spécifique, vous pouvez utiliser ALTER COLUMN modifier la commande avec le SET DATA TYPE commande de colonne. Les paramètres incluent le nom de la colonne, son nouveau type et un USING facultatif clause pour spécifier comment l'ancien type doit être converti en nouveau type.

Par exemple, pour définir la valeur d'un id colonne dans le resident table en un int en utilisant un cast explicite, nous pouvons taper ce qui suit :

ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;


Autres changements de tableau

De nombreux autres types de modifications peuvent être réalisés avec ALTER TABLE commande. Pour plus d'informations sur les options disponibles, consultez la documentation officielle de PostgreSQL pour ALTER TABLE .




Supprimer les tableaux

Si vous souhaitez supprimer une table, vous pouvez utiliser le DROP TABLE Instruction SQL. Cela supprimera le tableau ainsi que toutes les données qui y sont stockées.

La syntaxe de base ressemble à ceci :

DROP TABLE table_name;

Cela supprimera la table si elle existe et générera une erreur si le nom de la table n'existe pas.

Si vous souhaitez supprimer la table si elle existe et ne rien faire si elle n'existe pas, vous pouvez inclure le IF EXISTS qualificatif dans l'instruction :

DROP TABLE IF EXISTS table_name;

Les tables qui ont des dépendances sur d'autres tables ou objets ne peuvent pas être supprimées par défaut tant que ces dépendances existent. Pour éviter l'erreur, vous pouvez éventuellement inclure le CASCADE paramètre, qui supprime automatiquement toutes les dépendances avec la table :

DROP TABLE table_name CASCADE;

Si des tables ont une clé étrangère contrainte, qui fait référence à la table que vous supprimez, cette contrainte sera automatiquement supprimée.

Supprimer les supplies tableau que nous avons créé précédemment en tapant :

DROP TABLE supplies;

Nous garderons les teachers base de données pour démontrer que l'instruction de suppression des bases de données supprime également tous les objets enfants tels que les tables.



Supprimer des bases de données

La DROP DATABASE indique à PostgreSQL de supprimer la base de données spécifiée. La syntaxe de base ressemble à ceci :

DROP DATABASE database_name;

Remplacez le database_name espace réservé avec le nom de la base de données que vous souhaitez supprimer. Cela supprimera la base de données si elle est trouvée. Si la base de données est introuvable, une erreur se produit :

DROP DATABASE some_database;
 
ERROR:  database "some_database" does not exist

Si vous souhaitez supprimer la base de données si elle existe et ne rien faire autrement, incluez l'option IF EXISTS choix :

DROP DATABASE IF EXISTS some_database;
 
NOTICE:  database "some_database" does not exist, skippingDROP DATABASE

Cela supprimera la base de données ou ne fera rien si elle est introuvable.

Pour supprimer l'school base de données que nous avons utilisée dans ce guide, répertoriez les bases de données existantes sur votre système :

\l
 
                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)

Ouvrez une nouvelle connexion à l'une des bases de données que vous ne souhaitez pas supprimer :

\c defaultdb

Une fois la nouvelle connexion ouverte, supprimez le school base de données avec la commande suivante :

DROP DATABASE school;

Cela supprimera l'school base de données avec les teachers table définie à l'intérieur.

Si vous avez suivi SQL, vous pouvez terminer ici ou passer à la conclusion. Si vous souhaitez en savoir plus sur la création et la suppression de bases de données à partir de la ligne de commande, passez à la section suivante.



Utilisation des outils administratifs en ligne de commande pour créer et supprimer des bases de données

Si vous avez un accès shell au serveur ou au cluster où PostgreSQL est installé, vous pouvez avoir accès à des outils de ligne de commande supplémentaires qui peuvent vous aider à créer et supprimer des bases de données. Le createdb et dropdb les commandes sont regroupées avec PostgreSQL lorsqu'il est installé.


Créer une nouvelle base de données à partir de la ligne de commande

La syntaxe de base pour le createdb commande (qui doit être exécutée par un utilisateur système avec un accès administrateur à PostgreSQL) est :

createdb db_name

Cela créera une base de données appelée db_name dans PostgreSQL en utilisant les paramètres par défaut.

La commande accepte également des options pour modifier son comportement, un peu comme la variante SQL que vous avez vue précédemment. Vous pouvez en savoir plus sur ces options avec man createdb . Certaines des options les plus importantes sont :

  • --encoding= :définit l'encodage des caractères pour la base de données.
  • --locale= :définit les paramètres régionaux de la base de données.

Ceux-ci peuvent aider à garantir que la base de données peut stocker des données dans les formats que vous prévoyez de prendre en charge et avec les préférences de localisation de votre projet.

Par exemple, pour vous assurer que votre base de données est créée avec le support Unicode et pour remplacer les propres paramètres régionaux du serveur pour utiliser la localisation en anglais américain, vous pouvez saisir :

createdb --encoding=UTF8 --locale=en_US db_name

En supposant que vous disposiez des autorisations appropriées, la base de données sera créée conformément à vos spécifications.

Pour suivre les exemples de ce guide, vous pouvez créer une base de données appelée school en utilisant les paramètres régionaux par défaut et l'encodage de caractères UTF8 en tapant :

createdb --encoding=UTF8 school

Vous pouvez ensuite vous connecter à la base de données en utilisant psql pour configurer vos tables comme d'habitude.



Supprimer des bases de données depuis la ligne de commande

Le dropdb la commande reflète la DROP DATABASE Instruction SQL. Il a la syntaxe de base suivante :

dropdb database_name

Changez le database_name espace réservé pour référencer la base de données que vous souhaitez supprimer.

Par défaut, cette commande génère une erreur si la base de données spécifiée est introuvable. Pour éviter cela, vous pouvez inclure l'option --if-exists drapeau :

dropdb --if-exists database_name

Cela supprimera la base de données spécifiée si elle existe. Sinon, il ne fera rien.

Pour supprimer l'school base de données que nous avons créée précédemment, tapez :

dropdb school

Cela supprimera la base de données et tous les éléments enfants, comme les tables, qu'elle contient.




Conclusion

Cet article a couvert les bases de la création et de la suppression de bases de données et de tables dans PostgreSQL. Voici quelques-unes des commandes les plus élémentaires requises pour configurer un système de base de données et définir la structure de vos données.

Comme mentionné précédemment, les instructions SQL couvertes dans ce tutoriel PostgreSQL, en particulier le CREATE TABLE , de nombreux paramètres supplémentaires peuvent être utilisés pour modifier le comportement de PostgreSQL. Vous pouvez en savoir plus à ce sujet en consultant la documentation officielle de PostgreSQL.