Clés étrangères : FOREIGN KEY

Imagine que tu as deux tables : une avec les infos sur les étudiants et une autre avec les infos sur les cours. Tu te demandes comment on peut indiquer quels étudiants sont inscrits à quels cours ? Tu pourrais ajouter une colonne dans la table des étudiants pour stocker tous les cours auxquels ils sont inscrits, mais ça va vite devenir le bazar. Une des meilleures solutions, c'est d'utiliser les clés étrangères !

Une clé étrangère (FOREIGN KEY), c'est une colonne ou un groupe de colonnes qui sert à créer un lien entre des tables. Elle pointe vers une colonne (souvent un PRIMARY KEY) dans une autre table, ce qui garantit l'intégrité référentielle des données entre elles. Donc, si un étudiant est inscrit à un cours, on peut être sûr que ce cours existe vraiment.

Les clés étrangères :

• Aident à garder l'intégrité des données, en garantissant que les enregistrements d'une table correspondent à ceux d'une autre.
• Rendent la base de données plus claire et logique.
• Facilitent la gestion des données, évitent les doublons et les erreurs.

Exemple dans la vraie vie

Imagine une bibliothèque. La table books contient la liste des livres, et la table members — la liste des lecteurs. Pour suivre qui a emprunté quel livre, on peut créer une table borrowed_books qui va faire référence à books et members via des clés étrangères. Comme ça, à chaque fois que quelqu'un prend un livre, on sait exactement qui c'est et quel livre il a pris.

Types de relations entre les tables

Les clés étrangères permettent de décrire différents types de relations entre les tables. Voyons les trois principaux types :

1. Relation "Un-à-Un" (ONE-TO-ONE)

C'est la relation la plus simple, où un enregistrement dans une table correspond exactement à un enregistrement dans une autre table. Par exemple, la table users peut contenir des infos sur les utilisateurs, et la table profiles peut contenir des infos supplémentaires, comme leurs adresses ou leurs photos.

Exemple SQL pour une relation ONE-TO-ONE :

CREATE TABLE users (
    user_id SERIAL PRIMARY KEY,
    username TEXT NOT NULL
);

CREATE TABLE profiles (
    profile_id SERIAL PRIMARY KEY,
    user_id INT UNIQUE REFERENCES users(user_id), -- référence à users.user_id
    address TEXT
);

Ici, la colonne user_id dans la table profiles joue le rôle de clé étrangère qui pointe vers user_id dans la table users.

Exemple de table users :

Exemple de table profiles :

2. Relation "Un-à-Plusieurs" (ONE-TO-MANY)

C'est la relation la plus courante. Par exemple, un client peut passer plusieurs commandes. Dans ce cas, la table customers sera liée à la table orders grâce à une clé étrangère.

Exemple SQL pour une relation ONE-TO-MANY :

CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id),	-- référence à customers.customer_id
    order_date DATE NOT NULL
);

La table orders peut contenir plusieurs enregistrements qui pointent vers un seul enregistrement dans la table customers

Exemple de table customers :

Exemple de table orders :

3. Relation "Plusieurs-à-Plusieurs" (MANY-TO-MANY)

Parfois, un enregistrement dans une table peut être lié à plusieurs enregistrements dans une autre table, et inversement. Par exemple, les étudiants s'inscrivent à des cours, et un cours peut avoir plein d'étudiants. Pour ça, on crée généralement une table intermédiaire.

Exemple SQL pour une relation MANY-TO-MANY :

-- étudiants
CREATE TABLE students (
    student_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

-- cours
CREATE TABLE courses (
    course_id SERIAL PRIMARY KEY,
    title TEXT NOT NULL
);

-- "inscription d'un étudiant à un cours"
CREATE TABLE enrollments (
    student_id INT REFERENCES students(student_id), -- référence à id-étudiant
    course_id INT REFERENCES courses(course_id),	-- référence à id-cours
    PRIMARY KEY (student_id, course_id)
);

Ici, la table enrollments joue le rôle de "pont" entre les tables students et courses.

Exemple de table students :

Exemple de table courses :

Exemple de table enrollments :

Avantages d'utiliser les clés étrangères

1. Les données restent cohérentes. Si une clé étrangère pointe vers un enregistrement qui n'existe pas, PostgreSQL ne te laissera pas insérer ou mettre à jour les données.
2. Ça simplifie le boulot avec les tables. Les clés étrangères permettent de relier facilement les données entre les tables et de faire des requêtes complexes, comme les JOIN.
3. Comportement automatique. Tu peux configurer ce qui se passe quand tu supprimes ou modifies des enregistrements liés (genre suppression en cascade, mettre NULL, etc.).

À quoi ressemble une clé étrangère dans PostgreSQL ?

La syntaxe pour créer une clé étrangère lors de la création d'une table :

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id)   -- clé étrangère
);

Ici :

• customer_id — c'est la clé étrangère.
• Elle fait référence à customer_id dans la table customers.

Tu peux aussi déclarer explicitement la clé étrangère avec FOREIGN KEY :

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

Fun fact

Le terme "clé étrangère" (FOREIGN KEY) vient de la théorie des bases de données relationnelles, inventée dans les années 1970 par Edgar Codd. C'est ouf, mais l'idée de base est tellement puissante qu'elle reste un élément clé des bases de données modernes. Qui a dit que les classiques, c'était dépassé ?

Maintenant tu piges ce que c'est une clé étrangère et pourquoi c'est si important. Tu vas encore apprendre comment les créer quand tu fais des tables et comment bien utiliser les opérations en cascade. Mais ça, c'est pour les prochaines leçons !