Il est temps de plonger dans les erreurs classiques qui arrivent quand tu utilises ces fonctions. Même les pros du SQL se prennent parfois les pieds dans le tapis, et notre but ici, c’est d’apprendre à repérer ces pièges et à les éviter tranquille.
T’as déjà écrit une requête qui t’a sorti un message chelou du genre "column must appear in the GROUP BY clause or be used in an aggregate function" ? Ou alors, le résultat de ta requête avait l’air bizarre et tu pigeais pas pourquoi ? Ça, c’est juste la partie émergée de l’iceberg des erreurs typiques avec les fonctions d’agrégation. Ce cours, c’est ton guide de survie dans la mer des bugs et des incompréhensions.
Erreur 1 : Utiliser une colonne non agrégée hors du GROUP BY
Le problème
Tu as écrit une requête qui retourne des données agrégées, mais tu as ajouté une colonne qui n’est ni dans le groupement ni dans une fonction d’agrégation. Par exemple :
SELECT department, salary, SUM(salary)
FROM employees
GROUP BY department;
PostgreSQL va direct te dire :
ERROR: column "employees.salary" must appear in the GROUP BY clause or be used in an aggregate function
Pourquoi ça arrive ?
Quand tu utilises GROUP BY, PostgreSQL regroupe les lignes selon les colonnes indiquées. Mais si tu ajoutes une autre colonne (ici salary), PostgreSQL sait pas quoi en faire. Il sait pas si tu veux juste un salaire, la moyenne, ou autre chose.
Comment corriger ? Deux solutions :
- Assure-toi que toutes les colonnes non agrégées sont dans le
GROUP BY:
SELECT department, salary
FROM employees
GROUP BY department, salary;
- Ou alors, mets la colonne dans une fonction d’agrégation si ça a du sens :
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department;
Astuce : si PostgreSQL râle sur le GROUP BY, demande-toi : "Est-ce que j’ai vraiment besoin de cette colonne dans la requête ? Si oui, elle sert à quoi exactement ?"
Erreur 2 : Mauvaise gestion de COUNT() et NULL
Le problème : tu veux compter combien d’employés ont renseigné leur bonus, et tu écris :
SELECT COUNT(bonus) AS bonus_count
FROM employees;
Mais tu remarques que le résultat est plus bas que prévu. Pourquoi ? Parce que COUNT(column) ignore les lignes où column vaut NULL.
La solution : si tu veux compter toutes les lignes, utilise COUNT(*) :
SELECT COUNT(*) AS total_count
FROM employees;
Ou précise que tu veux seulement les lignes où le bonus n’est pas NULL :
SELECT COUNT(bonus) AS bonus_count
FROM employees
WHERE bonus IS NOT NULL;
Petit tip : si tu veux faire la différence entre les enregistrements avec NULL et l’absence totale de lignes dans la table, choisis bien entre COUNT(*) et COUNT(column).
Erreur 3 : Oublier de filtrer avec HAVING au lieu de WHERE
Le problème : tu veux trouver les départements où le salaire moyen dépasse 5000. Un nouveau dev pourrait écrire un truc comme ça :
SELECT department, AVG(salary) AS avg_salary
FROM employees
WHERE AVG(salary) > 5000
GROUP BY department;
PostgreSQL va te sortir une erreur :
ERROR: aggregate functions are not allowed in WHERE clause
Ça arrive parce que le filtre WHERE s’applique avant le groupement, alors que les fonctions d’agrégation sont calculées après le groupement. Du coup, la moyenne AVG(salary) n’est pas encore calculée au moment du WHERE.
Pour corriger ça, utilise HAVING pour filtrer les données agrégées :
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 5000;
Erreur 4 : Filtrer avec WHERE et se tromper dans l’ordre d’exécution
Le problème : tu veux savoir combien d’employés il y a dans les départements où l’âge des employés est supérieur à 30 ans. Ta requête pourrait ressembler à ça :
SELECT department, COUNT(*)
FROM employees
GROUP BY department
WHERE age > 30;
PostgreSQL va encore te casser :
ERROR: syntax error at or near "WHERE"
Pourquoi ? L’opérateur WHERE est toujours traité avant le GROUP BY. Là, tu as juste mis WHERE au mauvais endroit.
Pour éviter ça, change l’ordre : filtre d’abord les lignes, puis fais le groupement.
SELECT department, COUNT(*)
FROM employees
WHERE age > 30
GROUP BY department;
Erreur 5 : Utiliser NULL avec SUM(), AVG() et d’autres fonctions
Le problème : tu veux trouver le total des bonus donnés aux employés, et tu écris :
SELECT SUM(bonus) AS total_bonus
FROM employees;
Mais le résultat te paraît trop bas. C’est parce que la moitié des employés n’ont pas de bonus renseigné, et ces NULL sont juste ignorés.
La solution : gère les NULL à l’avance. Par exemple, tu peux remplacer les NULL par 0 :
SELECT SUM(COALESCE(bonus, 0)) AS total_bonus
FROM employees;
Maintenant, tous les NULL seront remplacés par 0, et la somme sera correcte.
On verra en détail comment marche la fonction COALESCE dans quelques cours.
Erreur 6 : Utiliser plusieurs fonctions d’agrégation sans comprendre leur lien
Le problème : tu veux compter le nombre total d’employés et le total des salaires. Mais tu écris un truc qui donne des résultats bizarres :
SELECT COUNT(salary) AS count_salary, SUM(salary) AS total_salary
FROM employees;
Pourquoi ça peut partir en vrille ? Si quelqu’un a un salaire à NULL, COUNT(salary) et SUM(salary) vont donner des résultats différents, et ça peut embrouiller.
Garde toujours en tête que les fonctions d’agrégation bossent chacune de leur côté. S’il y a des NULL, ça va donner des résultats différents. Utilise COALESCE ou COUNT(*) pour être sûr d’avoir des résultats cohérents :
SELECT COUNT(*) AS total_employees, SUM(COALESCE(salary, 0)) AS total_salary
FROM employees;
Erreur 7 : Requêtes non optimisées avec trop de groupements
Le problème : tu lances une requête avec plein de groupements, et elle tourne cinq heures au lieu de cinq minutes :
SELECT department, job_title, location, COUNT(*)
FROM employees
GROUP BY department, job_title, location;
Avant de faire un groupement, demande-toi si t’as vraiment besoin de toutes ces colonnes dans le GROUP BY. Plus il y a de valeurs uniques dans le groupe, plus la requête sera longue. Si tu peux, simplifie le groupement :
SELECT department, COUNT(*)
FROM employees
GROUP BY department;
Ces erreurs sont courantes, et même les devs SQL expérimentés y sont confrontés. J’espère qu’avec ça, tu pourras éviter ces pièges et écrire des requêtes qui tournent vite, juste et proprement.
GO TO FULL VERSION