Créer et modifier des tables

À propos du SQL abordé dans ce cours

Ce cours enseigne la syntaxe SQL universelle qui fonctionne sur les principaux SGBDR — MySQL, Oracle, PostgreSQL, SQL Server, et plus encore. Les bases comme CREATE TABLE / SELECT / WHERE / JOIN / GROUP BY s'écrivent de la même manière, peu importe la base de données vers laquelle tu bascules.

Pour des raisons techniques, la console intégrée au navigateur fait tourner SQLite, mais chaque fois qu'une fonctionnalité diffère entre les bases (vérification de longueur sur les types, manière de lister les tables, etc.) tu verras une note comparative du type En MySQL, tu écrirais... pour savoir quoi utiliser ailleurs.

Qu'est-ce qu'une table ?

Dans une base de données relationnelle, tu stockes les données dans des tables (grilles de lignes et de colonnes). Chaque table est composée de colonnes et de lignes (enregistrements), et chaque colonne a un type de données fixe qui contrôle les valeurs qu'elle peut contenir.

Concevoir une table, c'est décider à l'avance quelles colonnes inclure et quel type assigner à chacune. Verrouiller les types empêche que des valeurs inattendues s'y glissent plus tard.

CREATE TABLE — créer une table

Pour créer une table, tu utilises l'instruction CREATE TABLE. Écris le nom de la table, puis entre parenthèses liste les paires nom de colonne + type séparées par des virgules. Ne mets pas de virgule après la dernière colonne.

Verrouiller les types à l'avance rend plus difficile l'arrivée de données inattendues (comme une chaîne qui se retrouverait dans une colonne numérique).

-- Crée une table en listant les noms et types de colonnes
CREATE TABLE book_record (
  id INTEGER,
  title TEXT,
  price INTEGER,
  published_on TEXT
);

Types de données courants

Les types de données SQL varient en nom et en détail selon les systèmes de bases de données, mais pour démarrer tu n'as besoin de connaître que les types suivants.

Et les VARCHAR / CHAR / DATETIME de MySQL ?

En MySQL et PostgreSQL, tu verras souvent des types fins comme VARCHAR(255) / CHAR(13) / BOOLEAN / DATETIME. La console ici les accepte sur le plan syntaxique, mais la vérification de longueur (comme VARCHAR(10) rejetant un 11e caractère) ne s'active que sur les SGBDR à typage strict comme MySQL ou PostgreSQL.

Pour les exercices de ce cours, les colonnes utilisent surtout INTEGER / TEXT / REAL afin de rester simples. Quand tu portes une définition vers MySQL, tu peux remplacer INTEGER par INT et TEXT par VARCHAR(N) ou TEXT — la structure de CREATE TABLE elle-même reste la même.

Essaie de créer une table book_record pour stocker des livres. (Exécute correctement et l'explication apparaîtra.)

① Sur la première ligne, écris DROP TABLE IF EXISTS book_record; pour supprimer toute book_record existante.

② Ensuite, écris CREATE TABLE book_record (...) avec trois colonnes : id INTEGER, title TEXT, et price INTEGER.

③ Pour vérifier, termine par SELECT name FROM sqlite_master WHERE type='table'; et confirme que book_record apparaît dans la liste.

PRIMARY KEY — identifier une ligne de manière unique

Une clé primaire (PRIMARY KEY — colonne utilisée pour identifier une ligne de manière unique) est une colonne dont les valeurs doivent être uniques et jamais NULL. Tu fais d'une colonne la clé primaire quand ses valeurs doivent toujours exister et ne jamais entrer en collision, comme un numéro d'employé ou un ID utilisateur.

Avec une clé primaire en place, tu peux récupérer une seule ligne de manière fiable. En règle générale, chaque table devrait avoir exactement une clé primaire.

-- Ajoute PRIMARY KEY après la définition de colonne
CREATE TABLE member (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  joined_on TEXT
);

INTEGER PRIMARY KEY auto-numérote

Une colonne déclarée INTEGER PRIMARY KEY est auto-numérotée à partir de 1 chaque fois que tu fais un INSERT sans préciser sa valeur. En MySQL la même auto-numérotation s'écrit id INT PRIMARY KEY AUTO_INCREMENT, et en PostgreSQL id SERIAL PRIMARY KEY. Dans la console de ce cours, INTEGER PRIMARY KEY suffit.

Si tu fais un INSERT avec une valeur explicite, cette valeur est utilisée, et la prochaine auto-numérotation reprend à partir de l'entier juste après.

Essaie de créer une table member pour stocker des membres, avec id comme clé primaire.

① Écris DROP TABLE IF EXISTS member; pour supprimer toute member existante.

② Écris CREATE TABLE member (...) avec trois colonnes : id INTEGER PRIMARY KEY, name TEXT NOT NULL, et joined_on TEXT.

③ Écris INSERT INTO member (name, joined_on) VALUES ('Frank', '2026-04-01'), ('Grace', '2026-04-02'); pour insérer deux lignes sans préciser id.

④ Termine par SELECT * FROM member; pour confirmer que id a été auto-numéroté.

Tester une violation de contrainte — comment fonctionne NOT NULL

Cassons délibérément une règle pour voir comment fonctionnent les contraintes (règles auxquelles les valeurs d'une colonne doivent obéir) comme NOT NULL et PRIMARY KEY. NOT NULL est une règle qui n'autorise pas NULL dans la colonne. L'ajouter aux champs obligatoires (nom, adresse e-mail, etc.) empêche que des lignes incomplètes s'y glissent.

La table user créée en haut de l'article a été définie avec name TEXT NOT NULL. Si tu essaies d'insérer NULL dans la colonne name, la base de données rejettera l'INSERT et renverra une erreur.

La colonne name de la table user est définie avec la contrainte NOT NULL. Insère délibérément NULL pour voir l'erreur de violation de contrainte.

① Exécute le INSERT INTO user (...) VALUES (10, NULL, 30, 'Tokyo'); préparé (puisque tu essaies de mettre NULL dans name, tu devrais obtenir une erreur du type NOT NULL constraint failed: user.name).

(Cet exercice est correct quand une erreur revient — c'est exactement le rôle d'une contrainte : empêcher des données invalides d'entrer avant même qu'elles n'arrivent.)

-- INSERT qui déclenche une violation NOT NULL dans l'Exercice 3
INSERT INTO user (id, name, age, city)
  VALUES (10, NULL, 30, 'Tokyo');

Inspecter et supprimer des tables

Après avoir créé une table, tu vas vouloir vérifier quelles tables existent et quelles colonnes possède chacune. La console ici utilise ces deux requêtes :

- Liste des tables : SELECT name FROM sqlite_master WHERE type='table';

- Définitions des colonnes : PRAGMA table_info(nom_table);

En MySQL, tu écrirais SHOW TABLES; et DESCRIBE nom_table; ; Oracle utilise SELECT table_name FROM user_tables;. Chaque base a sa propre syntaxe dédiée. DROP TABLE pour supprimer une table fonctionne de la même façon dans toutes les bases.

-- ① Liste toutes les tables
SELECT name FROM sqlite_master WHERE type='table';

-- ② Affiche les définitions de colonnes de la table user
PRAGMA table_info(user);

-- ③ Supprime une table
DROP TABLE IF EXISTS book_record;

Jette un œil dans la table user mise en place en haut de l'article, puis entraîne-toi à supprimer une table dont tu n'as plus besoin.

① Écris PRAGMA table_info(user); pour afficher les définitions de colonnes de la table user.

② Regarde la colonne pk du résultat pour voir quelle colonne est la clé primaire.

③ Supprime la table book_record créée à l'Exercice 1 avec DROP TABLE IF EXISTS book_record;.

④ Enfin, exécute SELECT name FROM sqlite_master WHERE type='table'; et confirme que book_record a disparu de la liste.

ALTER TABLE — modifier une définition existante

Une fois ton système en production, des demandes comme « ajoute une colonne de plus » ou « renomme la table » sont inévitables. C'est là qu'intervient ALTER TABLE. Les quatre opérations couvertes ici fonctionnent en MySQL et PostgreSQL avec une syntaxe presque identique.

MODIFY / CHANGE COLUMN / AFTER de MySQL

En MySQL tu peux changer le type d'une colonne avec ALTER TABLE table MODIFY col type;, changer le nom et le type d'une colonne en même temps avec CHANGE COLUMN old new type;, et supprimer la clé primaire avec DROP PRIMARY KEY;.

-- Renomme la table
ALTER TABLE user RENAME TO user_record;

-- Ajoute une colonne (une colonne email est ajoutée à la fin)
ALTER TABLE user_record ADD COLUMN email TEXT;

-- Renomme une colonne
ALTER TABLE user_record RENAME COLUMN city TO area;

-- Supprime une colonne
ALTER TABLE user_record DROP COLUMN email;

Applique successivement les trois opérations ALTER TABLE (ajout, renommage, suppression) sur la table user. (C'est le dernier exercice de l'article.)

① Ajoute la colonne email avec ALTER TABLE user ADD COLUMN email TEXT;.

② Renomme la colonne city en area avec ALTER TABLE user RENAME COLUMN city TO area;.

③ Supprime la colonne email que tu as ajoutée avec ALTER TABLE user DROP COLUMN email;.

④ Enfin, exécute PRAGMA table_info(user); et confirme que area est en place après le renommage et que email n'est plus là.