SQL Server

Ordre d’une requête SQL : ordre d’écriture et ordre logique de traitement

On écrit SELECT en premier, mais SQL Server commence logiquement par FROM. Découvrez l’ordre logique de traitement d’une instruction SELECT et ce qu’il explique sur les alias, WHERE et HAVING, et GROUP BY.

Par JaviPublié 10 min de lectureDébutant

Dans la leçon précédente, vous avez appris les clauses d’une instruction SELECT et l’ordre dans lequel il faut les écrire. Cet ordre commence par SELECT. On suppose naturellement que SQL Server lit la requête de la même façon : d’abord les colonnes, puis la table, puis le filtre.

Ce n’est pas le cas. Cette leçon, cinquième étape des Fondamentaux de SQL Server, présente l’ordre dans lequel les clauses sont traitées logiquement, et montre pourquoi le connaître rend évidentes plusieurs erreurs déroutantes.

Deux ordres pour une même requête

L’ordre d’écriture est la syntaxe : l’ordre dans lequel les clauses doivent apparaître dans la requête.

  1. SELECT
  2. FROM
  3. JOIN
  4. WHERE
  5. GROUP BY
  6. HAVING
  7. ORDER BY

L’ordre logique de traitement est l’ordre dans lequel les clauses sont évaluées conceptuellement, chacune travaillant sur le résultat de la précédente :

  1. FROM
  2. JOIN
  3. WHERE
  4. GROUP BY
  5. HAVING
  6. SELECT
  7. ORDER BY
  • Ordre d’écritureComment vous tapez la requête
    1. 1SELECT
    2. 2FROM
    3. 3JOIN
    4. 4WHERE
    5. 5GROUP BY
    6. 6HAVING
    7. 7ORDER BY
  • Traitement logiqueComment le sens est évalué
    1. 1FROM
    2. 2JOIN
    3. 3WHERE
    4. 4GROUP BY
    5. 5HAVING
    6. 6SELECT
    7. 7ORDER BY
Ordre d’écriture et ordre logique de traitement. Les mêmes clauses, dans un ordre différent. SELECT s’écrit en premier mais n’est évalué logiquement que vers la fin, une fois les lignes lues, filtrées et regroupées.

Lisez l’ordre logique comme une histoire. D’abord, SQL Server décide d’où viennent les lignes (FROM, JOIN). Ensuite, il écarte les lignes qui ne correspondent pas (WHERE). Puis il regroupe ce qui reste (GROUP BY) et écarte les groupes qui ne correspondent pas (HAVING). Ce n’est qu’alors qu’il construit les colonnes du résultat (SELECT), et enfin il les trie (ORDER BY).

Un modèle logique, pas le plan d’exécution physique

C’est la mise en garde la plus importante de la leçon. L’ordre logique de traitement décrit ce que signifie une requête : quels noms sont visibles dans quelle clause et ce que reçoit chaque étape. Il ne décrit pas ce que SQL Server fait physiquement, étape par étape, quand il exécute votre requête.

Le travail physique est décidé par l’optimiseur de requêtes, qui peut lire les tables dans un autre ordre, appliquer les filtres plus tôt, utiliser des index ou combiner des étapes, du moment que le résultat est celui que décrit le modèle logique. La documentation de Microsoft fait la même distinction : l’ordre réel d’exécution physique est déterminé par le processeur de requêtes et peut varier. C’est un sujet pour la partie Performances et optimisation du site. Pour écrire des requêtes correctes, c’est le modèle logique qu’il faut garder en tête.

Pourquoi un alias ne fonctionne pas dans WHERE

Dans la leçon précédente, vous avez nommé une colonne calculée avec AS. Supposons que vous vouliez retrouver un client par ce nom complet :

Requête SQL: Pourquoi un alias ne fonctionne pas dans WHERET-SQL
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FullName = 'Ana Torres';
T-SQL4 lignesAffichage en lecture seule. Aucune connexion à une base de données.

SQL Server répond « Invalid column name ‘FullName’. »

L’ordre logique l’explique. WHERE est évalué à l’étape 3. L’alias FullName est créé dans SELECT, à l’étape 6. Quand WHERE s’exécute, FullName n’existe pas encore ; les seuls noms disponibles sont les colonnes de dbo.Customers.

Deux façons correctes de l’écrire :

Requête SQL: Pourquoi un alias ne fonctionne pas dans WHERE (2)T-SQL
-- Filter on the real columns.
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FirstName = 'Ana'
  AND LastName = 'Torres';

-- Or repeat the expression in WHERE.
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FirstName + ' ' + LastName = 'Ana Torres';
T-SQL12 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les deux renvoient Ana Torres. La première est généralement préférable : elle compare de simples colonnes, ce qui est plus lisible et, comme vous le verrez bien plus tard dans les leçons sur les performances, plus facile à exploiter avec des index.

Pourquoi ORDER BY peut utiliser un alias

Triez maintenant sur ce même alias :

Requête SQL: Pourquoi ORDER BY peut utiliser un aliasT-SQL
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
ORDER BY FullName;
T-SQL4 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Cela fonctionne. ORDER BY est l’étape 7, après que SELECT a créé FullName : l’alias est donc visible. Les dix clients reviennent triés par nom complet, d’Ana Torres à Jonas Weber.

La même règle explique pourquoi GROUP BY ne peut pas non plus utiliser un alias de SELECT dans SQL Server : GROUP BY est l’étape 4, avant que l’alias existe.

WHERE ou HAVING

Les deux clauses filtrent, mais à des moments différents de l’ordre logique, et sur des choses différentes.

  • WHERE (étape 3) filtre des lignes, avant tout regroupement.
  • HAVING (étape 5) filtre des groupes, après que GROUP BY les a construits.

Voilà pourquoi ceci échoue :

Requête SQL: WHERE ou HAVINGT-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE COUNT(*) > 1
GROUP BY State;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

SQL Server signale qu’un agrégat ne peut pas apparaître dans la clause WHERE. À l’étape 3, il n’existe encore aucun groupe : il n’y a rien à compter par État. Déplacez la condition dans HAVING, qui s’exécute une fois les groupes créés :

Requête SQL: WHERE ou HAVING (2)T-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
GROUP BY State
HAVING COUNT(*) > 1;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Elle renvoie FL avec 3 et TX avec 2.

Les deux peuvent fonctionner ensemble. Une condition sur les lignes individuelles va dans WHERE ; une condition sur le groupe va dans HAVING :

Requête SQL: WHERE ou HAVING (3)T-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE CreatedDate >= '20250201'
GROUP BY State
HAVING COUNT(*) > 1;
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

WHERE retire d’abord Ana Torres, la seule cliente créée avant février 2025. Il reste deux clients en Floride et deux au Texas : les deux groupes passent toujours HAVING. Filtrer les lignes tôt dans WHERE est d’ailleurs naturel : inutile de regrouper des lignes que l’on va écarter.

GROUP BY vient avant SELECT

Comme GROUP BY (étape 4) s’exécute avant SELECT (étape 6), au moment où SELECT construit le résultat il n’y a plus de clients individuels, seulement des groupes. C’est la raison de cette erreur :

Requête SQL: GROUP BY vient avant SELECTT-SQL
SELECT
    State,
    City,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
GROUP BY State;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

« Column ‘dbo.Customers.City’ is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause. » Le groupe de Floride contient Miami, Orlando et Tampa. SELECT reçoit un groupe et doit donner une seule ville : il n’y a pas de bonne réponse. Regroupez aussi par ville (GROUP BY State, City, une ligne par État et ville) ou résumez-la avec un agrégat, comme COUNT(DISTINCT City).

L’exemple complet, dans l’ordre logique

Reprenez la requête complète de la leçon précédente et suivez-la à travers les sept étapes logiques, en comptant les lignes au passage :

Requête SQL: L’exemple complet, dans l’ordre logiqueT-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE State IS NOT NULL
GROUP BY State
HAVING COUNT(*) > 1
ORDER BY CustomerCount DESC;
T-SQL8 lignesAffichage en lecture seule. Aucune connexion à une base de données.
  1. FROM lit dbo.Customers : 10 lignes.
  2. JOIN : il n’y en a pas, donc toujours 10 lignes.
  3. WHERE garde les lignes où State IS NOT NULL : tous les clients ont un État, il reste donc 10 lignes.
  4. GROUP BY transforme ces 10 lignes en 7 groupes : FL avec 3 clients, TX avec 2, et WA, CO, OR, MA et IL avec 1 chacun.
  5. HAVING garde les groupes où COUNT(*) > 1 : il reste 2 groupes, FL et TX.
  6. SELECT construit le résultat pour chaque groupe : l’État et son nombre de clients, nommé CustomerCount.
  7. ORDER BY trie sur CustomerCount, du plus grand au plus petit : FL (3), puis TX (2).

Deux détails de cette requête ne prennent sens que dans l’ordre logique. HAVING répète COUNT(*) au lieu d’utiliser l’alias : HAVING CustomerCount > 1 échoue avec « Invalid column name ‘CustomerCount’ », car l’étape 5 s’exécute avant que l’étape 6 crée ce nom. ORDER BY, à l’étape 7, peut utiliser CustomerCount, car il existe déjà. Une fois les étapes en tête, la règle n’a plus besoin d’être apprise par cœur : un nom ne peut être utilisé que dans une étape qui vient après celle qui le crée.

Assembler les deux ordres

Quand une requête échoue ou renvoie un résultat surprenant, parcourez-la dans l’ordre logique au lieu de la lire de haut en bas :

  1. FROM / JOIN : quelles lignes sont en jeu ?
  2. WHERE : lesquelles survivent ?
  3. GROUP BY : comment les survivantes sont-elles regroupées ?
  4. HAVING : quels groupes survivent ?
  5. SELECT : que calcule-t-on et comment nomme-t-on chaque ligne ou groupe restant ?
  6. ORDER BY : dans quel ordre le résultat est-il renvoyé ?

Deux détails s’intègrent à ce modèle : DISTINCT s’applique juste après SELECT, et TOP s’applique en dernier, après ORDER BY. C’est pourquoi TOP avec ORDER BY donne un ensemble de lignes prévisible.

Étape suivante

Vous connaissez maintenant deux ordres : celui que vous écrivez et celui qui donne son sens à la requête. La leçon suivante, Filtrer les données avec WHERE dans SQL Server, approfondit l’étape 3 : comparaisons, AND et OR, IN, BETWEEN, LIKE et NULL.

Le parcours complet se trouve sur le hub Fondamentaux de SQL Server.

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Quelle clause s’écrit avant FROM mais est évaluée logiquement après ?
Question 2 sur 2Pourquoi l’ordre logique de la requête est-il important ?

Fondamentaux de SQL Server

Leçon 5 sur 25

Continuer vers la leçon suivante

Filtrer les données avec WHERE dans SQL Server

Continuer vers la leçon 6

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL