Plusieurs JOIN dans une seule requête

Imagine que chaque table dans ta base, c’est une pièce d’un gros puzzle. La table des étudiants sait qui étudie, la table des cours — ce qu’on enseigne, et la table des inscriptions — qui est inscrit à quoi. Mais séparément, ces morceaux ne disent pas grand-chose. Tu veux voir l’image complète ? Il faut les assembler — et c’est là que le multiple JOIN entre en scène.

Dans la vraie vie, les données sont souvent organisées dans des tables liées pour garder une structure propre et éviter la redondance. Par exemple, dans notre base universitaire, on a les tables suivantes :

• students — données sur les étudiants.
• enrollments — infos sur les inscriptions des étudiants aux cours.
• courses — infos sur les cours.

Si on veut la liste complète des étudiants, leurs cours et les profs, il faut joindre les trois tables avec JOIN.

Ordre d’exécution des JOIN

Quand tu utilises plusieurs JOIN, PostgreSQL les traite de gauche à droite. Ça veut dire qu’il commence par joindre les deux premières tables, puis le résultat est joint à la troisième, et ainsi de suite.

Exemple :

SELECT *
FROM students
    INNER JOIN enrollments ON students.id = enrollments.student_id
    INNER JOIN courses ON enrollments.course_id = courses.id;

1. D’abord, les tables students et enrollments sont jointes sur la colonne students.id = enrollments.student_id.
2. Le résultat de cette jointure est utilisé pour joindre la table courses sur la colonne enrollments.course_id = courses.id.

L’ordre d’exécution est super important quand tu bosses avec de grosses tables. Une mauvaise structure de JOIN peut vraiment plomber les perfs.

Exemple : Liste des étudiants, de leurs cours et des profs

Imaginons qu’on a les tables suivantes avec des données :

Table students :

Table courses :

Table enrollments :

Requête :

SELECT
    students.name AS student_name,
    courses.name AS course_name,
    courses.teacher AS teacher_name
FROM students
    INNER JOIN enrollments ON students.id = enrollments.student_id
    INNER JOIN courses ON enrollments.course_id = courses.id;

Résultat :

Filtrage dans les requêtes avec plusieurs JOIN

Tu peux appliquer des conditions de filtrage dans les requêtes avec JOIN pour limiter le nombre de résultats et accélérer la requête. Par exemple, si tu veux afficher seulement les étudiants inscrits au cours "Mathematics" :

SELECT
    students.name AS student_name,
    courses.name AS course_name
FROM students
    INNER JOIN enrollments ON students.id = enrollments.student_id
    INNER JOIN courses ON enrollments.course_id = courses.id
WHERE courses.name = 'Mathematics';

Résultat :

Optimisation des requêtes avec plusieurs JOIN

Quand tu bosses avec de grosses tables, optimiser tes requêtes devient super important. Voilà quelques tips :

1. Utilise des index

Les index permettent à PostgreSQL d’aller plus vite, surtout quand tu joins sur des champs clés. Vérifie que tu as des index sur les colonnes student_id et course_id dans la table enrollments.

Exemple de création d’index :

CREATE INDEX idx_enrollments_student_id ON enrollments(student_id);
CREATE INDEX idx_enrollments_course_id ON enrollments(course_id);

Tu verras plus de détails sur les index dans les prochains niveaux, mais je voulais quand même en parler ici. Ils sont très souvent liés aux JOIN.

2. Filtre les données le plus tôt possible

Utilise des conditions WHERE pour réduire le nombre de lignes à traiter avant de faire le JOIN. Par exemple :

SELECT
    students.name AS student_name,
    courses.name AS course_name
FROM students
    INNER JOIN enrollments ON students.id = enrollments.student_id
    INNER JOIN courses ON enrollments.course_id = courses.id
WHERE 
    courses.teacher = 'Ivan Petrov';

3. Minimise le nombre de lignes à joindre

Au lieu de joindre toutes les lignes de deux tables, essaye d’abord de les filtrer avec des sous-requêtes :

SELECT
    students.name AS student_name,
    courses.name AS course_name
FROM 
    (SELECT * FROM students WHERE id IN (1, 2)) sub_students
INNER JOIN enrollments ON sub_students.id = enrollments.student_id
INNER JOIN courses ON enrollments.course_id = courses.id;

Tu verras plus sur les SELECT imbriqués littéralement au prochain niveau :P

Exemple de jointure complexe : étudiants, cours et facultés

Imaginons qu’on ajoute une table faculties :

Table faculties :

Table courses mise à jour :

Pour avoir la liste des étudiants, des cours et des facultés, on ajoute encore un JOIN :

SELECT
    students.name AS student_name,
    courses.name AS course_name,
    faculties.name AS faculty_name
FROM students
    INNER JOIN enrollments ON students.id = enrollments.student_id
    INNER JOIN courses ON enrollments.course_id = courses.id
    INNER JOIN faculties ON courses.faculty_id = faculties.id;

Résultat :

Les requêtes SQL avec plusieurs JOIN peuvent être costaudes, mais elles permettent de faire des rapports puissants et de sortir des infos précieuses. Si tu les optimises et structures bien, ça devient ton outil ultime pour gérer de grosses bases de données.