Insertion de données dans des tables avec des contraintes : NOT NULL, DEFAULT

Aujourd'hui, on va décortiquer un autre aspect super important du boulot avec les bases de données — comment insérer des données dans des tables qui ont les contraintes NOT NULL et DEFAULT. À ce stade, tu connais déjà la base de la commande INSERT INTO et tu piges comment ajouter des lignes dans des tables avec une structure définie. Maintenant, on va rentrer dans les détails — parce que bosser avec les contraintes, c'est souvent là que ça coince pour les devs. Mais t'inquiète, à la fin de la leçon, tu vas gérer ça comme un chef !

C'est quoi, les contraintes ?

Les contraintes, c'est des règles qu'on applique aux colonnes d'une table. Elles servent à garder les données dans un état logique et cohérent. Par exemple, tu peux pas laisser vide un champ qui doit obligatoirement contenir une valeur (NOT NULL), ou alors tu peux ne pas préciser une valeur pour une colonne si une valeur par défaut est déjà définie (DEFAULT).

Types de contraintes : - NOT NULL — indique que la colonne ne peut pas contenir NULL. - DEFAULT — définit une valeur qui sera automatiquement insérée dans la colonne si tu ne la précises pas.

Les contraintes aident à garder l'intégrité des données. Imagine que tu stockes une liste d'étudiants dans la table students, et une des règles, c'est que chaque étudiant doit absolument avoir un nom (NOT NULL). Sans cette contrainte, quelqu'un va oublier de mettre le nom, et tu te retrouves avec un "étudiant sans nom" dans la base. Autre exemple : tu décides que la valeur standard pour le nombre de crédits d'un nouveau cours, c'est 0 (DEFAULT), comme ça tu te prends pas la tête à chaque fois.

Travailler avec la contrainte NOT NULL

La contrainte NOT NULL t'oblige à mettre une valeur dans une colonne précise quand tu ajoutes une ligne. Si tu essaies d'insérer NULL dans cette colonne ou que tu la laisses vide, la base de données va "faire la gueule" (tu vas avoir une erreur). On va voir un exemple.

Créons une table simple students :

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,     -- Le nom ne peut pas être vide
    age INT
);

Regarde bien : la colonne name a la contrainte NOT NULL, alors que la colonne age n'a pas de contrainte.

Exemple d'insertion avec NOT NULL

Maintenant, on va essayer d'ajouter des étudiants :

-- Exemple d'insertion réussie
INSERT INTO students (name, age) VALUES ('Alice', 23);
-- Succès : le nom est précisé, la colonne respecte la contrainte NOT NULL

-- Exemple d'erreur :
INSERT INTO students (age) VALUES (30);
-- Erreur : la colonne name ne peut pas être NULL, car elle a la contrainte NOT NULL

Quand tu vois une erreur du genre null value in column "name" violates not-null constraint, panique pas — c'est juste PostgreSQL qui te rappelle de faire gaffe.

Utiliser les valeurs par défaut (DEFAULT)

La contrainte DEFAULT dit à la base de données : "Si jamais tu oublies de préciser une valeur pour cette colonne, utilise celle-là". Ça simplifie la vie des devs, parce que t'es pas obligé de remplir chaque champ à la main.

Exemple de table avec la contrainte DEFAULT

Créons la table courses :

CREATE TABLE courses (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    credits INT DEFAULT 0   -- Valeur par défaut pour la colonne credits — 0
);

Exemple d'insertion avec DEFAULT

On va maintenant ajouter des cours :

-- On précise explicitement la valeur de credits
INSERT INTO courses (name, credits) VALUES ('Mathematics', 5);

-- On ne précise pas la valeur de credits — la valeur par défaut (0) sera utilisée
INSERT INTO courses (name) VALUES ('History');

-- Voyons le résultat
SELECT * FROM courses;

Résultat :

Regarde bien : quand on a ajouté le cours History, on n'a pas précisé le nombre de crédits. PostgreSQL a automatiquement mis 0 dans la colonne credits.

Utiliser ensemble les contraintes NOT NULL et DEFAULT

Ces colonnes exigent une valeur, même si tu la précises pas toi-même. Par exemple, dans la table courses, la colonne credits peut être à la fois DEFAULT et NOT NULL, pour garantir que personne ne la laisse vide par accident (NULL).

CREATE TABLE courses (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    credits INT NOT NULL DEFAULT 0
);

Exemple d'insertion

Imaginons que chaque nouveau cours doit avoir par défaut 0 crédits, mais NULL n'est pas autorisé.

-- OK : credits prend la valeur par défaut
INSERT INTO courses (name) VALUES ('Physics');

-- Erreur : tentative d'insérer explicitement NULL dans une colonne NOT NULL
INSERT INTO courses (name, credits) VALUES ('Chemistry', NULL);

Exemple : Ajouter un étudiant avec un nom obligatoire

Créons la table students avec des contraintes :

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,                         -- Le nom est obligatoire
    enrollment_date DATE DEFAULT CURRENT_DATE   -- Date d'inscription par défaut — aujourd'hui
);

Ajoutons maintenant des étudiants :

-- Le nom est précisé, la date d'inscription sera remplie automatiquement
INSERT INTO students (name) VALUES ('Bob');

-- Essayons de ne pas préciser le nom (on aura une erreur)
INSERT INTO students (enrollment_date) VALUES ('2024-10-01');

Un super exemple de comment PostgreSQL t'aide à garantir la validité des données : tous les étudiants ont forcément un nom, et la date d'inscription n'a pas besoin d'être précisée à chaque fois.

Conseils et pièges à éviter

Quand tu bosses avec les contraintes NOT NULL et DEFAULT, retiens quelques trucs importants. Par exemple, si t'as souvent des NULL dans tes données, la contrainte NOT NULL peut vite devenir un vrai casse-tête. Et si tu mets une valeur par défaut pour toutes les colonnes, tu risques d'avoir des données pas très cohérentes (genre 0 au lieu d'une vraie valeur).

En général, si tu ajoutes une nouvelle colonne à une table existante, ses cellules pour les lignes déjà présentes seront remplies avec NULL. Mais si tu mets DEFAULT X, toute la colonne sera remplie avec la valeur X. C'est super pratique, et ça aide à garder la base cohérente.

Par exemple, une nouvelle colonne — c'est une FOREIGN KEY vers une table existante. Et elle ne peut pas contenir NULL ou 0. Elle doit pointer vers des lignes existantes de la table cible.

Que faire si t'as oublié d'ajouter des contraintes ?

Pas de panique — tu peux toujours ajouter des contraintes plus tard avec la commande ALTER TABLE. Par exemple :

-- Ajouter une contrainte DEFAULT à une colonne existante
ALTER TABLE courses ALTER COLUMN credits SET DEFAULT 0;

-- Ajouter une contrainte NOT NULL à une colonne existante
ALTER TABLE students ALTER COLUMN name SET NOT NULL;

Ces requêtes ne vont pas casser les données déjà présentes — tu peux les utiliser sur des tables qui contiennent déjà des trucs importants.

Maintenant, t'es prêt à utiliser toute la puissance de PostgreSQL pour gérer les contraintes ! Tes données seront plus structurées, protégées contre les erreurs, et tes requêtes seront logiques et prévisibles.