Guide SQL CREATE TABLE

CREATE TABLE ajoute un nouveau tableau à une base de données. Tu nommes le tableau et listes ses colonnes, chacune avec un type de données et les règles (contraintes) que ses valeurs doivent respecter. Les exemples fonctionnent sous PostgreSQL, MySQL, SQLite et SQL Server.

Comment utiliser CREATE TABLE

Nomme le tableau, puis liste ses colonnes entre parenthèses, séparées par des virgules. Chaque colonne reçoit un nom, un type de données et, en option, des contraintes comme PRIMARY KEY, NOT NULL, UNIQUE, DEFAULT ou CHECK :

CREATE TABLE table_name (
    column_name data_type constraints,
    another_column data_type constraints
);

CREATE TABLE customers (
    id INTEGER PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE,
    country CHAR(2) DEFAULT 'US',
    signed_up DATE
);

INSERT INTO customers (id, name, email, signed_up)
VALUES (1, 'Ana Lima', 'ana@example.com', '2026-03-02');

SELECT * FROM customers;

-- Output:
-- id | name     | email           | country | signed_up
-- ---+----------+-----------------+---------+-----------
-- 1  | Ana Lima | ana@example.com | US      | 2026-03-02

Le nouveau tableau reste vide tant que tu n’y insères pas de lignes. Cet insert omet country, donc la ligne a reçu la valeur par défaut, US.

Règles à connaître

• SQLite n’impose ni les types ni les longueurs. Là où d’autres bases de données rejettent une valeur qui ne correspond pas à la colonne, SQLite l’enregistre quand même. Ajoute STRICT après la parenthèse fermante pour activer la vérification (un tableau strict n’accepte que les types INT, INTEGER, REAL, TEXT, BLOB et ANY).

CREATE TABLE products (
    sku VARCHAR(5),
    quantity INTEGER
);

-- SQLite stores this row; other databases reject it with an error
INSERT INTO products VALUES ('LAMP-001', 'twelve');

SELECT sku, quantity FROM products;

-- Output (SQLite):
-- sku      | quantity
-- ---------+---------
-- LAMP-001 | twelve

• Déclare une clé étrangère sur sa propre ligne FOREIGN KEY, et non avec REFERENCES dans la définition de la colonne : MySQL 8 accepte cette forme courte puis l’ignore. SQLite n’applique les clés étrangères qu’après PRAGMA foreign_keys = ON;, à exécuter sur chaque connexion.
• CREATE TABLE échoue si le tableau existe déjà. Écris plutôt CREATE TABLE IF NOT EXISTS pour l’ignorer.
• Sous MySQL, une colonne TEXT ne peut pas avoir de DEFAULT ni de UNIQUE. Utilise VARCHAR(n), comme dans les exemples ici.

Syntaxe alternative

Les identifiants auto-incrémentés s’écrivent différemment selon la base de données :

Omets l’id dans un insert et la base de données remplit le numéro suivant.

SQL Server a aussi ses propres noms pour les colonnes vrai/faux et date-heure, et pas de IF NOT EXISTS. Utilise BIT (avec 1 et 0) au lieu de BOOLEAN, DATETIME2 pour une date et une heure (son TIMESTAMP est un numéro de version de ligne, pas une date), et vérifie OBJECT_ID avant de créer le tableau :

-- SQL Server
IF OBJECT_ID('users', 'U') IS NULL
CREATE TABLE users (
    id INT IDENTITY(1,1) PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE,
    is_active BIT NOT NULL DEFAULT 1,
    created_at DATETIME2 NOT NULL DEFAULT CURRENT_TIMESTAMP
);

Quand utiliser CREATE TABLE ?

Chaque tableau commence par CREATE TABLE, mais les colonnes et contraintes que tu choisis résolvent des problèmes différents.

Stocker un nouveau type de données

Chaque type d’élément suivi par ton application, comme des clients, des livres ou des factures, a son propre tableau, avec une colonne pour chaque information et un type adapté aux valeurs.

Donner un ID unique à chaque ligne

Une PRIMARY KEY empêche deux lignes de partager un identifiant, pour que tu puisses toujours trouver, modifier ou lier exactement une ligne. Laisse la base de données numéroter les lignes (voir « Syntaxe alternative » plus haut), ou combine deux colonnes quand il faut une paire de valeurs pour identifier une ligne.

Bloquer les données invalides ou manquantes

Les contraintes rejettent les lignes qui enfreignent tes règles : NOT NULL pour les colonnes obligatoires, UNIQUE pour des valeurs comme les adresses e-mail, et CHECK pour les plages autorisées. DEFAULT remplit une colonne omise par un insert.

Lier des tableaux entre eux

Une FOREIGN KEY fait pointer une colonne vers une ligne d’un autre tableau, pour qu’une commande ne puisse pas désigner un client inexistant. Ajoute ON DELETE CASCADE et la suppression de la ligne parente supprime aussi les lignes qui pointent vers elle.

Enregistrer les résultats d’une requête dans un tableau

CREATE TABLE ... AS SELECT crée un tableau et le remplit à partir d’une requête en une seule instruction. Utilise-le pour des instantanés, des tableaux de reporting ou une sauvegarde de lignes que tu t’apprêtes à modifier.

Exemples concrets de CREATE TABLE

Les messages d’erreur sont ceux de PostgreSQL. Les autres bases de données rejettent les mêmes lignes avec leur propre formulation.

Un tableau de liaison avec une clé sur deux colonnes

Les étudiants suivent plusieurs cours, et les cours ont plusieurs étudiants. Le tableau enrollments les relie, et sa clé primaire est la paire d’ids : un étudiant peut s’inscrire à plusieurs cours, mais pas deux fois au même :

CREATE TABLE enrollments (
    student_id INTEGER NOT NULL,
    course_id INTEGER NOT NULL,
    enrolled_on DATE,
    PRIMARY KEY (student_id, course_id)
);

INSERT INTO enrollments VALUES (1, 101, '2026-09-01');
INSERT INTO enrollments VALUES (1, 102, '2026-09-01');
INSERT INTO enrollments VALUES (1, 101, '2026-09-08');
-- ERROR: duplicate key value violates unique constraint "enrollments_pkey"
-- DETAIL: Key (student_id, course_id)=(1, 101) already exists.

SELECT * FROM enrollments;

-- Output:
-- student_id | course_id | enrolled_on
-- -----------+-----------+------------
-- 1          | 101       | 2026-09-01
-- 1          | 102       | 2026-09-01

Des inscriptions qui respectent les règles

Chaque compte a besoin d’une adresse e-mail qu’aucun autre compte n’utilise et d’au moins une place. Les nouveaux comptes démarrent sur l’offre gratuite avec une place :

CREATE TABLE accounts (
    id INTEGER PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE,
    tier VARCHAR(20) NOT NULL DEFAULT 'free',
    seats INTEGER NOT NULL DEFAULT 1 CHECK (seats > 0)
);

INSERT INTO accounts (id, email) VALUES (1, 'sam@example.com');

SELECT * FROM accounts;

-- Output:
-- id | email           | tier | seats
-- ---+-----------------+------+------
-- 1  | sam@example.com | free | 1

INSERT INTO accounts (id, email) VALUES (2, 'sam@example.com');
-- ERROR: duplicate key value violates unique constraint "accounts_email_key"

INSERT INTO accounts (id, email, seats) VALUES (3, 'kim@example.com', 0);
-- ERROR: new row ... violates check constraint "accounts_seats_check"

INSERT INTO accounts (id) VALUES (4);
-- ERROR: null value in column "email" ... violates not-null constraint

Des commandes qui doivent appartenir à un client

Chaque commande pointe vers un client. La clé étrangère rejette une commande pour un client inexistant, et ON DELETE CASCADE supprime les commandes d’un client quand celui-ci est supprimé. Sous SQLite, exécute d’abord PRAGMA foreign_keys = ON;.

CREATE TABLE customers (
    id INTEGER PRIMARY KEY,
    name VARCHAR(100) NOT NULL
);

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    total DECIMAL(10,2),
    FOREIGN KEY (customer_id) REFERENCES customers(id) ON DELETE CASCADE
);

-- Input: customers
-- id | name
-- ---+-----------
-- 1  | Ana Lima
-- 2  | Ben Okafor

-- Input: orders
-- id | customer_id | total
-- ---+-------------+------
-- 10 | 1           | 25.00
-- 11 | 1           | 60.00
-- 12 | 2           | 42.50

INSERT INTO orders VALUES (13, 99, 15.00);
-- ERROR: ... violates foreign key constraint "orders_customer_id_fkey"
-- DETAIL: Key (customer_id)=(99) is not present in table "customers".

DELETE FROM customers WHERE id = 1;

-- Output (orders after the DELETE):
-- id | customer_id | total
-- ---+-------------+------
-- 12 | 2           | 42.50

Un instantané des clients actifs

Copie les clients qui ont commandé cette année dans leur propre tableau, pour une liste de campagne qui ne doit pas changer au fil des nouvelles commandes :

-- Input: customers
-- customer_id | name       | email             | last_order_date
-- ------------+------------+-------------------+----------------
-- 1           | Ana Lima   | ana@example.com   | 2026-03-18
-- 2           | Ben Okafor | ben@example.com   | 2025-11-02
-- 3           | Chloe Park | chloe@example.com | 2026-06-30
-- 4           | Dev Shah   | dev@example.com   | NULL

CREATE TABLE active_customers AS
SELECT customer_id, name, email
FROM customers
WHERE last_order_date >= '2026-01-01';

-- SQL Server has no CREATE TABLE ... AS. Use SELECT ... INTO:
SELECT customer_id, name, email
INTO active_customers
FROM customers
WHERE last_order_date >= '2026-01-01';

-- Output (active_customers):
-- customer_id | name       | email
-- ------------+------------+------------------
-- 1           | Ana Lima   | ana@example.com
-- 3           | Chloe Park | chloe@example.com

Le nouveau tableau reçoit les colonnes, leurs types et les lignes, mais pas la clé primaire ni aucune autre contrainte. Ajoute-les avec ALTER TABLE si tu en as besoin.

Pour aller plus loin avec CREATE TABLE

Sur ce blog :

• Guide des tables temporaires SQL : des tableaux qui ne durent que le temps de ta session
• SQL ALTER TABLE add column : modifier un tableau après l’avoir créé
• Clés primaires composites en SQL : des clés composées de plusieurs colonnes
• Utiliser les clés étrangères dans PostgreSQL : les clés étrangères et leurs actions de suppression en détail
• Guide des relations en base de données : concevoir des tableaux liés entre eux
• L’instruction SQL INSERT : ajouter des lignes à un nouveau tableau
• Générateur de tableaux SQL : construis une instruction CREATE TABLE dans ton navigateur au lieu de l’écrire à la main

Documentation officielle :

• PostgreSQL : CREATE TABLE
• MySQL : CREATE TABLE
• SQLite : CREATE TABLE
• SQL Server : CREATE TABLE