Les fonctions d’agrégation SQL Oracle : guide complet avec exemples

Les fonctions d’agrégation SQL Oracle sont des outils incontournables pour analyser et synthétiser des volumes importants de données. Elles permettent de calculer des totaux, des moyennes, des comptages ou encore des extremums sur un ensemble de lignes. Maîtriser les fonctions d’agrégation SQL Oracle est essentiel pour tout développeur ou analyste travaillant avec une base de données relationnelle en entreprise.

Définition et utilisation des fonctions d’agrégation

Une fonction d’agrégation est une fonction SQL qui prend un ensemble de valeurs en entrée et retourne une valeur unique calculée à partir de cet ensemble. Contrairement aux fonctions scalaires qui opèrent ligne par ligne, les fonctions d’agrégation traitent un groupe de lignes pour produire un résultat synthétique.

En entreprise, ces fonctions sont utilisées dans de nombreux contextes métier :

• Finance : calculer le chiffre d’affaires total par mois, par région ou par produit.
• RH : déterminer le salaire moyen ou le nombre d’employés par département.
• Commerce : identifier les produits les plus vendus ou les commandes les plus élevées.
• Logistique : compter le nombre de livraisons en retard sur une période donnée.

Oracle propose les fonctions d’agrégation standard suivantes :

• COUNT() – compte le nombre de lignes ou de valeurs non nulles.
• SUM() – calcule la somme des valeurs d’une colonne numérique.
• AVG() – calcule la moyenne des valeurs d’une colonne numérique.
• MIN() – retourne la valeur minimale.
• MAX() – retourne la valeur maximale.

Ces fonctions s’utilisent généralement avec la clause GROUP BY pour regrouper les résultats selon un ou plusieurs critères, et avec la clause HAVING pour filtrer les groupes obtenus.

Syntaxe des fonctions d’agrégation SQL Oracle

La syntaxe générale d’une requête utilisant une fonction d’agrégation est la suivante :

SELECT colonne_de_groupe, FONCTION_AGREGATION(colonne)
FROM nom_table
[WHERE condition]
[GROUP BY colonne_de_groupe]
[HAVING condition_sur_agregat]
[ORDER BY colonne_de_groupe];

Détail des paramètres essentiels :

• FONCTION_AGREGATION(colonne) : l’une des fonctions COUNT, SUM, AVG, MIN ou MAX appliquée à une colonne.
• GROUP BY colonne_de_groupe : regroupe les lignes partageant la même valeur dans la colonne spécifiée. Toute colonne présente dans le SELECT et n’étant pas une fonction d’agrégation doit figurer dans le GROUP BY.
• WHERE : filtre les lignes avant l’agrégation.
• HAVING : filtre les groupes après l’agrégation. On ne peut pas utiliser WHERE pour filtrer sur un résultat d’agrégation.
• DISTINCT : option utilisable dans certaines fonctions (ex. COUNT(DISTINCT colonne)) pour ne compter que les valeurs uniques.

Exemples pratiques de fonctions d’agrégation Oracle

Exemple 1 – Analyse des ventes par département

Contexte métier : Le service commercial d’une entreprise souhaite connaître, pour chaque département, le nombre de commandes passées, le montant total des ventes et le montant moyen par commande, en ne conservant que les départements ayant généré plus de 50 000 € de chiffre d’affaires.

-- Analyse des ventes par département
-- On filtre uniquement les commandes validées (statut = 'VALIDEE')
-- On ne conserve que les départements avec un CA supérieur à 50 000

SELECT
    d.nom_departement,
    COUNT(c.id_commande)          AS nb_commandes,
    SUM(c.montant_total)          AS chiffre_affaires,
    ROUND(AVG(c.montant_total), 2) AS montant_moyen
FROM
    commandes c
    JOIN departements d ON c.id_departement = d.id_departement
WHERE
    c.statut = 'VALIDEE'
GROUP BY
    d.nom_departement
HAVING
    SUM(c.montant_total) > 50000
ORDER BY
    chiffre_affaires DESC;

Explication :

• COUNT(c.id_commande) compte le nombre de commandes par département (les valeurs NULL sont ignorées automatiquement).
• SUM(c.montant_total) additionne tous les montants pour obtenir le chiffre d’affaires.
• ROUND(AVG(...), 2) calcule la moyenne et l’arrondit à 2 décimales grâce à la fonction Oracle ROUND.
• HAVING SUM(...) > 50000 filtre les groupes après agrégation — ce qui serait impossible avec un simple WHERE.

Exemple 2 – Identification des produits les plus et les moins chers par catégorie

Contexte métier : Le service achats veut connaître, pour chaque catégorie de produit, le prix le plus bas, le prix le plus élevé et le nombre de références distinctes disponibles dans le catalogue.

-- Statistiques de prix par catégorie de produit
-- COUNT DISTINCT pour éviter de compter les doublons de références

SELECT
    cat.libelle_categorie,
    MIN(p.prix_unitaire)             AS prix_minimum,
    MAX(p.prix_unitaire)             AS prix_maximum,
    MAX(p.prix_unitaire)
        - MIN(p.prix_unitaire)       AS ecart_prix,
    COUNT(DISTINCT p.reference)      AS nb_references
FROM
    produits p
    JOIN categories cat ON p.id_categorie = cat.id_categorie
WHERE
    p.actif = 'O'
GROUP BY
    cat.libelle_categorie
ORDER BY
    ecart_prix DESC;

Explication :

• MIN et MAX identifient les bornes de prix par catégorie.
• La soustraction MAX - MIN directement dans le SELECT permet de calculer l’écart de prix, une astuce utile en Oracle.
• COUNT(DISTINCT p.reference) compte uniquement les références uniques, évitant les doublons potentiels dus aux jointures.
• Le filtre WHERE p.actif = 'O' exclut les produits désactivés avant l’agrégation pour alléger les calculs.

Erreurs courantes avec les fonctions d’agrégation Oracle

Erreur : utiliser WHERE à la place de HAVING pour filtrer un agrégat

Il s’agit de l’erreur la plus fréquente chez les débutants. Oracle retourne l’erreur ORA-00934: group function is not allowed here lorsqu’une fonction d’agrégation est placée dans une clause WHERE.

Code incorrect :

-- ERREUR : ORA-00934 - la fonction SUM ne peut pas être dans WHERE
SELECT id_departement, SUM(salaire) AS masse_salariale
FROM employes
WHERE SUM(salaire) > 100000   -- INTERDIT
GROUP BY id_departement;

Code corrigé :

-- CORRECT : le filtre sur l'agrégat se place dans HAVING
SELECT id_departement, SUM(salaire) AS masse_salariale
FROM employes
GROUP BY id_departement
HAVING SUM(salaire) > 100000;

Règle à retenir : WHERE filtre les lignes individuelles avant le regroupement. HAVING filtre les groupes après le calcul des agrégats. Ces deux clauses ne sont pas interchangeables.

Résumé

Bonnes pratiques Oracle

1. Filtrez avec WHERE avant GROUP BY : réduire le nombre de lignes traitées avant l’agrégation améliore significativement les performances, surtout sur des tables de plusieurs millions de lignes. N’agrégez que ce qui est nécessaire.
2. Utilisez COUNT(*) plutôt que COUNT(1) pour compter les lignes : en Oracle, les deux sont équivalents en termes de performance, mais COUNT(*) est la syntaxe standard recommandée par Oracle et plus lisible pour vos équipes. Réservez COUNT(colonne) lorsque vous souhaitez explicitement exclure les valeurs NULL.

Aller plus loin

Pour approfondir votre maîtrise de l’analyse de données avec Oracle, nous vous recommandons les sujets suivants :

• La clause GROUP BY en Oracle – comprenez comment structurer vos regroupements pour des rapports précis et performants.
• Les fonctions analytiques Oracle (OVER, PARTITION BY) – découvrez une alternative puissante aux agrégations classiques pour des calculs glissants et des classements.
• Les sous-requêtes en Oracle – apprenez à imbriquer des requêtes pour combiner agrégations et filtres complexes dans une seule instruction SQL.

Sur le même thème

• TO_CHAR Oracle : Convertir des données en chaîne SQL
• ADD_MONTHS Oracle : fonction SQL pour les dates
• Fonctions analytiques SQL Oracle – Guide complet
• ROW_NUMBER Oracle : fonction analytique SQL expliquée
• MONTHS_BETWEEN Oracle : calcul de mois entre deux dates
• LAST_DAY Oracle : Fonction SQL pour les dates

Veuillez laisser ce champ vide

Un nouveau tutoriel SQL par semaine

Nous ne spammons pas ! Consultez notre politique de confidentialité pour plus d’informations.

Vérifiez votre boite de réception ou votre répertoire d’indésirables pour confirmer votre abonnement.