blocks|key|1365327|text|丑陋，粗俗，但应该可以工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365328|select+top(M+%2B+N+-+1)+*+from+TableName
except
select+top(N+-+1)+*+from+TableName|code-block|syntax|javascript|1365329|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Ugly, hackish, but should work:

<pre><code>select top(M + N - 1) * from TableName
except
select top(N - 1) * from TableName
</code></pre>

blocks|key|1365394|text|@start+=+3
@records+=+2

Select+ID,+Value+
From
(SELECT+ROW_NUMBER()+OVER(ORDER+BY+ID)+AS+RowNum,+ID,Value+
From+MyTable)+as+sub
Where+sub.RowNum+between+@start+and+@start%2B@records|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1365395|这是一种方法。如果你用谷歌搜索SQL分页，还有很多其他的。|unstyled|1365396|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>@start = 3
@records = 2

Select ID, Value 
From
(SELECT ROW_NUMBER() OVER(ORDER BY ID) AS RowNum, ID,Value 
From MyTable) as sub
Where sub.RowNum between @start and @start+@records
</code></pre>

This is one way. there are a lot of others if you google SQL Paging.

blocks|key|1365517|text|对于T-SQL，有一个非常简单的方法，尽管我不确定如果您跳过大量行，它是否有效。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1365518|SELECT+TOP+numberYouWantToTake+
++++[yourColumns...]+
FROM+yourTable+
WHERE+yourIDColumn+NOT+IN+(
++++SELECT+TOP+numberYouWantToSkip+
++++++++yourIDColumn+
++++FROM+yourTable+
++++ORDER+BY+yourOrderColumn
)
ORDER+BY+yourOrderColumn|code-block|syntax|javascript|1365519|如果您使用的是.Net，则可以在IEnumerable上对数据结果使用以下内容：|1365520|IEnumerable<yourDataType>+yourSelectedData+=+yourDataInAnIEnumerable.Skip(nubmerYouWantToSkip).Take(numberYouWantToTake);|1365521|这有一个缺点，那就是你从数据存储中获取所有的数据。|1365522|entityMap^0|2|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

There is a pretty straight-forward method for <code>T-SQL</code>, although I'm not sure if it is prestanda-effective if you're skipping a large number of rows.

<pre><code>SELECT TOP numberYouWantToTake 
 [yourColumns...] 
FROM yourTable 
WHERE yourIDColumn NOT IN (
 SELECT TOP numberYouWantToSkip 
 yourIDColumn 
 FROM yourTable 
 ORDER BY yourOrderColumn
)
ORDER BY yourOrderColumn
</code></pre>

If you're using .Net, you can use the following on for example an IEnumerable with your data results:

<pre><code>IEnumerable&lt;yourDataType&gt; yourSelectedData = yourDataInAnIEnumerable.Skip(nubmerYouWantToSkip).Take(numberYouWantToTake);
</code></pre>

This has the backside that you're getting all the data from the data storage.

blocks|key|1580670|text|为什么不执行两个查询：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1580671|select+top(M%2BN-1)+*+from+table+into+temp+tmp_final+with+no+log;
select+top(N-1)+*+from+tmp_final+order+by+id+desc;|code-block|syntax|javascript|1580672|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Why not do two queries:

<pre><code>select top(M+N-1) * from table into temp tmp_final with no log;
select top(N-1) * from tmp_final order by id desc;
</code></pre>

blocks|key|1580734|text|如果要从第25条记录中选择100条记录：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1580735|select+TOP+100+*+from+TableName
where+PrimaryKeyField+
+++NOT+IN(Select+TOP+24+PrimaryKeyField+from+TableName);|code-block|syntax|javascript|1580736|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to select 100 records from 25th record:

<pre><code>select TOP 100 * from TableName
where PrimaryKeyField 
 NOT IN(Select TOP 24 PrimaryKeyField from TableName);
</code></pre>

blocks|key|1365662|text|下面的简单查询将列出表的M%2B1th行中的N行。将M和N替换为您喜欢的数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365663|Select+Top+N+B.PrimaryKeyColumn+from+
++++(SELECT+
++++++++top+M+PrimaryKeyColumn
+++++FROM+
++++++++MyTable
)+A+right+outer+join+MyTable+B+
on+
++++A.PrimaryKeyColumn+=+B.PrimaryKeyColumn
where+
++++A.PrimaryKeyColumn+IS+NULL|code-block|syntax|javascript|1365664|请告诉我这对你的情况是否有用。|1365665|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Following is the simple query will list N rows from M+1th row of the table. Replace M and N with your preferred numbers.

<pre><code>Select Top N B.PrimaryKeyColumn from 
 (SELECT 
 top M PrimaryKeyColumn
 FROM 
 MyTable
) A right outer join MyTable B 
on 
 A.PrimaryKeyColumn = B.PrimaryKeyColumn
where 
 A.PrimaryKeyColumn IS NULL
</code></pre>

Please let me know whether this is usefull for your situation.

blocks|key|1365686|text|可能适用于小结果，适用于所有版本的TSQL：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365687|SELECT+
++++++++*+
FROM
+++++(SELECT+TOP+(N)+*+
++++++FROM+
++++++++++++(SELECT+TOP+(M+%2B+N+-+1)+
+++++++++++++FROM+
+++++++++++++++++++Table
+++++++++++++ORDER+BY+
++++++++++++++++++++++MyColumn)+qasc
++++++ORDER+BY+
+++++++++++++++MyColumn+DESC)+qdesc
+ORDER+BY+
+++++++++MyColumn|code-block|syntax|javascript|1365688|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Probably good for small results, works in all versions of TSQL:

<pre><code>SELECT 
 * 
FROM
 (SELECT TOP (N) * 
 FROM 
 (SELECT TOP (M + N - 1) 
 FROM 
 Table
 ORDER BY 
 MyColumn) qasc
 ORDER BY 
 MyColumn DESC) qdesc
 ORDER BY 
 MyColumn
</code></pre>

blocks|key|1580857|text|++++++++--+*some*+implementations+may+support+this+syntax+(mysql?)
SELECT+Id,Value
FROM+xxx
ORDER+BY+Id
LIMIT+2+,+0
+++;

++++++++--+Separate+LIMIT,+OFFSET
SELECT+Id,Value
FROM+xxx
ORDER+BY+Id
LIMIT+2+OFFSET+2
+++;

++++++++--+SQL-2008+syntax
SELECT+Id,Value
FROM+xxx
ORDER+BY+Id
OFFSET+4
FETCH+NEXT+2+ROWS+ONLY
++;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1580858|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> -- *some* implementations may support this syntax (mysql?)
SELECT Id,Value
FROM xxx
ORDER BY Id
LIMIT 2 , 0
 ;

 -- Separate LIMIT, OFFSET
SELECT Id,Value
FROM xxx
ORDER BY Id
LIMIT 2 OFFSET 2
 ;

 -- SQL-2008 syntax
SELECT Id,Value
FROM xxx
ORDER BY Id
OFFSET 4
FETCH NEXT 2 ROWS ONLY
 ;
</code></pre>

blocks|key|1580868|text|SELECT+*+FROM+(
++SELECT
++++Row_Number()+Over+(Order+by+(Select+1))+as+RawKey,
++++*+
++FROM+[Alzh].[dbo].[DM_THD_TRANS_FY14]
)+AS+foo
WHERE+RawKey+between+17210400+and+17210500|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1580869|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>SELECT * FROM (
 SELECT
 Row_Number() Over (Order by (Select 1)) as RawKey,
 * 
 FROM [Alzh].[dbo].[DM_THD_TRANS_FY14]
) AS foo
WHERE RawKey between 17210400 and 17210500
</code></pre>

blocks|key|1365796|text|这个帖子和网络上其他地方的建议的问题是，所有提出的解决方案都是相对于记录数量线性时间运行的。例如，考虑如下查询。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365797|select+*
from
(
++++select
++++++++Row_Number()+over+(order+by+ClusteredIndexField)+as+RowNumber,
++++++++*
++++from+MyTable
)+as+PagedTable
where+RowNumber+between+@LowestRowNumber+and+@HighestRowNumber;|code-block|syntax|javascript|1365798|当获取第一页时，查询耗时0.577秒。然而，当获取第15,619页时，同样的查询耗时超过2分55秒。|1365799|我们可以通过创建记录编号、索引交叉表来极大地改进这一点，如以下查询所示。交叉表被称为PagedTable，并且是非持久性的。|1365800|select+*
from
(
++++select
++++++++Row_Number()+over+(order+by+Field1+asc,+Field2+asc,+Field3+asc)+as+RowNumber,
++++++++ClusteredIndexField
++++from+MyTable
)+as+PagedTable
left+join+MyTable+on+MyTable.ClusteredIndexField+=+PagedTable.ClusteredIndexField
where+RowNumber+between+@LowestRowNumber+and+@HighestRowNumber;|1365801|与前面的示例一样，我在一个包含780,928条记录的非常宽的表上对此进行了测试。我使用的页面大小为50，结果是15,619个页面。|1365802|第1页(第一页)的总时间为0.413秒。第15,619页(最后一页)所用的总时间为0.987秒，仅是第1页的两倍。这些时间是使用SQL+Server+Profiler测量的，数据库管理系统是SQL+Server2008+R2。|1365803|此解决方案适用于按索引对表进行排序的任何情况。索引不必是聚集的或简单的。在我的例子中，索引由三个字段组成:+varchar(50)+asc、varchar(15)+asc和numeric(19,0)+asc。尽管存在繁琐的索引，但性能非常出色，这进一步证明了这种方法是有效的。|1365804|但是，Row_Number窗口函数中的order+by子句必须与索引相对应，这一点至关重要。否则，性能将降级到与第一个示例相同的水平。|1365805|这种方法仍然需要一个线性操作来生成非持久的交叉表，但由于这只是一个添加了行号的索引，所以它发生得非常快。在我的例子中，它花费了0.347秒，但我的例子中有需要复制的varchars。单个数字索引所需的时间要短得多。|1365806|出于所有实际目的，此设计将服务器端分页的缩放从线性运算减少到对数运算，从而允许缩放大型表。下面是完整的解决方案。|1365807|--+For+a+sproc,+make+these+your+input+parameters
declare
++++@PageSize+int+=+50,
++++@Page+int+=+15619;

--+For+a+sproc,+make+these+your+output+parameters
declare+@RecordCount+int+=+(select+count(*)+from+MyTable);
declare+@PageCount+int+=+ceiling(convert(float,+@RecordCount)+/+@PageSize);
declare+@Offset+int+=+(@Page+-+1)+*+@PageSize;
declare+@LowestRowNumber+int+=+@Offset;
declare+@HighestRowNumber+int+=+@Offset+%2B+@PageSize+-+1;

select
++++@RecordCount+as+RecordCount,
++++@PageCount+as+PageCount,
++++@Offset+as+Offset,
++++@LowestRowNumber+as+LowestRowNumber,
++++@HighestRowNumber+as+HighestRowNumber;

select+*
from
(
++++select
++++++++Row_Number()+over+(order+by+Field1+asc,+Field2+asc,+Field3+asc)+as+RowNumber,
++++++++ClusteredIndexField
++++from+MyTable
)+as+PagedTable
left+join+MyTable+on+MyTable.ClusteredIndexField+=+PagedTable.ClusteredIndexField
where+RowNumber+between+@LowestRowNumber+and+@HighestRowNumber;|1365808|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

The problem with the suggestions in this thread and elsewhere on the web is that all the proposed solutions run in linear time with respect to the number of records. For example, consider a query like the following.

<pre><code>select *
from
(
 select
 Row_Number() over (order by ClusteredIndexField) as RowNumber,
 *
 from MyTable
) as PagedTable
where RowNumber between @LowestRowNumber and @HighestRowNumber;
</code></pre>

When getting page 1, the query takes 0.577 seconds. However, when getting page 15,619, this same query takes over 2 minutes and 55 seconds.

We can greatly improve this by creating a record number, index cross-table as shown in the following query. The cross-table is called PagedTable and is non-persistent.

<pre><code>select *
from
(
 select
 Row_Number() over (order by Field1 asc, Field2 asc, Field3 asc) as RowNumber,
 ClusteredIndexField
 from MyTable
) as PagedTable
left join MyTable on MyTable.ClusteredIndexField = PagedTable.ClusteredIndexField
where RowNumber between @LowestRowNumber and @HighestRowNumber;
</code></pre>

Like in the previous example, I tested this on a very wide table with 780,928 records. I used a page size of 50, which resulted in 15,619 pages.

The total time taken for page 1 (the first page) is 0.413 seconds. The total time taken for page 15,619 (the last page) is 0.987 seconds, merely twice times as long as page 1. These times were measured using SQL Server Profiler and the DBMS was SQL Server 2008 R2.

This solution works for any case when you are sorting your table by an index. The index does not have to be clustered or simple. In my case, the index was composed of three fields: varchar(50) asc, varchar(15) asc, numeric(19,0) asc. That the performance was excellent despite the cumbersome index just further demonstrates that this approach works.

However, it is critical that the order by clause in the Row_Number windowing function corresponds to an index. Otherwise performance will degrade to the same level as the first example.

This approach does still require a linear operation to generate the non-persistent cross-table, but since that's just an index with a row number added, it happens very quickly. In my case it took 0.347 seconds, but my case had varchars that needed to be copied. A single numeric index would take far less time.

For all practical purposes, this design reduces the scaling of server-side paging from a linear operation to a logarithmic operation allowing the scaling of large tables. Below is the complete solution.

<pre><code>-- For a sproc, make these your input parameters
declare
 @PageSize int = 50,
 @Page int = 15619;

-- For a sproc, make these your output parameters
declare @RecordCount int = (select count(*) from MyTable);
declare @PageCount int = ceiling(convert(float, @RecordCount) / @PageSize);
declare @Offset int = (@Page - 1) * @PageSize;
declare @LowestRowNumber int = @Offset;
declare @HighestRowNumber int = @Offset + @PageSize - 1;

select
 @RecordCount as RecordCount,
 @PageCount as PageCount,
 @Offset as Offset,
 @LowestRowNumber as LowestRowNumber,
 @HighestRowNumber as HighestRowNumber;

select *
from
(
 select
 Row_Number() over (order by Field1 asc, Field2 asc, Field3 asc) as RowNumber,
 ClusteredIndexField
 from MyTable
) as PagedTable
left join MyTable on MyTable.ClusteredIndexField = PagedTable.ClusteredIndexField
where RowNumber between @LowestRowNumber and @HighestRowNumber;
</code></pre>

blocks|key|1365915|text|我阅读了这里的所有回复，最终提出了一个有用的简单解决方案。性能问题源于BETWEEN语句，而不是行号本身的生成。因此，我使用了一种算法，通过传递页码和记录数来进行动态分页。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365916|遍不是起始行和行数，而是“每页行数(500)”和“页码(4)”，这将是行1501+-+2000。这些值可以由存储过程变量替换，这样您就不会被限制使用特定的分页量。|1365917|select+*+from+(
++++select
++++++++(((ROW_NUMBER()+OVER(ORDER+BY+MyField)+-+1)+/+500)+%2B+1)+AS+PageNum
++++++++,+*
++++from+MyTable
)+as+PagedTable
where+PageNum+=+4;|code-block|syntax|javascript|1365918|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I read all of the responses here and finally came up with a usable solution that is simple. The performance issues arise from the BETWEEN statement, not the generation of the row numbers themselves. So I used an algorithm to do dynamic paging by passing the page number and the number of records.

The passes are not start row and number of rows, but rather "rows per page (500)" and "page number (4)" which would be rows 1501 - 2000. These values can be replaced by stored procedure variables so you are not locked into using a specific paging amount.

<pre><code>select * from (
 select
 (((ROW_NUMBER() OVER(ORDER BY MyField) - 1) / 500) + 1) AS PageNum
 , *
 from MyTable
) as PagedTable
where PageNum = 4;
</code></pre>

blocks|key|1581144|text|这个线程已经很旧了，但是目前你可以这样做:更干净的imho|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1581145|SELECT+*
FROM+Sales.SalesOrderDetail
ORDER+BY+SalesOrderDetailID
OFFSET+20+ROWS
FETCH+NEXT+10+ROWS+ONLY;
GO|code-block|syntax|javascript|1581146|来源：http://blog.sqlauthority.com/2013/12/30/sql-server-mysql-limit-and-offset-skip-and-return-only-next-few-rows-paging-solution/|offset|length|1581147|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.sqlauthority.com/2013/12/30/sql-server-mysql-limit-and-offset-skip-and-return-only-next-few-rows-paging-solution/^0|0|0|3|3H|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

This thread is quite old, but currently you can do this: 
much cleaner imho

<pre><code>SELECT *
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
OFFSET 20 ROWS
FETCH NEXT 10 ROWS ONLY;
GO
</code></pre>

source: <a href="http://blog.sqlauthority.com/2013/12/30/sql-server-mysql-limit-and-offset-skip-and-return-only-next-few-rows-paging-solution/" rel="nofollow">http://blog.sqlauthority.com/2013/12/30/sql-server-mysql-limit-and-offset-skip-and-return-only-next-few-rows-paging-solution/</a>

blocks|key|1366093|text|为了在SQL+Server中执行此操作，必须按列对查询进行排序，以便可以指定所需的行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1366094|在执行此操作时，您不能使用"TOP“关键字，必须使用偏移N行获取下M行。|1366095|示例：|1366096|select+*+from+table+order+by+[some_column]+
offset+10+rows
FETCH+NEXT+10+rows+only|code-block|syntax|javascript|1366097|你可以在这里了解更多信息：https://technet.microsoft.com/pt-br/library/gg699618%2528v=sql.110%2529.aspx|offset|length|1366098|entityMap|0|LINK|mutability|MUTABLE|url|https://technet.microsoft.com/pt-br/library/gg699618%2528v=sql.110%2529.aspx^0|0|0|0|0|D|20|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

In order to do this in SQL Server, you must order the query by a column, so you can specify the rows you want.

You can't use the "TOP" keyword when doing this, you must use offset N rows fetch next M rows.

Example:

<pre><code>select * from table order by [some_column] 
offset 10 rows
FETCH NEXT 10 rows only
</code></pre>

You can learn more here:
<a href="https://technet.microsoft.com/pt-br/library/gg699618%28v=sql.110%29.aspx" rel="nofollow">https://technet.microsoft.com/pt-br/library/gg699618%28v=sql.110%29.aspx</a>

There is a simple way to get top N rows from any table:

<pre><code>SELECT TOP 10 * FROM MyTable ORDER BY MyColumn
</code></pre>

Is there any efficient way to query M rows starting from row N

For example,

<pre><code>Id Value
1 a
2 b
3 c
4 d
5 e
6 f
</code></pre>

And query like this

<pre><code>SELECT [3,2] * FROM MyTable ORDER BY MyColumn /* hypothetical syntax */
</code></pre>

queries 2 rows starting from 3d row, i.e 3d and 4th rows are returned.

How to get N rows starting from row M from sorted table in T-SQL

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有一种简单的方法可以从任何表中获取前N行：SELECT TOP 10 * FROM MyTable ORDER BY MyColumn有没有从第N行开始查询M行的有效方法例如,Id Value1    a2    b3    c4    d5    e6    f并像这样查询SELECT [3,2] * FROM My...

问如何从T-SQL的排序表中获得从M行开始的N行
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从T-SQL的排序表中获得从M行开始的N行EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从T-SQL的排序表中获得从M行开始的N行
EN