SELECT - Clause ORDER BY (Transact-SQL)

Article
07/20/2024

S’applique à : SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW) SQL analytics endpoint in Microsoft Fabric Warehouse in 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

Remarque

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

Syntaxe

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 et Parallel Data Warehouse.

[ 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. Une colonne de tri peut être spécifiée comme un nom ou un alias de colonne, ou un entier non négatif représentant la position de la colonne dans la liste de sélection.

Il est possible de définir 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é. 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.

Les noms de colonnes référencés 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, l’alias de colonne doit être utilisé seul, et non dans le cadre d’une expression dans ORDER BY la clause, par exemple :

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_name

Spécifie que l’opération ORDER BY doit être effectuée en fonction du classement spécifié 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.

OFFSET { integer_constant | offset_row_count_expression } { ROW | 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 de retourner des lignes à partir 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. Lorsqu’une sous-requête est utilisée, 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 s’affiche 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 à un.

fetch_row_count_expression peut être une variable, un paramètre ou une sous-requête scalaire constante. Lorsqu’une sous-requête est utilisée, 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.

Bonnes 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, l’instruction n’est pas aussi facilement comprise par d’autres que 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 afin d’é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 les lignes affectées par TOP. Pour plus d’informations, voir TOP.

Interopérabilité

Lorsqu’elle est utilisée avec un SELECT...INTO ou INSERT...SELECT une instruction pour insérer des lignes 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.

Limites

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.

Les colonnes de type ntext, text, image, geography, geometry et xml ne peuvent pas être utilisées dans une ORDER BY clause.

Un entier ou une constante ne peut pas être spécifié lorsque order_by_expression apparaît dans une fonction de classement. Pour plus d’informations, consultez la clause SELECT - OVER.

Si un nom de table est alias dans la FROM clause, seul le nom de l’alias peut être utilisé pour qualifier ses colonnes dans la ORDER BY clause.

Les noms de colonnes et les alias spécifiés dans la ORDER BY clause doivent être définis dans la liste de sélection si l’instruction SELECT contient l’une des clauses ou opérateurs suivants :

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

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

Dans une requête qui utilise UNION, EXCEPTou INTERSECT opérateurs, ORDER BY est autorisée uniquement à 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 qui suit.

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 les TOP ou OFFSET les FETCH clauses sont également spécifiées. Lorsqu’elle ORDER BY est utilisée dans 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.
OFFSET et FETCH ne peut pas être spécifié directement dans INSERT, UPDATE, MERGEet DELETE les instructions, mais peuvent être spécifiés dans une sous-requête définie dans ces instructions. Par exemple, dans l’instruction INSERT INTO SELECT , OFFSET et FETCH peut être spécifié dans l’instruction SELECT .
Dans une requête qui utilise UNION, EXCEPT ou INTERSECT des opérateurs, OFFSET et FETCH ne peut être spécifiée que dans la requête finale qui spécifie l’ordre des résultats de la requête.
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).

Utiliser OFFSET et FETCH pour limiter les lignes retournées

Vous devez utiliser 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. 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. Pour obtenir des résultats stables entre les requêtes utilisant OFFSET et FETCHles conditions suivantes doivent être remplies :

Les données sous-jacentes utilisées par la requête ne doivent pas changer. Autrement dit, les lignes touchées par la requête ne sont pas mises à jour ou toutes les demandes de pages de la requête sont exécutées dans une seule transaction à l’aide d’un instantané ou d’une isolation de transaction 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écution de plusieurs requêtes dans une transaction unique » dans la section Exemples plus loin dans cet article.

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 FETCH les OFFSET paramètres. Consultez Spécifier des expressions pour les valeurs OFFSET et FETCH dans la section Exemples plus loin dans cet article. Pour plus d’informations sur OPTIMIZE FOR, consultez indicateurs de requête.

Exemples

Les exemples de code Transact-SQL de cet article sont fondés sur l’échantillon de base de données AdventureWorks2022 ou AdventureWorksDW2022 fourni, que vous pouvez télécharger à partir de la page d’accueil Échantillons et projets communautaires Microsoft SQL Server.

Catégorie	É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. Étant donné qu’un ordre de tri spécifique n’est pas spécifié, la valeur par défaut (ordre croissant) est utilisée.

USE AdventureWorks2022;
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 qui n’est pas incluse dans la liste de sélection, mais est défini dans la table spécifiée dans la FROM clause.

USE AdventureWorks2022;
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 AdventureWorks2022;
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 AdventureWorks2022;
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 AdventureWorks2022;
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 AdventureWorks2022;
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 AdventureWorks2022;
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);
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é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;
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;

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 AdventureWorks2022;
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 FETCH les OFFSET 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 AdventureWorks2022;
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 FETCH les OFFSET clauses.

USE AdventureWorks2022;
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. 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 valeur FETCH. En outre, l’indicateur de requête, est OPTIMIZE FORspécifié. 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. 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 AdventureWorks2022;
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. 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 AdventureWorks2022;
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. 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 AdventureWorks2022;
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'AdventureWorks2022'
) = 0
ALTER DATABASE AdventureWorks2022
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

Utiliser ORDER BY avec UNION, EXCEPT et INTERSECT

Lorsqu’une requête utilise le UNION, EXCEPTou INTERSECT les opérateurs, la ORDER BY clause doit être spécifiée à la fin de l’instruction et les résultats des requêtes combinées sont triés. 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 AdventureWorks2022;
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;

Partager via

SELECT - Clause ORDER BY (Transact-SQL)

Syntaxe

Arguments

order_by_expression

COLLATE collation_name

ASC | DESC

OFFSET { integer_constant | offset_row_count_expression } { ROW | ROWS }

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

Bonnes pratiques

Interopérabilité

Limites

Utiliser OFFSET et FETCH pour limiter les lignes retournées

Exemples

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)

Commentaires

Ressources supplémentaires

Partager via

SELECT - Clause ORDER BY (Transact-SQL)

Syntaxe

Arguments

order_by_expression

COLLATE collation_name

ASC | DESC

OFFSET { integer_constant | offset_row_count_expression } { ROW | ROWS }

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

Bonnes pratiques

Interopérabilité

Limites

Utiliser OFFSET et FETCH pour limiter les lignes retournées

Exemples

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