Utiliser les sous-requêtes dans FROM

On va descendre encore plus loin dans le terrier du lapin : voyons comment utiliser les sous-requêtes dans la clause FROM. C’est l’une des techniques préférées des devs SQL, parce que ça permet de créer des tables temporaires super puissantes directement "sur place" et de les réutiliser comme si elles existaient vraiment dans la base.

Imagine que tu dois faire un rapport qui demande des calculs, des groupements ou des filtres sur les données, mais tu n’as pas envie de créer des tables temporaires sur le serveur. Tu fais quoi ? C’est là que les sous-requêtes dans FROM sauvent la mise. Elles te permettent de :

• Fusionner ou agréger des données temporairement avant la requête principale.
• Créer des ensembles de données structurés "à la volée".
• Réduire le nombre d’opérations, en demandant à la base de stocker un minimum de données intermédiaires.

Les sous-requêtes dans FROM agissent comme des mini-tables que tu peux utiliser dans ta requête principale. C’est un peu comme construire un Lego modulaire : rapide, flexible et sans prise de tête inutile :)

Bases des sous-requêtes dans FROM

Dans les sous-requêtes FROM, on utilise une sous-requête pour créer une table temporaire (ou sous-table) qui devient une partie de la requête globale. Pour ça, il faut faire trois étapes clés :

1. Écrire la sous-requête dans la clause FROM entre parenthèses.
2. Donner un alias (pseudo-nom) à la sous-requête.
3. Utiliser cet alias comme si c’était une vraie table.

Syntaxe

SELECT colonnes
FROM (
    SELECT colonnes
    FROM table
    WHERE condition
) AS alias
WHERE condition_externe;

Ça fait un peu peur ? Allez, on passe aux exemples.

Exemple : Étudiants et moyenne des notes

Imaginons qu’on a deux tables :

students (infos sur les étudiants — leur nom et ID) :

grades (infos sur les notes des étudiants) :

Maintenant, objectif : obtenir la liste des étudiants et leur moyenne de notes.

On peut commencer par une sous-requête simple qui calcule la moyenne de chaque étudiant, puis l’utiliser dans la requête principale.

SELECT s.student_name, g.avg_grade
FROM (
    SELECT student_id, AVG(grade) AS avg_grade
    FROM grades
    GROUP BY student_id
) AS g
JOIN students AS s ON s.student_id = g.student_id;

Résultat :

Tables temporaires "à la volée"

Les sous-requêtes dans FROM sont super utiles quand tu dois faire plus d’un niveau de traitement des données. Par exemple, si tu veux pas juste la moyenne, mais aussi la note max de chaque étudiant — tout ça dans une seule requête.

SELECT g.student_id, g.avg_grade, g.max_grade
FROM (
    SELECT student_id, 
           AVG(grade) AS avg_grade, 
           MAX(grade) AS max_grade
    FROM grades
    GROUP BY student_id
) AS g;

Résultat :

Remarque que ça marche comme une vraie table temporaire avec ses propres colonnes : avg_grade et max_grade.

Quand utiliser les sous-requêtes dans FROM ?

Pour les données agrégées. Si tu veux d’abord faire des calculs (genre moyenne, somme ou max), puis joindre les résultats à d’autres tables.

Pour filtrer les données. Quand tu dois filtrer avant de joindre avec la table principale.

Pour simplifier les requêtes complexes. Découper les tâches compliquées en étapes, ça évite de se perdre.

Exemple : Rapport sur les étudiants avec deux niveaux de traitement

Imaginons qu’on veut trouver les étudiants qui ont une moyenne supérieure à 80. On commence par une sous-requête qui calcule les moyennes, puis on l’utilise dans le filtre.

SELECT s.student_name, g.avg_grade
FROM students AS s
JOIN (
    SELECT student_id, AVG(grade) AS avg_grade
    FROM grades
    GROUP BY student_id
) AS g ON s.student_id = g.student_id
WHERE g.avg_grade > 80;

Résultat :

Particularités et conseils d’utilisation

Alias obligatoire. Donne toujours un alias à ta sous-requête (genre AS g), sinon PostgreSQL va râler parce qu’il saura pas comment appeler cette "table temporaire".

Optimisation. Les sous-requêtes dans FROM peuvent être plus lentes que les jointures (JOIN), surtout si tu filtres à l’intérieur de la sous-requête.

Indexation. Vérifie que les champs utilisés pour les jointures, les index et les filtres sont optimisés — ça change tout pour les perfs.

Exemple de requête complexe : cours et nombre d’étudiants

Maintenant, on va faire un vrai exercice un peu plus costaud. Imagine qu’on a cette table :

courses (liste des cours) :

Et enrollments (inscriptions des étudiants aux cours) :

Maintenant, on veut savoir combien d’étudiants sont inscrits à chaque cours.

SELECT c.course_name, e.students_count
FROM courses AS c
JOIN (
    SELECT course_id, COUNT(student_id) AS students_count
    FROM enrollments
    GROUP BY course_id
) AS e ON c.course_id = e.course_id;

Résultat :

J’espère que la leçon t’a plu... mais la prochaine sera encore plus fun :)