Question

我应该使用LINQ的Skip()和Take()方法进行分页，还是使用SQL查询实现自己的分页？

哪个最有效？为什么我会选择一个而不是另一个？

我正在使用SQL Server 2008，ASP.NET MVC和LINQ。

Answer 1

如果您在linq上执行skip(n).take(m)方法（使用SQL 2005/2008作为数据库服务器），请尝试简要回答您的疑问，您的查询将使用Select ROW_NUMBER() Over ...语句，在某种程度上是SQL引擎中的直接分页。

给你一个例子，我有一个名为mtcity的数据库表，我编写了以下查询（与linq一起工作到实体）：

using (DataClasses1DataContext c = new DataClasses1DataContext())
{
    var query = (from MtCity2 c1 in c.MtCity2s
                select c1).Skip(3).Take(3);
    //Doing something with the query.
}

结果查询将是：

SELECT [t1].[CodCity], 
    [t1].[CodCountry], 
    [t1].[CodRegion], 
    [t1].[Name],  
    [t1].[Code]
FROM (
    SELECT ROW_NUMBER() OVER (
        ORDER BY [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]) AS [ROW_NUMBER], 
        [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]
    FROM [dbo].[MtCity] AS [t0]
    ) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p0 + 1 AND @p0 + @p1
ORDER BY [t1].[ROW_NUMBER]

这是一个窗口数据访问（相当酷，从一开始就会返回数据，只要符合条件就会访问表）。这将非常类似于：

With CityEntities As 
(
    Select ROW_NUMBER() Over (Order By CodCity) As Row,
        CodCity //here is only accessed by the Index as CodCity is the primary
    From dbo.mtcity
)
Select [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]
From CityEntities c
Inner Join dbo.MtCity t0 on c.CodCity = t0.CodCity
Where c.Row Between @p0 + 1 AND @p0 + @p1
Order By c.Row Asc

除了这个例外，第二个查询将比linq结果执行得更快，因为它将专门使用索引来创建数据访问窗口;这意味着，如果您需要一些过滤，过滤应该（或必须）在Entity列表中（创建行的位置），并且还应创建一些索引以保持良好的性能。

现在，哪个更好？

如果您的逻辑中有相当可靠的工作流程，那么实现正确的SQL方法将会很复杂。在这种情况下，LINQ将成为解决方案。

如果你可以将逻辑的那部分直接降低到SQL（在存储过程中），它会更好，因为你可以实现我向你展示的第二个查询（使用索引）并允许SQL生成并存储执行查询计划（提高绩效）。

Answer 2

尝试使用

FROM [TableX]
ORDER BY [FieldX]
OFFSET 500 ROWS
FETCH NEXT 100 ROWS ONLY

在SQL服务器中获取501到600的行，而不将它们加载到内存中。请注意，此语法仅适用于SQL Server 2012

Answer 3

虽然LINQ-to-SQL将生成OFFSET子句（可能使用ROW_NUMBER() OVER() as others have mentioned进行模拟），但在SQL中执行分页的方式却完全不同，更快。这通常被称为“寻找方法”，如this blog post here中所述。

SELECT TOP 10 first_name, last_name, score
FROM players
WHERE (score < @previousScore)
   OR (score = @previousScore AND player_id < @previousPlayerId)
ORDER BY score DESC, player_id DESC

@previousScore和@previousPlayerId值是上一页中最后一条记录的相应值。这允许您获取“下一页”。如果ORDER BY方向为ASC，则只需使用>。

使用上述方法，您无法在未先读取前40条记录的情况下立即跳转到第4页。但通常情况下，你不想跳得那么远。相反，您可以获得更快的查询，该查询可能能够在固定时间内获取数据，具体取决于您的索引。此外，无论基础数据是否发生变化，您的页面都将保持“稳定”状态（例如，在第1页上，当您在第4页时）。

例如，这是在网络应用程序中延迟加载更多数据时实现分页的最佳方式。

注意，“搜索方法”也称为keyset paging。

Answer 4

LinqToSql会自动将.Skip（N1）.Take（N2）转换为TSQL语法。实际上，您在Linq中执行的每个“查询”实际上只是在后台为您创建SQL查询。要对此进行测试，只需在应用程序运行时运行SQL事件探查器。

skip / take方法对我和我读过的其他人都很有效。

出于好奇，您认为哪种类型的自我分页查询比Linq的skip / take更有效？

Answer 5

我们在存储过程中使用动态SQL包装的CTE（因为我们的应用程序需要动态排序数据服务器端）。如果你愿意，我可以提供一个基本的例子。

我没有机会查看LINQ生成的T / SQL。有人可以寄样品吗？

我们不使用LINQ或直接访问表，因为我们需要额外的安全层（授予动态SQL在某种程度上打破了这一点）。

这样的事情应该可以解决问题。您可以为参数添加参数化值等。

exec sp_executesql 'WITH MyCTE AS (
    SELECT TOP (10) ROW_NUMBER () OVER ' + @SortingColumn + ' as RowID, Col1, Col2
    FROM MyTable
    WHERE Col4 = ''Something''
)
SELECT *
FROM MyCTE
WHERE RowID BETWEEN 10 and 20'

Answer 6

在SQL Server 2008中：

DECLARE @PAGE INTEGER = 2
DECLARE @TAKE INTEGER = 50

SELECT [t1].*
FROM (
    SELECT ROW_NUMBER() OVER (ORDER BY [t0].[COLUMNORDER] DESC) AS [ROW_NUMBER], [t0].*
    FROM [dbo].[TABLA] AS [t0]
    WHERE ([t0].[COLUMNS_CONDITIONS] = 1)
    ) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN ((@PAGE*@TAKE) - (@TAKE-1)) AND (@PAGE*@TAKE)
ORDER BY [t1].[ROW_NUMBER]

在t0中都是记录在t1中只有与该页面相对应的那些

Answer 7

我提供的方法是SQL Server可以实现的最快分页。我已经对500万条记录进行了测试。这种方法比SQL Server提供的“仅偏移10行捕获下一个10行”要好得多。

-- The below given code computes the page numbers and the max row of previous page
-- Replace <<>> with the correct table data.
-- Eg. <<IdentityColumn of Table>> can be EmployeeId and <<Table>> will be dbo.Employees

DECLARE @PageNumber int=1; --1st/2nd/nth page. In stored proc take this as input param.
DECLARE @NoOfRecordsPerPage int=1000;

 DECLARE @PageDetails TABLE
       (
        <<IdentityColumn of Table>> int,
        rownum int,
        [PageNumber] int
       )           
       INSERT INTO @PageDetails values(0, 0, 0)
       ;WITH CTE AS
       (
       SELECT <<IdentityColumn of Table>>, ROW_NUMBER() OVER(ORDER BY <<IdentityColumn of Table>>) rownum FROM <<Table>>
       )
       Insert into @PageDetails 
       SELECT <<IdentityColumn of Table>>, CTE.rownum, ROW_NUMBER() OVER (ORDER BY rownum) as [PageNumber] FROM CTE WHERE CTE.rownum%@NoOfRecordsPerPage=0


--SELECT * FROM @PageDetails 

-- Actual pagination
SELECT TOP (@NoOfRecordsPerPage)
FROM <<Table>> AS <<Table>>
WHERE <<IdentityColumn of Table>> > (SELECT <<IdentityColumn of Table>> FROM 
@PageDetails WHERE PageNumber=@PageNumber)
ORDER BY <<Identity Column of Table>>

Answer 8

你可以进一步提高性能，这个

From CityEntities c
Inner Join dbo.MtCity t0 on c.CodCity = t0.CodCity
Where c.Row Between @p0 + 1 AND @p0 + @p1
Order By c.Row Asc

如果您将以这种方式使用from，它将提供更好的结果：

From   dbo.MtCity  t0
   Inner Join  CityEntities c on c.CodCity = t0.CodCity

原因：因为您正在使用CityEntities表中的where类，这将在加入MtCity之前消除许多记录，因此100％确定它会使性能提高许多倍......

无论如何，通过rodrigoelp回答真的很有帮助。

由于

Answer 9

您可以通过传递PageIndex

以这种简单的方式实现分页

Declare @PageIndex INT = 1
Declare  @PageSize INT = 20

Select ROW_NUMBER() OVER ( ORDER BY Products.Name ASC )  AS RowNumber,
    Products.ID,
    Products.Name
into #Result 
From Products

SELECT @RecordCount = COUNT(*) FROM #Results 

SELECT * 
FROM #Results
WHERE RowNumber
BETWEEN
    (@PageIndex -1) * @PageSize + 1 
    AND
    (((@PageIndex -1) * @PageSize + 1) + @PageSize) - 1

Answer 10

2008年我们不能使用Skip（）。Take（）

方式是：

var MinPageRank = (PageNumber - 1) * NumInPage + 1
var MaxPageRank = PageNumber * NumInPage

var visit = Visita.FromSql($"SELECT * FROM (SELECT [RANK] = ROW_NUMBER() OVER (ORDER BY Hora DESC),* FROM Visita WHERE ) A WHERE A.[RANK] BETWEEN {MinPageRank} AND {MaxPageRank}").ToList();

实现分页的有效方法

10 个答案: