SELECT - Clause ORDER BY (Transact-SQL)
S’applique à : SQL Server Base de données Azure SQL Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW) Point de terminaison d'analyse 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
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. COLLATE
s’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
, EXCEPT
ou 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
, EXCEPT
ou INTERSECT
opérateurs, ORDER BY
est autorisée uniquement à la fin de l’instruction. Cette restriction s’applique uniquement lorsque vous spécifiez UNION
, EXCEPT
et 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 chargeOFFSET
etFETCH
.OFFSET
etFETCH
ne peut pas être spécifié directement dansINSERT
,UPDATE
,MERGE
etDELETE
les instructions, mais peuvent être spécifiés dans une sous-requête définie dans ces instructions. Par exemple, dans l’instructionINSERT INTO SELECT
,OFFSET
etFETCH
peut être spécifié dans l’instructionSELECT
.Dans une requête qui utilise
UNION
,EXCEPT
ouINTERSECT
des opérateurs,OFFSET
etFETCH
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é avecOFFSET
etFETCH
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 FETCH
les 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.
R : 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
R : 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_NUMBER
de classement , RANK
, DENSE_RANK
et 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.
R : 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 FOR
spé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
, EXCEPT
ou 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;
Contenu connexe
- Expressions (Transact-SQL)
- SELECT (Transact-SQL)
- Clause FROM plus JOIN, APPLY, PIVOT (Transact-SQL)
- Fonctions de classement (Transact-SQL)
- TOP (Transact-SQL)
- Indicateurs de requête (Transact-SQL)
- Opérateurs de jeu - EXCEPT et INTERSECT (Transact-SQL)
- Opérateurs de jeu - UNION (Transact-SQL)
- CASE (Transact-SQL)