我应该使用LINQ Skip()
和Take()
方法进行分页,还是使用SQL查询实现自己的分页?
哪个最有效?我为什么要选择一个?
我正在使用SQL Server 2008,ASP.NET MVC和LINQ。
我应该使用LINQ Skip()
和Take()
方法进行分页,还是使用SQL查询实现自己的分页?
哪个最有效?我为什么要选择一个?
我正在使用SQL Server 2008,ASP.NET MVC和LINQ。
Answers:
如果您skip(n).take(m)
在linq上执行方法(使用SQL 2005/2008作为数据库服务器),尝试向您提供一个简短的答案,那么您的查询将使用该Select ROW_NUMBER() Over ...
语句,并以某种方式在SQL引擎中进行直接分页。
举个例子,我有一个db表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]
这是一个窗口式数据访问(非常酷,btw cuz从一开始就将返回数据,只要满足条件,它将访问表)。这将非常类似于:
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结果执行得更快之外,因为它将专门使用索引来创建数据访问窗口。这意味着,如果您需要一些过滤,则过滤应该(或必须是)在“实体”列表(创建行的位置)中,并且还应该创建一些索引以保持良好的性能。
现在,还有什么更好的呢?
如果您的逻辑中有非常扎实的工作流程,则实施正确的SQL方法将很复杂。在这种情况下,LINQ将是解决方案。
如果您可以将逻辑的那部分直接降低到SQL(在存储过程中),那么效果会更好,因为您可以实现我向您展示的第二个查询(使用索引),并允许SQL生成并存储该数据库的执行计划。查询(提高性能)。
尝试使用
FROM [TableX]
ORDER BY [FieldX]
OFFSET 500 ROWS
FETCH NEXT 100 ROWS ONLY
在SQL Server中获取从501到600的行,而无需将其加载到内存中。请注意,此语法仅在SQL Server 2012中可用
尽管LINQ-to-SQL将生成一个OFFSET
子句(可能使用ROW_NUMBER() OVER()
其他人提到的方法进行了仿真),但在SQL中执行分页的方法却完全不同,速度要快得多。如本文博客文章中所述,这通常称为“搜索方法” 。
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页上),您的页面仍保持“稳定”状态。
例如,这是在Web应用程序中延迟加载更多数据时实现分页的最佳方法。
注意,“搜索方法”也称为键集分页。
在存储过程中,我们使用包装在Dynamic 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'
sp_executesql
可以以安全的方式传递参数,例如:EXECUTE sp_executesql 'WITH myCTE AS ... WHERE Col4=@p1) ...', '@p1 nvarchar(max)', @ValueForCol4
。在这种情况下,安全性意味着它对SQL注入具有鲁棒性-您可以在变量内传递所有可能的值@ValueForCol4
-甚至'--'
,查询仍然可以使用!
SELECT ROW_NUMBER() OVER (ORDER BY CASE WHEN @CampoId = 1 THEN Id WHEN @CampoId = 2 THEN field2 END)
在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中只有与该页面相对应的记录
我提供的方法是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>>
您可以进一步改善性能,
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的回答确实很有帮助。
谢谢
您可以通过传递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
在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();