LIMIT 10..20 dans SQL Server

J'essaye de faire quelque chose comme:

SELECT * FROM table LIMIT 10,20

ou

SELECT * FROM table LIMIT 10 OFFSET 10

mais en utilisant SQL Server

La seule solution que j'ai trouvée semble exagérée:

SELECT * FROM ( 
  SELECT *, ROW_NUMBER() OVER (ORDER BY name) as row FROM sys.databases 
 ) a WHERE row > 5 and row <= 10

J'ai aussi trouvé :

SELECT TOP 10 * FROM stuff; 

... mais ce n'est pas ce que je veux faire car je ne peux pas spécifier la limite de départ.

Y a-t-il une autre façon pour moi de faire ça?

Aussi, juste curieux, y a-t-il une raison pour laquelle SQL Server ne prend pas en charge la LIMITfonction ou quelque chose de similaire? Je ne veux pas être méchant, mais cela ressemble vraiment à quelque chose dont un SGBD a besoin ... Si c'est le cas, je suis désolé d'être si ignorant! Je travaille avec MySQL et SQL + depuis 5 ans donc ...

La LIMITclause ne fait pas partie du SQL standard. Il est pris en charge en tant qu'extension de fournisseur de SQL par MySQL, PostgreSQL et SQLite.

D'autres marques de base de données peuvent avoir des fonctionnalités similaires (par exemple TOPdans Microsoft SQL Server), mais celles-ci ne fonctionnent pas toujours de la même manière.

Il est difficile d'utiliser TOPdans Microsoft SQL Server pour imiter la LIMITclause. Il y a des cas où cela ne fonctionne tout simplement pas.

La solution que vous avez présentée en utilisant ROW_NUMBER()est disponible dans Microsoft SQL Server 2005 et versions ultérieures. C'est la meilleure solution (pour l'instant) qui fonctionne uniquement dans le cadre de la requête.

Une autre solution consiste à utiliser TOPpour récupérer le premier lignes de comptage + décalage , puis à utiliser l'API pour rechercher au-delà des premières lignes de décalage .

Voir également:

• « Émuler la clause MySQL LIMIT dans Microsoft SQL Server 2000 »
• " Pagination de grands ensembles de résultats dans ASP.NET "

Pour SQL Server 2012 +, vous pouvez utiliser .

SELECT  *
FROM     sys.databases
ORDER BY name 
OFFSET  5 ROWS 
FETCH NEXT 5 ROWS ONLY 

comme vous l'avez trouvé, c'est la méthode de serveur sql préférée:

SELECT * FROM ( 
  SELECT *, ROW_NUMBER() OVER (ORDER BY name) as row FROM sys.databases 
 ) a WHERE a.row > 5 and a.row <= 10

Si vous utilisez SQL Server 2012+, votez pour la réponse de Martin Smith et utilisez les extensions OFFSETet FETCH NEXTpour ORDER BY,

Si vous avez la malchance d'être coincé avec une version antérieure, vous pouvez faire quelque chose comme ça,

WITH Rows AS
(
    SELECT
              ROW_NUMBER() OVER (ORDER BY [dbo].[SomeColumn]) [Row]
            , *
        FROM
              [dbo].[SomeTable]
)
SELECT TOP 10
          *
     FROM
         Rows
    WHERE Row > 10

Je crois que c'est fonctionnellement équivalent à

SELECT * FROM SomeTable LIMIT 10 OFFSET 10 ORDER BY SomeColumn

et la manière la plus performante que je connaisse de le faire dans TSQL, avant MS SQL 2012.

S'il y a beaucoup de lignes, vous pouvez obtenir de meilleures performances en utilisant une table temporaire au lieu d'un CTE.

Malheureusement, ROW_NUMBER()c'est le mieux que vous puissiez faire. C'est en fait plus correct, car les résultats d'une clause limitou topn'ont pas vraiment de sens sans un ordre spécifique. Mais c'est toujours une douleur à faire.

Mise à jour: Sql Server 2012 ajoute une limitfonctionnalité similaire via les mots-clés OFFSET et FETCH . C'est l'approche standard ansi, par opposition à LIMIT, qui est une extension MySql non standard.

Que dis-tu de ça?

SET ROWCOUNT 10 

SELECT TOP 20 *
FROM sys.databases
ORDER BY database_id DESC

Il vous donne les 10 dernières lignes des 20 premières lignes. Un inconvénient est que l'ordre est inversé, mais au moins c'est facile à retenir.

SELECT TOP 10 *
FROM TABLE
WHERE IDCOLUMN NOT IN (SELECT TOP 10 IDCOLUMN FROM TABLE)

Devrait donner des enregistrements 11-20. Probablement pas trop efficace si vous augmentez pour obtenir d'autres pages, et ne savez pas comment cela pourrait être affecté par la commande. Il se peut que vous deviez le spécifier dans les deux instructions WHERE.

Un bon moyen est de créer une procédure:

create proc pagination (@startfrom int ,@endto int) as
SELECT * FROM ( 
  SELECT *, ROW_NUMBER() OVER (ORDER BY name desc) as row FROM sys.databases 
 ) a WHERE a.row > @startfrom and a.row <= @endto

tout comme limite 0,2 /////////////// exécuter la pagination 0,4

Juste pour la solution d'enregistrement qui fonctionne sur la plupart des moteurs de base de données, mais peut-être pas la plus efficace:

Select Top (ReturnCount) *
From (
    Select Top (SkipCount + ReturnCount) *
    From SourceTable
    Order By ReverseSortCondition
) ReverseSorted
Order By SortCondition

Remarque Pelase: la dernière page contiendrait toujours des lignes ReturnCount, quel que soit SkipCount. Mais cela pourrait être une bonne chose dans de nombreux cas.

L'équivalent de LIMIT est SET ROWCOUNT, mais si vous voulez une pagination générique, il est préférable d'écrire une requête comme celle-ci:

;WITH Results_CTE AS
(
    SELECT
        Col1, Col2, ...,
        ROW_NUMBER() OVER (ORDER BY SortCol1, SortCol2, ...) AS RowNum
    FROM Table
    WHERE <whatever>
)
SELECT *
FROM Results_CTE
WHERE RowNum >= @Offset
AND RowNum < @Offset + @Limit

select * from (select id,name,ROW_NUMBER() OVER (ORDER BY id  asc) as row
from tableName1) tbl1
where tbl1.row>=10 and tbl1.row<=15

Imprime les lignes de 10 à 15.

Jusqu'à présent, ce format est ce qui fonctionne pour moi (pas la meilleure performance cependant):

SELECT TOP {desired amount of rows} * 
FROM (SELECT *, ROW_NUMBER() OVER (ORDER BY {order columns} asc)__row__ FROM {table})tmp
WHERE __row__ > {offset row count}

Une note sur le côté, paginer sur des données dynamiques peut conduire à des résultats étranges / inattendus.

De la documentation en ligne de MS SQL Server ( http://technet.microsoft.com/en-us/library/ms186734.aspx ), voici leur exemple que j'ai testé et fonctionne, pour récupérer un ensemble spécifique de lignes. ROW_NUMBER nécessite un OVER, mais vous pouvez commander ce que vous voulez:

WITH OrderedOrders AS
(
  SELECT SalesOrderID, OrderDate,
  ROW_NUMBER() OVER (ORDER BY OrderDate) AS RowNumber
  FROM Sales.SalesOrderHeader 
) 
SELECT SalesOrderID, OrderDate, RowNumber  
FROM OrderedOrders 
WHERE RowNumber BETWEEN 50 AND 60;

Utilisez tout le serveur SQL:; avec tbl as (SELECT ROW_NUMBER () over (order by (select 1)) as RowIndex, * from table) select top 10 * from tbl where RowIndex> = 10

 SELECT * FROM users WHERE Id Between 15 and 25

il imprimera de 15 à 25 comme limite dans MYSQl