Voici un TP complet (sans machine), que tu peux faire sur feuille, dans le même esprit que

ton TP1.

🧮 TP2 SQL — Gestion Commerciale

(Niveau Avancé)
Partie 1 : Création de la base et des tables
1. Créez une base de données nommée gestionVentes.
2. Sélectionnez cette base pour y travailler.
3. Créez les tables suivantes :

Table Clients

Colonne Type Contraintes

NumCli INT PRIMARY KEY
Nom VARCHAR(50) NOT NULL
Prenom VARCHAR(50) NOT NULL
Ville VARCHAR(50)
Telephone VARCHAR(15)

Table Produits

Colonne Type Contraintes

NumProd INT PRIMARY KEY
Designation VARCHAR(100) NOT NULL
Categorie VARCHAR(50)
Prix DECIMAL(8,2) CHECK (Prix >= 0)

Table Commandes

Colonne Type Contraintes

NumCmd INT PRIMARY KEY
DateCmd DATE
NumCli INT FOREIGN KEY REFERENCES Clients(NumCli)

Table Lignes_Commande
Colonne Type Contraintes
NumCmd INT FOREIGN KEY REFERENCES Commandes(NumCmd)
NumProd INT FOREIGN KEY REFERENCES Produits(NumProd)
Quantite INT CHECK (Quantite > 0)

Partie 2 : Insertion des données

1. Insérez 5 clients, 5 produits, 3 commandes, et pour chaque commande, plusieurs
lignes de commande.
2. Exemple (écris tout sur feuille, pas besoin que ça s’exécute) :
3. INSERT INTO Clients VALUES
4. (1, 'Dupont', 'Marie', 'Casablanca', '0612121212'),
5. (2, 'Brahimi', 'Ahmed', 'Rabat', '0698989898'),
6. (3, 'Lopez', 'Inès', 'Tanger', '0622222222'),
7. (4, 'Nguyen', 'Thi', 'Fès', '0677777777'),
8. (5, 'Ali', 'Sara', 'Agadir', '0655555555');

Partie 3 : Requêtes de sélection

Écrivez la requête SQL complète pour chaque question.

1. Afficher le nom et la ville de tous les clients habitant à Rabat.

2. Afficher la désignation et le prix des produits dont le prix est supérieur à 500 dh.
3. Afficher tous les produits de la catégorie 'Informatique' triés du plus cher au
moins cher.
4. Afficher les commandes qui ont eu lieu après le 1er septembre 2024.

Partie 4 : Jointures et regroupements

1. Afficher, pour chaque commande, le nom du client, la date de commande et le
montant total (prix × quantité).

🔑 Utiliser INNER JOIN entre Commandes, Lignes_Commande et Produits.

2. Afficher le montant total des ventes effectuées par chaque ville de clients.

🔑 Utiliser GROUP BY Ville.

3. Afficher les clients qui ont passé plus d’une commande.

🔑 Utiliser COUNT + HAVING.

4. Afficher la catégorie de produit et la somme totale des ventes par catégorie.

Tri décroissant selon le chiffre d’affaires (ORDER BY SUM(...) DESC).

 5. Afficher les produits dont le prix est supérieur à la moyenne générale des prix.

🔑 Utiliser une sous-requête dans le WHERE.

Partie 5 : Mise à jour et suppression

1. Modifier la catégorie de tous les produits dont le prix est < 100 pour les passer en
catégorie 'Accessoires'.
2. Supprimer toutes les lignes de commande associées à la commande numéro 3.

Partie 6 : Fonctions d’agrégation et analyse

1. Donner le nombre total de clients enregistrés.
2. Donner le prix moyen des produits.
3. Donner le montant total de toutes les ventes.
4. Donner le produit le plus cher (MAX(Prix)) et le moins cher (MIN(Prix)).
5. Donner, pour chaque ville, le nombre de clients.

Partie 7 : Questions de réflexion

1. Quelle est la différence entre WHERE et HAVING ?
2. Pourquoi INNER JOIN est-il utile dans les bases relationnelles ?
3. Quelle est la différence entre GROUP BY et ORDER BY ?
4. Explique en une phrase la signification de SUM(Prix * Quantite) dans une requête
de vente.

Excellent 👏 !
Voici :
✅ La feuille corrigée complète du TP2 Gestion Commerciale (avec toutes les requêtes
SQL)
et ensuite
🧩 Un TP3 entièrement nouveau, dans un autre contexte (Gestion Scolaire), dans le même
style d’examen papier MySQL.

🧮 TP2 SQL – Gestion Commerciale

(Corrigé complet)
Partie 1 : Création de la base et des tables
CREATE DATABASE gestionVentes;
USE gestionVentes;

CREATE TABLE Clients (

NumCli INT PRIMARY KEY,
Nom VARCHAR(50) NOT NULL,
Prenom VARCHAR(50) NOT NULL,
Ville VARCHAR(50),
Telephone VARCHAR(15)
);

CREATE TABLE Produits (

NumProd INT PRIMARY KEY,
Designation VARCHAR(100) NOT NULL,
Categorie VARCHAR(50),
Prix DECIMAL(8,2) CHECK (Prix >= 0)
);

CREATE TABLE Commandes (

NumCmd INT PRIMARY KEY,
DateCmd DATE,
NumCli INT,
FOREIGN KEY (NumCli) REFERENCES Clients(NumCli)
);

CREATE TABLE Lignes_Commande (

NumCmd INT,
NumProd INT,
Quantite INT CHECK (Quantite > 0),
FOREIGN KEY (NumCmd) REFERENCES Commandes(NumCmd),
FOREIGN KEY (NumProd) REFERENCES Produits(NumProd)
);

Partie 2 : Insertion des données

INSERT INTO Clients VALUES
(1, 'Dupont', 'Marie', 'Casablanca', '0612121212'),
(2, 'Brahimi', 'Ahmed', 'Rabat', '0698989898'),
(3, 'Lopez', 'Inès', 'Tanger', '0622222222'),
(4, 'Nguyen', 'Thi', 'Fès', '0677777777'),
(5, 'Ali', 'Sara', 'Agadir', '0655555555');

INSERT INTO Produits VALUES

(1, 'Ordinateur Portable', 'Informatique', 7500),
(2, 'Clavier', 'Accessoire', 250),
(3, 'Souris', 'Accessoire', 150),
(4, 'Écran 24 pouces', 'Informatique', 1200),
(5, 'Imprimante', 'Bureau', 2000);

INSERT INTO Commandes VALUES

(1, '2024-09-25', 1),
(2, '2024-10-02', 2),
(3, '2024-10-10', 1);

INSERT INTO Lignes_Commande VALUES

(1, 1, 2),
(1, 3, 3),
(2, 4, 1),
(2, 2, 2),
(3, 5, 1);

Partie 3 : Requêtes de sélection

-- 1
SELECT Nom, Ville FROM Clients WHERE Ville = 'Rabat';

-- 2
SELECT Designation, Prix FROM Produits WHERE Prix > 500;

-- 3
SELECT * FROM Produits
WHERE Categorie = 'Informatique'
ORDER BY Prix DESC;

-- 4
SELECT * FROM Commandes WHERE DateCmd > '2024-09-01';

Partie 4 : Jointures et regroupements

-- 1. Nom du client, date de commande et montant total
SELECT
[Link], [Link],
SUM([Link] * [Link]) AS MontantTotal
FROM Commandes cmd
INNER JOIN Clients c ON [Link] = [Link]
INNER JOIN Lignes_Commande lc ON [Link] = [Link]
INNER JOIN Produits p ON [Link] = [Link]
GROUP BY [Link], [Link], [Link];

-- 2. Montant total des ventes par ville

SELECT
[Link],
SUM([Link] * [Link]) AS TotalVentes
FROM Clients c
INNER JOIN Commandes cmd ON [Link] = [Link]
INNER JOIN Lignes_Commande lc ON [Link] = [Link]
INNER JOIN Produits p ON [Link] = [Link]
GROUP BY [Link];

-- 3. Clients ayant passé plus d’une commande

SELECT
[Link], COUNT([Link]) AS NbCommandes
FROM Clients c
INNER JOIN Commandes cmd ON [Link] = [Link]
GROUP BY [Link]
HAVING COUNT([Link]) > 1;

-- 4. Somme totale des ventes par catégorie de produit

SELECT
[Link],
SUM([Link] * [Link]) AS ChiffreAffaires
FROM Produits p
INNER JOIN Lignes_Commande lc ON [Link] = [Link]
GROUP BY [Link]
ORDER BY ChiffreAffaires DESC;

-- 5. Produits plus chers que la moyenne

SELECT Designation, Prix
FROM Produits
WHERE Prix > (SELECT AVG(Prix) FROM Produits);

Partie 5 : Mise à jour et suppression

-- 1
UPDATE Produits SET Categorie = 'Accessoires'
WHERE Prix < 100;

-- 2
DELETE FROM Lignes_Commande WHERE NumCmd = 3;

Partie 6 : Fonctions d’agrégation

SELECT COUNT(*) AS Nombre_Clients FROM Clients;
SELECT AVG(Prix) AS Prix_Moyen FROM Produits;
SELECT SUM([Link] * [Link]) AS Total_Ventes
FROM Produits p
INNER JOIN Lignes_Commande lc ON [Link] = [Link];
SELECT MAX(Prix) AS Prix_Max, MIN(Prix) AS Prix_Min FROM Produits;
SELECT Ville, COUNT(*) AS Nb_Clients FROM Clients GROUP BY Ville;

Partie 7 : Réponses de réflexion

Question Réponse
Différence WHERE / WHERE filtre avant agrégation, HAVING filtre après GROUP
HAVING BY
Permet de combiner des lignes communes entre tables avec clés
INNER JOIN
correspondantes
GROUP BY / ORDER BY GROUP BY regroupe, ORDER BY trie les résultats
SUM(Prix * Quantite) Calcule le total des ventes (prix unitaire × quantité vendue)

🧩 TP3 SQL – Gestion Scolaire (Nouveau

contexte)
Partie 1 : Création
1. Créez la base GestionScolaire.
2. Créez les tables suivantes :

Élèves Colonnes
NumEleve (INT, PK) Nom (VARCHAR(50))
Cours Colonnes
CodeCours (INT, PK) NomCours (VARCHAR(100))
Notes Colonnes
NumEleve (INT, FK) CodeCours (INT, FK)

Partie 2 : Insertion
Insérez au moins 5 élèves, 4 cours et 10 notes.

Partie 3 : Requêtes
1. Afficher le nom et la ville des élèves habitant à “Casablanca”.
2. Afficher tous les cours dont le coefficient > 3.
3. Afficher la moyenne des notes de chaque élève (AVG(Note)), triée du meilleur au
moins bon.
4. Afficher la moyenne de chaque cours (GROUP BY CodeCours).
5. Afficher les élèves ayant une note > moyenne générale (HAVING AVG(Note) >
(SELECT AVG(Note) FROM Notes)).
6. Afficher les élèves, les cours et les notes correspondantes (INNER JOIN Notes).
7. Afficher le nombre d’élèves par ville.
8. Afficher le ou les cours où la note moyenne est la plus élevée.

Partie 4 : Modifications
1. Ajouter une colonne Email à la table Élèves.
2. Mettre à jour la ville de tous les élèves qui n'ont pas de ville (UPDATE ... SET Ville
= 'Inconnue' WHERE Ville IS NULL;).
3. Supprimer les notes inférieures à 5.

Partie 5 : Sujets de réflexion

1. Quelle différence entre INNER JOIN et LEFT JOIN ?
2. Quel est l’intérêt de GROUP BY dans une base d’évaluation scolaire ?
3. À quoi sert la clause HAVING ici ?

Parfait 💪 !
Voici la feuille corrigée complète du TP3 SQL – Gestion Scolaire, avec toutes les requêtes
SQL attendues, dans le même style qu’un TP ou examen papier MySQL.
Chaque section correspond à une partie du sujet précédent.

🧩 TP3 SQL – Gestion Scolaire (Corrigé

complet)

🎓 Partie 1 : Création de la base et des tables

CREATE DATABASE GestionScolaire;
USE GestionScolaire;

CREATE TABLE Eleves (

NumEleve INT PRIMARY KEY,
Nom VARCHAR(50) NOT NULL,
Prenom VARCHAR(50) NOT NULL,
Ville VARCHAR(50)
);

CREATE TABLE Cours (

CodeCours INT PRIMARY KEY,
NomCours VARCHAR(100) NOT NULL,
Coefficient INT CHECK (Coefficient > 0)
);

CREATE TABLE Notes (

NumEleve INT,
CodeCours INT,
Note DECIMAL(4,2) CHECK (Note BETWEEN 0 AND 20),
FOREIGN KEY (NumEleve) REFERENCES Eleves(NumEleve),
FOREIGN KEY (CodeCours) REFERENCES Cours(CodeCours)
);

🧾 Partie 2 : Insertion des données

INSERT INTO Eleves VALUES
(1, 'Bennani', 'Ali', 'Casablanca'),
(2, 'Khalid', 'Sara', 'Rabat'),
(3, 'El Amrani', 'Youssef', 'Marrakech'),
(4, 'Ndiaye', 'Amina', 'Casablanca'),
(5, 'Dupont', 'Léa', 'Tanger');

INSERT INTO Cours VALUES

(101, 'Bases de Données', 4),
(102, 'Programmation', 5),
(103, 'Comptabilité', 3),
(104, 'Statistiques', 2);

INSERT INTO Notes VALUES

(1, 101, 15.5),
(1, 102, 14.0),
(2, 101, 12.0),
(2, 103, 9.5),
(3, 104, 16.0),
(3, 101, 10.0),
(4, 102, 17.0),
(4, 103, 14.5),
(5, 101, 8.0),
(5, 104, 11.5);

🔍 Partie 3 : Requêtes
1. Élèves de Casablanca
SELECT Nom, Prenom, Ville
FROM Eleves
WHERE Ville = 'Casablanca';

2. Cours avec coefficient > 3

SELECT NomCours, Coefficient
FROM Cours
WHERE Coefficient > 3;

3. Moyenne de chaque élève (avec tri décroissant)

SELECT
[Link], [Link],
ROUND(AVG([Link]),2) AS Moyenne
FROM Eleves e
INNER JOIN Notes n ON [Link] = [Link]
GROUP BY [Link], [Link], [Link]
ORDER BY Moyenne DESC;

4. Moyenne de chaque cours

SELECT
[Link],
ROUND(AVG([Link]),2) AS MoyenneCours
FROM Cours c
INNER JOIN Notes n ON [Link] = [Link]
GROUP BY [Link]
ORDER BY MoyenneCours DESC;

5. Élèves avec moyenne > moyenne générale

SELECT
[Link], [Link], ROUND(AVG([Link]),2) AS Moyenne
FROM Eleves e
INNER JOIN Notes n ON [Link] = [Link]
GROUP BY [Link], [Link]
HAVING AVG([Link]) > (SELECT AVG(Note) FROM Notes);

6. Lister toutes les notes avec élèves et cours

SELECT
[Link], [Link],
[Link], [Link]
FROM Notes n
INNER JOIN Eleves e ON [Link] = [Link]
INNER JOIN Cours c ON [Link] = [Link]
ORDER BY [Link], [Link];

7. Nombre d’élèves par ville

SELECT
Ville, COUNT(*) AS NombreEleves
FROM Eleves
GROUP BY Ville;

8. Cours ayant la meilleure moyenne

SELECT NomCours, MoyenneCours
FROM (
SELECT
[Link],
ROUND(AVG([Link]),2) AS MoyenneCours
FROM Cours c
INNER JOIN Notes n ON [Link] = [Link]
GROUP BY [Link]
) AS moyennes
WHERE MoyenneCours = (SELECT MAX(AVG(Note)) FROM Notes n INNER JOIN Cours c
ON [Link] = [Link]);

(Autre méthode simplifiée possible selon le niveau attendu.)

🛠 Partie 4 : Modifications (ALTER, UPDATE, DELETE)

1. Ajouter une colonne Email
ALTER TABLE Eleves ADD COLUMN Email VARCHAR(100);

2. Mettre une valeur par défaut aux villes manquantes

UPDATE Eleves
SET Ville = 'Inconnue'
WHERE Ville IS NULL;

3. Supprimer les notes inférieures à 5

DELETE FROM Notes
WHERE Note < 5;

📊 Partie 5 : Réflexion théorique

 Question Réponse détaillée

INNER JOIN ne garde que les enregistrements correspondants dans les deux
Différence INNER
tables. LEFT JOIN garde tous les enregistrements de la table gauche, même
JOIN / LEFT JOIN
sans correspondance.

Intérêt de GROUP Permet de regrouper les données (par élève, par cours…) afin de calculer des
BY moyennes, sommes ou comptes sur chaque groupe.

Sert à filtrer les résultats après regroupement (GROUP BY). Contrairement à

Rôle de HAVING
WHERE, il agit sur les résultats agrégés.

💡 Résumé des notions couvertes

✅ Création de tables avec contraintes
✅ Insertion en masse
✅ Jointures simples et multiples
✅ Fonctions d’agrégation (SUM, AVG, COUNT, MAX, MIN)
✅ Clauses WHERE, GROUP BY, HAVING, ORDER BY
✅ Sous-requêtes
✅ Commandes ALTER, UPDATE, DELETE

Souhaites-tu que je te prépare un TP4 “Gestion Hospitalière” (dossier médical,

patients/docteurs, regroupement par service) pour continuer ton entraînement avant examen ?

🧩 TP : Gestion simple des étudiants et de leurs cours

🔧 Partie 1 : Création de la base de données

 1. Crée une base de données appelée universite.
2. Connecte-toi à cette base.
3. Crée les tables suivantes :

Table 1 : etudiants

Champ Type Contraintes

id_etudiant INT PRIMARY KEY, AUTO_INCREMENT
nom VARCHAR(50) NOT NULL
prenom VARCHAR(50) NOT NULL
age INT NULL

Table 2 : inscriptions

Champ Type Contraintes

id_inscription INT PRIMARY KEY, AUTO_INCREMENT
id_etudiant INT FOREIGN KEY vers etudiants(id_etudiant)
cours VARCHAR(50) NOT NULL
note DECIMAL(4,2) NULL

💾 Partie 2 : Insertion de données

1. Insère au moins 5 étudiants dans la table etudiants.
2. Insère plusieurs lignes d’inscription dans la table inscriptions, de sorte qu’un
étudiant puisse suivre plusieurs cours.

✏️Partie 3 : Requêtes de base

1. Affiche tous les étudiants.
2. Affiche toutes les inscriptions.
3. Affiche le nom et le prénom des étudiants triés par ordre alphabétique.
4. Sélectionne uniquement les noms distincts des cours depuis inscriptions.

🔗 Partie 4 : Jointures (INNER JOIN )

1. Affiche la liste des étudiants et les cours auxquels ils sont inscrits.
2. Affiche uniquement les étudiants qui ont obtenu une note supérieure à 10.
3. Affiche les étudiants avec leur note et trie les résultats par ordre décroissant de note.
4. Affiche le nombre total d’étudiants inscrits à chaque cours.
5. Affiche la moyenne des notes pour chaque cours.
⚙️Partie 5 : Mise à jour et suppression
1. Mets à jour la note d’un étudiant dans un cours donné.
2. Modifie l’âge d’un étudiant.
3. Supprime un étudiant spécifique. Que se passe-t-il avec ses inscriptions ?
4. Supprime tous les étudiants ayant plus de 25 ans.

📊 Partie 6 : Fonctions d’agrégation et GROUP BY

1. Calcule la moyenne générale de toutes les notes.
2. Calcule le nombre d’étudiants inscrits à chaque cours (GROUP BY).
3. Calcule le meilleur et le pire résultat obtenu par cours (MAX, MIN).
4. Affiche la moyenne des notes par étudiant.
5. Affiche combien de cours différents chaque étudiant suit.

💡 Partie 7 : Requêtes combinées et avancées

1. Affiche la liste des étudiants ayant une moyenne supérieure à 12.
2. Affiche les cours où tous les étudiants ont obtenu plus de 10.
3. Affiche les étudiants non inscrits à aucun cours (pense à une autre jointure).

Très bien 👍 Voici la correction complète et détaillée du TP MySQL sur les jointures, les
manipulations de données et les fonctions d’agrégation.
Chaque partie contient les requêtes SQL accompagnées d’explications pour t’aider à
comprendre.

🧩 Correction complète du TP MySQL

🔧 Partie 1 : Création de la base et des tables
-- 1. Création de la base de données
CREATE DATABASE universite;

-- 2. Utilisation de cette base

USE universite;

-- 3. Création des tables

CREATE TABLE etudiants (

id_etudiant INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
prenom VARCHAR(50) NOT NULL,
 age INT
);

CREATE TABLE inscriptions (

id_inscription INT AUTO_INCREMENT PRIMARY KEY,
id_etudiant INT,
cours VARCHAR(50) NOT NULL,
note DECIMAL(4,2),
FOREIGN KEY (id_etudiant) REFERENCES etudiants(id_etudiant)
);

💾 Partie 2 : Insertion des données

-- Insertion d’étudiants
INSERT INTO etudiants (nom, prenom, age) VALUES
('Dupont', 'Marie', 20),
('Durand', 'Luc', 22),
('Martin', 'Sophie', 19),
('Bernard', 'Julien', 23),
('Petit', 'Laura', 21);

-- Insertion d’inscriptions
INSERT INTO inscriptions (id_etudiant, cours, note) VALUES
(1, 'Mathématiques', 15.5),
(1, 'Informatique', 12.0),
(2, 'Mathématiques', 8.5),
(3, 'Informatique', 14.0),
(3, 'Physique', 13.0),
(4, 'Mathématiques', 11.0),
(4, 'Physique', 9.5),
(5, 'Informatique', 17.0);

✏️Partie 3 : Requêtes simples

-- 1. Tous les étudiants
SELECT * FROM etudiants;

-- 2. Toutes les inscriptions

SELECT * FROM inscriptions;

-- 3. Étudiants triés par nom

SELECT nom, prenom FROM etudiants ORDER BY nom ASC;

-- 4. Cours distincts
SELECT DISTINCT cours FROM inscriptions;

🔗 Partie 4 : Jointures (INNER JOIN)

-- 1. Liste des étudiants et leurs cours

SELECT [Link], [Link], [Link]
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant;

-- 2. Étudiants avec note > 10

SELECT [Link], [Link], [Link], [Link]
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
WHERE [Link] > 10;

-- 3. Étudiants et notes triées par note décroissante

SELECT [Link], [Link], [Link], [Link]
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
ORDER BY [Link] DESC;

-- 4. Nombre d’étudiants inscrits à chaque cours

SELECT cours, COUNT(id_etudiant) AS nb_etudiants
FROM inscriptions
GROUP BY cours;

-- 5. Moyenne des notes par cours

SELECT cours, ROUND(AVG(note), 2) AS moyenne_cours
FROM inscriptions
GROUP BY cours;

⚙️Partie 5 : Mises à jour et suppression

-- 1. Modifier une note
UPDATE inscriptions
SET note = 16.0
WHERE id_etudiant = 2 AND cours = 'Mathématiques';

-- 2. Modifier l’âge d’un étudiant

UPDATE etudiants
SET age = 24
WHERE nom = 'Bernard';

-- 3. Supprimer un étudiant (suppose que le SGBD gère la contrainte

manuellement)
DELETE FROM etudiants WHERE nom = 'Durand';

-- 4. Supprimer tous les étudiants de plus de 25 ans

DELETE FROM etudiants WHERE age > 25;

💡 Remarque : si ton SGBD refuse la suppression d’un étudiant à cause de la clé étrangère, tu
devras d’abord supprimer ses inscriptions :
DELETE FROM inscriptions WHERE id_etudiant = ...;

📊 Partie 6 : Agrégations et GROUP BY

-- 1. Moyenne générale de toutes les notes
SELECT ROUND(AVG(note), 2) AS moyenne_generale FROM inscriptions;

-- 2. Nombre d’étudiants par cours

SELECT cours, COUNT(DISTINCT id_etudiant) AS nb_etudiants
FROM inscriptions
GROUP BY cours;

-- 3. Meilleure et pire note par cours

SELECT cours, MAX(note) AS meilleure_note, MIN(note) AS pire_note
FROM inscriptions
GROUP BY cours;

-- 4. Moyenne des notes par étudiant

SELECT [Link], [Link], ROUND(AVG([Link]), 2) AS moyenne_etudiant
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
GROUP BY e.id_etudiant;

-- 5. Nombre de cours suivis par étudiant

SELECT [Link], [Link], COUNT([Link]) AS nb_cours
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
GROUP BY e.id_etudiant;

💡 Partie 7 : Requêtes combinées et avancées

-- 1. Étudiants avec moyenne > 12
SELECT [Link], [Link], ROUND(AVG([Link]), 2) AS moyenne
FROM etudiants e
INNER JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
GROUP BY e.id_etudiant
HAVING moyenne > 12;

-- 2. Cours où tous les étudiants ont eu > 10

SELECT cours
FROM inscriptions
GROUP BY cours
HAVING MIN(note) > 10;

-- 3. Étudiants non inscrits à un cours (LEFT JOIN)

SELECT [Link], [Link]
FROM etudiants e
LEFT JOIN inscriptions i ON e.id_etudiant = i.id_etudiant
WHERE i.id_inscription IS NULL;

🧠 Pour aller plus loin (optionnel)

Exemple d’ajout d’une table professeurs :

CREATE TABLE professeurs (

id_prof INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50),
prenom VARCHAR(50)
);

ALTER TABLE inscriptions ADD COLUMN id_prof INT;

ALTER TABLE inscriptions

ADD FOREIGN KEY (id_prof) REFERENCES professeurs(id_prof);

Souhaites-tu que je te crée un jeu d’exercices d’entraînement supplémentaire (sans

correction cette fois) pour revoir INNER JOIN, GROUP BY et HAVING avant ton examen ?