Les exemples SQL utilisent PostgreSQL à moins qu'un autre dialecte ne soit nommé. Les extraits courts supposent que leurs tables référencées existent déjà. Validez le DDL dans votre base de données cible avant de l'appliquer.
Que sont les contraintes SQL ?
Contraintes sont des règles appliquées par le moteur de base de données pour garantir l'exactitude et la fiabilité des données dans une table. Elles agissent comme des garde-fous — empêchant les insertions, mises à jour et suppressions non valides à la frontière de la base de données. Elles protègent les règles déclarées ; la validation par l'application et la conception des transactions restent importantes.
Le SQL définit plusieurs types de contraintes. Dans ce guide, nous couvrirons chacune d'elles en profondeur, montrerons quand l'utiliser et mettrons en évidence les pièges courants.
NOT NULL
Le NOT NULL la contrainte garantit qu'une colonne a toujours une valeur. Tout INSERT ou UPDATE qui tente de définir la colonne sur NULL sera rejeté. Une chaîne vide reste une valeur ; ajoutez un CHECK lorsque le texte vide est interdit.
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(150) NOT NULL, -- every product MUST have a name
price NUMERIC(10,2) NOT NULL -- every product MUST have a price
);
-- This will fail:
INSERT INTO products (name, price) VALUES (NULL, 9.99);
-- ERROR: null value in column "name" violates not-null constraintAstuce : Par défaut à NOT NULL pour chaque colonne et ne la supprimez que lorsque vous avez une raison commerciale claire d'autoriser les valeurs nulles. Les valeurs nulles introduisent une logique à trois valeurs dans les requêtes et constituent une source fréquente de bugs subtils.
UNIQUE
A UNIQUE la contrainte garantit qu'aucun doublon de ligne ne contient la même valeur dans la colonne contrainte (ou la combinaison de colonnes). Contrairement à une clé primaire, un UNIQUE colonne peut contiennent NULL. PostgreSQL et MySQL autorisent normalement plusieurs valeurs NULL dans une colonne unique ; SQL Server en autorise une dans une contrainte d'unicité sur une seule colonne. Il s'agit d'une règle d'unicité, et non du résultat de l'évaluation de NULL = NULL.
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE,
username VARCHAR(50) NOT NULL UNIQUE
);
-- Multi-column unique constraint
CREATE TABLE reservations (
id SERIAL PRIMARY KEY,
room_id INT NOT NULL,
date DATE NOT NULL,
CONSTRAINT uq_room_date UNIQUE (room_id, date)
);Le multi-colonne UNIQUE la contrainte ci-dessus garantit qu'une même chambre ne peut pas être réservée deux fois à la même date.
CHECK
CHECK les contraintes valident qu'une valeur satisfait une expression booléenne avant d'être stockée. Elles appliquent des règles au niveau de la ligne que le système de types seul ne peut pas exprimer. Un CHECK accepte TRUE ou UNKNOWN ; combinez-le avec NOT NULL lorsqu'une valeur est requise.
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
age INT NOT NULL CHECK (age >= 18 AND age <= 120),
salary NUMERIC(12,2) NOT NULL CHECK (salary > 0)
);
-- Named CHECK constraint with multiple columns
CREATE TABLE events (
id SERIAL PRIMARY KEY,
start_date DATE NOT NULL,
end_date DATE NOT NULL,
CONSTRAINT chk_dates CHECK (end_date >= start_date)
);Piège à éviter : Dans les versions de MySQL antérieures à 8.0.16,CHECK les contraintes sont analysées mais ignoré en silence. Vérifiez toujours que votre version de base de données les applique réellement.
DEFAULT
Le DEFAULT fournit une valeur lorsqu'une colonne est omise d'un INSERT ou que DEFAULT est demandé explicitement. Un NULL explicite n'invoque pas la valeur par défaut. Les valeurs par défaut réduisent le code passe-partout dans le code applicatif et rendent les schémas auto-documentés.
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
status VARCHAR(20) NOT NULL DEFAULT 'pending',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
quantity INT NOT NULL DEFAULT 1
);
-- Inserting without specifying status, created_at, or quantity
INSERT INTO orders DEFAULT VALUES;
-- Result: status='pending', created_at=<current time>, quantity=1DEFAULT avec expressions
PostgreSQL et SQL Server autorisent les expressions et les appels de fonction dans les valeurs par défaut. MySQL prend en charge cela depuis la version 8.0.13 pour certains types.
-- PostgreSQL: UUID default
CREATE TABLE tokens (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
value TEXT NOT NULL
);Contraintes PRIMARY KEY & FOREIGN KEY
Ce sont les contraintes les plus structurelles dans les bases de données relationnelles. Un PRIMARY KEY identifie de manière unique chaque ligne et ajoute implicitement NOT NULL + UNIQUE. Un FOREIGN KEY lie une table à une autre et applique l'intégrité référentielle.
CREATE TABLE departments (
id SERIAL PRIMARY KEY,
name VARCHAR(80) NOT NULL UNIQUE
);
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
department_id INT NOT NULL,
CONSTRAINT fk_emp_dept
FOREIGN KEY (department_id)
REFERENCES departments (id)
ON DELETE RESTRICT
ON UPDATE CASCADE
);Consultez notre guide détaillé sur Clés primaires vs Clés étrangères pour les actions en cascade, les clés composées et les meilleures pratiques. Vous pouvez également modéliser ces relations visuellement dans le Éditeur Erd Go.
Contraintes au niveau de la colonne vs au niveau de la table
Les contraintes peuvent être définies en ligne (au niveau de la colonne) ou comme une clause distincte après toutes les colonnes (au niveau de la table). Le résultat est identique, mais le niveau de la table est requis lorsque la contrainte s'étend sur plusieurs colonnes.
-- Column-level (single column)
CREATE TABLE items (
id SERIAL PRIMARY KEY,
code VARCHAR(20) NOT NULL UNIQUE,
price NUMERIC(10,2) NOT NULL CHECK (price >= 0)
);
-- Table-level (multi-column constraint)
CREATE TABLE shipments (
id SERIAL PRIMARY KEY,
origin VARCHAR(3) NOT NULL,
destination VARCHAR(3) NOT NULL,
CONSTRAINT chk_different_locations CHECK (origin <> destination),
CONSTRAINT uq_route UNIQUE (origin, destination)
);Contraintes nommées et importance
Nommez toujours vos contraintes explicitement en utilisant le CONSTRAINT mot-clé. Lorsqu'une contrainte est violée, la base de données renvoie le nom de la contrainte dans le message d'erreur — un nom explicite comme chk_positive_salary est infiniment plus utile qu'un hachage généré automatiquement.
-- Good: named constraint
ALTER TABLE products
ADD CONSTRAINT chk_positive_price CHECK (price > 0);
-- You can also drop a constraint by name
ALTER TABLE products
DROP CONSTRAINT chk_positive_price;Une convention de nommage cohérente rend les migrations, le débogage et l'intégration des équipes beaucoup plus fluides. Un modèle courant est :
pk_<table>— clés primairesfk_<table>_<column>— clés étrangèresuq_<table>_<column(s)>— contraintes d'unicitéchk_<table>_<rule>— contraintes de vérification (check)
Combinaison de contraintes et motifs courants
En pratique, les colonnes portent plusieurs contraintes à la fois. Voici des modèles que vous utiliserez sans cesse :
CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL,
role VARCHAR(20) NOT NULL DEFAULT 'user'
CHECK (role IN ('user', 'admin', 'moderator')),
balance NUMERIC(12,2) NOT NULL DEFAULT 0.00
CHECK (balance >= 0),
is_active BOOLEAN NOT NULL DEFAULT TRUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
deleted_at TIMESTAMPTZ -- nullable: NULL means "not deleted"
);Modèle de suppression logique (Soft-Delete)
Le deleted_at la colonne ci-dessus implémente un suppression logique. Au lieu de supprimer des lignes, vous définissez deleted_at = now(). Associez cela à un index unique partiel pour empêcher les doublons « actifs » tout en autorisant les lignes supprimées avec la même adresse e-mail. La table ne comporte délibérément aucune contrainte UNIQUE globale sur l'e-mail ; en conserver une rejetterait également les doublons parmi les lignes supprimées :
-- PostgreSQL: unique email only among active accounts
CREATE UNIQUE INDEX uq_accounts_active_email
ON accounts (email)
WHERE deleted_at IS NULL;Pièges courants
- NULL et UNIQUE : La plupart des bases de données autorisent plusieurs
NULLvaleurs dans unUNIQUEcolonne carNULLn'est égal à rien — y compris à lui-même. SQL Server fait exception et traiteNULLcomme un doublon par défaut ; utilisez un index filtré pour contourner ce problème. - CHECK dans les versions plus anciennes de MySQL : Comme indiqué ci-dessus, MySQL avant la version 8.0.16 analyse mais ignore
CHECKdes contraintes. Validez votre version de MySQL ou appliquez les règles dans le code de l'application. - Contraintes différées : PostgreSQL prend en charge la vérification différée pour les contraintes de clé étrangère, d'unicité, de clé primaire et d'exclusion déclarées
DEFERRABLE INITIALLY DEFERRED. CHECK et NOT NULL ne peuvent pas être différés. C'est utile pour les références circulaires, mais cela peut rendre le débogage plus difficile. - Performances de CHECK : Simple
CHECKles contraintes ont un surcoût négligeable. Évitez d'incorporer des sous-requêtes ou des appels de fonction dansCHECK— elles peuvent même ne pas être prises en charge et peuvent masquer une logique lente. - Modification de contraintes sur de grandes tables : L'ajout d'un
NOT NULLla contrainte dans PostgreSQL peut nécessiter un parcours de table à moins qu'un CHECK validé existant ne prouve que la colonne ne contient aucun null. Sur de très grandes tables, envisagez d'ajouter unCHECK (column IS NOT NULL) NOT VALIDd'abord, puis en le validant séparément.
Examinez conjointement les contraintes dans le SQL et le diagramme dans le Éditeur SQL vers ERD, puis validez leur comportement dans la base de données cible. Un diagramme n'applique pas l'intégrité des données.



