sintaxis - sql server limit 1

LÍMITE 10... 20 en SQL Server

Question

Estoy tratando de hacer algo como:

SELECT * FROM table LIMIT 10,20

o

SELECT * FROM table LIMIT 10 OFFSET 10

pero usando SQL Server

La única solución que encontré parece excesiva:

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

También found :

SELECT TOP 10 * FROM stuff;

... pero no es lo que quiero hacer ya que no puedo especificar el límite de inicio.

¿Hay alguna otra manera para que yo haga eso?

Además, solo curiosidad, ¿hay alguna razón por la cual SQL Server no admite la función LIMIT o algo similar? No quiero ser malo, pero eso realmente suena como algo que un DBMS necesita ... Si lo hace, ¡entonces lo siento por ser tan ignorante! He estado trabajando con MySQL y SQL + durante los últimos 5 años, así que ...

Answer 1

¿Qué tal esto?

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

Le da las últimas 10 filas de las primeras 20 filas. Una desventaja es que el orden se invierte, pero, al menos, es fácil de recordar.

Answer 2

De la documentación en línea de MS SQL Server ( http://technet.microsoft.com/en-us/library/ms186734.aspx ), este es el ejemplo que he probado y funciona para recuperar un conjunto específico de filas. ROW_NUMBER requiere un OVER, pero puedes ordenar por lo que quieras:

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;

Answer 3

Desafortunadamente, ROW_NUMBER() es lo mejor que puedes hacer. En realidad es más correcto, porque los resultados de un limit o cláusula top realidad no tienen significado sin respeto a algún orden específico. Pero todavía es un dolor hacerlo.

Actualización: Sql Server 2012 agrega una característica de tipo limit través de las palabras clave OFFSET y FETCH.

Answer 4

El equivalente de LIMIT es SET ROWCOUNT, pero si desea una paginación genérica, es mejor escribir una consulta como esta:

;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

Answer 5

Hasta ahora, este formato es el que funciona para mí (aunque no el mejor rendimiento):

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 al costado, paginar sobre datos dinámicos puede conducir a resultados extraños / inesperados.

Answer 6

La cláusula LIMIT no es parte de SQL estándar. Es compatible como una extensión de proveedor de SQL por MySQL, PostgreSQL y SQLite.

Otras marcas de bases de datos pueden tener características similares (por ejemplo, TOP en Microsoft SQL Server), pero estas no siempre funcionan de manera idéntica.

Es difícil utilizar TOP en Microsoft SQL Server para imitar la cláusula LIMIT . Hay casos en los que simplemente no funciona.

La solución que mostró, utilizando ROW_NUMBER() está disponible en Microsoft SQL Server 2005 y posterior. Esta es la mejor solución (por ahora) que funciona únicamente como parte de la consulta.

Otra solución es usar TOP para obtener las primeras filas count + offset , y luego usar la API para buscar más allá de las primeras filas de compensación .

Ver también:

• " Emular la cláusula LIMIT de MySQL en Microsoft SQL Server 2000 "
• " Paginación de grandes conjuntos de resultados en ASP.NET "

Answer 7

Para SQL Server 2012 + puede usar .

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

Answer 8

Si usa SQL Server 2012+ vote por la respuesta de Martin Smith y use las extensiones OFFSET y FETCH NEXT para ORDER BY ,

Si tiene la mala suerte de tener una versión anterior, podría hacer algo como esto,

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

Creo que es funcionalmente equivalente a

SELECT * FROM SomeTable LIMIT 10 OFFSET 10 ORDER BY SomeColumn

y la mejor forma de ejecución que conozco de hacerlo en TSQL, antes de MS SQL 2012.

Si hay muchas filas, puede obtener un mejor rendimiento utilizando una tabla temporal en lugar de un CTE.

Answer 9

Solo por la solución de registro que funciona en la mayoría de los motores de bases de datos, aunque podría no ser la más eficiente:

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

Nota Pelase: la última página aún contendría filas ReturnCount sin importar qué es SkipCount. Pero eso podría ser algo bueno en muchos casos.

Answer 10

Una buena forma es crear un procedimiento:

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

al igual que el límite 0,2 /////////////// ejecutar la paginación 0,4

Answer 11

Use todo el servidor SQL:; con tbl as (SELECT ROW_NUMBER () over (order by (select 1)) as RowIndex, * from table) seleccione top 10 * from tbl where RowIndex> = 10

Answer 12

como has encontrado, este es el método de servidor sql preferido:

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

Answer 13

 SELECT * FROM users WHERE Id Between 15 and 25

imprimirá de 15 a 25 como límite similar en MYSQl

Answer 14

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

Debería dar los registros 11-20. Probablemente no sea demasiado eficiente si se incrementa para obtener más páginas, y no está seguro de cómo podría verse afectado por el pedido. Podría tener que especificar esto en ambas declaraciones WHERE.

Answer 15

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

Imprimirá filas de 10 a 15.