CHECK en SQL / MySQL : Pour sécuriser votre base de données

Lorsque vous travaillez avec des bases de données, l’un des enjeux les plus importants est l’intégrité des données. C’est là qu’intervient une clause souvent méconnue mais extrêmement utile : la contrainte CHECK en SQL. Elle permet de garantir que les données insérées dans une table respectent des conditions précises.

• Créer une contrainte CHECK simple
• Écrire un CHECK multi-colonnes
• Vérifier vos contraintes avec SHOW CREATE TABLE
• Éviter le piège MySQL < 8.0.16

Dans ce tutoriel, nous allons découvrir ce qu’est la contrainte CHECK en SQL, pourquoi elle est essentielle, comment l’utiliser dans vos projets, et surtout, nous vous proposerons des exemples concrets pour bien comprendre.

Qu’est-ce que la contrainte CHECK en SQL ?

La clause CHECK est une contrainte (ou constraint en anglais) que l’on peut appliquer sur une colonne ou sur une table entière. Elle sert à restreindre les valeurs qu’un champ peut accepter selon une condition définie par le développeur.

Par exemple, si vous avez une table contenant les âges de vos utilisateurs, vous pouvez décider que cet âge doit toujours être supérieur à 0. Cela évitera les erreurs absurdes comme un âge négatif.

Syntaxe générale :

CREATE TABLE nom_table (
    nom_colonne TYPE DONNÉE CHECK (condition)
);

Pourquoi utiliser CHECK en SQL ?

Voici les principaux avantages de la contrainte CHECK :

• ✅ Prévention des erreurs de saisie
• ✅ Respect des règles métier
• ✅ Sécurité renforcée
• ✅ Gain de temps pour le contrôle des données
• ✅ Automatisation de la validation côté base de données

Elle fonctionne directement au niveau du serveur SQL, ce qui signifie que toutes les applications qui insèrent ou modifient des données dans cette base devront respecter ces règles, même si elles ne sont pas codées dans le programme.

Exemple simple de contrainte CHECK

Créons une table d’utilisateurs avec une contrainte sur l’âge :

CREATE TABLE utilisateurs (
    id INT PRIMARY KEY,
    nom VARCHAR(100),
    age INT CHECK (age >= 18)
);

Ici, la colonne age ne peut contenir que des valeurs supérieures ou égales à 18. Si quelqu’un tente d’insérer une valeur comme age = 15, une erreur sera levée et l’insertion sera refusée.

Exemple plus complet : commande d’un site e-commerce

Imaginons une table pour gérer les commandes de votre boutique en ligne :

CREATE TABLE commandes (
    id INT PRIMARY KEY,
    montant DECIMAL(10,2),
    statut VARCHAR(50),
    CHECK (montant >= 0),
    CHECK (statut IN ('en attente', 'expédiée', 'livrée', 'annulée'))
);

Explication :

• Le montant ne peut jamais être négatif.
• Le statut doit obligatoirement faire partie d’une liste de statuts définis.

Cela évite par exemple que l’on se retrouve avec un statut erroné comme « en cours de validation » ou « en expédition », qui ne sont pas gérés dans l’application.

Mini quiz :

Question : quel est le résultat de cette requête ?

CREATE TABLE test (
  age INT CHECK (age >= 18)
);
INSERT INTO test(age) VALUES (15);

A) ça passe
B) erreur SQL
C) ça dépend de MySQL

Réponse du mini quiz

Afficher la réponse

✅ Bonne réponse : C) Ça dépend de MySQL.

Sur MySQL 8.0.16 et versions plus récentes, la contrainte CHECK est réellement appliquée : l’insertion de 15 déclenche une erreur.

Sur des versions plus anciennes, MySQL accepte parfois le CHECK… mais peut l’ignorer.

CHECK sur plusieurs colonnes

La clause CHECK peut également porter sur plusieurs colonnes à la fois. C’est très utile pour faire respecter des relations logiques.

Exemple : une table de réductions valables à partir d’un certain montant :

CREATE TABLE reductions (
    id INT PRIMARY KEY,
    seuil DECIMAL(5,2),
    reduction DECIMAL(5,2),
    CHECK (reduction <= seuil)
);

Ici, on impose que le montant de la réduction ne dépasse jamais le seuil à atteindre. Cela permet d’éviter des incohérences comme une réduction de 30€ pour un seuil de 10€.

⚠️ Attention à la compatibilité SQL

Toutes les bases de données SQL ne gèrent pas de la même manière les contraintes CHECK. Voici un aperçu :

Système de gestion	Prise en charge de CHECK
MySQL	✅ (à partir de la version 8.0.16)
PostgreSQL	✅
SQL Server	✅
SQLite	✅
Oracle	✅

Important : Si vous utilisez une version de MySQL inférieure à 8.0.16, les contraintes CHECK sont ignorées silencieusement. Pensez à mettre à jour votre système !

Cas d’usage de la contrainte CHECK en SQL / MySQL

1. Formulaires d’inscription

Vous créez un formulaire d’inscription pour votre plateforme d’e-learning :

CREATE TABLE inscriptions (
    id INT PRIMARY KEY,
    email VARCHAR(100),
    mot_de_passe VARCHAR(100),
    niveau_etude VARCHAR(30) CHECK (niveau_etude IN ('collège', 'lycée', 'bac+2', 'bac+5', 'autre'))
);

Ici, le champ niveau_etude est contraint pour n’accepter que des valeurs prédéfinies. Cela permet de créer des filtres efficaces dans l’application sans avoir à nettoyer les données manuellement.

2. Gestion des stocks

Pour une table de produits :

CREATE TABLE produits (
    id INT PRIMARY KEY,
    nom VARCHAR(100),
    stock INT CHECK (stock >= 0),
    prix DECIMAL(6,2) CHECK (prix > 0)
);

Impossible d’avoir un stock négatif ou un prix à zéro : c’est la base pour une bonne gestion d’un inventaire.

3. Application de réservation

CREATE TABLE reservations (
    id INT PRIMARY KEY,
    date_debut DATE,
    date_fin DATE,
    CHECK (date_debut <= date_fin)
);

Cela évite les erreurs de logique comme une réservation qui se terminerait avant de commencer. La base de données agit ici comme une « double vérification ».

4. Inscription / formulaire

Un formulaire de création de compte, c’est exactement le genre d’endroit où les bugs et les failles se glissent tranquillement. Côté base de données, on veut éviter des données absurdes ou dangereuses, du style :

• un âge négatif (oui, ça arrive…)
• un prix négatif (si vous stockez un abonnement ou une commande)
• une date incohérente (date de naissance dans le futur, ou date d’inscription impossible)

Avec un CHECK, vous pouvez imposer des règles “de bon sens” directement dans la table. Et ça, c’est très rassurant, parce que même si un jour un bout de code PHP part en vrille, la base de données, elle, continue à protéger vos données.

CREATE TABLE utilisateurs (
  id INT AUTO_INCREMENT PRIMARY KEY,
  pseudo VARCHAR(50) NOT NULL,
  age INT NOT NULL,
  date_naissance DATE NOT NULL,

  CHECK (age >= 0),
  CHECK (date_naissance <= CURDATE())
);

CHECK vs autres contraintes

Il existe d’autres types de contraintes SQL :

Contrainte	Rôle
NOT NULL	Interdit les valeurs nulles
UNIQUE	Empêche les doublons
PRIMARY KEY	Identifiant unique de chaque ligne
FOREIGN KEY	Lien entre deux tables
CHECK	Contrôle personnalisé selon une condition

La contrainte CHECK est la plus souple pour vos propres règles métier. Elle permet de personnaliser à volonté les vérifications.

Ajouter ou supprimer une contrainte CHECK après la création d’une table

Si votre table existe déjà, vous pouvez ajouter une contrainte CHECK avec cette commande :

ALTER TABLE produits
ADD CONSTRAINT check_prix_pos CHECK (prix > 0);

Et pour la supprimer :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

ALTER TABLE produits
DROP CONSTRAINT check_prix_pos;

(Note : la syntaxe exacte peut varier selon le SGBD utilisé.)

CHECK vs validation PHP (et pourquoi les deux sont utiles)

Quand on débute en SQL (ou même quand on commence à structurer correctement ses projets), une question revient souvent : “Si je valide déjà mes données en PHP, est-ce que j’ai vraiment besoin d’un CHECK en base de données ?”

Et la réponse est simple : oui, dans l’idéal vous avez besoin des deux, parce qu’ils ne protègent pas la même chose… et surtout pas au même moment.

La validation PHP : la sécurité côté application

La validation en PHP sert à protéger votre application côté serveur, au moment où vous recevez les données d’un formulaire ou d’une requête HTTP.

Concrètement, c’est ici que vous allez vérifier des choses comme :

• est-ce que le champ est rempli ?
• est-ce que c’est bien un nombre ?
• est-ce que la valeur respecte vos règles métier (ex : âge minimum, prix positif, etc.) ?
• est-ce que la donnée est cohérente et “logique” ?

Par exemple, si vous récupérez un âge :

$age = (int) $_POST['age'];

if ($age < 18) {
  die("Erreur : vous devez avoir au moins 18 ans.");
}

Cette validation est indispensable pour une raison très simple : le front (HTML/JS) peut être contourné, et c’est votre serveur qui doit rester le juge final.

Le CHECK : la sécurité côté base de données

Le problème, c’est que même avec un bon code PHP, il peut toujours arriver quelque chose :

• un bug dans votre code
• un oubli lors d’une mise à jour
• un autre script qui écrit dans la base (import, API, plugin, admin…)
• un collègue (ou vous-même dans 6 mois) qui fait un INSERT “trop vite”

Et là, si la base n’a aucune règle, elle va accepter les données, même si elles sont absurdes. C’est exactement là que CHECK devient intéressant : il impose une règle directement au niveau SQL, dans la table :

CREATE TABLE utilisateurs (
  id INT AUTO_INCREMENT PRIMARY KEY,
  age INT NOT NULL,
  CHECK (age >= 18)
);

Si quelqu’un tente d’insérer un âge invalide, la base dit non. Même si PHP laisse passer.
Et ça, c’est très rassurant, parce que vos données restent propres sur la durée.

Les deux ne sont pas en concurrence, ils travaillent ensemble

Pour retenir l’idée simplement :

• La validation PHP sécurise votre application (côté serveur).
• Le CHECK sécurise vos données (côté base).

Et le duo est redoutable : PHP filtre et explique proprement l’erreur à l’utilisateur, pendant que la base empêche les valeurs incohérentes de rentrer “quoi qu’il arrive”. En clair, PHP améliore la logique et le contrôle, et CHECK renforce la fiabilité.

Comment vérifier la version MySQL ?

Avant de vous appuyer sur CHECK en production, il y a une étape toute simple (mais très importante) à faire : vérifier la version de MySQL que vous utilisez.

Pourquoi ? Parce que, selon la version, CHECK peut être :

• soit réellement appliqué (ce qu’on veut)
• soit accepté mais ignoré (et là c’est piégeux)

La requête la plus simple du monde

Pour connaître votre version MySQL, vous pouvez exécuter :

SELECT VERSION();

Cette commande retourne votre version exacte, par exemple :

• 8.0.36
• 5.7.41
• etc.

Pourquoi c’est important ?

À partir de MySQL 8.0.16, les contraintes CHECK sont correctement prises en compte et appliquées. Donc si vous êtes sur une version récente, vous pouvez utiliser CHECK sans mauvaise surprise.

En revanche, sur des versions plus anciennes, MySQL peut très bien :

• accepter votre table
• accepter votre contrainte CHECK
• mais ne pas la faire respecter à l’insertion…

Et là, vous pensez être protégé… alors qu’en réalité, non.

La bonne habitude à prendre

Si vous codez un projet, ou même une application en production, la meilleure habitude à prendre est très simple :

1. vous vérifiez votre version avec SELECT VERSION();
2. vous testez une insertion invalide
3. vous confirmez que la base refuse bien la donnée

C’est rapide, efficace, et ça vous évite les mauvaises surprises.

Vérification des contraintes dans PhpMyAdmin ou MySQL Workbench

Si vous travaillez avec des outils comme PhpMyAdmin ou MySQL Workbench (Site officiel), les contraintes CHECK peuvent parfois ne pas s’afficher directement dans l’interface (surtout sur les anciennes versions de MySQL).

Dans ce cas, utilisez la commande :

SHOW CREATE TABLE nom_table;

Cela vous montrera toutes les contraintes, y compris les CHECK définies dans le schéma de votre table.

CHECK et performances

Contrairement à ce que l’on pourrait croire, les contraintes CHECK n’impactent pas fortement les performances. Elles sont très rapides car exécutées directement dans le moteur SQL. Elles permettent même d’éviter des traitements supplémentaires dans votre code (PHP, JavaScript, etc.).

Résumé : Ce qu’il faut retenir

• La contrainte CHECK en SQL permet de valider les données à l’entrée selon vos propres règles.
• Elle s’utilise pour des colonnes uniques ou pour plusieurs colonnes combinées.
• Elle renforce la sécurité, la cohérence et l’automatisation dans vos bases de données.
• Elle est prise en charge par la plupart des systèmes, sauf certaines versions anciennes de MySQL.
• Elle peut s’ajouter à tout moment avec une commande ALTER TABLE.

Tableau comparatif : CHECK vs ENUM en SQL

Critère	CHECK	ENUM
Définition	Contrainte qui impose une condition logique sur les valeurs	Type de données spécifique qui limite les valeurs à une liste prédéfinie
Type de fonctionnalité	Contrainte (restriction)	Type de données (spécifique à certaines bases de données comme MySQL)
Syntaxe simple	CHECK (valeur > 0) ou CHECK (statut IN ('actif','inactif'))	statut ENUM('actif','inactif')
Support multi-SGBD	Large compatibilité (PostgreSQL, SQL Server, Oracle, SQLite, MySQL ≥ 8)	Limité : principalement MySQL, non standard en PostgreSQL ou SQLite
Flexibilité	Très flexible (opérations mathématiques, logique entre colonnes)	Moins flexible, uniquement une liste figée de valeurs
Lisibilité	Plus explicite pour les conditions complexes	Plus compact pour des valeurs fixes et simples
Modification des valeurs	Facile à modifier avec ALTER TABLE et DROP CONSTRAINT	Modification plus contraignante (nécessite recréation du champ dans MySQL)
Portabilité	✔️ Compatible avec SQL standard	❌ Peu portable : ENUM est une extension MySQL
Performance	Légèrement plus lente que ENUM (validation à chaque insertion)	Très rapide (stocké comme index interne en MySQL)
Cas d’usage idéal	Règles métiers complexes (âge > 18, date_debut < date_fin, etc.)	Liste fermée de choix simples (sexe, statut, type, catégorie…)
Validation croisée	✔️ Possible entre plusieurs colonnes	❌ Impossible (ne concerne qu’un champ)

Vous pouvez également consultez notre tutoriel : Tout savoir sur le type ENUM.

Exemple avec CHECK :

CREATE TABLE utilisateurs (
    id INT,
    age INT CHECK (age >= 18)
);

Exemple avec ENUM (MySQL uniquement) :

CREATE TABLE utilisateurs (
    id INT,
    statut ENUM('actif', 'inactif', 'banni')
);

• Utilisez CHECK si vous avez besoin de conditions logiques ou de comparaisons complexes.
• Utilisez ENUM si vous avez besoin d’un champ à valeurs fixes limitées, uniquement avec MySQL.

Si vous développez une application que vous souhaitez facilement transférer entre plusieurs bases de données, privilégiez CHECK car il est plus universel.

Souhaitez-vous intégrer ce tableau directement dans votre article sur le blog Crea-Troyes ? Je peux aussi le convertir en HTML si vous le souhaitez.

Utiliser la contrainte CHECK en SQL, c’est anticiper les erreurs et garantir la qualité de vos données. Dans un monde où la donnée est au cœur des systèmes, cette clause est un outil simple mais puissant que tout développeur ou administrateur de base devrait connaître.

Si vous débutez avec SQL, n’hésitez pas à expérimenter dans un environnement local ou avec des outils comme Adminer, MySQL Workbench ou PhpMyAdmin. Testez différentes contraintes, provoquez volontairement des erreurs pour mieux comprendre leur effet. C’est en pratiquant que vous assimilerez vraiment leur utilité.

Allez plus loin avec SQL / MySQL :

• PhpMyAdmin : Importer une BDD
• Shéma relationnel : CDM, LDM, ERD et PDM pour MySQL
• Liste complète des requêtes SQL
• Clé et Index SQL / MySQL
• Le type ENUM en SQL
• La requête JOIN en SQL
• Trigger et Stored procedure MySQL
• Le type BLOB en MySQL
• Exporter BDD au format CSV en PHP