Modélisation de la relation ONE-TO-MANY entre les tables

Il est temps d'améliorer nos skills et de créer l'une des relations les plus fréquentes dans les bases de données relationnelles — la relation ONE-TO-MANY.

Imagine une petite boîte. Un employé ne peut bosser que dans un seul département, mais un département peut avoir des dizaines d'employés. On a donc deux objets du monde réel : employés et départements. La relation entre eux peut se décrire comme "un département peut inclure plein d'employés", ou plus formellement "un à plusieurs" (ONE-TO-MANY).

Exactement pareil, les relations ONE-TO-MANY sont partout :

• un client peut passer plein de commandes ;
• un auteur peut écrire plein de livres ;
• un prof peut enseigner à plusieurs étudiants.

Dans une base de données relationnelle, la relation ONE-TO-MANY se fait via une clé étrangère (FOREIGN KEY). Une des colonnes de la table "plusieurs" (MANY) pointe vers la clé primaire de la table "un" (ONE).

Comment créer une relation ONE-TO-MANY

Regardons un exemple classique : la relation entre clients et commandes. Un client peut passer plusieurs commandes, mais chaque commande est liée à un seul client. On va créer deux tables : customers (clients) et orders (commandes).

Table customers

C'est notre table "un". Elle va stocker les infos sur les clients.

CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY, -- Identifiant unique du client
    name TEXT NOT NULL              -- Nom du client
);

Table orders

C'est la table "plusieurs". Elle stocke les commandes, où chaque commande a une clé étrangère customer_id qui pointe vers customer_id de la table customers.

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,           -- Identifiant unique de la commande
    order_date DATE NOT NULL,              -- Date de la commande
    customer_id INT REFERENCES customers(customer_id) -- Clé étrangère
);

Application pratique

Insertion de données

Maintenant, on va ajouter quelques données dans nos tables pour tester la relation.

Ajoutons des clients dans la table customers :

INSERT INTO customers (name)
VALUES
    ('Ada Lovelace'),
    ('Grace Hopper'),
    ('Linus Torvalds');

Résultat :

Ajoutons des commandes dans la table orders :

INSERT INTO orders (order_date, customer_id)
VALUES
    ('2023-10-01', 1),  -- Commande d'Ada
    ('2023-10-02', 2),  -- Commande de Grace
    ('2023-10-03', 1);  -- Encore une commande d'Ada

Table orders :

Fais gaffe : quand tu ajoutes une commande, il faut absolument mettre un customer_id qui existe. Si tu tentes de mettre un ID qui n'existe pas, la base va te balancer une erreur. C'est pour protéger l'intégrité des données.

Vérification de la relation

Voyons maintenant comment nos tables sont liées. Par exemple, on demande : quelles commandes a passé Ada Lovelace ?

SELECT orders.order_id, orders.order_date, customers.name
FROM orders
JOIN customers ON orders.customer_id = customers.customer_id
WHERE customers.name = 'Ada Lovelace';

Résultat :

Ici, on a utilisé la commande JOIN pour combiner les deux tables grâce à la clé étrangère. Pratique, propre — et pas de données dupliquées !

Pourquoi c'est utile

La relation ONE-TO-MANY est ultra courante et super utile dans la vraie vie. Imagine un site e-commerce avec des milliers de clients et des millions de commandes. Au lieu de répéter les infos du client dans chaque commande, on garde les infos uniques des clients dans une table, et les commandes dans une autre. Ça réduit la taille des données et rend la base plus clean.

En plus, pouvoir relier les données permet de faire des requêtes puissantes pour l'analyse. Par exemple, tu peux demander : "Combien de commandes chaque client a-t-il passées ?" ou "Quels clients ont passé des commandes le mois dernier ?".

Pièges et difficultés

Voilà où les débutants se plantent souvent :

Absence de clé étrangère. Si tu oublies de mettre une clé étrangère dans la table "plusieurs", la relation sera juste logique (dans ta tête), mais la base ne pourra pas l'appliquer en vrai. Du coup, tu risques d'avoir une base "cassée", où des commandes pointent vers des clients qui n'existent pas.

Essayer de supprimer une ligne de la table "un". Par exemple, si tu supprimes un client de customers, ses commandes dans orders vont devenir "orphelines". Pour éviter ça, tu peux utiliser ON DELETE CASCADE, comme ça quand tu supprimes un client, ses commandes partent avec lui automatiquement.

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    order_date DATE NOT NULL,
    customer_id INT REFERENCES customers(customer_id) ON DELETE CASCADE
);

Maintenant, si tu supprimes un client :

DELETE FROM customers WHERE customer_id = 1;

Toutes ses commandes seront supprimées aussi. La base sera clean, comme une bonne tasse de café fraîchement préparée.

Erreurs d'insertion de données. Si tu essaies d'insérer une commande avec un customer_id qui n'existe pas, tu vas avoir une erreur du genre :

ERROR:  insert or update on table "orders" violates foreign key constraint