SQL Server

Comprendre les parties d’une instruction SELECT dans SQL Server

Le rôle de chaque clause d’une instruction SELECT en T-SQL, les parties obligatoires et facultatives, et la lecture d’une requête complète de SELECT à ORDER BY.

Par JaviPublié 9 min de lectureDébutant

Dans la leçon précédente, vous avez écrit vos premières requêtes : SELECT quelques colonnes FROM une table, parfois avec un WHERE et un ORDER BY. Ces requêtes utilisaient déjà la plupart des briques de T-SQL. Simplement, pas toutes à la fois.

Cette leçon, quatrième étape des Fondamentaux de SQL Server, démonte l’instruction SELECT. Vous verrez les sept clauses que vous rencontrerez dans presque toutes les requêtes que vous lirez, le rôle de chacune, celles qui sont obligatoires, et comment elles s’assemblent dans un exemple complet sur la table d’entraînement dbo.Customers.

Une instruction SELECT est une suite de clauses

Une clause est une partie d’une instruction qui commence par un mot-clé et remplit une seule fonction. FROM dbo.Customers est une clause. WHERE State = 'FL' en est une autre. Une instruction SELECT est une suite de clauses écrites dans un ordre fixe :

Requête SQL: Une instruction SELECT est une suite de clausesT-SQL
SELECT    -- which columns or values to return
FROM      -- where the rows come from
JOIN      -- other tables to combine with (optional)
WHERE     -- which rows to keep (optional)
GROUP BY  -- how to group rows (optional)
HAVING    -- which groups to keep (optional)
ORDER BY  -- how to sort the final result (optional)
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Ce bloc n’est pas une requête exécutable : c’est le squelette. Vous n’êtes jamais obligé d’utiliser toutes les clauses, mais quand vous en utilisez plusieurs, elles doivent apparaître dans cet ordre. Écrire WHERE avant FROM, ou ORDER BY avant GROUP BY, est une erreur de syntaxe.

    1. ObligatoireSELECT
    2. Colonnes et résultat
    1. Point de départFROM
    2. Table source
    1. FacultatifJOIN
    2. Combiner des tables
    1. FacultatifWHERE
    2. Filtrer les lignes
    1. FacultatifGROUP BY
    2. Créer des groupes
    1. FacultatifHAVING
    2. Filtrer les groupes
    1. FacultatifORDER BY
    2. Trier le résultat final
L’anatomie d’une instruction SELECT. Chaque clause a une seule fonction. SELECT et FROM sont le point de départ de toute requête ; les autres s’ajoutent quand la question l’exige.

Les parties obligatoires : SELECT et FROM

SELECT indique ce que doit contenir le résultat. En général, c’est une liste de colonnes, mais ce peut aussi être des valeurs calculées, comme FirstName + ' ' + LastName, ou des synthèses comme COUNT(*). Chaque élément de la liste devient une colonne du résultat. Vous pouvez nommer un élément avec AS : c’est un alias de colonne.

Requête SQL: Les parties obligatoires : SELECT et FROMT-SQL
SELECT
    CustomerId,
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers;
T-SQL4 lignesAffichage en lecture seule. Aucune connexion à une base de données.

FROM indique d’où viennent les lignes : une table comme dbo.Customers, une vue ou, plus loin dans cette série, plusieurs tables jointes.

À strictement parler, seul SELECT est obligatoire. SELECT 1 + 1; ou SELECT GETDATE(); s’exécutent sans FROM, car ils ne lisent aucune table. C’est pratique pour une vérification rapide. Mais dès que vous voulez des données stockées dans une table, il faut FROM ; en pratique, toute requête de travail commence donc par ces deux clauses.

Les clauses facultatives

Tout ce qui suit FROM est facultatif. Chaque clause ne s’ajoute que si la question l’exige.

JOIN fait entrer dans la requête les lignes d’une deuxième table, associées sur une colonne commune aux deux tables. Par exemple, une table de commandes jointe aux clients sur CustomerId permet d’afficher dans un même résultat la commande et le nom du client. Notre base d’entraînement ne contient encore qu’une table : il n’y a donc pas de jointure dans cette leçon. Les jointures ont leur propre étape du parcours.

WHERE filtre les lignes. Chaque ligne est testée avec la condition, et seules celles pour lesquelles elle est vraie sont conservées : WHERE State = 'FL' garde les clients de Floride et écarte tous les autres. La leçon sur WHERE le traite en détail.

GROUP BY transforme de nombreuses lignes en groupes. GROUP BY State met tous les clients de Floride dans un groupe, tous ceux du Texas dans un autre, et ainsi de suite. Le résultat contient alors une ligne par groupe, et non une ligne par client. Le regroupement s’accompagne presque toujours d’une fonction d’agrégation comme COUNT(*), SUM ou AVG, qui calcule une valeur par groupe.

HAVING filtre les groupes, comme WHERE filtre les lignes. HAVING COUNT(*) > 1 ne garde que les groupes de plus d’une ligne. Cette clause n’a de sens qu’avec un regroupement ou des agrégats.

ORDER BY trie le résultat final. Sans elle, SQL Server renvoie les lignes dans l’ordre qui lui coûte le moins, et cet ordre peut changer d’une exécution à l’autre. Si l’ordre compte pour la personne qui lit le résultat, dites-le avec ORDER BY.

Une requête complète

Voici une requête qui utilise toutes les clauses sauf JOIN. Elle répond à une vraie question : quels États comptent plus d’un client, et combien chacun en a-t-il ?

Requête SQL: Une requête complèteT-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.

Sur les dix clients de JaviBuildsLab, elle renvoie deux lignes :

State CustomerCount
FL 3
TX 2

Lisez-la clause par clause :

  • SELECT State, COUNT(*) AS CustomerCount demande deux colonnes : le code de l’État, et le nombre de lignes de chaque groupe, nommé CustomerCount.
  • FROM dbo.Customers lit la table d’entraînement.
  • WHERE State IS NOT NULL écarte, avant tout regroupement, les clients sans État. Tous nos clients en ont un : aujourd’hui la clause n’enlève rien, mais elle protège le résultat si une ligne sans État est ajoutée un jour. (IS NOT NULL est la bonne façon de tester une valeur manquante ; = NULL ne fonctionne pas, comme l’explique la leçon sur WHERE.)
  • GROUP BY State crée un groupe par État : trois clients en FL, deux en TX, un chacun en WA, CO, OR, MA et IL.
  • HAVING COUNT(*) > 1 ne garde que les groupes de plus d’un client : FL et TX.
  • ORDER BY CustomerCount DESC trie le résultat du plus grand nombre au plus petit. DESC signifie décroissant ; la valeur par défaut, ASC, est croissante.

Remarquez que chaque clause réduit ou transforme ce que la précédente a produit. Cet enchaînement est au cœur de la leçon suivante, qui montre que SQL Server n’évalue pas les clauses dans l’ordre où vous les écrivez.

Requêtes simples et requêtes avancées utilisent les mêmes clauses

Une requête simple et une requête qui a demandé une journée de travail sont faites des mêmes pièces. La différence tient au nombre de clauses utilisées et à ce que fait chacune.

La requête de la leçon 3 utilise trois clauses :

Requête SQL: Requêtes simples et requêtes avancées utilisent les mêmes clausesT-SQL
SELECT
    CustomerId,
    FirstName,
    LastName
FROM dbo.Customers
WHERE State = 'FL';
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Celle de la section précédente en utilise six. Un rapport de production peut ajouter plusieurs jointures, un WHERE plus long avec de nombreuses conditions et davantage d’agrégats, mais il se lit toujours comme SELECT … FROM … JOIN … WHERE … GROUP BY … HAVING … ORDER BY. Face à une longue requête, repérez d’abord les mots-clés des clauses. Ils vous disent où sont définies les colonnes, d’où viennent les données, comment elles sont filtrées, puis résumées et triées.

Conventions de mise en forme

SQL Server se moque de la mise en page, mais pas les personnes qui lisent vos requêtes. Les conventions utilisées dans toute cette série sont courantes dans les équipes SQL Server :

  • Mots-clés en majuscules : SELECT, FROM, WHERE, GROUP BY. Ils se distinguent des noms de tables et de colonnes.
  • Une clause par ligne, alignée à gauche, pour voir la structure d’un coup d’œil.
  • Une colonne par ligne dans les longues listes SELECT, en retrait sous SELECT. Ajouter, retirer ou commenter une colonne ne touche alors qu’une ligne.
  • Des noms en deux parties pour les tables : dbo.Customers, pas Customers.
  • Des alias avec AS : COUNT(*) AS CustomerCount se lit mieux que COUNT(*) CustomerCount et évite la surprise de la virgule oubliée vue en leçon 3.
  • Un point-virgule à la fin de chaque instruction.

Certaines équipes placent les virgules en début de ligne plutôt qu’en fin, ou mettent en retrait les conditions AND et OR sous WHERE. Tout style cohérent convient. L’essentiel est que chaque clause soit facile à repérer.

Erreurs courantes avec les clauses

Des clauses dans le mauvais ordre. SELECT State FROM dbo.Customers ORDER BY State WHERE State <> 'FL'; échoue avec « Incorrect syntax near the keyword ‘WHERE’. » WHERE doit venir avant ORDER BY.

Filtrer un agrégat dans WHERE. WHERE COUNT(*) > 1 n’est pas autorisé : WHERE travaille sur les lignes individuelles, avant que les groupes existent. Les conditions sur les groupes vont dans HAVING. La leçon suivante explique pourquoi.

Sélectionner une colonne non regroupée. Avec GROUP BY State, écrire SELECT State, City, COUNT(*) échoue : un groupe de trois clients de Floride a trois villes différentes, et SQL Server ne peut pas en choisir une. Chaque colonne de la liste SELECT doit figurer dans GROUP BY ou se trouver dans une fonction d’agrégation.

Attendre un ordre sans ORDER BY. Un résultat qui revient trié par hasard n’est pas garanti de le rester.

Étape suivante

Vous savez maintenant nommer chaque clause d’une instruction SELECT et dire à quoi elle sert. La leçon suivante, Ordre d’une requête SQL : ordre d’écriture et ordre logique de traitement, explique dans quel ordre ces clauses sont évaluées logiquement, et pourquoi cet ordre explique les erreurs ci-dessus.

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 2Que précise la liste SELECT ?
Question 2 sur 2Quel est le rôle de FROM dans un SELECT simple ?

Fondamentaux de SQL Server

Leçon 4 sur 25

Continuer vers la leçon suivante

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

Continuer vers la leçon 5

Étiquettes

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