Come implementare LIMIT con Microsoft SQL Server?

Question

Ho questa domanda con mysql:

select * from table1 LIMIT 10,20

Come posso farlo con Microsoft sql?

Answer 1

A partire da SQL SERVER 2005, è possibile farlo ...

USE AdventureWorks;
GO
WITH OrderedOrders AS
(
    SELECT SalesOrderID, OrderDate,
    ROW_NUMBER() OVER (ORDER BY OrderDate) AS 'RowNumber'
    FROM Sales.SalesOrderHeader 
) 
SELECT * 
FROM OrderedOrders 
WHERE RowNumber BETWEEN 10 AND 20;

o qualcosa del genere per 2000 e versioni precedenti ...

SELECT TOP 10 * FROM (SELECT TOP 20 FROM Table ORDER BY Id) ORDER BY Id DESC

Answer 2

Clunky, ma funzionerà.

SELECT TOP 10 * FROM table WHERE id NOT IN (SELECT TOP 10 id FROM table ORDER BY id) FROM table ORDER BY id

L'omissione di MSSQL di una clausola LIMIT è criminale, IMO. Non dovresti fare questo tipo di soluzione kludgy.

Answer 3

A partire da SQL SERVER 2012, è possibile utilizzare la clausola FETCH OFFSET:

USE AdventureWorks;
GO
SELECT SalesOrderID, OrderDate
FROM Sales.SalesOrderHeader 
ORDER BY SalesOrderID
    OFFSET 10 ROWS
    FETCH NEXT 10 ROWS ONLY;
GO

http://msdn.microsoft.com/en-us/ biblioteca / ms188385 (v = sql.110) aspx

Potrebbe non funzionare correttamente quando l'ordine per non è univoco.

Se la query viene modificata in ORDER BY OrderDate, il set di risultati restituito non è come previsto.

Answer 4

Questo è quasi un duplicato di una domanda che ho posto in ottobre: Emula la clausola LIMIT di MySQL in Microsoft SQL Server 2000

Se si utilizza Microsoft SQL Server 2000, non esiste una buona soluzione. La maggior parte delle persone deve ricorrere alla cattura del risultato della query in una tabella temporanea con una chiave primaria IDENTITY . Quindi esegui una query sulla colonna chiave primaria utilizzando una condizione TRA .

Se si utilizza Microsoft SQL Server 2005 o versione successiva, si dispone della funzione ROW_NUMBER () , in modo da poter ottenere lo stesso risultato ma evitare la tabella temporanea.

SELECT t1.*
FROM (
    SELECT ROW_NUMBER OVER(ORDER BY id) AS row, t1.*
    FROM ( ...original SQL query... ) t1
) t2
WHERE t2.row BETWEEN @offset+1 AND @offset+@count;

Puoi anche scrivere questo come espressione di tabella comune come mostrato nella risposta di @Leon Tayson .

Answer 5

SELECT  *
FROM    (
        SELECT  TOP 20
                t.*, ROW_NUMBER() OVER (ORDER BY field1) AS rn
        FROM    table1 t
        ORDER BY
                field1
        ) t
WHERE   rn > 10

Answer 6

Ecco come limito i risultati in MS SQL Server 2012:

SELECT * 
FROM table1
ORDER BY columnName
  OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY

NOTA: OFFSET può essere utilizzato solo o in tandem con ORDER BY .

Per spiegare la riga di codice OFFSET xx ROWS FETCH NEXT yy ROW ONLY

Il xx è il numero di record / riga che si desidera iniziare a estrarre dalla tabella, ovvero: Se nella tabella 1 sono presenti 40 record, il codice sopra inizierà a tirare dalla riga 10.

yy è il numero di record / righe che si desidera estrarre dalla tabella.

Per basarsi sull'esempio precedente: se la tabella 1 ha 40 record e hai iniziato a tirare dalla riga 10 e prendi il set NEXT di 10 ( yy ). Ciò significherebbe che il codice sopra estrarrà i record dalla tabella 1 a partire dalla riga 10 e termina alle 20. Quindi estraendo le righe da 10 a 20.

Controlla il link per ulteriori informazioni su OFFSET

Answer 7

La query LIMIT sintatticamente di MySQL è qualcosa del genere:

SELECT * FROM table LIMIT OFFSET, ROW_COUNT

Questo può essere tradotto in Microsoft SQL Server come

SELECT * FROM 
(
    SELECT TOP #{OFFSET+ROW_COUNT} *, ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS rnum 
    FROM table
) a
WHERE rnum > OFFSET

Ora la tua query seleziona * dalla tabella1 LIMIT 10,20 sarà così:

SELECT * FROM 
(
    SELECT TOP 30 *, ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS rnum 
    FROM table1
) a
WHERE rnum > 10 

Answer 8

Questo è uno dei motivi per cui cerco di evitare di usare MS Server ... ma comunque. A volte semplicemente non hai un'opzione (yei! E devo usare una versione obsoleta !!).

Il mio suggerimento è di creare una tabella virtuale:

Da:

SELECT * FROM table

A:

CREATE VIEW v_table AS    
    SELECT ROW_NUMBER() OVER (ORDER BY table_key) AS row,* FROM table

Quindi esegui una query:

SELECT * FROM v_table WHERE row BETWEEN 10 AND 20

Se i campi vengono aggiunti o rimossi, " riga " viene aggiornato automaticamente.

Il problema principale con questa opzione è che ORDER BY è stato risolto. Quindi, se vuoi un ordine diverso, dovresti creare un'altra vista.

Aggiorna

C'è un altro problema con questo approccio: se provi a filtrare i tuoi dati, non funzioneranno come previsto. Ad esempio, se lo fai:

SELECT * FROM v_table WHERE field = 'test' AND row BETWEEN 10 AND 20

DOVE si limita a quei dati che si trovano nelle righe tra 10 e 20 (invece di cercare l'intero set di dati e limitare l'output).

Answer 9

Questo è un approccio in più passaggi che funzionerà in SQL2000.

-- Create a temp table to hold the data
CREATE TABLE #foo(rowID int identity(1, 1), myOtherColumns)

INSERT INTO #foo (myColumns) SELECT myData order By MyCriteria

Select * FROM #foo where rowID > 10

Answer 10

SELECT 
    * 
FROM 
    (
        SELECT 
            top 20              -- ($a) number of records to show
            * 
        FROM
            (
                SELECT 
                    top 29      -- ($b) last record position
                    * 
                FROM 
                    table       -- replace this for table name (i.e. "Customer")
                ORDER BY 
                    2 ASC
            ) AS tbl1 
        ORDER BY 
            2 DESC
    ) AS tbl2 
ORDER BY 
    2 ASC;

-- Examples:

-- Show 5 records from position 5:
-- $a = 5;
-- $b = (5 + 5) - 1
-- $b = 9;

-- Show 10 records from position 4:
-- $a = 10;
-- $b = (10 + 4) - 1
-- $b = 13;

-- To calculate $b:
-- $b = ($a + position) - 1

-- For the present exercise we need to:
-- Show 20 records from position 10:
-- $a = 20;
-- $b = (20 + 10) - 1
-- $b = 29;

Answer 11

In SQL non esiste una parola chiave LIMIT. Se hai bisogno solo di un numero limitato di righe, dovresti usare una parola chiave TOP simile a LIMIT.

Answer 12

Deve provare. Nella query di seguito, puoi visualizzare raggruppa, ordina per, Salta righe e limita righe.

select emp_no , sum(salary_amount) from emp_salary
Group by emp_no 
ORDER BY emp_no 
OFFSET 5 ROWS       -- Skip first 5 
FETCH NEXT 10 ROWS ONLY; -- limit to retrieve next 10 row after skiping rows

Answer 13

Se il tuo ID è un tipo di identificatore univoco o il tuo ID nella tabella non è ordinato, devi procedere come segue.

select * from
(select ROW_NUMBER() OVER (ORDER BY (select 0)) AS RowNumber,* from table1) a
where a.RowNumber between 2 and 5

Il codice sarà

select * from limit 2,5

Answer 14

Se ricordo bene (è da un po 'che non mi diletto con SQL Server) potresti essere in grado di usare qualcosa del genere: (dal 2005 in poi)

SELECT
    *
   ,ROW_NUMBER() OVER(ORDER BY SomeFields) AS [RowNum]
FROM SomeTable
WHERE RowNum BETWEEN 10 AND 20

Answer 15

SELECT TOP 10 * FROM table;

È uguale a

SELECT * FROM table LIMIT 0,10;

Ecco un articolo sull'implementazione di Limit in MsSQL È una buona lettura, specialmente i commenti.