1. Fonctions d'Agrégation

Les fonctions d'agrégation traitent un ensemble de valeurs pour retourner une valeur unique. Les plus courantes sont :

• COUNT() : Compte le nombre d'enregistrements.
• SUM() : Calcule la somme des valeurs d'une colonne numérique.
• AVG() : Détermine la valeur moyenne d'une colonne numérique.
• MAX() : Trouve la valeur maximale dans une colonne.
• MIN() : Identifie la valeur minimale dans une colonne.
• GROUP_CONCAT() : Concatène les valeurs de plusieurs lignes en une seule chaîne.

2. Groupement de Données avec GROUP BY

La clause GROUP BY est utilisée pour regrouper les lignes ayant les mêmes valeurs dans une ou plusieurs colonnes. Les fonctions d'agrégation peuvent ensuite être appliquées à chaque groupe.

2.1. Exemple

Considérons une table ventes contenant des enregistrements de ventes par vendeur :

   -- Structure de la table ventes (exemple)
   CREATE TABLE ventes (
       id_vente INT PRIMARY KEY AUTO_INCREMENT,
       vendeur VARCHAR(100),
       montant DECIMAL(10, 2),
       date_vente DATE
   );

   -- Données d'exemple
   INSERT INTO ventes (vendeur, montant, date_vente) VALUES
   ('Alice', 300.00, '2024-01-10'),
   ('Bob', 150.00, '2024-01-15'),
   ('Alice', 200.00, '2024-02-10'),
   ('Charlie', 250.00, '2024-01-20'),
   ('Bob', 100.00, '2024-01-25');
   

Pour obtenir le total des ventes par vendeur :

SELECT vendeur, SUM(montant) AS total_ventes
FROM ventes
GROUP BY vendeur;
   

2.2. Résultat

+---------+--------------+
| vendeur | total_ventes |
+---------+--------------+
| Alice   |       500.00 |
| Bob     |       250.00 |
| Charlie |       250.00 |
+---------+--------------+
   

Cette requête calcule la somme des montants pour chaque vendeur distinct.

3. Filtrage après Groupement avec HAVING

La clause HAVING est utilisée pour filtrer les groupes basés sur des conditions appliquées aux résultats des fonctions d'agrégation. Contrairement à WHERE qui filtre les lignes avant le groupement, HAVING filtre les groupes après leur création.

3.1. Exemple

Pour ne sélectionner que les vendeurs dont le total des ventes dépasse 300 :

SELECT vendeur, SUM(montant) AS total_ventes
FROM ventes
GROUP BY vendeur
HAVING SUM(montant) > 300;
   

3.2. Résultat

+---------+--------------+
| vendeur | total_ventes |
+---------+--------------+
| Alice   |       500.00 |
+---------+--------------+
   

Ici, HAVING restreint le résultat aux groupes (vendeurs) dont la somme calculée est supérieure à 300.

4. Combinaison de Fonctions d'Agrégation

Il est possible d'utiliser plusieurs fonctions d'agrégation dans une même requête pour obtenir diverses statistiques par groupe.

4.1. Exemple

Obtenir le nombre de ventes, le total des ventes et le montant de la plus grosse vente pour chaque vendeur :

SELECT
   vendeur,
   COUNT(id_vente) AS nombre_ventes,
   SUM(montant) AS total_ventes,
   MAX(montant) AS vente_max
FROM ventes
GROUP BY vendeur;
   

4.2. Résultat

+---------+-------------+--------------+-----------+
| vendeur | nombre_ventes | total_ventes | vente_max |
+---------+-------------+--------------+-----------+
| Alice   |           2 |       500.00 |    300.00 |
| Bob     |           2 |       250.00 |    150.00 |
| Charlie |           1 |       250.00 |    250.00 |
+---------+-------------+--------------+-----------+
   

Cette requête fournit une vue plus complète des performances de chaque vendeur.

5. Cas d'Utilisation Courants

• Analyse Commerciale : Évaluation des performances de vente par produit, région ou vendeur.
• Statistiques Utilisateurs : Analyse du comportement des utilisateurs, comme le nombre de connexions ou le volume d'achats par utilisateur.
• Génération de Rapports : Création de résumés financiers ou opérationnels par période, catégorie, etc.

6. Optimisation des Performances

Pour améliorer l'efficacité des requêtes utilisant GROUP BY et HAVING :

• Indexatino : Créez des index sur les colonnes utilisées dans la clause GROUP BY.
• Filtrage Précoce : Utilisez la clause WHERE pour réduire le nombre de lignes avant le groupement, si possible.
• Sélection Ciblée : Ne sélectionnez que les colonnes nécessaires.
• Agrégation Progressive : Pour les très grands ensembles de données, envisagez des techniques d'agrégation par étapes.

7. Points Importants

• Distinguez WHERE (filtre les lignes avant agrégation) de HAVING (filtre les groupes après agrégation).
• L'utilisation de sous-requêtes ou de vues peut améliorer la clarté des requêtes complexes impliquant des agrégations.