Pourquoi maîtriser ces requêtes SQL est crucial pour le Bac NSI ?
Salut ! Si tu es en spécialité NSI, tu le sais : la partie bases de données et SQL est un pilier de l'épreuve écrite du Bac. Elle représente souvent un exercice complet, noté sur un bon nombre de points. La clé pour réussir ? Ne pas se contenter de lire le cours, mais s'entraîner sur des requêtes types. Ces exercices te permettent de comprendre la logique derrière le langage SQL et de gagner en rapidité le jour J. Dans cet article, on va décortiquer ensemble les requêtes les plus fréquemment demandées, avec des exemples concrets basés sur un schéma de base de données classique.
Le schéma de base de données de référence pour nos exercices
Pour que tout soit clair, on va travailler avec une base de données simplifiée d'une bibliothèque. Voici les tables :
- Livres (id_livre, titre, auteur, annee_publication, id_genre)
- Genres (id_genre, nom_genre)
- Emprunts (id_emprunt, id_livre, id_usager, date_emprunt, date_retour)
- Usagers (id_usager, nom, prenom, classe)
Les clés primaires sont en italique. id_genre dans la table Livres est une clé étrangère qui fait référence à la table Genres. De même, id_livre et id_usager dans Emprunts sont des clés étrangères. Garde ce schéma en tête, c'est notre terrain de jeu pour la suite !
Exercice 1 : Les requêtes de base (SELECT, WHERE, ORDER BY, LIMIT)
C'est le B.A.-BA. Le correcteur vérifie que tu maîtrises la structure fondamentale d'une requête.
Corrigé 1.1 : Sélection et filtrage simple
Énoncé : Affiche le titre et l'auteur de tous les livres publiés après 2010, triés par titre par ordre alphabétique.
Correction & Explication :
SELECT titre, auteur FROM Livres WHERE annee_publication > 2010 ORDER BY titre ASC;
Ici, on utilise WHERE pour filtrer les lignes selon une condition (annee_publication > 2010). ORDER BY permet de trier le résultat. ASC (ascendant) est l'ordre par défaut, tu peux l'omettre. Pour un tri inverse, utilise DESC.
Corrigé 1.2 : Limiter les résultats et utiliser des opérateurs
Énoncé : Trouve les 5 premiers usagers (nom et prénom) dont le nom commence par 'D' ou 'M'.
Correction & Explication :
SELECT nom, prenom FROM Usagers WHERE nom LIKE 'D%' OR nom LIKE 'M%' ORDER BY nom LIMIT 5;
Points clés : L'opérateur LIKE avec le joker % (qui remplace n'importe quelle suite de caractères) permet de faire une recherche par motif. L'opérateur OR combine deux conditions. LIMIT est essentiel pour restreindre le nombre de lignes retournées, très utile sur de grosses tables.
Exercice 2 : Les jointures (INNER JOIN, LEFT JOIN) et le regroupement (GROUP BY)
C'est souvent la partie la plus délicate, mais aussi la plus importante. Les jointures permettent de croiser les informations de plusieurs tables.
Corrigé 2.1 : Jointure simple pour afficher des informations liées
Énoncé : Affiche le titre des livres et le nom de leur genre correspondant.
Correction & Explication :
SELECT Livres.titre, Genres.nom_genre FROM Livres INNER JOIN Genres ON Livres.id_genre = Genres.id_genre;
On utilise INNER JOIN pour lier la table Livres à la table Genres. La condition de jointure (ON) précise que l'id_genre doit correspondre dans les deux tables. Note l'utilisation de la notation avec le point (NomTable.nom_colonne) pour éviter les ambiguïtés, surtout si des colonnes ont le même nom dans différentes tables.
Corrigé 2.2 : Regroupement et fonctions d'agrégation (COUNT, AVG, SUM)
Énoncé : Pour chaque genre de livre, calcule le nombre de livres disponibles dans la bibliothèque. Affiche le nom du genre et le compte, trié du genre le plus représenté au moins représenté.
Correction & Explication :
SELECT Genres.nom_genre, COUNT(Livres.id_livre) AS nb_livres FROM Genres LEFT JOIN Livres ON Genres.id_genre = Livres.id_genre GROUP BY Genres.id_genre, Genres.nom_genre ORDER BY nb_livres DESC;
Cette requête est plus riche :
1. LEFT JOIN : On part de la table Genres pour être sûr d'afficher tous les genres, même ceux qui n'ont pas de livre (ils compteront pour 0).
2. COUNT(...) : Fonction d'agrégation qui compte le nombre de lignes (ici, de livres).
3. AS nb_livres : Donne un alias plus lisible à la colonne résultat du COUNT.
4. GROUP BY : C'est le cœur. Il indique que les calculs (COUNT) doivent être faits pour chaque groupe distinct de id_genre et nom_genre. Toute colonne dans le SELECT qui n'est pas dans une fonction d'agrégation doit apparaître dans le GROUP BY.
5. On trie enfin par le compte calculé.
Exercice 3 : Les sous-requêtes et requêtes imbriquées
Elles permettent d'effectuer des requêtes en plusieurs étapes, souvent pour filtrer sur un résultat calculé.
Corrigé 3.1 : Sous-requête dans la condition WHERE
Énoncé : Trouve les usagers qui ont emprunté plus de livres que la moyenne des emprunts par usager.
Correction & Explication :
SELECT Usagers.nom, Usagers.prenom, COUNT(Emprunts.id_emprunt) AS nb_emprunts FROM Usagers INNER JOIN Emprunts ON Usagers.id_usager = Emprunts.id_usager GROUP BY Usagers.id_usager, Usagers.nom, Usagers.prenom HAVING COUNT(Emprunts.id_emprunt) > ( SELECT AVG(nb_e) FROM ( SELECT COUNT(id_emprunt) AS nb_e FROM Emprunts GROUP BY id_usager ) AS subquery );
Décomposons cette requête en deux parties :
1. La requête principale (lignes 1 à 4) : Elle joint usagers et emprunts, groupe par usager et compte ses emprunts.
2. La sous-requête (lignes 5 à 9) : Elle calcule d'abord le nombre d'emprunts par usager (sous-requête interne), puis la moyenne de ces nombres. C'est cette moyenne qui est utilisée dans la condition HAVING.
Rappel : WHERE filtre sur les lignes brutes, HAVING filtre sur les groupes créés par GROUP BY. Ici, on compare le compte d'un groupe (nb_emprunts) à une valeur calculée.
Check-list de révision avant le Bac
Avant de te lancer dans les annales, assure-toi de savoir faire sans hésiter :
- Écrire une requête SELECT simple avec WHERE et ORDER BY.
- Utiliser les opérateurs LIKE, BETWEEN, IN dans tes conditions.
- Effectuer une jointure (INNER, LEFT) entre deux tables et comprendre la différence.
- Utiliser GROUP BY avec au moins une fonction d'agrégat (COUNT, SUM, AVG, MAX, MIN).
- Filtrer les groupes avec HAVING.
- Comprendre la logique d'une sous-requête (même si tu ne la rédiges pas parfaitement du premier coup).
L'entraînement est la seule méthode pour que ces concepts deviennent des réflexes. N'hésite pas à recréer des petites bases sur des outils comme SQLite Browser ou sqliteonline.com pour tester tes requêtes en direct. Bon courage pour tes révisions !
