Bases de la création de tables : CREATE TABLE

Dans les premiers cours, on a posé les bases sur les bases de données relationnelles et PostgreSQL, on a vu comment bosser avec psql et pgAdmin, et aussi comment créer et gérer des bases de données. Maintenant, il est temps de passer à la création du "matériau de construction" principal des bases relationnelles – les tables. C’est dans les tables qu’on stocke toutes les infos qu’on pourra ensuite filtrer, trier ou joindre.

Pour créer des tables dans PostgreSQL, on utilise la commande CREATE TABLE. Cette commande décrit la structure de la table : son nom, ses colonnes et leurs types de données.

Structure générale de la commande

Voilà à quoi ressemble la syntaxe de base :

CREATE TABLE table (
    colonne1 type_de_donnée contraintes,
    colonne2 type_de_donnée contraintes,
    ...
);

On découpe ça :

• table – le nom de la table (par exemple, students).
• colonne1 – le nom de la colonne (genre id, name).
• type_de_donnée – le type de données de la colonne (genre INTEGER, VARCHAR).
• contraintes – les contraintes sur les données (genre NOT NULL, PRIMARY KEY).

Allez, on va créer notre première table.

Exemple de création de table

Scénario : dans une base de données d’apprentissage, il faut stocker des infos sur les étudiants. Pour ça, on va créer une table students avec les champs :

• id : identifiant unique de l’étudiant (s’incrémente tout seul);
• name : nom de l’étudiant (jusqu’à 100 caractères);
• age : âge de l’étudiant (entier positif).

CREATE TABLE students (
    id SERIAL PRIMARY KEY,  -- ID unique de l’étudiant
    name VARCHAR(100),      -- nom
    age INTEGER             -- âge
);

Ce qui se passe ici :

1. id SERIAL PRIMARY KEY : on crée une colonne id qui génère automatiquement des nombres uniques (1, 2, 3...) pour chaque ligne. C’est aussi la clé primaire de la table.
2. name VARCHAR(100) : on crée une colonne texte, où VARCHAR(100) veut dire que la chaîne peut faire jusqu’à 100 caractères.
3. age INTEGER : on crée une colonne numérique pour stocker l’âge.

Maintenant, si tu exécutes cette requête dans psql ou pgAdmin, la table students sera créée.

Types de données pour les colonnes

Quand tu crées une table, c’est super important de choisir le bon type de données pour chaque colonne. PostgreSQL en propose plein, mais on va commencer par les plus courants.

Choisir le bon type de données

• Si tu stockes des nombres – prends INTEGER.
• Pour des chaînes avec une longueur max connue – mieux vaut VARCHAR(n).
• Pour du texte sans limite – utilise TEXT.
• Les dates et heures, mets-les dans DATE ou TIMESTAMP.

Exemple : on crée la table courses

Imaginons que dans notre base, il faut aussi stocker des infos sur les cours. Chaque cours a :

• id : identifiant unique ;
• name : nom du cours (jusqu’à 100 caractères) ;
• description : description du cours (texte long) ;
• start_date : date de début du cours.

Code SQL :

CREATE TABLE courses (
    id SERIAL PRIMARY KEY,      -- ID unique du cours
    name VARCHAR(100),          -- nom du cours
    description TEXT,           -- description
    start_date DATE             -- date de début
);

Exercice pratique

À toi de jouer pour créer une table ! Voilà l’exercice :

1. Crée une table teachers avec les champs :
   • id : identifiant unique.
   • name : nom de l’enseignant (jusqu’à 50 caractères).
   • subject : matière qu’il/elle enseigne (jusqu’à 50 caractères).
   • hire_date : date d’embauche.

Exemple de code à exécuter :

CREATE TABLE teachers (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50),
    subject VARCHAR(50),
    hire_date DATE
);

Après ça, utilise la commande \d teachers dans psql pour vérifier que la table a bien été créée.

Erreurs classiques quand on crée des tables

Quand tu commences à bosser avec les tables, tu peux tomber sur des erreurs. Voilà quelques cas fréquents :

Erreur dans le nom de la table ou de la colonne. Dans PostgreSQL, les noms ne sont pas sensibles à la casse, mais si tu utilises des guillemets " autour des noms, fais gaffe. Par exemple, CREATE TABLE "MyTable" crée une table "MyTable", et mytable ne sera pas reconnu comme son nom.

Mauvais type de donnée. Si tu mets un type de donnée qui n’existe pas, la requête plantera.

CREATE TABLE example (
    column1 TYPE_BIZARRE
);

Cette requête ne marchera pas, parce que TYPE_BIZARRE n’existe pas.

Oubli du PRIMARY KEY. Si tu oublies d’ajouter une clé primaire, la table sera créée, mais ce sera plus galère d’identifier les lignes.