10 exercices SQL corrigés pour le BAC NSI

Pourquoi s'entraîner avec des exercices SQL pour le BAC NSI ?

L'épreuve de Numérique et Sciences Informatiques (NSI) au BAC accorde une place importante aux bases de données et au langage SQL. Que ce soit dans l'écrit ou le projet, tu dois être capable de modéliser une base, d'écrire des requêtes pour interroger les données et de comprendre les résultats. La meilleure façon de progresser ? La pratique ! À travers ces 10 exercices, nous allons revoir les concepts clés, des plus basiques aux plus avancés, avec à chaque fois une correction commentée pour que tu comprennes la logique, et pas seulement la syntaxe. Prépare ton SGBD préféré (SQLite, MySQL, PostgreSQL...) et c'est parti !

La base de données d'exemple

Pour tous nos exercices, nous allons utiliser une base de données simplifiée d'une bibliothèque. Voici le schéma et les données d'exemple. Tu peux les recréer sur ta machine pour tester tes requêtes.

Structure des tables

Table `Livres` : Contient les informations sur les livres.

• id_livre (INT, Clé Primaire)
• titre (VARCHAR)
• auteur (VARCHAR)
• annee_publication (INT)
• id_genre (INT, Clé Étrangère vers `Genres.id_genre`)

Table `Genres` : Liste les genres littéraires.

• id_genre (INT, Clé Primaire)
• nom_genre (VARCHAR) (ex: 'Science-Fiction', 'Roman', 'Biographie')

Table `Emprunts` : Gère les emprunts des livres par des adhérents.

• id_emprunt (INT, Clé Primaire)
• id_livre (INT, Clé Étrangère vers `Livres.id_livre`)
• id_adherent (INT, Clé Étrangère vers `Adherents.id_adherent`)
• date_emprunt (DATE)
• date_retour (DATE, peut être NULL si le livre n'est pas encore rendu)

Table `Adherents` : Liste les adhérents de la bibliothèque.

• id_adherent (INT, Clé Primaire)
• nom (VARCHAR)
• prenom (VARCHAR)
• date_inscription (DATE)

Les 10 exercices SQL corrigés

Exercices 1 à 3 : Les requêtes simples (SELECT, WHERE, ORDER BY)

Exercice 1 : Sélection et filtrage basique
Écris une requête pour afficher le titre et l'auteur de tous les livres publiés après 2010.

Correction :
SELECT titre, auteur FROM Livres WHERE annee_publication > 2010;
Ici, on utilise la clause WHERE pour filtrer les lignes selon une condition numérique.

Exercice 2 : Trier les résultats
Affiche la liste complète des adhérents, triée par ordre alphabétique de nom, puis de prénom.

Correction :
SELECT * FROM Adherents ORDER BY nom, prenom;
La clause ORDER BY permet de trier. On peut spécifier plusieurs colonnes pour un tri plus fin.

Exercice 3 : Combinaison de filtres
Trouve les livres dont l'auteur est 'Garcia' et qui ont été publiés avant 2005.

Correction :
SELECT * FROM Livres WHERE auteur = 'Garcia' AND annee_publication < 2005;
L'opérateur logique AND permet de combiner plusieurs conditions. Toutes doivent être vraies.

Exercices 4 à 6 : Les jointures (INNER JOIN)

Exercice 4 : Première jointure
Affiche le titre des livres et le nom de leur genre associé.

Correction :
SELECT Livres.titre, Genres.nom_genre FROM Livres INNER JOIN Genres ON Livres.id_genre = Genres.id_genre;
C'est la jointure fondamentale. On relie deux tables via leur clé étrangère/clé primaire pour combiner leurs informations.

Exercice 5 : Jointure avec filtre
Affiche le nom et le prénom des adhérents qui ont emprunté un livre après le 1er janvier 2024. (Attention aux doublons !)

Correction :
SELECT DISTINCT Adherents.nom, Adherents.prenom FROM Adherents INNER JOIN Emprunts ON Adherents.id_adherent = Emprunts.id_adherent WHERE Emprunts.date_emprunt > '2024-01-01';
On joint Adherents et Emprunts, on filtre par date, et on utilise DISTINCT pour éviter d'afficher plusieurs fois le même adhérent s'il a fait plusieurs emprunts.

Exercice 6 : Jointure triple
Affiche le titre du livre, le nom de l'adhérent et la date d'emprunt pour tous les emprunts en cours (livres non encore rendus).

Correction :
SELECT Livres.titre, Adherents.nom, Emprunts.date_emprunt FROM Emprunts INNER JOIN Livres ON Emprunts.id_livre = Livres.id_livre INNER JOIN Adherents ON Emprunts.id_adherent = Adherents.id_adherent WHERE Emprunts.date_retour IS NULL;
Une jointure peut concerner plus de deux tables. On enchaîne les clauses INNER JOIN. Le filtre IS NULL est crucial pour trouver les valeurs non renseignées.

Exercices 7 à 9 : Agrégations et regroupements (COUNT, GROUP BY, HAVING)

Exercice 7 : Compter simplement
Compte le nombre total de livres dans la bibliothèque.

Correction :
SELECT COUNT(*) AS nombre_total_livres FROM Livres;
La fonction d'agrégation COUNT() compte les lignes. AS permet de renommer la colonne de résultat pour plus de clarté.

Exercice 8 : Regroupement
Pour chaque genre, affiche son nom et le nombre de livres qui lui sont associés.

Correction :
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;
Ici, on utilise GROUP BY pour créer des groupes (un par genre). COUNT() s'applique alors à chaque groupe. On utilise un LEFT JOIN pour inclure les genres qui n'ont aucun livre (ils compteront 0).

Exercice 9 : Filtrer sur un agrégat (HAVING)
Trouve les adhérents qui ont emprunté plus de 3 livres. Affiche leur nom et le nombre d'emprunts.

Correction :
SELECT Adherents.nom, COUNT(Emprunts.id_emprunt) AS nb_emprunts FROM Adherents INNER JOIN Emprunts ON Adherents.id_adherent = Emprunts.id_adherent GROUP BY Adherents.id_adherent, Adherents.nom HAVING COUNT(Emprunts.id_emprunt) > 3;
La grande difficulté ! WHERE filtre les lignes avant le regroupement. HAVING filtre les groupes après le regroupement, en fonction d'une condition sur l'agrégat (ici, le compte).

Exercice 10 : Requête imbriquée (sous-requête)

Exercice 10 : Le livre le plus récent
Affiche le titre et l'année du livre (ou des livres) ayant l'année de publication la plus récente dans la base.

Correction :
SELECT titre, annee_publication FROM Livres WHERE annee_publication = (SELECT MAX(annee_publication) FROM Livres);
La sous-requête (SELECT MAX(annee_publication) FROM Livres) est exécutée en premier et retourne une seule valeur : l'année maximum. La requête principale utilise ensuite cette valeur dans son filtre WHERE. Cette méthode est élégante et évite de devoir trier toute la table.

Conseils pour le jour du BAC NSI

Maintenant que tu t'es entraîné, voici quelques conseils pour aborder sereinement les questions SQL le jour J :

• Lis attentivement le schéma de la base : Identifie bien les tables, les clés primaires (PK) et les clés étrangères (FK). C'est la carte de ton territoire !
• Comprends le résultat attendu : Avant de coder, essaie de verbaliser en français ce que la requête doit faire. « Je dois sélectionner les noms des clients qui ont passé une commande après une certaine date... ».
• Construis ta requête pas à pas : Commence par le SELECT des colonnes nécessaires, ajoute les JOIN, puis les WHERE, et enfin les GROUP BY/HAVING si besoin.
• Pense aux doublons : Est-ce que le résultat peut en contenir ? Dois-tu utiliser DISTINCT ?
• Gère les NULL : Les dates de retour, les genres non attribués... Utilise IS NULL ou IS NOT NULL pour les filtrer correctement.
• Vérifie tes parenthèses : Surtout dans les requêtes complexes avec plusieurs conditions ou sous-requêtes.

Avec cette méthodologie et une pratique régulière, les questions SQL du BAC NSI deviendront un vrai point fort pour toi. Bon courage dans tes révisions !