Fonctions SQL et agrégations : COUNT, SUM, GROUP BY et HAVING

Combien d’alertes critiques non acquittées ? Quel est le temps moyen de déploiement par service ? Quel serveur a le plus gros disque ? Toutes ces questions se résolvent en une seule requête SQL grâce aux fonctions d’agrégation (COUNT, SUM, AVG, MIN, MAX) combinées avec GROUP BY.

Au-delà de l’agrégation, SQL propose des dizaines de fonctions intégrées pour manipuler les chaînes, les dates et les nombres — directement dans vos requêtes, sans passer par un langage de programmation. Ce guide couvre les fonctions les plus utiles au quotidien, avec les particularités de SQLite et les différences avec PostgreSQL/MySQL.

Ce que vous allez apprendre

• Compter, sommer, moyenner avec COUNT, SUM, AVG, MIN, MAX
• Regrouper les résultats avec GROUP BY
• Filtrer les groupes avec HAVING (distinct de WHERE)
• Manipuler les chaînes : UPPER, LOWER, TRIM, SUBSTR, concaténation avec ||
• Travailler avec les dates : date(), datetime(), strftime() en SQLite
• Convertir et gérer les NULL : CAST, COALESCE, NULLIF

Dans quel contexte ?

Les fonctions SQL sont utilisées constamment en administration :

• Compter les alertes par sévérité et par serveur
• Calculer le temps moyen de déploiement par service
• Trouver la date du dernier déploiement réussi pour chaque service
• Nettoyer des données (majuscules, espaces parasites) avant une migration
• Formater des dates pour un export CSV lisible par l’équipe

Ce guide ne couvre pas…

• Les fonctions de fenêtrage (ROW_NUMBER, RANK, LAG, LEAD) → voir le guide SQL avancé
• Les jointures (JOIN) → voir le guide Jointures et sous-requêtes
• La création de fonctions personnalisées (CREATE FUNCTION) → consultez la documentation de votre SGBD

Prérequis

• Savoir écrire un SELECT … WHERE (guide Syntaxe de base)
• La base fil rouge infra.db chargée dans ~/Projets/cours-sql
• Comprendre les jointures (guide précédent) pour les exemples multi-tables

Les fonctions d’agrégation

Les fonctions d’agrégation calculent une seule valeur à partir de plusieurs lignes.

COUNT : compter les lignes

-- Nombre total de serveurs
SELECT COUNT(*) FROM servers;

-- Nombre de serveurs actifs
SELECT COUNT(*) FROM servers WHERE active = 1;

COUNT(*) vs COUNT(colonne) vs COUNT(DISTINCT)

Expression	Comportement
COUNT(*)	Compte toutes les lignes (y compris celles avec des NULL)
COUNT(email)	Compte les lignes où email n’est pas NULL
COUNT(DISTINCT os)	Compte le nombre de valeurs uniques de os

Glissez pour voir

SELECT COUNT(*) AS total_users,
       COUNT(email) AS avec_email,
       COUNT(DISTINCT role) AS nb_roles
FROM   users;

SUM et AVG : somme et moyenne

-- RAM totale de tous les serveurs de production
SELECT SUM(ram_gb) AS ram_totale
FROM   servers
WHERE  environment = 'production' AND active = 1;

-- Durée moyenne de déploiement (en secondes)
SELECT AVG(duration_seconds) AS duree_moyenne
FROM   deployments
WHERE  status = 'success';

AVG ignore les NULL

AVG ne compte que les lignes non NULL. Si certaines lignes ont duration_seconds = NULL, elles sont exclues du calcul. Utilisez COALESCE pour traiter les NULL comme 0 si nécessaire.

MIN et MAX : valeurs extrêmes

-- Premier et dernier serveur créé
SELECT MIN(created_at) AS premier, MAX(created_at) AS dernier
FROM   servers;

-- Disque le plus grand
SELECT MAX(disk_gb) AS plus_gros_disque FROM servers;

MIN et MAX fonctionnent aussi sur les chaînes (ordre alphabétique) et les dates.

Regrouper avec GROUP BY

Principe : une ligne par groupe

GROUP BY divise les lignes en groupes selon une ou plusieurs colonnes, puis applique les fonctions d’agrégation sur chaque groupe :

-- Nombre de serveurs par environnement
SELECT environment, COUNT(*) AS nb_serveurs
FROM   servers
WHERE  active = 1
GROUP BY environment;

Résultat : une ligne par environment, avec le nombre de serveurs associé.

GROUP BY sur plusieurs colonnes

-- Nombre d'alertes par serveur et par sévérité
SELECT server_id, severity, COUNT(*) AS nb
FROM   alerts
GROUP BY server_id, severity
ORDER BY server_id, nb DESC;

GROUP BY avec jointure

Pour afficher le hostname au lieu de l’ID, combinez GROUP BY et JOIN :

SELECT sv.hostname, a.severity, COUNT(*) AS nb_alertes
FROM   alerts a
INNER JOIN servers sv ON sv.id = a.server_id
GROUP BY sv.hostname, a.severity
ORDER BY nb_alertes DESC;

Pièges courants : colonnes non agrégées dans le SELECT

Règle SQL : chaque colonne du SELECT doit être dans GROUP BY ou dans une fonction d'agrégation

-- ERREUR : hostname n'est ni dans GROUP BY ni dans une agrégation
SELECT hostname, COUNT(*)
FROM   servers
GROUP BY environment;

SQLite et PostgreSQL : renvoient une erreur explicite. MySQL (mode par défaut) : peut renvoyer une valeur aléatoire pour hostname — ce qui est encore plus dangereux. Activez ONLY_FULL_GROUP_BY dans MySQL pour détecter ces erreurs.

Filtrer les groupes avec HAVING

HAVING vs WHERE

Clause	Filtre	Exécuté
WHERE	Lignes individuelles avant le regroupement	Avant GROUP BY
HAVING	Groupes après le regroupement	Après GROUP BY

Glissez pour voir

-- WHERE filtre les lignes AVANT le regroupement
SELECT server_id, COUNT(*) AS nb
FROM   alerts
WHERE  severity = 'critical'
GROUP BY server_id;

-- HAVING filtre les groupes APRÈS le regroupement
SELECT server_id, COUNT(*) AS nb
FROM   alerts
GROUP BY server_id
HAVING COUNT(*) > 3;

Exemple : groupes au-dessus d’un seuil

-- Utilisateurs qui ont effectué plus de 3 déploiements
SELECT u.full_name, COUNT(*) AS nb_deploy
FROM   deployments d
INNER JOIN users u ON u.id = d.deployed_by
GROUP BY u.full_name
HAVING COUNT(*) > 3
ORDER BY nb_deploy DESC;

Fonctions de manipulation de chaînes

LENGTH, UPPER, LOWER, TRIM

SELECT LENGTH('bonjour');          -- 7
SELECT UPPER('bonjour');           -- BONJOUR
SELECT LOWER('BONJOUR');           -- bonjour
SELECT TRIM('  bonjour  ');        -- bonjour
SELECT LTRIM('  bonjour');         -- bonjour
SELECT RTRIM('bonjour  ');         -- bonjour

SUBSTR, REPLACE, concaténation

-- Extraire les 3 premiers caractères du hostname
SELECT SUBSTR(hostname, 1, 3) FROM servers;

-- Remplacer un domaine dans les emails
SELECT REPLACE(email, '@infra.local', '@newdomain.fr') FROM users WHERE email IS NOT NULL;

En SQLite (et PostgreSQL), la concaténation utilise || :

SELECT username || ' (' || role || ')' AS display FROM users;
-- Résultat : jdupont (admin)

Concaténation et NULL

En SQLite/PostgreSQL, si l’un des opérandes de || est NULL, le résultat est NULL. Utilisez COALESCE pour éviter cela :

SELECT username || ' <' || COALESCE(email, 'N/A') || '>' FROM users;

En MySQL, || est un OR logique — utilisez CONCAT() qui ignore les NULL.

Pattern matching au-delà de LIKE

SQLite ne dispose pas de ILIKE (PostgreSQL) ni de REGEXP natif. LIKE est insensible à la casse pour les lettres ASCII (A-Z) par défaut en SQLite :

-- Fonctionne en SQLite : LIKE est case-insensitive pour l'ASCII
SELECT * FROM users WHERE email LIKE '%@infra.local';

En PostgreSQL et MySQL

• PostgreSQL : ILIKE pour insensible à la casse, opérateur ~ pour les regex
• MySQL : LIKE est insensible à la casse par défaut (collation), REGEXP pour les regex

Fonctions de dates et heures

SQLite stocke les dates comme du texte au format ISO 8601 ('2026-04-13 08:30:00'). Les comparaisons avec <, >, BETWEEN fonctionnent correctement sur ce format. Les fonctions de date de SQLite sont différentes de celles de PostgreSQL et MySQL.

Date et heure courantes

SELECT date('now');           -- 2026-04-13
SELECT time('now');           -- 08:30:00
SELECT datetime('now');       -- 2026-04-13 08:30:00

Extraire une partie de la date avec strftime

SELECT strftime('%Y', created_at) AS annee,
       strftime('%m', created_at) AS mois,
       strftime('%w', created_at) AS jour_semaine
FROM   servers;

Formats courants : %Y (année), %m (mois), %d (jour), %H (heure), %M (minute), %S (seconde), %w (jour de la semaine 0=dimanche).

En PostgreSQL et MySQL

• PostgreSQL : EXTRACT(YEAR FROM created_at), EXTRACT(MONTH FROM created_at)
• MySQL : YEAR(created_at), MONTH(created_at)

Arithmétique de dates (modificateurs)

SQLite utilise des modificateurs au lieu de INTERVAL :

-- Alertes de moins de 24 heures
SELECT * FROM alerts
WHERE  created_at > datetime('now', '-24 hours');

-- Serveurs créés dans les 30 derniers jours
SELECT hostname, created_at FROM servers
WHERE  created_at > date('now', '-30 days');

-- Dans 7 jours
SELECT date('now', '+7 days');

Syntaxe INTERVAL en PostgreSQL et MySQL

• PostgreSQL : NOW() - INTERVAL '24 hours'
• MySQL : NOW() - INTERVAL 24 HOUR

Formater une date

-- SQLite : strftime avec le format souhaité
SELECT strftime('%d/%m/%Y %H:%M', created_at) AS date_fr
FROM   servers;
-- Résultat : 15/03/2025 09:00

En PostgreSQL et MySQL

• PostgreSQL : TO_CHAR(created_at, 'DD/MM/YYYY HH24:MI')
• MySQL : DATE_FORMAT(created_at, '%d/%m/%Y %H:%i')

Fonctions numériques

SELECT ROUND(3.14159, 2);    -- 3.14
SELECT ROUND(ram_gb * 1.0 / cpu_cores, 1) AS ram_par_core FROM servers;

SELECT ABS(-42);              -- 42
SELECT MAX(disk_gb) % 100 FROM servers;   -- modulo

FLOOR et CEIL en SQLite

SQLite ne dispose pas de FLOOR() et CEIL() natifs. Alternatives :

SELECT CAST(3.7 AS INTEGER);              -- 3 (troncature, équivalent FLOOR pour les positifs)
SELECT CAST(3.2 AS INTEGER) + 1;          -- 4 (équivalent CEIL pour les positifs non entiers)

PostgreSQL et MySQL disposent de FLOOR() et CEIL() natifs.

Fonctions de conversion

CAST

-- SQL standard (fonctionne partout)
SELECT CAST('42' AS INTEGER);
SELECT CAST(ram_gb AS REAL) / cpu_cores FROM servers;

Syntaxe :: de PostgreSQL

PostgreSQL offre le raccourci '42'::INTEGER et created_at::DATE. Ni SQLite ni MySQL ne supportent cette syntaxe — utilisez CAST.

COALESCE : remplacer les NULL

COALESCE renvoie la première valeur non NULL parmi ses arguments :

-- Afficher "non renseigné" si l'email est NULL
SELECT username, COALESCE(email, 'non renseigné') AS email FROM users;

-- Afficher "Aucune note" pour les serveurs sans note
SELECT hostname, COALESCE(notes, 'Aucune note') AS notes FROM servers;

-- Traiter les NULL comme 0 dans un calcul
SELECT SUM(COALESCE(duration_seconds, 0)) FROM deployments;

NULLIF : comparer deux valeurs

NULLIF(a, b) renvoie NULL si a = b, sinon renvoie a. Utile pour éviter les divisions par zéro :

-- Taux de succès par service (évite la division par zéro)
SELECT s.name,
       COUNT(CASE WHEN d.status = 'success' THEN 1 END) * 100.0
       / NULLIF(COUNT(*), 0) AS taux_succes
FROM   deployments d
INNER JOIN services s ON s.id = d.service_id
GROUP BY s.name;

Exercice pratique

Ouvrez sqlite3 infra.db et pratiquez :

1. Comptez le nombre d’alertes par sévérité.

   SELECT severity, COUNT(*) AS nb
   FROM   alerts
   GROUP BY severity
   ORDER BY nb DESC;

2. Calculez la durée moyenne de déploiement par utilisateur, uniquement pour ceux qui ont plus de 3 déploiements réussis.

   SELECT u.full_name, AVG(d.duration_seconds) AS duree_moyenne, COUNT(*) AS nb
   FROM   deployments d
   INNER JOIN users u ON u.id = d.deployed_by
   WHERE  d.status = 'success'
   GROUP BY u.full_name
   HAVING COUNT(*) > 3
   ORDER BY duree_moyenne;

3. Listez les serveurs créés ces 12 derniers mois avec la date formatée en français.

   SELECT hostname, os,
          strftime('%d/%m/%Y', created_at) AS date_creation
   FROM   servers
   WHERE  created_at > date('now', '-12 months')
   ORDER BY created_at DESC;

4. Remplacez les emails NULL par « non renseigné » et les notes NULL par « Aucune note ».

   SELECT username,
          COALESCE(email, 'non renseigné') AS email
   FROM   users;
   
   SELECT hostname,
          COALESCE(notes, 'Aucune note') AS notes
   FROM   servers;

5. Calculez la RAM totale et le nombre de cœurs par datacenter pour les serveurs actifs.

   SELECT datacenter,
          COUNT(*) AS nb_serveurs,
          SUM(ram_gb) AS ram_totale,
          SUM(cpu_cores) AS cores_totaux
   FROM   servers
   WHERE  active = 1
   GROUP BY datacenter;

Dépannage

Symptôme	Cause probable	Solution
column must appear in GROUP BY	Colonne dans le SELECT sans agrégation ni GROUP BY	Ajoutez la colonne au GROUP BY ou entourez-la d’une fonction d’agrégation
AVG donne un résultat inattendu	Les NULL sont ignorés par AVG	Utilisez COALESCE(col, 0) avant l’agrégation si les NULL doivent compter comme 0
Division par zéro	Le dénominateur est 0	Utilisez NULLIF(denominateur, 0)
HAVING ne filtre pas	Vous avez mis la condition dans WHERE au lieu de HAVING	Déplacez les conditions sur des agrégats dans HAVING
strftime renvoie NULL	La date n’est pas au format ISO 8601	Vérifiez que les données sont au format YYYY-MM-DD HH:MM:SS

Glissez pour voir

À retenir

• COUNT, SUM, AVG, MIN, MAX calculent une valeur par groupe de lignes
• GROUP BY définit les groupes — toute colonne du SELECT doit y figurer ou être dans une agrégation
• WHERE filtre avant le regroupement, HAVING filtre après
• COALESCE remplace les NULL par une valeur par défaut — indispensable pour les calculs
• NULLIF protège contre les divisions par zéro
• La concaténation utilise || en SQLite/PostgreSQL et CONCAT() en MySQL
• Les fonctions de dates SQLite utilisent strftime(), date(), datetime() avec des modificateurs ('-30 days', '+1 hour')

Prochaines étapes

SQL avancé CTE, fonctions de fenêtrage, vues et SQL:2023

Jointures et sous-requêtes Croisez les données de plusieurs tables avec JOIN et EXISTS

Administrer PostgreSQL Appliquez ces fonctions sur une vraie base PostgreSQL

×

📖 Voir la documentation →