LIMIT 10..20 in SQL Server

Sto cercando di fare qualcosa del tipo:

SELECT * FROM table LIMIT 10,20

o

SELECT * FROM table LIMIT 10 OFFSET 10

ma utilizzando SQL Server

L'unica soluzione che ho trovato sembra eccessiva:

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

Ho anche trovato :

SELECT TOP 10 * FROM stuff; 

... ma non è quello che voglio fare poiché non riesco a specificare il limite iniziale.

C'è un altro modo per farlo?

Inoltre, solo curioso, c'è un motivo per cui SQL Server non supporta la LIMITfunzione o qualcosa di simile? Non voglio essere cattivo, ma sembra davvero qualcosa di cui un DBMS ha bisogno ... Se lo fa, allora mi dispiace di essere così ignorante! Ho lavorato con MySQL e SQL + negli ultimi 5 anni, quindi ...

La LIMITclausola non fa parte di SQL standard. È supportato come estensione del fornitore per SQL da MySQL, PostgreSQL e SQLite.

Altre marche di database potrebbero avere caratteristiche simili (ad es. TOPIn Microsoft SQL Server), ma non sempre funzionano in modo identico.

È difficile da utilizzare TOPin Microsoft SQL Server per imitare la LIMITclausola. Ci sono casi in cui semplicemente non funziona.

La soluzione che hai mostrato, utilizzando ROW_NUMBER()è disponibile in Microsoft SQL Server 2005 e versioni successive. Questa è la soluzione migliore (per ora) che funziona esclusivamente come parte della query.

Un'altra soluzione è utilizzare TOPper recuperare il primo conteggio + righe di offset , quindi utilizzare l'API per cercare oltre le prime righe di offset .

Guarda anche:

• " Emula la clausola LIMIT di MySQL in Microsoft SQL Server 2000 "
• " Paging di grandi set di risultati in ASP.NET "

Per SQL Server 2012 + è possibile utilizzare .

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

come hai trovato, questo è il metodo server SQL preferito:

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

Se si utilizza il voto di SQL Server 2012+ per la risposta di Martin Smith e si utilizzano le estensioni OFFSETe ,FETCH NEXTORDER BY

Se sei abbastanza sfortunato da rimanere bloccato con una versione precedente, potresti fare qualcosa del genere,

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

Credo funzionalmente equivalente a

SELECT * FROM SomeTable LIMIT 10 OFFSET 10 ORDER BY SomeColumn

e il modo migliore che conosco per farlo in TSQL, prima di MS SQL 2012.

Se sono presenti molte righe, è possibile ottenere prestazioni migliori utilizzando una tabella temporanea anziché un CTE.

Sfortunatamente, ROW_NUMBER()è il meglio che puoi fare. In realtà è più corretto, perché i risultati di una clausola limito topnon hanno davvero significato senza rispetto di un ordine specifico. Ma è ancora un dolore da fare.

Aggiornamento: SQL Server 2012 aggiunge una limitfunzione simile tramite le parole chiave OFFSET e FETCH . Questo è l'approccio ansi standard, al contrario LIMIT, che è un'estensione MySql non standard.

Cosa ne pensi di questo?

SET ROWCOUNT 10 

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

Ti dà le ultime 10 righe delle prime 20 righe. Uno svantaggio è che l'ordine è invertito, ma almeno è facile da ricordare.

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

Dovrebbe dare record 11-20. Probabilmente non troppo efficiente se si incrementa per ottenere ulteriori pagine, e non sono sicuro di come potrebbe essere influenzato dall'ordinamento. Potrebbe essere necessario specificarlo in entrambe le istruzioni WHERE.

Un buon modo è quello di creare una procedura:

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

proprio come limite 0,2 /////////////// eseguire l'impaginazione 0,4

Solo per la soluzione record che funziona sulla maggior parte dei motori di database potrebbe non essere la più efficiente:

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

Nota Pelase: l'ultima pagina conterrebbe comunque le righe ReturnCount, indipendentemente da SkipCount. Ma potrebbe essere una buona cosa in molti casi.

L'equivalente di LIMIT è SET ROWCOUNT, ma se si desidera l'impaginazione generica è meglio scrivere una query come questa:

;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

Stampa le righe da 10 a 15.

Finora questo formato è ciò che funziona per me (non la migliore prestazione però):

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}

Una nota a lato, l'impaginazione su dati dinamici può portare a risultati strani / imprevisti.

Dalla documentazione online di MS SQL Server ( http://technet.microsoft.com/en-us/library/ms186734.aspx ), ecco il loro esempio che ho testato e funziona, per recuperare un set specifico di righe. ROW_NUMBER richiede un OVER, ma puoi ordinare come preferisci:

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;

Usa tutto il server SQL:; con tbl as (SELECT ROW_NUMBER () su (ordina per (seleziona 1)) come RowIndex, * dalla tabella) seleziona i primi 10 * da tbl dove RowIndex> = 10

 SELECT * FROM users WHERE Id Between 15 and 25

verrà stampato da 15 a 25 come limite simile in MYSQl