menu FixWins.com apps Spring MVC Spring Boot Angular Laravel MongoDB Mysql ExpressJS ReactJS list

GROUP BY

GROUP BY est une clause SQL utilisée pour regrouper les lignes d'un résultat de requête en fonction des valeurs d'une ou plusieurs colonnes. Cette clause est généralement utilisée en conjonction avec des fonctions d'agrégation telles que SUM, COUNT, AVG, MAX, ou MIN pour effectuer des calculs sur les groupes de lignes regroupées. Le résultat renvoie un ensemble de lignes regroupées qui résume les données de manière agrégée.
Exemple
Supposons que vous ayez une table nommée commandes contenant des informations sur les ventes de produits, avec des colonnes telles que produit, quantite et prix_unitaire. Vous souhaitez savoir combien de chaque produit a été vendu et quel est le montant total des ventes pour chaque produit. Vous pouvez utiliser GROUP BY pour effectuer cette agrégation.
Exemple de données dans la table commandes : 
+-------+----------+--------------+
| produit | quantite | prix_unitaire |
+-------+----------+--------------+
| A       | 5        | 10.00        |
| B       | 3        | 15.00        |
| A       | 2        | 10.00        |
| C       | 4        | 20.00        |
| B       | 2        | 15.00        |
+-------+----------+--------------+
Vous pouvez utiliser la requête suivante avec GROUP BY pour regrouper les données par produit et obtenir le total des ventes de chaque produit : 
SELECT produit, SUM(quantite) AS total_quantite, SUM(quantite * prix_unitaire) AS total_ventes
FROM commandes
GROUP BY produit;
Résultat de la requête : 
+-------+----------------+-------------+
| produit | total_quantite | total_ventes |
+-------+----------------+-------------+
| A       | 7              | 70.00       |
| B       | 5              | 75.00       |
| C       | 4              | 80.00       |
+-------+----------------+-------------+
Explication :
La clause GROUP BY est utilisée pour regrouper les lignes par la colonne produit.

Les fonctions d'agrégation SUM sont utilisées pour calculer la somme des quantités vendues (total_quantite) et la somme totale des ventes (total_ventes) pour chaque produit.
Le résultat renvoie une ligne pour chaque produit avec les totaux correspondants.
En utilisant GROUP BY, vous pouvez résumer et agréger les données de manière significative pour obtenir des informations utiles à partir d'un grand ensemble de données.
Questions & répones

(SELECT avec GROUP BY): Sélectionnez le nombre de produits par marque. 

SELECTmarque, COUNT(*) AS nombre_de_produits FROM produits GROUP BY marque;

(SELECT avec GROUP BY): Sélectionnez le montant total des ventes par client. 

SELECTidClient, SUM(prixVente * QuantiteVendue) AS montant_total_ventes FROM ventes GROUP BY idClient;

(SELECT avec GROUP BY): Sélectionnez la quantité totale en stock par catégorie de produits. 

SELECTcategorie, SUM(quantiteStock) AS quantite_totale_stock FROM produits GROUP BY categorie;

(SELECT avec WHERE et GROUP BY): Sélectionnez le montant total des ventes pour un client spécifique (ID 2) effectuées après une date donnée (par exemple, '2023-01-01'). 

SELECTidClient, SUM(prixVente * QuantiteVendue) AS montant_total_ventes
FROM ventes
WHERE idClient = 2 AND dateVente >= '2023-01-01'
GROUP BY idClient;

(SELECT avec WHERE et GROUP BY): Sélectionnez le produit le plus vendu (en termes de quantité vendue) dans chaque catégorie de produits. 

SELECTcategorie, produit_id, MAX(quantite_vendue) AS quantite_max
FROM (SELECT p.categorie, v.idProduit AS produit_id, SUM(v.QuantiteVendue) AS quantite_vendue
      FROM produits p
      JOIN ventes v ON p.id = v.idProduit
      GROUP BY p.categorie, v.idProduit) subquery
GROUP BY categorie;

(SELECT avec WHERE et GROUP BY): Sélectionnez le client avec le montant total d'achats le plus élevé. 

SELECTidClient, SUM(prixVente * QuantiteVendue) AS montant_total_ventes
FROM ventes
GROUP BY idClient
ORDER BY montant_total_ventes DESC
LIMIT 1;

(SELECT avec WHERE et GROUP BY): Sélectionnez le produit le moins cher dans chaque catégorie de produits. 

SELECTcategorie, produit_id, MIN(prix) AS prix_min
FROM (SELECT p.categorie, p.id AS produit_id, p.prix
      FROM produits p
      WHERE p.prix = (SELECT MIN(prix) FROM produits p2 WHERE p2.categorie = p.categorie)
      ) subquery
GROUP BY categorie;

(SELECT avec WHERE et GROUP BY): Sélectionnez la quantité totale vendue de chaque produit pour une date spécifique (par exemple, '2023-04-15'). 

SELECTidProduit, SUM(QuantiteVendue) AS quantite_totale
FROM ventes
WHERE dateVente = '2023-04-15'
GROUP BY idProduit;

(SELECT avec WHERE et GROUP BY): Sélectionnez le nombre de clients par ville. 

SELECTville, COUNT(*) AS nombre_de_clients FROM clients GROUP BY ville;

(SELECT avec WHERE et GROUP BY): Sélectionnez la date de vente la plus récente pour chaque client. 

SELECTidClient, MAX(dateVente) AS date_vente_recente
FROM ventes
GROUP BY idClient;

(SELECT avec WHERE et GROUP BY): Sélectionnez la quantité totale en stock par catégorie de produits, mais uniquement pour les catégories dont la quantité totale en stock est supérieure à 100. 

SELECTcategorie, SUM(quantiteStock) AS quantite_totale_stock
FROM produits
GROUP BY categorie
HAVING quantite_totale_stock > 100;

(SELECT avec WHERE et GROUP BY): Sélectionnez le produit le plus cher dans chaque catégorie de produits. 

SELECTcategorie, produit_id, MAX(prix) AS prix_max
FROM (SELECT p.categorie, p.id AS produit_id, p.prix
      FROM produits p
      WHERE p.prix = (SELECT MAX(prix) FROM produits p2 WHERE p2.categorie = p.categorie)
      ) subquery
GROUP BY categorie;
Exemple 2
Supposons un schéma de base de données avec trois tables : "étudiants", "cours", et "notes". Les colonnes de ces tables sont les suivantes : 

CREATE TABLE etudiants (
    etudiant_id INT AUTO_INCREMENT PRIMARY KEY,
    nom VARCHAR(255) NOT NULL
);

CREATE TABLE cours (
    cours_id INT AUTO_INCREMENT PRIMARY KEY,
    nom_cours VARCHAR(255) NOT NULL
);

CREATE TABLE notes (
    note_id INT AUTO_INCREMENT PRIMARY KEY,
    etudiant_id INT,
    cours_id INT,
    note INT,
    FOREIGN KEY (etudiant_id) REFERENCES etudiants(etudiant_id),
    FOREIGN KEY (cours_id) REFERENCES cours(cours_id)
);
Exemple 1 : Calculer la moyenne des notes pour chaque étudiant. 
SELECT étudiants.nom AS "Nom de l'étudiant", AVG(notes.note) AS "Moyenne des notes"
FROM étudiants
JOIN notes ON étudiants.etudiant_id = notes.etudiant_id
GROUP BY étudiants.etudiant_id, étudiants.nom;
Résultat : 
Nom de l'étudiant	Moyenne des notes
Alice					85
Bob					76
Carol				92
Exemple 2 : Obtenir la liste des étudiants ayant obtenu une note supérieure à 90 dans au moins un cours. 
SELECTétudiants.nom AS "Nom de l'étudiant", MAX(notes.note) AS "Note maximale"
FROM étudiants
JOIN notes ON étudiants.etudiant_id = notes.etudiant_id
WHERE notes.note > 90
GROUP BY étudiants.etudiant_id, étudiants.nom;
Résultat : 
Nom de l'étudiant	Note maximale
Alice					95
Carol				94
Exemple 3 : Trouver le cours avec la note la plus élevée. 
SELECTcours.nom_cours AS "Nom du cours", MAX(notes.note) AS "Note maximale"
FROM cours
JOIN notes ON cours.cours_id = notes.cours_id
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Note maximale
Mathématiques		95
Science			92
Littérature		94
Exemple 4 : Calculer la somme des notes de tous les étudiants dans un cours donné. 
SELECT cours.nom_cours AS "Nom du cours", SUM(notes.note) AS "Somme des notes"
FROM cours
JOIN notes ON cours.cours_id = notes.cours_id
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Somme des notes
Mathématiques		280
Science			261
Littérature		285
Exemple 5 : Compter le nombre d'étudiants ayant des notes dans chaque cours. 
SELECT cours.nom_cours AS "Nom du cours", COUNT(notes.etudiant_id) AS "Nombre d'étudiants"
FROM cours
LEFT JOIN notes ON cours.cours_id = notes.cours_id
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Nombre d'étudiants
Mathématiques		3
Science			2
Littérature		3
Exemple 6 : Obtenir la note minimale et maximale de chaque étudiant. 
SELECT étudiants.nom AS "Nom de l'étudiant", MIN(notes.note) AS "Note minimale", MAX(notes.note) AS "Note maximale"
FROM étudiants
JOIN notes ON étudiants.etudiant_id = notes.etudiant_id
GROUP BY étudiants.etudiant_id, étudiants.nom;
Résultat : 
Nom de l'étudiant	Note minimale	Note maximale
Alice	80	95
Bob	72	79
Carol	90	94
Exemple 7 : Trouver le cours avec la note minimale et maximale. 
SELECT cours.nom_cours AS "Nom du cours", MIN(notes.note) AS "Note minimale", MAX(notes.note) AS "Note maximale"
FROM cours
JOIN notes ON cours.cours_id = notes.cours_id
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Note minimale	Note maximale
Mathématiques	78	95
Science	70	92
Littérature	85	94
Exemple 8 : Calculer la moyenne des notes pour chaque cours. 
SELECT cours.nom_cours AS "Nom du cours", AVG(notes.note) AS "Moyenne des notes"
FROM cours
JOIN notes ON cours.cours_id = notes.cours_id
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Moyenne des notes
Mathématiques	93
Science	87
Littérature	89
Exemple 9 : Compter le nombre d'étudiants ayant des notes supérieures ou égales à 90 dans chaque cours. 
SELECT cours.nom_cours AS "Nom du cours", COUNT(notes.etudiant_id) AS "Nombre d'étudiants"
FROM cours
LEFT JOIN notes ON cours.cours_id = notes.cours_id
WHERE notes.note >= 90
GROUP BY cours.cours_id, cours.nom_cours;
Résultat : 
Nom du cours	Nombre d'étudiants
Mathématiques	3
Science	2
Littérature	2
Exemple 10 : Obtenir la liste des étudiants ayant obtenu la note minimale dans au moins un cours. 
SELECT étudiants.nom AS "Nom de l'étudiant", MIN(notes.note) AS "Note minimale"
FROM étudiants
JOIN notes ON étudiants.etudiant_id = notes.etudiant_id
GROUP BY étudiants.etudiant_id, étudiants.nom
HAVING MIN(notes.note) <= 75;
Résultat : 
Nom de l'étudiant	Note minimale
Bob	72