Langage SQL

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

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 |
+--------------+---------------+

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :