Faut-il apprendre le SQL pour vérifier une requête ?

Non. Il suffit de reconnaître une dizaine de mots et de savoir ce qu'ils changent au résultat. Écrire une requête et la relire sont deux compétences différentes.

Que veut dire SELECT * ?

« Toutes les colonnes ». La documentation de PostgreSQL le décrit comme un raccourci pratique pour une requête ponctuelle, mais déconseillé dans un programme durable.

Comprendre une requête SQL sans savoir l'écrire

Q: Quelle différence entre WHERE et HAVING ?

Selon la documentation de PostgreSQL, WHERE choisit les lignes avant le calcul des totaux, HAVING choisit les groupes après ce calcul.

Une requête SQL (langage de requête structuré) se lit comme une phrase dans un ordre un peu inhabituel : quoi afficher, depuis où, avec quel filtre, regroupé comment, trié comment. Vous n'avez pas besoin de savoir l'écrire pour la vérifier. Il suffit de reconnaître une dizaine de mots, et de savoir lequel peut fausser votre chiffre.

La phrase type

Prenons une requête illustrative, sur une base qui aurait une table factures :

SELECT client, sum(montant_ht) AS total_ht
FROM factures
WHERE date_facture >= '2026-01-01'
GROUP BY client
HAVING sum(montant_ht) > 10000
ORDER BY total_ht DESC
LIMIT 10;

En français : « Pour chaque client, affiche le total hors taxes de ses factures depuis le 01/01/2026, garde seulement ceux qui dépassent 10 000, du plus gros au plus petit, et montre les 10 premiers. »

Les mots, un par un

Mot	Se lit	Ce qu'il faut vérifier
`SELECT`	« affiche »	Les colonnes demandées sont les bonnes (hors taxes ou toutes taxes ?)
`AS`	« appelle ce résultat »	Le nom donné ne trompe pas sur le contenu
`FROM`	« depuis la table »	C'est la bonne table (factures et non devis)
`JOIN … ON`	« relie à l'autre table par »	La liaison se fait sur la bonne colonne
`WHERE`	« seulement les lignes où »	Période, statut, site : le filtre correspond à votre question
`GROUP BY`	« pour chaque »	Le regroupement est celui que vous vouliez (par client, par mois)
`HAVING`	« seulement les groupes où »	Le seuil s'applique au total, pas à chaque ligne
`ORDER BY`	« trie par »	Le sens : `DESC` du plus grand au plus petit, `ASC` l'inverse
`LIMIT`	« montre les N premiers »	Il y a bien un tri avant
`DISTINCT`	« sans doublons »	Il est présent quand vous comptez des clients, pas des commandes

La documentation de PostgreSQL décrit la requête de base en trois parties : la liste de ce qu'on affiche, la clause FROM qui dit d'où viennent les lignes, et la clause WHERE facultative qui les filtre. Tout le reste précise ces trois parties.

Les quatre pièges à connaître

1. La jointure qui fait disparaître des lignes. Un JOIN simple ne garde que les lignes qui ont une correspondance dans les deux tables. La documentation de PostgreSQL le montre sur un exemple : une ville sans correspondance disparaît du résultat. Pour la garder, il faut un LEFT JOIN (jointure externe gauche), qui conserve toutes les lignes de la première table et laisse vides les colonnes de la seconde. Si vous cherchez « les clients sans commande », un JOIN simple ne les trouvera jamais.

2. La jointure qui multiplie les lignes. Relier des clients à leurs commandes donne une ligne par commande. Si la requête additionne ensuite une colonne qui appartient au client (son encours, par exemple), le total est compté autant de fois qu'il a de commandes.

3. WHERE ou HAVING. PostgreSQL l'explique ainsi : WHERE choisit les lignes avant le calcul des totaux, HAVING choisit les groupes après. « Les clients qui ont acheté pour plus de 10 000 » s'écrit avec HAVING. Avec WHERE montant_ht > 10000, on garderait seulement les factures de plus de 10 000, ce qui est une autre question.

4. LIMIT sans ORDER BY. La documentation de PostgreSQL prévient : sans ORDER BY, LIMIT renvoie un sous-ensemble imprévisible des lignes. « Les 10 meilleurs clients » sans tri, ce sont dix clients au hasard.

Les fonctions de calcul

Fonction	Ce qu'elle fait
`count(*)`	compte les lignes
`sum(colonne)`	additionne
`avg(colonne)`	fait la moyenne
`min(colonne)`, `max(colonne)`	plus petite et plus grande valeur

PostgreSQL les appelle fonctions d'agrégat : elles calculent un seul résultat à partir de plusieurs lignes. Avec GROUP BY, elles donnent un résultat par groupe.

Une méthode de lecture en trois passes

Lisez FROM et JOIN d'abord : de quelles tables part-on, et comment sont-elles reliées ?
Lisez WHERE ensuite : quelles lignes sont gardées ? Comparez avec les mots de votre question.
Lisez SELECT, GROUP BY et ORDER BY à la fin : qu'est-ce qui est calculé, pour chaque quoi, dans quel ordre ?

Ensuite, entraînez-vous sur nos exemples de requêtes SQL annotés, puis appliquez la liste de contrôle d'une requête générée. Et apprenez à reconnaître les mots qui ne lisent pas mais modifient : ils sont dans cette page.