Retour à tous les guides
SQL··7 min de lecture

Comprendre les contraintes SQL : NOT NULL, UNIQUE, CHECK, DEFAULT et plus

Maîtrisez les contraintes SQL pour protéger l'intégrité des données. Apprenez NOT NULL, UNIQUE, CHECK, DEFAULT, PRIMARY KEY et FOREIGN KEY avec des exemples clairs.

Table Products avec NOT NULL, UNIQUE, CHECK de prix non négatif et DEFAULT zéro
Dans ce guide
  1. Que sont les contraintes SQL ?
  2. NOT NULL
  3. UNIQUE
  4. CHECK
  5. DEFAULT
  6. Contraintes PRIMARY KEY & FOREIGN KEY
  7. Contraintes au niveau de la colonne vs au niveau de la table
  8. Contraintes nommées et importance
  9. Combinaison de contraintes et motifs courants
  10. Pièges courants
  11. Références et lecture complémentaire

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 constraint

Astuce : 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=1

DEFAULT 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 primaires
  • fk_<table>_<column> — clés étrangères
  • uq_<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 NULL valeurs dans un UNIQUE colonne car NULL n'est égal à rien — y compris à lui-même. SQL Server fait exception et traite NULL comme 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 CHECK des 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 CHECK les contraintes ont un surcoût négligeable. Évitez d'incorporer des sous-requêtes ou des appels de fonction dans CHECK — 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 NULL la 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 un CHECK (column IS NOT NULL) NOT VALID d'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.

Références et lecture complémentaire

Plus d'articles