Éléments d'une instruction SELECT

La syntaxe complète de l'instruction SELECT est complexe mais en voici les principales clauses :

SELECT select_list

[ INTO new_table_name ]

FROM table_list

[ WHERE search_conditions ]

[ GROUP BY group_by_list ]

[ HAVING search_conditions ]

[ ORDER BY order_list [ ASC | DESC ] ]

select_list

Décrit les colonnes du jeu de résultats. Il s'agit d'une liste d'expressions séparées par des virgules. Chaque expression définit à la fois le format (type de données et taille) et la source des données de la colonne du jeu de résultats. Chaque expression de la liste de sélection fait généralement référence à une colonne de la table ou de la vue source d'où proviennent les données, mais elle peut être toute autre expression, telle qu'une constante ou une fonction Transact-SQL. Si l'expression * figure dans une liste de sélection, toutes les colonnes de la table source sont retournées.

INTO new_table_name

Précise que le jeu de résultats sert à créer une nouvelle table. new_table_name indique le nom que portera la nouvelle table.

FROM table_list

Indique la liste des tables d'où sont extraites les données du jeu de résultats. Les données peuvent provenir de :

• Tables de base du serveur local exécutant SQL Server 2005.
• Vues dans l'instance locale de SQL Server. SQL Server résout en interne la référence à une vue par rapport aux tables de base qui constituent la vue.
• Tables liées. Ce sont les tables des sources de données OLE DB accessibles par SQL Server. Ceci s'appelle une requête distribuée. Les sources de données OLE DB sont accessibles à partir de SQL Server en les associant à un serveur lié ou en faisant référence à la source de données dans une fonction OPENROWSET ou OPENQUERY.

La clause FROM peut également contenir des spécifications de jointure. Elles définissent le chemin d'accès spécifique que SQL Server doit utiliser pour passer d'une table à l'autre.

La clause FROM est également utilisée dans les instructions DELETE et UPDATE pour définir les tables concernées.

WHERE search_conditions

La clause WHERE est un filtre qui définit les critères que toutes les lignes des tables source doivent remplir pour être sélectionnées par l'instruction SELECT. Seules les lignes répondant à ces critères apportent des données pour le jeu de résultats. Les données des lignes ne répondant pas aux critères ne sont pas utilisées.

La clause WHERE est également utilisée dans les instructions DELETE et UPDATE pour définir les lignes à modifier dans les tables cible.

GROUP BY group_by_list

La clause GROUP BY décompose le jeu de résultats en groupes selon les valeurs des colonnes de group_by_list. Par exemple, la table AdventureWorksSales.SalesOrderHeader possède dix valeurs dans TerritoryID. Une clause GROUP BY TerritoryID décompose le jeu de résultats en 10 groupes, un pour chaque valeur de TerritoryID.

HAVING search_conditions

La clause HAVING est un filtre supplémentaire qui s'applique au jeu de résultats. Logiquement, la clause HAVING filtre les lignes du jeu de résultats intermédiaire issu de l'application des clauses FROM, WHERE ou GROUP BY de l'instruction SELECT. Les clauses HAVING sont généralement utilisées avec une clause GROUP BY, bien qu'une clause GROUP BY ne s'avère pas nécessaire avant une clause HAVING.

ORDER BY order_list[ ASC | DESC ]

La clause ORDER BY précise l'ordre dans lequel les lignes du jeu de résultats sont triées. order_list identifie les colonnes du jeu de résultats qui constituent la liste de tri. Les mots clés ASC et DESC servent à préciser si le tri des lignes se fait dans l'ordre croissant ou décroissant.

La clause ORDER BY est importante car la théorie relationnelle précise que les lignes d'un jeu de résultats ne sont pas censées être classées si la clause ORDER BY n'est pas spécifiée. ORDER BY doit être utilisée dans toute instruction SELECT où l'ordre des lignes du jeu de résultats est important.

Les clauses d'une instruction SELECT doivent être spécifiées dans l'ordre approprié.

Chaque référence à un objet de base de données ne doit pas être ambiguë. L'ambiguïté peut avoir l'une des origines suivantes :

• Il peut exister plusieurs objets du même nom dans un système. Par exemple, Schema1 et Schema2 peuvent très bien avoir tous deux une table nommée TableX. Pour lever l'ambiguïté et préciser qu'il s'agit de la TableX dont Schema1 est le propriétaire, qualifiez le nom de table en l'accompagnant au moins du nom du schéma :

  SELECT *
  FROM Schema1.TableX
  

• La base de données où réside l'objet n'est pas nécessairement la base de données active lors de l'exécution de l'instruction SELECT. Pour garantir que l'objet correct est toujours utilisé, quelle que soit la configuration de la base de données actuelle, qualifiez le nom d'objet par la base de données et le schéma :

  SELECT *
  FROM AdventureWorks.Purchasing.ShipMethod
  

• Les tables et les vues mentionnées dans la clause FROM peuvent posséder des noms de colonne en double. En effet, il est courant que les clés étrangères possèdent le même nom de colonne que la clé primaire qui leur est associée. Pour lever toute ambiguïté entre des doublons, le nom de colonne doit être qualifié avec le nom de table ou de vue :

  SELECT DISTINCT Sales.Customer.CustomerID, Sales.Store.Name
  FROM Sales.Customer JOIN Sales.Store ON
         ( Sales.Customer.CustomerID = Sales.Store.CustomerID)
  WHERE Sales.Customer.TerritoryID = 1
  

  Cette syntaxe devient alors lourde lorsque les noms de table et de vue doivent être tous deux entièrement qualifiés. Vous pouvez remédier à ce problème en attribuant à la table un nom de corrélation, aussi appelé variable de plage ou alias, à l'aide du mot clé AS de la clause FROM. Dans ce cas, le nom de la table ou de la vue entièrement qualifiée ne doit figurer que dans la clause FROM. Toute autre référence à une table ou à une vue peut ensuite utiliser le nom de corrélation. Si vous appliquez des noms de corrélation et qualifiez entièrement les tables de l'exemple précédent, voici en quoi consiste alors l'instruction SELECT :

  SELECT DISTINCT c.CustomerID, s.Name
  FROM Sales.Customer AS c
     JOIN
       Sales.Store AS s
     ON ( c.CustomerID = s.CustomerID)
  WHERE c.TerritoryID = 1
  

Pour plus d'informations sur la qualification des objets, consultez Identificateurs.

Dans la documentation en ligne SQL Server, de nombreux exemples Transact-SQL sont simplifiés et ne font pas intervenir de noms qualifiés. Bien que ces éléments soient volontairement écartés des exemples pour en faciliter la lecture, vous avez tout intérêt à les utiliser dans les instructions Transact-SQL des systèmes de production.

Voir aussi

Autres ressources

Expressions (Transact-SQL)
SELECT (Transact-SQL)
IDENTITY (Propriété) (Transact-SQL)

Aide et Informations

Assistance sur SQL Server 2005