Fonctions d'agrégation

• Fonctions scalaires
• Sommaire
• Regroupement

Les fonctions d'agrégation, ou de groupement, sont des fonctions qui vont regrouper les lignes. Elles agissent sur une colonne, et renvoient un résultat unique pour toutes les lignes sélectionnées (ou pour chaque groupe de lignes, mais nous verrons cela plus tard).

Elles servent majoritairement à faire des statistiques, comme nous allons le voir dans la première partie de ce chapitre (compter des lignes, connaître une moyenne, trouver la valeur maximale d'une colonne,…). Nous verrons ensuite la fonction GROUP_CONCAT() qui, comme son nom l'indique, est une fonction de groupement qui sert à concaténer des valeurs.

• Fonctions statistiques
• Concaténation

Fonctions statistiques

La plupart des fonctions d'agrégation vont vous permettre de faire des statistiques sur vos données.

Nombre de lignes

La fonction COUNT() permet de savoir combien de lignes sont sélectionnées par la requête.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- Combien de races avons-nous ? --
-- ---------------------------------
SELECT COUNT(*) AS nb_races
FROM Race;

-- Combien de chiens avons-nous ? --
-- ---------------------------------
SELECT COUNT(*) AS nb_chiens
FROM Animal 
INNER JOIN Espece ON Espece.id = Animal.espece_id
WHERE Espece.nom_courant = 'Chien';

COUNT(*) ou COUNT(colonne)

Vous l'avez vu, j'ai utilisé COUNT(*) dans les exemples ci-dessus. Cela signifie que l'on compte tout simplement les lignes, sans se soucier de ce qu'elles contiennent.

Par contre, si on utilise COUNT(colonne), seules les lignes dont la valeur de colonne n'est pas NULL seront prises en compte.

Exemple : comptons les lignes de la table Animal, avec COUNT(*) et COUNT(race_id).

1
2

SELECT COUNT(race_id), COUNT(*)
FROM Animal;

Il n'y a donc que 31 animaux sur nos 60 pour lesquels la race est définie.

Doublons

Comme dans une requête SELECT tout à fait banale, il est possible d'utiliser le mot-clé DISTINCT pour ne pas prendre en compte les doublons.

Exemple : comptons le nombre de races distinctes définies dans la table Animal.

1
2

SELECT COUNT(DISTINCT race_id)
FROM Animal;

Parmi nos 31 animaux dont la race est définie, on trouve donc 7 races différentes.

Minimum et maximum

Nous avons déjà eu l'occasion de rencontrer la fonction MIN(x), qui retourne la plus petite valeur de x. Il existe également une fonction MAX(x), qui renvoie la plus grande valeur de x.

1
2

SELECT MIN(prix), MAX(prix)
FROM Race;

Notez que MIN() et MAX() ne s'utilisent pas uniquement sur des données numériques. Si vous lui passez des chaînes de caractères, MIN() récupérera la première chaîne dans l'ordre alphabétique, MAX() la dernière ; avec des dates, MIN() renverra la plus vieille et MAX() la plus récente.

Exemple :

1
2

SELECT MIN(nom), MAX(nom), MIN(date_naissance), MAX(date_naissance)
FROM Animal;

Somme et moyenne

Somme

La fonction SUM(x) renvoie la somme de x.

1
2

SELECT SUM(prix)
FROM Espece;

Moyenne

La fonction AVG(x) (du mot anglais average) renvoie la valeur moyenne de x.

1
2

SELECT AVG(prix)
FROM Espece;

Concaténation

Principe

Avec les fonctions d'agrégation, on regroupe plusieurs lignes. Les fonctions statistiques nous permettent d'avoir des informations fort utiles sur le résultat d'une requête, mais parfois, il est intéressant d'avoir également les valeurs concernées. Ceci est faisable avec GROUP_CONCAT(nom_colonne). Cette fonction concatène les valeurs de nom_colonne pour chaque groupement réalisé.

Exemple : on récupère la somme des prix de chaque espèce, et on affiche les espèces concernées par la même occasion.

1
2

SELECT SUM(prix), GROUP_CONCAT(nom_courant)
FROM Espece;

Syntaxe

Voici la syntaxe de cette fonction :

1
2
3
4
5

GROUP_CONCAT(
              [DISTINCT] col1 [, col2, ...]
              [ORDER BY col [ASC | DESC]]
              [SEPARATOR sep]
            )

• DISTINCT : sert comme d'habitude à éliminer les doublons.
• col1 : est le nom de la colonne dont les valeurs doivent être concaténées. C'est le seul argument obligatoire.
• col2,… : sont les éventuelles autres colonnes (ou chaînes de caractères) à concaténer.
• ORDER BY : permet de déterminer dans quel ordre les valeurs seront concaténées.
• SEPARATOR : permet de spécifier une chaîne de caractères à utiliser pour séparer les différentes valeurs. Par défaut, c'est une virgule.

Exemples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

-- --------------------------------------
-- CONCATENATION DE PLUSIEURS COLONNES --
-- --------------------------------------
SELECT SUM(Race.prix), GROUP_CONCAT(Race.nom, Espece.nom_courant)
FROM Race
INNER JOIN Espece ON Espece.id = Race.espece_id;

-- ---------------------------------------------------
-- CONCATENATION DE PLUSIEURS COLONNES EN PLUS JOLI --
-- ---------------------------------------------------
SELECT SUM(Race.prix), GROUP_CONCAT(Race.nom, ' (', Espece.nom_courant, ')')
FROM Race
INNER JOIN Espece ON Espece.id = Race.espece_id;

-- ---------------------------
-- ELIMINATION DES DOUBLONS --
-- ---------------------------
SELECT SUM(Espece.prix), GROUP_CONCAT(DISTINCT Espece.nom_courant) -- Essayez sans le DISTINCT pour voir
FROM Espece
INNER JOIN Race ON Race.espece_id = Espece.id;

-- --------------------------
-- UTILISATION DE ORDER BY --
-- --------------------------
SELECT SUM(Race.prix), GROUP_CONCAT(Race.nom, ' (', Espece.nom_courant, ')' ORDER BY Race.nom DESC)
FROM Race
INNER JOIN Espece ON Espece.id = Race.espece_id;

-- ----------------------------
-- CHANGEMENT DE SEPARATEUR  --
-- ----------------------------
SELECT SUM(Race.prix), GROUP_CONCAT(Race.nom, ' (', Espece.nom_courant, ')' SEPARATOR ' - ')
FROM Race
INNER JOIN Espece ON Espece.id = Race.espece_id;

En résumé

• La plupart des fonctions d'agrégation permettent de faire des statistiques sur les données : nombre de lignes, moyenne d'une colonne,…
• COUNT(*) compte toutes les lignes quel que soit leur contenu, tandis que COUNT(colonne_x) compte les lignes pour lesquelles colonne_x n'est pas NULL.
• GROUP_CONCAT(colonne_x) permet de concaténer les valeurs de colonne_x dont les lignes ont été groupées par une autre fonction d'agrégation.

• Fonctions scalaires
• Sommaire
• Regroupement