Organiser des données identiques en groupes - GROUP BY et HAVING
La clause GROUP BY en SQL permet d’organiser des données identiques en groupes à l’aide de certaines fonctions. C'est-à-dire si une colonne particulière a les mêmes valeurs dans différentes lignes, elle organisera ces lignes dans un groupe.
- La clause GROUP BY est utilisée avec l'instruction SELECT.
- Dans la requête, la clause GROUP BY est placée après la clause WHERE.
- Dans la requête, la clause GROUP BY est placée avant la clause ORDER BY si elle est utilisée.
Vous pouvez également utiliser certaines fonctions d'agrégation telles que COUNT, SUM, MIN, MAX, AVG, etc. sur la colonne groupée.
Syntaxe :
SELECT colonne1, colonne2, ... colonneN,
fonction_agregation (nom_colonne)
FROM tables
[WHERE conditions]
GROUP BY colonne1, colonne2, ... colonneN;
colonne1, colonne2, ... colonneN - spécifie les colonnes(ou expressions) qui ne sont pas encapsulées dans une fonction d'agrégation et doivent être incluses dans la clause GROUP BY.
fonction_agregation (nom_colonne) - Nom de la fonction d'agrégation utilisée, par exemple, SUM(), AVG ()... voir les différentes fonctions d'agrégation
WHERE conditions - C'est optionnel. Elle spécifie les conditions qui doivent être remplies pour que les enregistrements soient sélectionnés.
Pendant ce cours, nous allons travailler sur ces deux tables
Table - Employes
+----+---------+-----+---------+------------+------+
| Id | Nom | Age | Salaire | Profession | Dep |
+----+---------+-----+---------+------------+------+
| 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 5 | Omar | 30 | 9000.00 | Ingenieur | 1 |
| 7 | Mostafa | 29 | 7500.00 | Ingenieur | NULL |
+----+---------+-----+---------+------------+------+
Table - Departement
+--------+--------------+
| Id_dep | Nom_dep |
+--------+--------------+
| 1 | Informatique |
| 2 | RH |
| 3 | Vente |
| 4 | Strategies |
+--------+--------------+
Regroupement à l'aide d'une seule colonne
Regroupement à l'aide d'une seule colonne signifie placer toutes les lignes ayant la même valeur que cette colonne particulière dans un groupe.
Pour mieux comprendre l'effet de la clause GROUP BY, exécutons une requête simple qui renvoie toutes les entrées Age de la table Employes.
SELECT Age FROM Employes;
Cette requête produira le jeu de résultats suivant :
+-----+ | Age | +-----+ | 25 | | 30 | | 29 | | 30 | | 30 | | 29 | +-----+
Supposons que nous voulions obtenir les valeurs uniques pour Age. Nous pouvons utiliser une requête suivante
SELECT Age FROM Employes GROUP BY Age;
Cette requête produira le jeu de résultats suivant :
+-----+ | Age | +-----+ | 25 | | 29 | | 30 | +-----+
Notez que seuls trois résultats ont été renvoyés. C'est parce que nous n'avons que trois âges différents. La clause GROUP BY a regroupée tous les employés de la valeur Age="25" et n'a renvoyée qu'une seule ligne. La même chose avec les valeurs "29" et "30".
Groupe 1 - Age = 25 +-----+ | Age | +-----+ | 25 | +-----+ Groupe 2 - Age=29 +-----+ | Age | +-----+ | 29 | | 29 | +-----+ Groupe 3 - Age = 30 +-----+ | Age | +-----+ | 30 | | 30 | | 30 | +-----+
Vous pouvez maintenant compter le nombre d'employés de chaque groupe à l'aide de la clause COUNT
SELECT Age, count(*) AS "Nombre d'employés" FROM Employes GROUP BY Age;
Cette requête produira le jeu de résultats suivant :
+-----+--------------------+ | Age | Nombre d'employés | +-----+--------------------+ | 25 | 1 | | 29 | 2 | | 30 | 3 | +-----+--------------------+
Exemple 1 :
Compter le salaire moyen sur chaque groupe d'âge
SELECT Age, AVG(Salaire) AS "Salaire moyen" FROM Employes GROUP BY Age;
Cette requête produira le jeu de résultats suivant :
+-----+---------------+ | Age | Salaire moyen | +-----+---------------+ | 25 | 6000.000000 | | 29 | 6750.000000 | | 30 | 8000.133333 | +-----+---------------+
Exemple 2 :
Récupérez l'identifiant du département et le nombre d'employés dans chaque département.
SELECT Dep, COUNT(Dep) AS "Nombre d'employés" FROM Employes GROUP BY Dep;
Cette requête produira le jeu de résultats suivant :
+------+--------------------+ | Dep | Nombre d'employés | +------+--------------------+ | NULL | 0 | | 1 | 2 | | 2 | 1 | | 3 | 1 | | 4 | 1 | +------+--------------------+
Exemple 3 :
Récupérez le nom du département et le nombre d'employés dans chaque département.
SELECT D.Nom_dep, COUNT(E.Dep) AS "Nombre d'employés"
FROM Employes AS E INNER JOIN Departement AS D
ON E.Dep=D.Id_dep
GROUP BY D.Nom_dep;
Cette requête produira le jeu de résultats suivant :
+--------------+--------------------+ | Nom_dep | Nombre d'employés | +--------------+--------------------+ | Informatique | 2 | | RH | 1 | | Strategies | 1 | | Vente | 1 | +--------------+--------------------+
Regroupement sur plusieurs colonnes
Regroupement par plusieurs colonnes, par exemple, GROUP BY colonne1, colonne2. Cela signifie placer toutes les lignes avec les mêmes valeurs des colonnes colonne1 et colonne2 dans un groupe.
Exemple 4 :
Supposons maintenant que nous voulions regrouper tous les employés en fonction de leur âge et de leur département.
SELECT Age, Dep, COUNT(*) FROM Employes GROUP BY Age, Dep;
Cette requête produira le jeu de résultats suivant :
+-----+------+----------+ | Age | Dep | COUNT(*) | +-----+------+----------+ | 25 | 2 | 1 | | 29 | NULL | 1 | | 29 | 3 | 1 | | 30 | 1 | 2 | | 30 | 4 | 1 | +-----+------+----------+
Exemple 5 :
SELECT D.Nom_dep, E.Age , COUNT(E.Dep) AS "Nombre d'employés"
FROM Employes AS E INNER JOIN Departement AS D
ON E.Dep=D.Id_dep
GROUP BY D.Nom_dep, E.Age;
Cette requête produira le jeu de résultats suivant :
+--------------+-----+--------------------+ | Nom_dep | Age | Nombre d'employés | +--------------+-----+--------------------+ | Informatique | 30 | 2 | | RH | 25 | 1 | | Strategies | 30 | 1 | | Vente | 29 | 1 | +--------------+-----+--------------------+
Clause HAVING
Nous savons que la clause WHERE est utilisée pour imposer des conditions aux colonnes, mais que se passe-t-il si nous voulons imposer des conditions aux groupes?
C'est ici que la clause HAVING entre en vigueur. Nous pouvons utiliser la clause HAVING pour poser des conditions afin de décider quel groupe fera partie de l'ensemble des résultats finaux. De plus, nous ne pouvons pas utiliser les fonctions d'agrégation telles que SUM(), COUNT(), etc. avec la clause WHERE. Nous devons donc utiliser la clause HAVING si nous voulons utiliser l'une de ces fonctions dans les conditions.
Syntaxe :
SELECT colonne1, colonne2, ... colonneN,
fonction_agregation (nom_colonne)
FROM tables
[WHERE conditions]
GROUP BY colonne1[, colonne2, ... colonneN]
HAVING condition ;
Exemple 6 :
La requête suivante récupère les noms de département et le salaire moyen de chaque département
SELECT D.Nom_dep, AVG(E.Salaire) AS "Salaire moyen"
FROM Employes AS E INNER JOIN Departement AS D
ON E.Dep=D.Id_dep
GROUP BY D.Nom_dep;
Cette requête produira le jeu de résultats suivant :
+--------------+---------------+ | Nom_dep | Salaire moyen | +--------------+---------------+ | Informatique | 8500.200000 | | RH | 6000.000000 | | Strategies | 7000.000000 | | Vente | 6000.000000 | +--------------+---------------+
Supposons maintenant que nous ne voulions montrer que les départements dont le salaire moyen est supérieur à 6000 ?
SELECT D.Nom_dep, AVG(E.Salaire) AS "Salaire moyen"
FROM Employes AS E INNER JOIN Departement AS D
ON E.Dep=D.Id_dep
GROUP BY D.Nom_dep
HAVING AVG(E.Salaire) > 6000;
Cette requête produira le jeu de résultats suivant :
+--------------+---------------+ | Nom_dep | Salaire moyen | +--------------+---------------+ | Informatique | 8500.200000 | | Strategies | 7000.000000 | +--------------+---------------+
Commentaire(s)