Offset di riga in SQL Server

Esiste un modo in SQL Server per ottenere i risultati a partire da un determinato offset? Ad esempio, in un altro tipo di database SQL, è possibile fare:

SELECT * FROM MyTable OFFSET 50 LIMIT 25

per ottenere risultati 51-75. Questo costrutto non sembra esistere in SQL Server.

Come posso farlo senza caricare tutte le righe che non mi interessano? Grazie!

Eviterei di usare SELECT *. Specifica le colonne che desideri effettivamente, anche se potrebbero essere tutte.

SQL Server 2005+

SELECT col1, col2 
FROM (
    SELECT col1, col2, ROW_NUMBER() OVER (ORDER BY ID) AS RowNum
    FROM MyTable
) AS MyDerivedTable
WHERE MyDerivedTable.RowNum BETWEEN @startRow AND @endRow

SQL Server 2000

Paging efficiente tramite set di risultati di grandi dimensioni in SQL Server 2000

Un metodo più efficiente per il paging tramite set di risultati di grandi dimensioni

Se elaborerai tutte le pagine in ordine, ricordati semplicemente di ricordare l'ultimo valore chiave visualizzato nella pagina precedente e l'utilizzo TOP (25) ... WHERE Key > @last_key ORDER BY Keypuò essere il metodo con le migliori prestazioni se esistono indici adeguati per consentire una ricerca efficiente - o un cursore API se non lo fanno .

Per selezionare una pagina arbitrale, la migliore soluzione per SQL Server 2005 - 2008 R2 è probabilmente ROW_NUMBEReBETWEEN

Per SQL Server 2012+ è possibile utilizzare la clausola ORDER BY avanzata per questa esigenza.

SELECT  *
FROM     MyTable 
ORDER BY OrderingColumn ASC 
OFFSET  50 ROWS 
FETCH NEXT 25 ROWS ONLY 

Anche se resta da vedere come pure l'esecuzione di questa opzione sarà .

Questo è un modo (SQL2000)

SELECT * FROM
(
    SELECT TOP (@pageSize) * FROM
    (
        SELECT TOP (@pageNumber * @pageSize) *
        FROM tableName 
        ORDER BY columnName ASC
    ) AS t1 
    ORDER BY columnName DESC
) AS t2 
ORDER BY columnName ASC

e questo è un altro modo (SQL 2005)

;WITH results AS (
    SELECT 
        rowNo = ROW_NUMBER() OVER( ORDER BY columnName ASC )
        , *
    FROM tableName 
) 
SELECT * 
FROM results
WHERE rowNo between (@pageNumber-1)*@pageSize+1 and @pageNumber*@pageSize

Puoi usare la ROW_NUMBER()funzione per ottenere ciò che vuoi:

SELECT *
FROM (SELECT ROW_NUMBER() OVER(ORDER BY id) RowNr, id FROM tbl) t
WHERE RowNr BETWEEN 10 AND 20

C'è OFFSET .. FETCHin SQL Server 2012, ma sarà necessario specificare una ORDER BYcolonna.

Se davvero non hai alcuna colonna esplicita che potresti passare come ORDER BYcolonna (come altri hanno suggerito), puoi usare questo trucco:

SELECT * FROM MyTable 
ORDER BY @@VERSION 
OFFSET 50 ROWS FETCH NEXT 25 ROWS ONLY

... o

SELECT * FROM MyTable 
ORDER BY (SELECT 0)
OFFSET 50 ROWS FETCH NEXT 25 ROWS ONLY

Lo stiamo usando in jOOQ quando gli utenti non specificano esplicitamente un ordine. Ciò produrrà quindi un ordinamento piuttosto casuale senza costi aggiuntivi.

Per le tabelle con più e grandi colonne di dati, preferisco:

SELECT 
  tablename.col1,
  tablename.col2,
  tablename.col3,
  ...
FROM
(
  (
    SELECT
      col1
    FROM 
    (
      SELECT col1, ROW_NUMBER() OVER (ORDER BY col1 ASC) AS RowNum
      FROM tablename
      WHERE ([CONDITION])
    )
    AS T1 WHERE T1.RowNum BETWEEN [OFFSET] AND [OFFSET + LIMIT]
  )
  AS T2 INNER JOIN tablename ON T2.col1=tablename.col1
);

-

[CONDITION] can contain any WHERE clause for searching.
[OFFSET] specifies the start,
[LIMIT] the maximum results.

Ha prestazioni molto migliori su tabelle con dati di grandi dimensioni come BLOB, perché la funzione ROW_NUMBER deve solo guardare attraverso una colonna e solo le righe corrispondenti vengono restituite con tutte le colonne.

Vedi la mia selezione per impaginatore

SELECT TOP @limit * FROM (
   SELECT ROW_NUMBER() OVER (ORDER BY colunx ASC) offset, * FROM (

     -- YOU SELECT HERE
     SELECT * FROM mytable


   ) myquery
) paginator
WHERE offset > @offset

Questo risolve l'impaginazione;)

SELECT TOP 75 * FROM MyTable
EXCEPT 
SELECT TOP 50 * FROM MyTable

A seconda della versione non puoi farlo direttamente, ma potresti fare qualcosa di simile

select top 25 *
from ( 
  select top 75 *
  from   table 
  order by field asc
) a 
order by field desc 

dove "campo" è la chiave.

Di seguito verranno visualizzati 25 record esclusi i primi 50 record di lavori in SQL Server 2012.

SELECT * FROM MyTable ORDER BY ID OFFSET 50 ROWS FETCH NEXT 25 ROWS ONLY;

è possibile sostituire l'ID come requisito

Dovresti stare attento quando usi l' ROW_NUMBER() OVER (ORDER BY)istruzione poiché le prestazioni sono piuttosto scarse. Lo stesso vale per l'uso delle espressioni comuni delle tabelle con ROW_NUMBER()questo è ancora peggio. Sto usando il seguente frammento che ha dimostrato di essere leggermente più veloce rispetto all'utilizzo di una variabile di tabella con un'identità per fornire il numero di pagina.

DECLARE @Offset INT = 120000
DECLARE @Limit INT = 10

DECLARE @ROWCOUNT INT = @Offset+@Limit
SET ROWCOUNT @ROWCOUNT

SELECT * FROM MyTable INTO #ResultSet
WHERE MyTable.Type = 1

SELECT * FROM
(
    SELECT *, ROW_NUMBER() OVER(ORDER BY SortConst ASC) As RowNumber FROM
    (
        SELECT *, 1 As SortConst FROM #ResultSet
    ) AS ResultSet
) AS Page
WHERE RowNumber BETWEEN @Offset AND @ROWCOUNT

DROP TABLE #ResultSet

Uso questa tecnica per l'impaginazione. Non recupero tutte le righe. Ad esempio, se la mia pagina deve visualizzare le prime 100 righe, prendo solo le 100 con la clausola where. L'output di SQL dovrebbe avere una chiave univoca.

La tabella presenta quanto segue:

ID, KeyId, Rank

Lo stesso grado verrà assegnato per più di un KeyId.

SQL è select top 2 * from Table1 where Rank >= @Rank and ID > @Id

Per la prima volta passo 0 per entrambi. La seconda volta passa 1 e 14. 3a volta passa 2 e 6 ....

Il valore del decimo record Rank & Id viene passato al successivo

11  21  1
14  22  1
7   11  1
6   19  2
12  31  2
13  18  2

Ciò avrà il minimo stress sul sistema

In SqlServer2005 è possibile effettuare le seguenti operazioni:

DECLARE @Limit INT
DECLARE @Offset INT
SET @Offset = 120000
SET @Limit = 10

SELECT 
    * 
FROM
(
   SELECT 
       row_number() 
   OVER 
      (ORDER BY column) AS rownum, column2, column3, .... columnX
   FROM   
     table
) AS A
WHERE 
 A.rownum BETWEEN (@Offset) AND (@Offset + @Limit-1) 

Il modo migliore per farlo senza perdere tempo per ordinare i record è in questo modo:

select 0 as tmp,Column1 from Table1 Order by tmp OFFSET 5000000 ROWS FETCH NEXT 50 ROWS ONLY

ci vuole meno di un secondo!
migliore soluzione per tavoli di grandi dimensioni.

Sto cercando questa risposta da un po 'di tempo (per query generiche) e ho scoperto un altro modo di farlo su SQL Server 2000+ utilizzando ROWCOUNT e cursori e senza TOP o alcuna tabella temporanea.

Usando SET ROWCOUNT [OFFSET+LIMIT]puoi limitare i risultati, e con i cursori, vai direttamente alla riga che desideri, quindi esegui il ciclo 'fino alla fine.

Quindi la tua query sarebbe così:

SET ROWCOUNT 75 -- (50 + 25)
DECLARE MyCursor SCROLL CURSOR FOR SELECT * FROM pessoas
OPEN MyCursor
FETCH ABSOLUTE 50 FROM MyCursor -- OFFSET
WHILE @@FETCH_STATUS = 0 BEGIN
    FETCH next FROM MyCursor
END
CLOSE MyCursor
DEALLOCATE MyCursor
SET ROWCOUNT 0

Con SQL Server 2012 (11.x) e versioni successive e il database SQL di Azure, puoi anche avere "fetch_row_count_expression", puoi anche avere la clausola ORDER BY insieme a questa.

USE AdventureWorks2012;  
GO  
-- Specifying variables for OFFSET and FETCH values    
DECLARE @skip int = 0  , @take int = 8;  
SELECT DepartmentID, Name, GroupName  
FROM HumanResources.Department  
ORDER BY DepartmentID ASC   
    OFFSET @skip ROWS   
    FETCH NEXT @take ROWS ONLY; 

https://docs.microsoft.com/en-us/sql/t-sql/queries/select-order-by-clause-transact-sql?view=sql-server-ver15

Nota OFFSET Specifica il numero di righe da saltare prima che inizi a restituire le righe dall'espressione della query. NON è il numero della riga iniziale. Quindi, deve essere 0 per includere il primo record.