SELECT - Clause ORDER BY (Transact-SQL)SELECT - ORDER BY Clause (Transact-SQL)

S’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data WarehouseS’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data Warehouse

Trie les données retournées par une requête dans SQL ServerSQL Server.Sorts data returned by a query in SQL ServerSQL Server. Utilisez cette clause pour effectuer les opérations suivantes :Use this clause to:

  • Trier le jeu de résultats d'une requête par la liste de colonnes spécifiée et, éventuellement, limiter les lignes retournées à une plage spécifiée.Order the result set of a query by the specified column list and, optionally, limit the rows returned to a specified range. L'ordre dans lequel les lignes sont retournées dans un jeu de résultats n'est pas garanti sauf si une clause ORDER BY a été spécifiée.The order in which rows are returned in a result set are not guaranteed unless an ORDER BY clause is specified.

  • Déterminer l’ordre dans lequel les valeurs de fonction de classement sont appliquées au jeu de résultats.Determine the order in which ranking function values are applied to the result set.

Icône Lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

Notes

ORDER BY n’est pas pris en charge dans les instructions SELECT/INTO ou CREATE TABLE AS SELECT (CTAS) dans Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) ou Parallel Data WarehouseParallel Data Warehouse.ORDER BY is not supported in SELECT/INTO or CREATE TABLE AS SELECT (CTAS) statements in Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) or Parallel Data WarehouseParallel Data Warehouse.

SyntaxeSyntax

-- Syntax for SQL Server and Azure SQL Database  
  
ORDER BY order_by_expression  
    [ COLLATE collation_name ]   
    [ ASC | DESC ]   
    [ ,...n ]   
[ <offset_fetch> ]  
  
<offset_fetch> ::=  
{   
    OFFSET { integer_constant | offset_row_count_expression } { ROW | ROWS }  
    [  
      FETCH { FIRST | NEXT } {integer_constant | fetch_row_count_expression } { ROW | ROWS } ONLY  
    ]  
}  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
[ ORDER BY   
    {  
    order_by_expression   
    [ ASC | DESC ]   
    } [ ,...n ]   
]   

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumentsArguments

order_by_expressionorder_by_expression
Spécifie une colonne ou une expression sur laquelle trier le jeu de résultats de la requête.Specifies a column or expression on which to sort the query result set. Une colonne de tri peut être définie comme un nom ou alias de colonne ou comme un nombre entier non négatif représentant la position de la colonne dans la liste de sélection.A sort column can be specified as a name or column alias, or a nonnegative integer representing the position of the column in the select list.

Il est possible de définir plusieurs colonnes de tri.Multiple sort columns can be specified. Les noms de colonne doivent être uniques.Column names must be unique. La séquence des colonnes de tri de la clause ORDER BY définit la structure du jeu de résultats trié.The sequence of the sort columns in the ORDER BY clause defines the organization of the sorted result set. Autrement dit, le jeu de résultats est trié par la première colonne puis, cette liste triée est triée par la deuxième colonne, et ainsi de suite.That is, the result set is sorted by the first column and then that ordered list is sorted by the second column, and so on.

Les noms de colonnes référencés dans la clause ORDER BY doivent correspondre à une colonne ou à un alias de colonne de la liste de sélection, ou à une colonne définie dans une table spécifiée dans la clause FROM, sans ambiguïté.The column names referenced in the ORDER BY clause must correspond to either a column or column alias in the select list or to a column defined in a table specified in the FROM clause without any ambiguities. Si la clause ORDER BY référence un alias de colonne de la liste de sélection, l’alias de colonne doit être utilisé de manière autonome, et non dans le cadre d’une expression dans la clause ORDER BY, par exemple :If the ORDER BY clause references a column alias from the select list, the column alias must be used standalone, and not as a part of some expression in ORDER BY clause, for example:

SELECT SCHEMA_NAME(schema_id) AS SchemaName FROM sys.objects 
ORDER BY SchemaName; -- correct 
SELECT SCHEMA_NAME(schema_id) AS SchemaName FROM sys.objects 
ORDER BY SchemaName + ''; -- wrong

COLLATE collation_nameCOLLATE collation_name
Spécifie que l’opération ORDER BY doit être exécutée conformément au classement spécifié dans collation_name, et pas selon le classement de la colonne défini dans la table ou l’affichage.Specifies that the ORDER BY operation should be performed according to the collation specified in collation_name, and not according to the collation of the column as defined in the table or view. collation_name peut être un nom de classement Windows ou SQL.collation_name can be either a Windows collation name or a SQL collation name. Pour plus d’informations, consultez Prise en charge d’Unicode et du classement.For more information, see Collation and Unicode Support. COLLATE est applicable uniquement aux colonnes de types char, varchar, nchar et nvarchar.COLLATE is applicable only for columns of type char, varchar, nchar, and nvarchar.

ASC | DESCASC | DESC
Spécifie que les valeurs dans la colonne spécifiée doivent être triées par ordre croissant ou décroissant.Specifies that the values in the specified column should be sorted in ascending or descending order. ASC effectue le tri de la valeur la plus faible à la valeur la plus élevée.ASC sorts from the lowest value to highest value. DESC effectue le tri de la valeur la plus élevée à la valeur la plus faible.DESC sorts from highest value to lowest value. ASC correspond à l'ordre de tri par défaut.ASC is the default sort order. Les valeurs NULL sont traitées comme les plus petites valeurs possibles.Null values are treated as the lowest possible values.

OFFSET { integer_constant | offset_row_count_expression } { ROW | ROWS }OFFSET { integer_constant | offset_row_count_expression } { ROW | ROWS }
Spécifie le nombre de lignes à ignorer avant de retourner des lignes à partir de l'expression de requête.Specifies the number of rows to skip before it starts to return rows from the query expression. La valeur peut être une constante entière ou une expression supérieure ou égale à zéro.The value can be an integer constant or expression that is greater than or equal to zero.

S’applique à : SQL Server 2012 (11.x)SQL Server 2012 (11.x) et versions ultérieures et Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012 (11.x)SQL Server 2012 (11.x) and later and Azure SQL DatabaseAzure SQL Database.s

offset_row_count_expression peut être une variable, un paramètre ou une sous-requête scalaire constante.offset_row_count_expression can be a variable, parameter, or constant scalar subquery. Lorsqu'une sous-requête est utilisée, elle ne peut pas référencer de colonnes définies dans l'étendue de requête externe.When a subquery is used, it cannot reference any columns defined in the outer query scope. Autrement dit, elle ne peut pas être mise en corrélation avec la requête externe.That is, it cannot be correlated with the outer query.

ROW et ROWS sont synonymes et sont fournis pour la compatibilité ANSI.ROW and ROWS are synonyms and are provided for ANSI compatibility.

Dans les plans d’exécution de requêtes, la valeur du nombre de lignes du décalage est affichée dans l’attribut Offset de l’opérateur de requête TOP.In query execution plans, the offset row count value is displayed in the Offset attribute of the TOP query operator.

FETCH { FIRST | NEXT } { integer_constant | fetch_row_count_expression } { ROW | ROWS } ONLYFETCH { FIRST | NEXT } { integer_constant | fetch_row_count_expression } { ROW | ROWS } ONLY
Spécifie le nombre de lignes à retourner une fois la clause OFFSET traitée.Specifies the number of rows to return after the OFFSET clause has been processed. La valeur peut être une constante entière ou une expression supérieure ou égale à un.The value can be an integer constant or expression that is greater than or equal to one.

S’applique à : SQL Server 2012 (11.x)SQL Server 2012 (11.x) et versions ultérieures et Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012 (11.x)SQL Server 2012 (11.x) and later and Azure SQL DatabaseAzure SQL Database.

fetch_row_count_expression peut être une variable, un paramètre ou une sous-requête scalaire constante.fetch_row_count_expression can be a variable, parameter, or constant scalar subquery. Lorsqu'une sous-requête est utilisée, elle ne peut pas référencer de colonnes définies dans l'étendue de requête externe.When a subquery is used, it cannot reference any columns defined in the outer query scope. Autrement dit, elle ne peut pas être mise en corrélation avec la requête externe.That is, it cannot be correlated with the outer query.

FIRST et NEXT sont synonymes et sont fournis pour la compatibilité ANSI.FIRST and NEXT are synonyms and are provided for ANSI compatibility.

ROW et ROWS sont synonymes et sont fournis pour la compatibilité ANSI.ROW and ROWS are synonyms and are provided for ANSI compatibility.

Dans les plans d’exécution de requêtes, la valeur du nombre de lignes du décalage est affichée dans l’attribut Rows ou Top de l’opérateur de requête TOP.In query execution plans, the offset row count value is displayed in the Rows or Top attribute of the TOP query operator.

Bonnes pratiquesBest Practices

Évitez de spécifier des entiers dans la clause ORDER BY comme représentations positionnelles des colonnes dans la liste de sélection.Avoid specifying integers in the ORDER BY clause as positional representations of the columns in the select list. Par exemple, bien qu'une instruction telle que SELECT ProductID, Name FROM Production.Production ORDER BY 2 soit valide, l'instruction n'est pas comprise aussi facilement que celles spécifiant le nom de colonne réel.For example, although a statement such as SELECT ProductID, Name FROM Production.Production ORDER BY 2 is valid, the statement is not as easily understood by others compared with specifying the actual column name. De plus, si vous modifiez la liste de sélection, par exemple en changeant l’ordre des colonnes ou en ajoutant de nouvelles colonnes, vous devez modifier la clause ORDER BY pour éviter des résultats inattendus.In addition, changes to the select list, such as changing the column order or adding new columns, requires modifying the ORDER BY clause in order to avoid unexpected results.

Dans une instruction SELECT TOP (N), utilisez toujours une clause ORDER BY.In a SELECT TOP (N) statement, always use an ORDER BY clause. Il s'agit de la seule méthode permettant d'indiquer de manière prévisible les lignes qui sont affectées par TOP.This is the only way to predictably indicate which rows are affected by TOP. Pour plus d’informations, consultez TOP (Transact-SQL).For more information, see TOP (Transact-SQL).

InteropérabilitéInteroperability

Quand elle est utilisée avec une instruction SELECT...INTO qui insère des lignes provenant d’une autre source, la clause ORDER BY ne garantit pas l’insertion des lignes dans l’ordre spécifié.When used with a SELECT...INTO statement to insert rows from another source, the ORDER BY clause does not guarantee the rows are inserted in the specified order.

L'utilisation d'OFFSET et de FETCH dans une vue ne modifie pas la propriété Updateability de la vue.Using OFFSET and FETCH in a view does not change the updateability property of the view.

Limitations et restrictionsLimitations and Restrictions

Il n'existe aucune limite quant au nombre de colonnes dans la clause ORDER BY ; toutefois, la taille totale des colonnes spécifiée dans une clause ORDER BY ne peut pas dépasser 8 060 octets.There is no limit to the number of columns in the ORDER BY clause; however, the total size of the columns specified in an ORDER BY clause cannot exceed 8,060 bytes.

Les colonnes de types ntext, text, image, geography, geometry, et xml ne sont pas autorisées dans une clause ORDER BY.Columns of type ntext, text, image, geography, geometry, and xml cannot be used in an ORDER BY clause.

Il n’est pas possible de spécifier un entier ou une constante quand l’argument order_by_expression est utilisé dans une fonction de classement.An integer or constant cannot be specified when order_by_expression appears in a ranking function. Pour plus d’informations, consultez Clause OVER (Transact-SQL).For more information, see OVER Clause (Transact-SQL).

Si un nom de table possède un alias dans la clause FROM, seul le nom de l'alias peut être utilisé pour qualifier ses colonnes dans la clause ORDER BY.If a table name is aliased in the FROM clause, only the alias name can be used to qualify its columns in the ORDER BY clause.

Les noms de colonne et les alias spécifiés dans la clause ORDER BY doivent être définis dans la liste de sélection si l'instruction SELECT contient l'un des clauses ou opérateurs suivants :Column names and aliases specified in the ORDER BY clause must be defined in the select list if the SELECT statement contains one of the following clauses or operators:

  • opérateur UNIONUNION operator

  • opérateur EXCEPTEXCEPT operator

  • opérateur INTERSECTINTERSECT operator

  • SELECT DISTINCTSELECT DISTINCT

De plus, quand une instruction SELECT comprend un opérateur UNION, EXCEPT ou INTERSECT, les noms ou alias de colonne doivent correspondre à ceux spécifiés dans la liste de sélection de la première requête (côté gauche).Additionally, when the statement includes a UNION, EXCEPT, or INTERSECT operator, the column names, or column aliases must be specified in the select list of the first (left-side) query.

Dans une requête qui utilise des opérateurs UNION, EXCEPT ou INTERSECT, la clause ORDER BY est autorisée uniquement à la fin de l'instruction.In a query that uses UNION, EXCEPT, or INTERSECT operators, ORDER BY is allowed only at the end of the statement. Cette restriction ne s’applique qu’en cas de spécification des opérateurs UNION, EXCEPT et INTERSECT dans une requête de niveau supérieur, et non dans une sous-requête.This restriction applies only to when you specify UNION, EXCEPT, and INTERSECT in a top-level query and not in a subquery. Consultez la section Exemples qui suit.See the Examples section that follows.

La clause ORDER BY n'est pas valide dans les vues, les fonctions incluses, les tables dérivées et les sous-requêtes, sauf si les clauses TOP ou OFFSET et FETCH sont également spécifiées.The ORDER BY clause is not valid in views, inline functions, derived tables, and subqueries, unless either the TOP or OFFSET and FETCH clauses are also specified. Lorsque ORDER BY est utilisé dans ces objets, la clause est utilisée uniquement pour déterminer les lignes retournées par la clause TOP ou les clauses OFFSET et FETCH.When ORDER BY is used in these objects, the clause is used only to determine the rows returned by the TOP clause or OFFSET and FETCH clauses. La clause ORDER BY ne garantit pas des résultats classés lorsque ces constructions sont interrogées, sauf si ORDER BY est également spécifié dans la requête proprement dite.The ORDER BY clause does not guarantee ordered results when these constructs are queried, unless ORDER BY is also specified in the query itself.

OFFSET et FETCH ne sont pas prises en charge dans les vues indexées ou dans une vue définie à l'aide de la clause CHECK OPTION.OFFSET and FETCH are not supported in indexed views or in a view that is defined by using the CHECK OPTION clause.

OFFSET et FETCH peuvent être utilisés dans toute requête qui autorise TOP et ORDER BY, avec les limitations suivantes :OFFSET and FETCH can be used in any query that allows TOP and ORDER BY with the following limitations:

  • La clause OVER ne prend pas en charge OFFSET ni FETCH.The OVER clause does not support OFFSET and FETCH.

  • OFFSET et FETCH ne peuvent pas être spécifiées directement dans des instructions INSERT, UPDATE, MERGE et DELETE, mais peuvent l'être dans une sous-requête définie dans ces instructions.OFFSET and FETCH cannot be specified directly in INSERT, UPDATE, MERGE, and DELETE statements, but can be specified in a subquery defined in these statements. Par exemple, dans l'instruction INSERT INTO SELECT, OFFSET et FETCH peuvent être spécifiées dans l'instruction SELECT.For example, in the INSERT INTO SELECT statement, OFFSET and FETCH can be specified in the SELECT statement.

  • Dans une requête qui utilise des opérateurs UNION, EXCEPT ou INTERSECT, OFFSET et FETCH peuvent être spécifiées uniquement dans la dernière requête qui spécifie l'ordre des résultats de la requête.In a query that uses UNION, EXCEPT or INTERSECT operators, OFFSET and FETCH can only be specified in the final query that specifies the order of the query results.

  • TOP ne peut pas être combiné avec OFFSET et FETCH dans la même expression de requête (dans la même étendue de requête).TOP cannot be combined with OFFSET and FETCH in the same query expression (in the same query scope).

Utilisation d'OFFSET et de FETCH pour limiter les lignes retournéesUsing OFFSET and FETCH to limit the rows returned

Nous vous recommandons d'utiliser les clauses OFFSET et FETCH au lieu de la clause TOP pour implémenter une solution de pagination de requête et limiter le nombre de lignes envoyées à une application cliente.We recommend that you use the OFFSET and FETCH clauses instead of the TOP clause to implement a query paging solution and limit the number of rows sent to a client application.

L'utilisation d'OFFSET et de FETCH comme une solution de pagination requiert l'exécution de la requête une fois pour chaque « page » de données retournée à l'application cliente.Using OFFSET and FETCH as a paging solution requires running the query one time for each "page" of data returned to the client application. Par exemple, pour retourner les résultats d'une requête par incréments de 10 lignes, vous devez exécuter la requête une fois pour retourner les lignes 1 à 10 et exécuter, puis une nouvelle fois pour retourner les lignes 11 à 20 et ainsi de suite.For example, to return the results of a query in 10-row increments, you must execute the query one time to return rows 1 to 10 and then run the query again to return rows 11 to 20 and so on. Chaque requête est indépendante et sans rapport les unes avec les autres.Each query is independent and not related to each other in any way. Cela signifie que, contrairement à l'utilisation d'un curseur dans lequel la requête est exécutée une fois et l'état est géré sur le serveur, l'application cliente est chargée du suivi de l'état.This means that, unlike using a cursor in which the query is executed once and state is maintained on the server, the client application is responsible for tracking state. Pour obtenir des résultats stables entre des requêtes d'interrogation à l'aide d'OFFSET et de FETCH, les conditions suivantes doivent être réunies :To achieve stable results between query requests using OFFSET and FETCH, the following conditions must be met:

  1. Les données sous-jacentes utilisées par la requête ne doivent pas changer.The underlying data that is used by the query must not change. Autrement dit, soit les lignes touchées par la requête ne sont pas mises à jour, soit toutes les demandes pour les pages de la requête sont exécutées dans une transaction unique à l'aide de l'isolement des transactions instantané ou sérialisable.That is, either the rows touched by the query are not updated or all requests for pages from the query are executed in a single transaction using either snapshot or serializable transaction isolation. Pour plus d’informations sur ces niveaux d’isolement, consultez SET TRANSACTION ISOLATION LEVEL (Transact-SQL).For more information about these transaction isolation levels, see SET TRANSACTION ISOLATION LEVEL (Transact-SQL).

  2. La clause ORDER BY contient une colonne ou une combinaison de colonnes dont l'unicité est garantie.The ORDER BY clause contains a column or combination of columns that are guaranteed to be unique.

Consultez l'exemple « Exécution de plusieurs requêtes dans une transaction unique » dans la section Exemples dans la suite de cette rubrique.See the example "Running multiple queries in a single transaction" in the Examples section later in this topic.

Si des plans d'exécution cohérents sont importants dans votre solution de pagination, envisagez d'utiliser l'indicateur de requête OPTIMIZE FOR pour les paramètres OFFSET et FETCH.If consistent execution plans are important in your paging solution, consider using the OPTIMIZE FOR query hint for the OFFSET and FETCH parameters. Consultez « Spécification d'expressions pour les valeurs OFFSET et FETCH » dans la section Exemples dans la suite de cette rubrique.See "Specifying expressions for OFFSET and FETCH values" in the Examples section later in this topic. Pour plus d’informations sur OPTIMZE FOR, consultez Indicateurs de requête (Transact-SQL).For more information about OPTIMIZE FOR, see Query Hints (Transact-SQL).

ExemplesExamples

CategoryCategory Éléments syntaxiques proposésFeatured syntax elements
Syntaxe de baseBasic syntax ORDER BYORDER BY
Spécification de l’ordre croissant et décroissantSpecifying ascending and descending order DESC • ASCDESC • ASC
Spécification d’un classementSpecifying a collation COLLATECOLLATE
Spécification d’un ordre conditionnelSpecifying a conditional order Expression CASECASE expression
Utilisation de la clause ORDER BY dans une fonction de classementUsing ORDER BY in a ranking function Fonctions de classementRanking functions
Limitation du nombre de lignes retournéesLimiting the number of rows returned OFFSET • FETCHOFFSET • FETCH
Utilisation de la clause ORDER BY avec UNION, EXCEPT et INTERSECTUsing ORDER BY with UNION, EXCEPT, and INTERSECT UNIONUNION

Syntaxe de baseBasic syntax

Les exemples fournis dans cette section présentent les fonctionnalités de base de la clause ORDER BY en utilisant la syntaxe minimale requise.Examples in this section demonstrate the basic functionality of the ORDER BY clause using the minimum required syntax.

R.A. Spécification d'une colonne unique définie dans la liste de sélectionSpecifying a single column defined in the select list

L'exemple suivant classe le jeu de résultats selon la colonne ProductID numérique.The following example orders the result set by the numeric ProductID column. Étant donné qu'aucun ordre de tri spécifique n'est spécifié, la valeur par défaut (ordre croissant) est utilisée.Because a specific sort order is not specified, the default (ascending order) is used.

USE AdventureWorks2012;  
GO  
SELECT ProductID, Name FROM Production.Product  
WHERE Name LIKE 'Lock Washer%'  
ORDER BY ProductID;  

B.B. Spécification d'une colonne qui n'est pas définie dans la liste de sélectionSpecifying a column that is not defined in the select list

L'exemple suivant classe le jeu de résultats selon une colonne qui n'est pas incluse dans la liste de sélection, mais est définie dans la table spécifiée dans la clause FROM.The following example orders the result set by a column that is not included in the select list, but is defined in the table specified in the FROM clause.

USE AdventureWorks2012;  
GO  
SELECT ProductID, Name, Color  
FROM Production.Product  
ORDER BY ListPrice;  
  

C.C. Spécification d'un alias comme colonne de triSpecifying an alias as the sort column

L'exemple suivant spécifie l'alias de colonne SchemaName comme colonne d'ordre de tri.The following example specifies the column alias SchemaName as the sort order column.

USE AdventureWorks2012;  
GO  
SELECT name, SCHEMA_NAME(schema_id) AS SchemaName  
FROM sys.objects  
WHERE type = 'U'  
ORDER BY SchemaName;  
  

D.D. Spécification d'une expression comme colonne de triSpecifying an expression as the sort column

L'exemple suivant utilise une expression comme colonne de tri.The following example uses an expression as the sort column. L'expression est définie en utilisant la fonction DATEPART pour trier le jeu de résultats selon l'année au cours de laquelle les employés ont été embauchés.The expression is defined by using the DATEPART function to sort the result set by the year in which employees were hired.

USE AdventureWorks2012;  
GO  
SELECT BusinessEntityID, JobTitle, HireDate  
FROM HumanResources.Employee  
ORDER BY DATEPART(year, HireDate);  
  

Spécification de l’ordre de tri croissant et décroissantSpecifying ascending and descending sort order

R.A. Spécification d'un ordre de tri décroissantSpecifying a descending order

L'exemple suivant classe le jeu de résultats selon la colonne ProductID numérique par ordre décroissant.The following example orders the result set by the numeric column ProductID in descending order.

USE AdventureWorks2012;  
GO  
SELECT ProductID, Name FROM Production.Product  
WHERE Name LIKE 'Lock Washer%'  
ORDER BY ProductID DESC;  
  

B.B. Spécification d’un ordre croissantSpecifying an ascending order

L'exemple suivant classe le jeu de résultats selon la colonne Name dans l'ordre croissant.The following example orders the result set by the Name column in ascending order. Les caractères sont triés par ordre alphabétique, et non par ordre numérique.The characters are sorted alphabetically, not numerically. Autrement dit, 10 arrive avant 2.That is, 10 sorts before 2.

USE AdventureWorks2012;  
GO  
SELECT ProductID, Name FROM Production.Product  
WHERE Name LIKE 'Lock Washer%'  
ORDER BY Name ASC ;  
  

C.C. Spécification d'un ordre de tri croissant et décroissantSpecifying both ascending and descending order

L'exemple suivant classe le jeu de résultats selon deux colonnes.The following example orders the result set by two columns. Le jeu de résultats de la requête fait d'abord l'objet d'un tri par ordre croissant selon la colonne FirstName, suivi d'un second tri par ordre décroissant selon la colonne LastName.The query result set is first sorted in ascending order by the FirstName column and then sorted in descending order by the LastName column.

USE AdventureWorks2012;  
GO  
SELECT LastName, FirstName FROM Person.Person  
WHERE LastName LIKE 'R%'  
ORDER BY FirstName ASC, LastName DESC ;  
  

Spécification d’un classementSpecifying a collation

L'exemple suivant indique comment la spécification d'un classement dans la clause ORDER BY peut modifier l'ordre dans lequel les résultats de la requête sont retournés.The following example shows how specifying a collation in the ORDER BY clause can change the order in which the query results are returned. Une table contenant une colonne définie à l'aide d'un classement non sensible à la casse et ne tenant pas compte des accents est créée.A table is created that contains a column defined by using a case-insensitive, accent-insensitive collation. Les valeurs sont insérées selon différentes variantes d'accent et de casse.Values are inserted with a variety of case and accent differences. Étant donné qu'aucun classement n'est spécifié dans la clause ORDER BY, la première requête utilise le classement de la colonne lors du tri des valeurs.Because a collation is not specified in the ORDER BY clause, the first query uses the collation of the column when sorting the values. Dans la deuxième requête, un classement sensible à la casse et tenant compte des accents est spécifié dans la clause ORDER BY, ce qui modifie l'ordre dans lequel les lignes sont retournées.In the second query, a case-sensitive, accent-sensitive collation is specified in the ORDER BY clause, which changes the order in which the rows are returned.

USE tempdb;  
GO  
CREATE TABLE #t1 (name nvarchar(15) COLLATE Latin1_General_CI_AI)  
GO  
INSERT INTO #t1 VALUES(N'Sánchez'),(N'Sanchez'),(N'sánchez'),(N'sanchez');  
  
-- This query uses the collation specified for the column 'name' for sorting.  
SELECT name  
FROM #t1  
ORDER BY name;  
-- This query uses the collation specified in the ORDER BY clause for sorting.  
SELECT name  
FROM #t1  
ORDER BY name COLLATE Latin1_General_CS_AS;  
  

Spécification d’un ordre conditionnelSpecifying a conditional order

Les exemples suivants utilisent l’expression CASE dans une clause ORDER BY pour déterminer de façon conditionnelle l’ordre de tri des lignes d’après la valeur d’une colonne donnée.The following examples use the CASE expression in an ORDER BY clause to conditionally determine the sort order of the rows based on a given column value. Dans le premier exemple, la valeur de la colonne SalariedFlag de la table HumanResources.Employee est évaluée.In the first example, the value in the SalariedFlag column of the HumanResources.Employee table is evaluated. Les employés pour lesquels SalariedFlag a la valeur 1 sont retournés par ordre décroissant d'BusinessEntityID.Employees that have the SalariedFlag set to 1 are returned in order by the BusinessEntityID in descending order. Les employés pour lesquels SalariedFlag a la valeur 0 sont retournés par ordre croissant d'BusinessEntityID.Employees that have the SalariedFlag set to 0 are returned in order by the BusinessEntityID in ascending order. Dans le deuxième exemple, le jeu de résultats est classé par la colonne TerritoryName lorsque la colonne CountryRegionName est égale à « United States » et par CountryRegionName pour toutes les autres lignes.In the second example, the result set is ordered by the column TerritoryName when the column CountryRegionName is equal to 'United States' and by CountryRegionName for all other rows.

SELECT BusinessEntityID, SalariedFlag  
FROM HumanResources.Employee  
ORDER BY CASE SalariedFlag WHEN 1 THEN BusinessEntityID END DESC  
        ,CASE WHEN SalariedFlag = 0 THEN BusinessEntityID END;  
GO  
  
SELECT BusinessEntityID, LastName, TerritoryName, CountryRegionName  
FROM Sales.vSalesPerson  
WHERE TerritoryName IS NOT NULL  
ORDER BY CASE CountryRegionName WHEN 'United States' THEN TerritoryName  
         ELSE CountryRegionName END;  
  

Utilisation de la clause ORDER BY dans une fonction de classementUsing ORDER BY in a ranking function

L'exemple suivant utilise la clause ORDER BY dans les fonctions de classement ROW_NUMBER, RANK, DENSE_RANK et NTILE.The following example uses the ORDER BY clause in the ranking functions ROW_NUMBER, RANK, DENSE_RANK, and NTILE.

USE AdventureWorks2012;  
GO  
SELECT p.FirstName, p.LastName  
    ,ROW_NUMBER() OVER (ORDER BY a.PostalCode) AS "Row Number"  
    ,RANK() OVER (ORDER BY a.PostalCode) AS "Rank"  
    ,DENSE_RANK() OVER (ORDER BY a.PostalCode) AS "Dense Rank"  
    ,NTILE(4) OVER (ORDER BY a.PostalCode) AS "Quartile"  
    ,s.SalesYTD, a.PostalCode  
FROM Sales.SalesPerson AS s   
    INNER JOIN Person.Person AS p   
        ON s.BusinessEntityID = p.BusinessEntityID  
    INNER JOIN Person.Address AS a   
        ON a.AddressID = p.BusinessEntityID  
WHERE TerritoryID IS NOT NULL AND SalesYTD <> 0;  
  

Limitation du nombre de lignes retournéesLimiting the number of rows returned

Les exemples suivants utilisent OFFSET et FETCH pour limiter le nombre de lignes retournées par une requête.The following examples use OFFSET and FETCH to limit the number of rows returned by a query.

S’applique à : SQL Server 2012 (11.x)SQL Server 2012 (11.x) et versions ultérieures et Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012 (11.x)SQL Server 2012 (11.x) and later and Azure SQL DatabaseAzure SQL Database.

R.A. Spécification de constantes entières pour les valeurs OFFSET et FETCHSpecifying integer constants for OFFSET and FETCH values

L'exemple suivant spécifie une constante entière comme valeur pour les clauses OFFSET et FETCH.The following example specifies an integer constant as the value for the OFFSET and FETCH clauses. La première requête retourne toutes les lignes triées selon la colonne DepartmentID.The first query returns all rows sorted by the column DepartmentID. Comparez les résultats retournés par cette requête avec les résultats des deux requêtes qui la suivent.Compare the results returned by this query with the results of the two queries that follow it. La requête suivante utilise la clause OFFSET 5 ROWS pour ignorer les 5 premières lignes et retourner toutes les lignes restantes.The next query uses the clause OFFSET 5 ROWS to skip the first 5 rows and return all remaining rows. La dernière requête utilise la clause OFFSET 0 ROWS pour démarrer avec la première ligne, puis utilise FETCH NEXT 10 ROWS ONLY pour limiter les lignes retournées à 10 depuis le jeu de résultats trié.The final query uses the clause OFFSET 0 ROWS to start with the first row and then uses FETCH NEXT 10 ROWS ONLY to limit the rows returned to 10 rows from the sorted result set.

USE AdventureWorks2012;  
GO  
-- Return all rows sorted by the column DepartmentID.  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID;  
  
-- Skip the first 5 rows from the sorted result set and return all remaining rows.  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID OFFSET 5 ROWS;  
  
-- Skip 0 rows and return only the first 10 rows from the sorted result set.  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID   
    OFFSET 0 ROWS  
    FETCH NEXT 10 ROWS ONLY;  
  

B.B. Spécification de variables pour les valeurs OFFSET et FETCHSpecifying variables for OFFSET and FETCH values

L'exemple suivant déclare les variables @RowsToSkip et @FetchRows, puis spécifie ces variables dans les clauses OFFSET et FETCH.The following example declares the variables @RowsToSkip and @FetchRows and specifies these variables in the OFFSET and FETCH clauses.

USE AdventureWorks2012;  
GO  
-- Specifying variables for OFFSET and FETCH values    
DECLARE @RowsToSkip tinyint = 2
      , @FetchRows tinyint = 8;  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID ASC   
    OFFSET @RowsToSkip ROWS   
    FETCH NEXT @FetchRows ROWS ONLY;  

C.C. Spécification d'expressions pour les valeurs OFFSET et FETCHSpecifying expressions for OFFSET and FETCH values

L'exemple suivant utilise l'expression @StartingRowNumber - 1 pour spécifier la valeur OFFSET et l'expression @EndingRowNumber - @StartingRowNumber + 1 pour spécifier la valeur FETCH.The following example uses the expression @StartingRowNumber - 1 to specify the OFFSET value and the expression @EndingRowNumber - @StartingRowNumber + 1 to specify the FETCH value. De plus, l'indicateur de requête, OPTIMIZE FOR, est spécifié.In addition, the query hint, OPTIMIZE FOR, is specified. Cet indicateur permet d'attribuer à une variable locale une valeur déterminée lors de la compilation et de l'optimisation de la requête.This hint can be used to provide a particular value for a local variable when the query is compiled and optimized. Cette valeur n'est utilisée que pendant l'optimisation de la requête, et non pas lors de son exécution.The value is used only during query optimization, and not during query execution. Pour plus d’informations, consultez Indicateurs de requête (Transact-SQL).For more information, see Query Hints (Transact-SQL).

USE AdventureWorks2012;  
GO  
  
-- Specifying expressions for OFFSET and FETCH values      
DECLARE @StartingRowNumber tinyint = 1  
      , @EndingRowNumber tinyint = 8;  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID ASC   
    OFFSET @StartingRowNumber - 1 ROWS   
    FETCH NEXT @EndingRowNumber - @StartingRowNumber + 1 ROWS ONLY  
OPTION ( OPTIMIZE FOR (@StartingRowNumber = 1, @EndingRowNumber = 20) );  
  

D.D. Spécification d'une sous-requête scalaire constante pour les valeurs OFFSET et FETCHSpecifying a constant scalar subquery for OFFSET and FETCH values

L'exemple suivant utilise une sous-requête scalaire constante pour définir la valeur de la clause FETCH.The following example uses a constant scalar subquery to define the value for the FETCH clause. Le sous-requête retourne une valeur unique de la colonne PageSize dans la table dbo.AppSettings.The subquery returns a single value from the column PageSize in the table dbo.AppSettings.

-- Specifying a constant scalar subquery  
USE AdventureWorks2012;  
GO  
CREATE TABLE dbo.AppSettings (AppSettingID int NOT NULL, PageSize int NOT NULL);  
GO  
INSERT INTO dbo.AppSettings VALUES(1, 10);  
GO  
DECLARE @StartingRowNumber tinyint = 1;  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID ASC   
    OFFSET @StartingRowNumber ROWS   
    FETCH NEXT (SELECT PageSize FROM dbo.AppSettings WHERE AppSettingID = 1) ROWS ONLY;  

E.E. Exécution de plusieurs requêtes dans une transaction uniqueRunning multiple queries in a single transaction

L'exemple suivant affiche une méthode d'implémentation d'une solution de pagination qui garantit le retour de résultats stables dans toutes les demandes émanant de la requête.The following example shows one method of implementing a paging solution that ensures stable results are returned in all requests from the query. La requête est exécutée dans une transaction unique à l'aide du niveau d'isolement d'instantané, et la colonne spécifiée dans la clause ORDER BY garantit l'unicité de colonne.The query is executed in a single transaction using the snapshot isolation level, and the column specified in the ORDER BY clause ensures column uniqueness.

USE AdventureWorks2012;  
GO  
  
-- Ensure the database can support the snapshot isolation level set for the query.  
IF (SELECT snapshot_isolation_state FROM sys.databases WHERE name = N'AdventureWorks2012') = 0  
    ALTER DATABASE AdventureWorks2012 SET ALLOW_SNAPSHOT_ISOLATION ON;  
GO  
  
-- Set the transaction isolation level  to SNAPSHOT for this query.  
SET TRANSACTION ISOLATION LEVEL SNAPSHOT;  
GO  
  
-- Beginning the transaction.
BEGIN TRANSACTION;  
GO  
-- Declare and set the variables for the OFFSET and FETCH values.  
DECLARE @StartingRowNumber int = 1  
      , @RowCountPerPage int = 3;  
  
-- Create the condition to stop the transaction after all rows have been returned.  
WHILE (SELECT COUNT(*) FROM HumanResources.Department) >= @StartingRowNumber  
BEGIN  
  
-- Run the query until the stop condition is met.  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID ASC   
    OFFSET @StartingRowNumber - 1 ROWS   
    FETCH NEXT @RowCountPerPage ROWS ONLY;  
  
-- Increment @StartingRowNumber value.  
SET @StartingRowNumber = @StartingRowNumber + @RowCountPerPage;  
CONTINUE  
END;  
GO  
COMMIT TRANSACTION;  
GO  

Utilisation de la clause ORDER BY avec UNION, EXCEPT et INTERSECTUsing ORDER BY with UNION, EXCEPT, and INTERSECT

Lorsqu'une requête utilise les opérateurs UNION, EXCEPT ou INTERSECT, la clause ORDER BY doit être spécifiée à la fin de l'instruction et les résultats des requêtes combinées sont triés.When a query uses the UNION, EXCEPT, or INTERSECT operators, the ORDER BY clause must be specified at the end of the statement and the results of the combined queries are sorted. L'exemple suivant retourne tous les produits qui sont rouges ou jaunes et effectue le tri de cette liste combinée selon la colonne ListPrice.The following example returns all products that are red or yellow and sorts this combined list by the column ListPrice.

USE AdventureWorks2012;  
GO  
SELECT Name, Color, ListPrice  
FROM Production.Product  
WHERE Color = 'Red'  
-- ORDER BY cannot be specified here.  
UNION ALL  
SELECT Name, Color, ListPrice  
FROM Production.Product  
WHERE Color = 'Yellow'  
ORDER BY ListPrice ASC;  

Exemples : Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) et Parallel Data WarehouseParallel Data WarehouseExamples: Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) and Parallel Data WarehouseParallel Data Warehouse

L’exemple suivant illustre le tri d’un jeu de résultats par ordre croissant selon la colonne EmployeeKey numérique.The following example demonstrates ordering of a result set by the numerical EmployeeKey column in ascending order.

-- Uses AdventureWorks  
  
SELECT EmployeeKey, FirstName, LastName FROM DimEmployee  
WHERE LastName LIKE 'A%'  
ORDER BY EmployeeKey;  

L’exemple suivant trie un jeu de résultats par ordre décroissant selon la colonne EmployeeKey numérique.The following example orders a result set by the numerical EmployeeKey column in descending order.

-- Uses AdventureWorks  
  
SELECT EmployeeKey, FirstName, LastName FROM DimEmployee  
WHERE LastName LIKE 'A%'  
ORDER BY EmployeeKey DESC;  

L’exemple suivant trie un jeu de résultats sur la colonne LastName.The following example orders a result set by the LastName column.

-- Uses AdventureWorks  
  
SELECT EmployeeKey, FirstName, LastName FROM DimEmployee  
WHERE LastName LIKE 'A%'  
ORDER BY LastName;  

L’exemple suivant trie un jeu de résultats sur deux colonnes.The following example orders by two columns. Cette requête effectue un premier tri par ordre croissant selon la colonne FirstName, puis elle trie les valeurs FirstName communes par ordre décroissant selon la colonne LastName.This query first sorts in ascending order by the FirstName column, and then sorts common FirstName values in descending order by the LastName column.

-- Uses AdventureWorks  
  
SELECT EmployeeKey, FirstName, LastName FROM DimEmployee  
WHERE LastName LIKE 'A%'  
ORDER BY LastName, FirstName;  

Voir aussiSee Also

Expressions (Transact-SQL) Expressions (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
FROM (Transact-SQL) FROM (Transact-SQL)
Fonctions de classement (Transact-SQL) Ranking Functions (Transact-SQL)
TOP (Transact-SQL) TOP (Transact-SQL)
Indicateurs de requête (Transact-SQL) Query Hints (Transact-SQL)
EXCEPT et INTERSECT (Transact-SQL) EXCEPT and INTERSECT (Transact-SQL)
UNION (Transact-SQL) UNION (Transact-SQL)
CASE (Transact-SQL)CASE (Transact-SQL)