SELECT - Clause ORDER BY (Transact-SQL)

S’applique à :SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW)Point de terminaison d’analytique SQL dans Microsoft Fabric Entrepôt dans Microsoft Fabric Base de données SQL dans Microsoft Fabric

Trie les données retournées par une requête dans SQL Server. Utilisez cette clause pour effectuer les opérations suivantes :

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. L’ordre dans lequel les lignes sont retournées dans un jeu de résultats n’est pas garanti, sauf si une ORDER BY clause est spécifiée.
Déterminer l’ordre dans lequel les valeurs de fonction de classement sont appliquées au jeu de résultats.

Conventions de la syntaxe Transact-SQL

Note

ORDER BY n’est pas pris en charge dans SELECT/INTO ou CREATE TABLE AS SELECT (CTAS) instructions dans Azure Synapse Analytics ou Analytics Platform System (PDW).

Syntax

Syntaxe pour SQL Server et 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
    ]
}

Syntaxe pour azure Synapse Analytics and Analytics Platform System (PDW) :

[ ORDER BY
    {
    order_by_expression
    [ ASC | DESC ]
    } [ , ...n ]
]

Arguments

order_by_expression

Spécifie une colonne ou une expression sur laquelle trier le jeu de résultats de la requête. Vous pouvez spécifier une colonne de tri sous la forme d’un nom ou d’un alias de colonne, ou en tant qu’entier non négatif représentant la position de la colonne dans la liste de sélection.

Vous pouvez spécifier plusieurs colonnes de tri. Les noms de colonne doivent être uniques. La séquence des colonnes de tri dans la ORDER BY clause définit l’organisation du jeu de résultats trié. 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.

Les noms de colonnes que vous référencez dans la ORDER BY clause doivent correspondre à une colonne ou un alias de colonne dans la liste de sélection, ou à une colonne définie dans une table spécifiée dans la FROM clause, sans ambiguïté. Si la ORDER BY clause fait référence à un alias de colonne dans la liste de sélection, utilisez l’alias de colonne lui-même. N’utilisez pas l’alias de colonne dans le cadre d’une expression dans la ORDER BY clause.

Par exemple:

Utilisation correcte :

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

Utilisation incorrecte :

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

COLLATE collation_name

Spécifie que l’opération ORDER BY doit être effectuée en fonction du classement que vous spécifiez dans collation_name, et non selon le classement de la colonne tel que défini dans la table ou la vue. Le collation_name peut être un nom de classement Windows ou un nom de classement SQL. Pour plus d’informations, voir Classement et prise en charge d’Unicode. COLLATEs’applique uniquement aux colonnes de type char, varchar, nchar et nvarchar.

ASC | DESC

Spécifie que les valeurs dans la colonne spécifiée doivent être triées par ordre croissant ou décroissant. ASC effectue le tri de la valeur la plus faible à la valeur la plus élevée. DESC effectue le tri de la valeur la plus élevée à la valeur la plus faible. ASC correspond à l’ordre de tri par défaut. Les valeurs NULL sont traitées comme les plus petites valeurs possibles.

DÉCALAGE { integer_constant | offset_row_count_expression } { LIGNE | ROWS }

S’applique à : SQL Server 2012 (11.x) et versions ultérieures, Azure SQL Database et Azure SQL Managed Instance.

Spécifie le nombre de lignes à ignorer avant que la requête ne commence à retourner des lignes de l’expression de requête. La valeur peut être une constante entière ou une expression supérieure ou égale à zéro.

offset_row_count_expression peut être une variable, un paramètre ou une sous-requête scalaire constante. Lorsque vous utilisez une sous-requête, elle ne peut référencer aucune colonne définie dans l’étendue de requête externe. Autrement dit, elle ne peut pas être corrélée à la requête externe.

ROW et ROWS sont des synonymes et sont fournis pour la compatibilité ANSI.

Dans les plans d’exécution de requête, la valeur du nombre de lignes de décalage apparaît dans l’attribut Offset de l’opérateur TOP de requête.

FETCH { FIRST | NEXT } { integer_constant fetch_row_count_expression | } { ROW | ROWS } ONLY

S’applique à : SQL Server 2012 (11.x) et versions ultérieures, Azure SQL Database et Azure SQL Managed Instance.

Spécifie le nombre de lignes à retourner après le traitement de la OFFSET clause. La valeur peut être une constante entière ou une expression supérieure ou égale à une.

fetch_row_count_expression peut être une variable, un paramètre ou une sous-requête scalaire constante. Lorsque vous utilisez une sous-requête, elle ne peut référencer aucune colonne définie dans l’étendue de requête externe. Autrement dit, elle ne peut pas être corrélée à la requête externe.

FIRST et NEXT sont des synonymes et sont fournis pour la compatibilité ANSI.

ROW et ROWS sont des synonymes et sont fournis pour la compatibilité ANSI.

Dans les plans d’exécution de requête, la valeur de nombre de lignes de décalage s’affiche dans l’attribut Lignes ou Top de l’opérateur TOP de requête.

Meilleures pratiques

Évitez de spécifier des entiers dans la ORDER BY clause en tant que représentations positionnelles des colonnes dans la liste de sélection. Par exemple, bien qu’une instruction telle qu’elle SELECT ProductID, Name FROM Production.Production ORDER BY 2 soit valide, les utilisateurs peuvent avoir du mal à comprendre par rapport à la spécification du nom de colonne réel. En outre, les modifications apportées à la liste de sélection, telles que la modification de l’ordre des colonnes ou l’ajout de nouvelles colonnes, nécessitent la modification de la ORDER BY clause pour éviter les résultats inattendus.

Dans une SELECT TOP (<n>) instruction, utilisez toujours une ORDER BY clause. Il s’agit du seul moyen d’indiquer de manière prévisible quelles TOP lignes affectent. Pour plus d’informations, voir TOP.

Interoperability

Lorsque vous utilisez ORDER BY une instruction ou INSERT...SELECT une SELECT...INTO instruction pour insérer des lignes à partir d’une autre source, la ORDER BY clause ne garantit pas que les lignes sont insérées dans l’ordre spécifié.

L’utilisation OFFSET et FETCH dans une vue ne modifie pas la propriété de mise à jour de la vue.

Limitations

Il n’existe aucune limite au nombre de colonnes de la ORDER BY clause. Toutefois, la taille totale des colonnes spécifiées dans une ORDER BY clause ne peut pas dépasser 8 060 octets.

Vous ne pouvez pas utiliser de colonnes de type ntext, text, image, geography, geometry ou xml dans une ORDER BY clause.

Vous ne pouvez pas spécifier d’entier ou de constante lorsque order_by_expression apparaît dans une fonction de classement. Pour plus d’informations, consultez la clause SELECT - OVER.

Si vous alias un nom de table dans la FROM clause, vous devez utiliser le nom de l’alias pour qualifier ses colonnes dans la ORDER BY clause.

Si l’instruction SELECT contient l’une des clauses ou opérateurs suivants, vous devez définir des noms de colonnes et des alias spécifiés dans la clause dans la ORDER BY liste de sélection :

Opérateur UNION
Opérateur EXCEPT
Opérateur INTERSECT
SELECT DISTINCT

En outre, lorsque l’instruction inclut un UNION, EXCEPTou INTERSECT un opérateur, la liste de sélection de la première requête (côté gauche) doit spécifier les noms de colonnes ou les alias de colonne.

Dans une requête qui utilise UNION, EXCEPTou INTERSECT opérateurs, vous ne pouvez utiliser ORDER BY qu’à la fin de l’instruction. Cette restriction s’applique uniquement lorsque vous spécifiez UNION, EXCEPTet INTERSECT dans une requête de niveau supérieur et non dans une sous-requête. Consultez la section Exemples.

La ORDER BY clause n’est pas valide dans les vues, les fonctions inline, les tables dérivées et les sous-requêtes, sauf si vous spécifiez également les TOP ou OFFSET les FETCH clauses. Lorsque vous utilisez ORDER BY ces objets, la clause est utilisée uniquement pour déterminer les lignes retournées par la TOP clause ou OFFSET les FETCH clauses. La ORDER BY clause ne garantit pas les résultats ordonnés lorsque ces constructions sont interrogées, sauf si ORDER BY elle est également spécifiée dans la requête elle-même.

OFFSET et FETCH ne sont pas pris en charge dans les vues indexées ou dans une vue définie à l’aide de la CHECK OPTION clause.

OFFSET et FETCH peut être utilisé dans n’importe quelle requête qui autorise TOP et ORDER BY avec les limitations suivantes :

La OVER clause ne prend pas en charge OFFSET et FETCH.
Vous ne pouvez pas spécifier OFFSET et FETCH directement dans INSERT, UPDATE, MERGEet DELETE les instructions, mais vous pouvez les spécifier dans une sous-requête définie dans ces instructions. Par exemple, dans l’instruction INSERT INTO SELECT , vous pouvez spécifier OFFSET et FETCH dans l’instruction SELECT .
Dans une requête qui utilise UNION, EXCEPT ou INTERSECT opérateurs, seule la requête finale qui spécifie l’ordre des résultats de la requête peut spécifier OFFSET et FETCH.
Vous ne pouvez pas combiner TOP avec OFFSET et FETCH dans la même expression de requête (dans la même étendue de requête).

Utiliser OFFSET et FETCH pour limiter les lignes retournées

Utilisez les clauses et FETCH les OFFSET clauses au lieu de la TOP clause pour implémenter une solution de pagination de requête et limiter le nombre de lignes envoyées à une application cliente.

L’utilisation OFFSET et FETCH en tant que solution de pagination nécessite l’exécution de la requête une fois pour chaque page de données retournée à l’application cliente. 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, puis réexécuter la requête pour renvoyer les lignes 11 à 20, et ainsi de suite. Chaque requête est indépendante et sans rapport les unes avec les autres. Cette condition signifie que, contrairement à l’utilisation d’un curseur dans lequel la requête est exécutée une fois et qu’elle est conservée sur le serveur, l’application cliente est responsable du suivi de l’état. Pour obtenir des résultats stables entre les requêtes utilisant OFFSET et FETCHles conditions suivantes doivent être remplies :

Les données sous-jacentes que la requête utilise ne changent pas. Autrement dit, la requête ne met pas à jour les lignes, ou toutes les demandes de pages de la requête s’exécutent dans une transaction unique à l’aide d’un instantané ou d’une isolation transactionnelle sérialisable. Pour plus d’informations sur ces niveaux d’isolation des transactions, consultez SET TRANSACTION ISOLATION LEVEL.
La ORDER BY clause contient une colonne ou une combinaison de colonnes qui sont garanties d’être uniques.

Consultez l’exemple Exécuter plusieurs requêtes dans une transaction unique dans la section Exemples .

Si les plans d’exécution cohérents sont importants dans votre solution de pagination, envisagez d’utiliser l’indicateur OPTIMIZE FOR de requête pour les paramètres et OFFSET les FETCH paramètres. Consultez Spécifier des expressions pour les valeurs OFFSET et FETCH dans la section Exemples . Pour plus d’informations sur OPTIMIZE FOR, consultez indicateurs de requête.

Examples

Les exemples de code de cet article utilisent les bases de données d'exemple AdventureWorks2025 ou AdventureWorksDW2025, que vous pouvez télécharger à partir de la page d'accueil Microsoft SQL Server Samples and Community Projects.

Category	Éléments syntaxiques proposés
Syntaxe de base	`ORDER BY`
Spécifier l’ordre croissant et décroissant	`DESC` ou `ASC`
Spécifier un classement	`COLLATE`
Spécifier un ordre conditionnel	Expression `CASE`
Utiliser ORDER BY dans une fonction de classement	Fonctions de classement
Limiter le nombre de lignes retournées	`OFFSET` et `FETCH`
Utiliser ORDER BY avec UNION, EXCEPT et INTERSECT	`UNION`

Syntaxe de base

Les exemples de cette section illustrent les fonctionnalités de base de la clause à l’aide ORDER BY de la syntaxe minimale requise.

A. Spécifier une seule colonne définie dans la liste de sélection

L'exemple suivant classe le jeu de résultats selon la colonne ProductID numérique. Comme vous ne spécifiez pas d’ordre de tri, la requête utilise l’ordre croissant par défaut.

USE AdventureWorks2025;
GO

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

B. Spécifier une colonne qui n’est pas définie dans la liste de sélection

L’exemple suivant trie le jeu de résultats par une colonne que la liste de sélection n’inclut pas, mais la FROM clause spécifie la table qui contient la colonne.

USE AdventureWorks2025;
GO

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

C. Spécifier un alias comme colonne de tri

L'exemple suivant spécifie l'alias de colonne SchemaName comme colonne d'ordre de tri.

USE AdventureWorks2025;
GO

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

D. Spécifier une expression comme colonne de tri

L'exemple suivant utilise une expression comme colonne de tri. L’expression est définie à l’aide de la DATEPART fonction pour trier le jeu de résultats par année dans laquelle les employés ont été embauchés.

USE AdventureWorks2025;
GO

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

Spécifier l’ordre de tri croissant et décroissant

A. Spécifier un ordre décroissant

L'exemple suivant classe le jeu de résultats selon la colonne ProductID numérique par ordre décroissant.

USE AdventureWorks2025;
GO

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

B. Spécifier un ordre croissant

L'exemple suivant classe le jeu de résultats selon la colonne Name dans l'ordre croissant. Les caractères sont triés par ordre alphabétique, et non par ordre numérique. Autrement dit, 10 arrive avant 2.

USE AdventureWorks2025;
GO

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

C. Spécifier à la fois l’ordre croissant et décroissant

L'exemple suivant classe le jeu de résultats selon deux colonnes. 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.

USE AdventureWorks2025;
GO

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

Spécifier un classement

L’exemple suivant montre comment spécifier un classement dans la clause peut modifier l’ordre dans lequel les résultats de la ORDER BY requête sont retournés. 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. Les valeurs sont insérées avec différentes différences de casse et d’accentuation. Étant donné qu’un classement n’est pas spécifié dans la clause, la ORDER BY première requête utilise le classement de la colonne lors du tri des valeurs. Dans la deuxième requête, un classement respectant la casse et sensible aux accents est spécifié dans la ORDER BY clause, ce qui modifie l’ordre dans lequel les lignes sont retournées.

USE tempdb;
GO

CREATE TABLE #t1
(
    name NVARCHAR (15) COLLATE Latin1_General_CI_AI
);

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écifier un ordre conditionnel

Les exemples suivants utilisent l’expression CASE dans une ORDER BY clause pour déterminer de manière conditionnelle l’ordre de tri des lignes en fonction d’une valeur de colonne donnée. Dans le premier exemple, la valeur de la colonne SalariedFlag de la table HumanResources.Employee est évaluée. Les employés pour lesquels SalariedFlag a la valeur 1 sont retournés par ordre décroissant d'BusinessEntityID. Les employés pour lesquels SalariedFlag a la valeur 0 sont retournés par ordre croissant d'BusinessEntityID. 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.

SELECT BusinessEntityID,
       SalariedFlag
FROM HumanResources.Employee
ORDER BY
    CASE SalariedFlag
        WHEN 1 THEN BusinessEntityID
    END DESC,
    CASE
        WHEN SalariedFlag = 0 THEN BusinessEntityID
    END;

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;

Utiliser ORDER BY dans une fonction de classement

L’exemple suivant utilise la ORDER BY clause dans les fonctions ROW_NUMBERde classement , RANK, DENSE_RANKet NTILE.

USE AdventureWorks2025;
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;

Limiter le nombre de lignes retournées

S’applique à : SQL Server 2012 (11.x) et versions ultérieures, Azure SQL Database et Azure SQL Managed Instance.

Les exemples suivants utilisent OFFSET et FETCH limitent le nombre de lignes retournées par une requête.

A. Spécifier des constantes entières pour les valeurs OFFSET et FETCH

L’exemple suivant spécifie une constante entière comme valeur pour les clauses et OFFSET les FETCH clauses. La première requête retourne toutes les lignes triées selon la colonne DepartmentID. Comparez les résultats retournés par cette requête avec les résultats des deux requêtes qui la suivent. La requête suivante utilise la clause OFFSET 5 ROWS pour ignorer les cinq premières lignes et retourner toutes les lignes restantes. 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é.

USE AdventureWorks2025;
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. Spécifier des variables pour les valeurs OFFSET et FETCH

L’exemple suivant déclare les variables @RowsToSkip et @FetchRows spécifie ces variables dans les clauses et OFFSET les FETCH clauses.

USE AdventureWorks2025;
GO

-- Specifying variables for OFFSET and FETCH values
DECLARE @RowsToSkip AS TINYINT = 2,
        @FetchRows AS TINYINT = 8;

SELECT DepartmentID,
       Name,
       GroupName
FROM HumanResources.Department
ORDER BY DepartmentID ASC OFFSET @RowsToSkip ROWS
FETCH NEXT @FetchRows ROWS ONLY;

C. Spécifier des expressions pour les valeurs OFFSET et FETCH

L’exemple suivant utilise l’expression @StartingRowNumber - 1 pour spécifier la OFFSET valeur et l’expression @EndingRowNumber - @StartingRowNumber + 1 pour spécifier la FETCH valeur. En outre, l’indicateur de requête, est OPTIMIZE FORspécifié. Utilisez cet indicateur pour fournir une valeur particulière pour une variable locale lorsque la requête est compilée et optimisée. Cette valeur n'est utilisée que pendant l'optimisation de la requête, et non pas lors de son exécution. Pour plus d’informations, consultez indicateurs de requête.

USE AdventureWorks2025;
GO

-- Specifying expressions for OFFSET and FETCH values
DECLARE @StartingRowNumber AS TINYINT = 1,
        @EndingRowNumber AS 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. Spécifier une sous-requête scalaire constante pour les valeurs OFFSET et FETCH

L’exemple suivant utilise une sous-requête scalaire constante pour définir la valeur de la FETCH clause. Le sous-requête retourne une valeur unique de la colonne PageSize dans la table dbo.AppSettings.

-- Specifying a constant scalar subquery
USE AdventureWorks2025;
GO

CREATE TABLE dbo.AppSettings
(
    AppSettingID INT NOT NULL,
    PageSize INT NOT NULL
);

INSERT INTO dbo.AppSettings
VALUES (1, 10);

DECLARE @StartingRowNumber AS 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. Exécuter plusieurs requêtes dans une seule 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. La requête est exécutée dans une transaction unique à l’aide du niveau d’isolation d’instantané, et la colonne spécifiée dans la ORDER BY clause garantit l’unicité des colonnes.

USE AdventureWorks2025;
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'AdventureWorks2025') = 0
ALTER DATABASE AdventureWorks2025
SET ALLOW_SNAPSHOT_ISOLATION ON;

-- Set the transaction isolation level to SNAPSHOT for this query.
SET TRANSACTION ISOLATION LEVEL SNAPSHOT;

-- Beginning the transaction.
BEGIN TRANSACTION;

-- Declare and set the variables for the OFFSET and FETCH values.
DECLARE @StartingRowNumber AS INT = 1,
        @RowCountPerPage AS 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
COMMIT TRANSACTION;

Utiliser ORDER BY avec UNION, EXCEPT et INTERSECT

Lorsqu’une requête utilise les UNIONopérateurs , ou INTERSECT les EXCEPTopérateurs, spécifiez la ORDER BY clause à la fin de l’instruction. La requête trie les résultats des requêtes combinées. 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.

USE AdventureWorks2025;
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 et Analytics Platform System (PDW)

L’exemple suivant illustre le tri d’un jeu de résultats par ordre croissant selon la colonne EmployeeKey numérique.

-- 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.

-- 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.

-- 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. 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.

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-05

Partager via

SELECT - Clause ORDER BY (Transact-SQL)

Syntax

Arguments

order_by_expression

COLLATE collation_name

ASC | DESC

DÉCALAGE { integer_constant | offset_row_count_expression } { LIGNE | ROWS }

FETCH { FIRST | NEXT } { integer_constant fetch_row_count_expression | } { ROW | ROWS } ONLY

Meilleures pratiques

Interoperability

Limitations

Utiliser OFFSET et FETCH pour limiter les lignes retournées

Examples

Syntaxe de base

A. Spécifier une seule colonne définie dans la liste de sélection

B. Spécifier une colonne qui n’est pas définie dans la liste de sélection

C. Spécifier un alias comme colonne de tri

D. Spécifier une expression comme colonne de tri

Spécifier l’ordre de tri croissant et décroissant

A. Spécifier un ordre décroissant

B. Spécifier un ordre croissant

C. Spécifier à la fois l’ordre croissant et décroissant

Spécifier un classement

Spécifier un ordre conditionnel

Utiliser ORDER BY dans une fonction de classement

Limiter le nombre de lignes retournées

A. Spécifier des constantes entières pour les valeurs OFFSET et FETCH

B. Spécifier des variables pour les valeurs OFFSET et FETCH

C. Spécifier des expressions pour les valeurs OFFSET et FETCH

D. Spécifier une sous-requête scalaire constante pour les valeurs OFFSET et FETCH

E. Exécuter plusieurs requêtes dans une seule transaction

Utiliser ORDER BY avec UNION, EXCEPT et INTERSECT

Exemples : Azure Synapse Analytics et Analytics Platform System (PDW)

Contenu connexe

Commentaires

Ressources supplémentaires