数据分页

很多人不知道SQL语句在SQL?SERVER中是如何执行的,他们担心自己所写的SQL语句会被SQL?SERVER误解。比如：

　　select?*?from?table1?where?name='zhangsan'?and?tID?>?10000

　　和执行:

　　select?*?from?table1?where?tID?>?10000?and?name='zhangsan'

　　一些人不知道以上两条语句的执行效率是否一样,因为如果简单的从语句先后上看,这两个语句的确是不一样,如果tID是一个聚合索引,那么后一句仅仅从表的10000条以后的记录中查找就行了；而前一句则要先从全表中查找看有几个name='zhangsan'的,而后再根据限制条件条件tID>10000来提出查询结果。
　　事实上,这样的担心是不必要的。SQL?SERVER中有一个“查询分析优化器”,它可以计算出where子句中的搜索条件并确定哪个索引能缩小表扫描的搜索空间,也就是说,它能实现自动优化。
　　虽然查询优化器可以根据where子句自动的进行查询优化,但大家仍然有必要了解一下“查询优化器”的工作原理,如非这样,有时查询优化器就会不按照您的本意进行快速查询。
　　在查询分析阶段,查询优化器查看查询的每个阶段并决定限制需要扫描的数据量是否有用。如果一个阶段可以被用作一个扫描参数(SARG）,那么就称之为可优化的,并且可以利用索引快速获得所需数据。
　　SARG的定义：用于限制搜索的一个操作,因为它通常是指一个特定的匹配,一个值得范围内的匹配或者两个以上条件的AND连接。形式如下：
　　列名?操作符?<常数?或?变量>

　　或

　　<常数?或?变量>?操作符列名

　　列名可以出现在操作符的一边,而常数或变量出现在操作符的另一边。如：

　　Name=’张三’
　　价格>5000
　　5000<价格
　　Name=’张三’?and?价格>5000

　　如果一个表达式不能满足SARG的形式,那它就无法限制搜索的范围了,也就是SQL?SERVER必须对每一行都判断它是否满足WHERE子句中的所有条件。所以一个索引对于不满足SARG形式的表达式来说是无用的。
　　介绍完SARG后,我们来总结一下使用SARG以及在实践中遇到的和某些资料上结论不同的经验：

　　1、Like语句是否属于SARG取决于所使用的通配符的类型

　　如：name?like?‘张%’?,这就属于SARG

　　而：name?like?‘%张’?,就不属于SARG。

　　原因是通配符%在字符串的开通使得索引无法使用。

　　2、or?会引起全表扫描

　　Name=’张三’?and?价格>5000?符号SARG,而：Name=’张三’?or?价格>5000?则不符合SARG。使用or会引起全表扫描。

　　3、非操作符、函数引起的不满足SARG形式的语句

　　不满足SARG形式的语句最典型的情况就是包括非操作符的语句,如：NOT、!=、<>、!<、!>、NOT?EXISTS、NOT?IN、NOT?LIKE等,另外还有函数。下面就是几个不满足SARG形式的例子：

　　ABS(价格)<5000

　　Name?like?‘%三’

　　有些表达式,如：

　　WHERE?价格*2>5000

　　SQL?SERVER也会认为是SARG,SQL?SERVER会将此式转化为：

　　WHERE?价格>2500/2

　　但我们不推荐这样使用,因为有时SQL?SERVER不能保证这种转化与原始表达式是完全等价的。

　　4、IN?的作用相当与OR

　　语句：

　　Select?*?from?table1?where?tid?in?(2,3)

　　和

　　Select?*?from?table1?where?tid=2?or?tid=3

　　是一样的,都会引起全表扫描,如果tid上有索引,其索引也会失效。

　　5、尽量少用NOT

　　6、exists?和?in?的执行效率是一样的

　　很多资料上都显示说,exists要比in的执行效率要高,同时应尽可能的用not?exists来代替not?in。但事实上,我试验了一下,发现二者无论是前面带不带not,二者之间的执行效率都是一样的。因为涉及子查询,我们试验这次用SQL?SERVER自带的pubs数据库。运行前我们可以把SQL?SERVER的statistics?I/O状态打开。

?

(1）select?title,price?from?titles?where?title_id?in?(select?title_id?from?sales?where?qty>30)

　　该句的执行结果为：

　　表?'sales'。扫描计数?18,逻辑读?56?次,物理读?0?次,预读?0?次。

　　表?'titles'。扫描计数?1,逻辑读?2?次,预读?0?次。

　　(2）select?title,price?from?titles?where?exists?(select?*?from?sales?where?sales.title_id=titles.title_id?and?qty>30)

　　第二句的执行结果为：

　　表?'sales'。扫描计数?18,预读?0?次。

　　我们从此可以看到用exists和用in的执行效率是一样的。

　　7、用函数charindex()和前面加通配符%的LIKE执行效率一样

　　前面,我们谈到,如果在LIKE前面加上通配符%,那么将会引起全表扫描,所以其执行效率是低下的。但有的资料介绍说,用函数charindex()来代替LIKE速度会有大的提升,经我试验,发现这种说明也是错误的：

select?gid,title,fariqi,reader?from?tgongwen?where?charindex('刑侦支队',reader)>0?and?fariqi>'2004-5-5'

　　用时：7秒,另外：扫描计数?4,逻辑读?7155?次,预读?0?次。

　　select?gid,reader?from?tgongwen?where?reader?like?'%'?+?'刑侦支队'?+?'%'?and?fariqi>'2004-5-5'

　　用时：7秒,预读?0?次。

　　8、union并不绝对比or的执行效率高

　　我们前面已经谈到了在where子句中使用or会引起全表扫描,一般的,我所见过的资料都是推荐这里用union来代替or。事实证明,这种说法对于大部分都是适用的。

　　select?gid,neibuyonghu,reader,title?from?Tgongwen?where?fariqi='2004-9-16'?or?gid>9990000

　　用时：68秒。扫描计数?1,逻辑读?404008?次,物理读?283?次,预读?392163?次。

　　select?gid,title?from?Tgongwen?where?fariqi='2004-9-16'?

　　union

　　select?gid,title?from?Tgongwen?where?gid>9990000

　　用时：9秒。扫描计数?8,逻辑读?67489?次,物理读?216?次,预读?7499?次。

　　看来,用union在通常情况下比用or的效率要高的多。

　　但经过试验,笔者发现如果or两边的查询列是一样的话,那么用union则反倒和用or的执行速度差很多,虽然这里union扫描的是索引,而or扫描的是全表。

　　select?gid,title?from?Tgongwen?where?fariqi='2004-9-16'?or?fariqi='2004-2-5'

　　用时：6423毫秒。扫描计数?2,逻辑读?14726?次,物理读?1?次,预读?7176?次。

　　select?gid,title?from?Tgongwen?where??fariqi='2004-2-5'

　　用时：11640毫秒。扫描计数?8,逻辑读?14806?次,物理读?108?次,预读?1144?次。

　　9、字段提取要按照“需多少、提多少”的原则,避免“select?*”

　　我们来做一个试验：

　　select?top?10000?gid,title?from?tgongwen?order?by?gid?desc

　　用时：4673毫秒

　　select?top?10000?gid,title?from?tgongwen?order?by?gid?desc

　　用时：1376毫秒

　　select?top?10000?gid,fariqi?from?tgongwen?order?by?gid?desc

　　用时：80毫秒

　　由此看来,我们每少提取一个字段,数据的提取速度就会有相应的提升。提升的速度还要看您舍弃的字段的大小来判断。

　　10、count(*)不比count(字段)慢

　　某些资料上说：用*会统计所有列,显然要比一个世界的列名效率低。这种说法其实是没有根据的。我们来看：

select?count(*)?from?Tgongwen

　　用时：1500毫秒

　　select?count(gid)?from?Tgongwen?

　　用时：1483毫秒

　　select?count(fariqi)?from?Tgongwen

　　用时：3140毫秒

　　select?count(title)?from?Tgongwen

　　用时：52050毫秒

　　从以上可以看出,如果用count(*)和用count(主键)的速度是相当的,而count(*)却比其他任何除主键以外的字段汇总速度要快,而且字段越长,汇总的速度就越慢。我想,如果用count(*),?SQL?SERVER可能会自动查找最小字段来汇总的。当然,如果您直接写count(主键)将会来的更直接些。

　　11、order?by按聚集索引列排序效率最高

　　我们来看：(gid是主键,fariqi是聚合索引列）

　　select?top?10000?gid,title?from?tgongwen

　　用时：196?毫秒。?扫描计数?1,逻辑读?289?次,预读?1527?次。

　　select?top?10000?gid,title?from?tgongwen?order?by?gid?asc

　　用时：4720毫秒。?扫描计数?1,逻辑读?41956?次,预读?1287?次。

　　select?top?10000?gid,title?from?tgongwen?order?by?gid?desc

　　用时：4736毫秒。?扫描计数?1,逻辑读?55350?次,物理读?10?次,预读?775?次。

　　select?top?10000?gid,title?from?tgongwen?order?by?fariqi?asc

　　用时：173毫秒。?扫描计数?1,逻辑读?290?次,预读?0?次。

select?top?10000?gid,title?from?tgongwen?order?by?fariqi?desc

　　用时：156毫秒。?扫描计数?1,预读?0?次。

　　从以上我们可以看出,不排序的速度以及逻辑读次数都是和“order?by?聚集索引列”?的速度是相当的,但这些都比“order?by?非聚集索引列”的查询速度是快得多的。

　　同时,按照某个字段进行排序的时候,无论是正序还是倒序,速度是基本相当的。

　　12、高效的TOP

　　事实上,在查询和提取超大容量的数据集时,影响数据库响应时间的最大因素不是数据查找,而是物理的I/0操作。如：

　　select?top?10?*?from?(select?top?10000?gid,title?from?tgongwen

　　where?neibuyonghu='办公室'?order?by?gid?desc)?as?a

　　order?by?gid?asc

　　这条语句,从理论上讲,整条语句的执行时间应该比子句的执行时间长,但事实相反。因为,子句执行后返回的是10000条记录,而整条语句仅返回10条语句,所以影响数据库响应时间最大的因素是物理I/O操作。而限制物理I/O操作此处的最有效方法之一就是使用TOP关键词了。TOP关键词是SQL?SERVER中经过系统优化过的一个用来提取前几条或前几个百分比数据的词。经笔者在实践中的应用,发现TOP确实很好用,效率也很高。但这个词在另外一个大型数据库ORACLE中却没有,这不能说不是一个遗憾,虽然在ORACLE中可以用其他方法(如：rownumber）来解决。在以后的关于“实现千万级数据的分页显示存储过程”的讨论中,我们就将用到TOP这个关键词。

　　到此为止,我们上面讨论了如何实现从大容量的数据库中快速地查询出您所需要的数据方法。当然,我们介绍的这些方法都是“软”方法,在实践中,我们还要考虑各种“硬”因素,如：网络性能、服务器的性能、操作系统的性能,甚至网卡、交换机等。

　三、实现小数据量和海量数据的通用分页显示存储过程

　　建立一个web?应用,分页浏览功能必不可少。这个问题是数据库处理中十分常见的问题。经典的数据分页方法是:ADO?纪录集分页法,也就是利用ADO自带的分页功能(利用游标）来实现分页。但这种分页方法仅适用于较小数据量的情形,因为游标本身有缺点：游标是存放在内存中,很费内存。游标一建立,就将相关的记录锁住,直到取消游标。游标提供了对特定集合中逐行扫描的手段,一般使用游标来逐行遍历数据,根据取出数据条件的不同进行不同的操作。而对于多表和大表中定义的游标(大的数据集合）循环很容易使程序进入一个漫长的等待甚至死机。

更重要的是,对于非常大的数据模型而言,分页检索时,如果按照传统的每次都加载整个数据源的方法是非常浪费资源的。现在流行的分页方法一般是检索页面大小的块区的数据,而非检索所有的数据,然后单步执行当前行。

　　最早较好地实现这种根据页面大小和页码来提取数据的方法大概就是“俄罗斯存储过程”。这个存储过程用了游标,由于游标的局限性,所以这个方法并没有得到大家的普遍认可。

　　后来,网上有人改造了此存储过程,下面的存储过程就是结合我们的办公自动化实例写的分页存储过程：

　　CREATE?procedure?pagination1

　　(@pagesize?int,??--页面大小,如每页存储20条记录

　　@pageindex?int???--当前页码

　　)

　　as

　　set?nocount?on

　　begin

　　declare?@indextable?table(id?int?identity(1,1),nid?int)??--定义表变量

　　declare?@PageLowerBound?int??--定义此页的底码

　　declare?@PageUpperBound?int??--定义此页的顶码

　　set?@PageLowerBound=(@pageindex-1)*@pagesize

　　set?@PageUpperBound=@PageLowerBound+@pagesize

　　set?rowcount?@PageUpperBound

　　insert?into?@indextable(nid)?select?gid?from?TGongwen?where?fariqi?>dateadd(day,-365,getdate())?order?by?fariqi?desc

　　select?O.gid,O.mid,O.title,O.fadanwei,O.fariqi?from?TGongwen?O,@indextable?t?where?O.gid=t.nid

　　and?t.id>@PageLowerBound?and?t.id<=@PageUpperBound?order?by?t.id

　　end

　　set?nocount?off

　　以上存储过程运用了SQL?SERVER的最新技术――表变量。应该说这个存储过程也是一个非常优秀的分页存储过程。当然,在这个过程中,您也可以把其中的表变量写成临时表：CREATE?TABLE?#Temp。但很明显,在SQL?SERVER中,用临时表是没有用表变量快的。所以笔者刚开始使用这个存储过程时,感觉非常的不错,速度也比原来的ADO的好。但后来,我又发现了比此方法更好的方法。

　　笔者曾在网上看到了一篇小短文《从数据表中取出第n条到第m条的记录的方法》,全文如下：

　　从publish?表中取出第?n?条到第?m?条的记录：?

　　SELECT?TOP?m-n+1?*?
　　FROM?publish?
　　WHERE?(id?NOT?IN?
　　　　(SELECT?TOP?n-1?id?
　　　　?FROM?publish))?

　　id?为publish?表的关键字?

　　我当时看到这篇文章的时候,真的是精神为之一振,觉得思路非常得好。等到后来,我在作办公自动化系统(ASP.NET+?C#＋SQL?SERVER）的时候,忽然想起了这篇文章,我想如果把这个语句改造一下,这就可能是一个非常好的分页存储过程。于是我就满网上找这篇文章,没想到,文章还没找到,却找到了一篇根据此语句写的一个分页存储过程,这个存储过程也是目前较为流行的一种分页存储过程,我很后悔没有争先把这段文字改造成存储过程：

　　CREATE?PROCEDURE?pagination2
　　(
　　?@SQL?nVARCHAR(4000),????--不带排序语句的SQL语句
　　?@Page?int,??????????????--页码
　　?@RecsPerPage?int,???????--每页容纳的记录数
　　?@ID?VARCHAR(255),???????--需要排序的不重复的ID号
　　?@Sort?VARCHAR(255)??????--排序字段及规则
　　)
　　AS

　　DECLARE?@Str?nVARCHAR(4000)

　　SET?@Str='SELECT???TOP?'+CAST(@RecsPerPage?AS?VARCHAR(20))+'?*?FROM?('+@SQL+')?T?WHERE?T.'+@ID+'NOT?IN?
　　(SELECT???TOP?'+CAST((@RecsPerPage*(@Page-1))?AS?VARCHAR(20))+'?'+@ID+'?FROM?('+@SQL+')?T9?ORDER?BY?'+@Sort+')?ORDER?BY?'+@Sort

　　PRINT?@Str

　　EXEC?sp_ExecuteSql?@Str
　　GO

　　其实,以上语句可以简化为：

　　SELECT?TOP?页大小?*

　　FROM?Table1

　　WHERE?(ID?NOT?IN

??????????(SELECT?TOP?页大小*页数?id?


????????　　?FROM?表

?????????ORDER?BY?id))

　　ORDER?BY?ID

　　但这个存储过程有一个致命的缺点,就是它含有NOT?IN字样。虽然我可以把它改造为：

　　SELECT?TOP?页大小?*

　　FROM?Table1

　　WHERE?not?exists

　　(select?*?from?(select?top?(页大小*页数)?*?from?table1?order?by?id)?b?where?b.id=a.id?)

　　order?by?id

　　即,用not?exists来代替not?in,但我们前面已经谈过了,二者的执行效率实际上是没有区别的。

　　既便如此,用TOP?结合NOT?IN的这个方法还是比用游标要来得快一些。

　　虽然用not?exists并不能挽救上个存储过程的效率,但使用SQL?SERVER中的TOP关键字却是一个非常明智的选择。因为分页优化的最终目的就是避免产生过大的记录集,而我们在前面也已经提到了TOP的优势,通过TOP?即可实现对数据量的控制。

　　在分页算法中,影响我们查询速度的关键因素有两点：TOP和NOT?IN。TOP可以提高我们的查询速度,而NOT?IN会减慢我们的查询速度,所以要提高我们整个分页算法的速度,就要彻底改造NOT?IN,同其他方法来替代它。

　　我们知道,几乎任何字段,我们都可以通过max(字段)或min(字段)来提取某个字段中的最大或最小值,所以如果这个字段不重复,那么就可以利用这些不重复的字段的max或min作为分水岭,使其成为分页算法中分开每页的参照物。在这里,我们可以用操作符“>”或“<”号来完成这个使命,使查询语句符合SARG形式。如：

　　Select?top?10?*?from?table1?where?id>200

　　于是就有了如下分页方案：

　　select?top?页大小?*

　　from?table1?

　　where?id>

　　??????(select?max?(id)?from?

　　??????(select?top?((页码-1)*页大小)?id?from?table1?order?by?id)?as?T

　　???????)?????

　　??order?by?id

　　在选择即不重复值,又容易分辨大小的列时,我们通常会选择主键。下表列出了笔者用有着1000万数据的办公自动化系统中的表,在以GID(GID是主键,但并不是聚集索引。）为排序列、提取gid,title字段,分别以第1、10、100、500、1000、1万、10万、25万、50万页为例,测试以上三种分页方案的执行速度：(单位：毫秒）

　　页??码
　　方案1
　　方案2
　　方案3
?
　　1
　　60
　　30
　　76
?
　　10
　　46
　　16
　　63
?
　　100
　　1076
　　720
　　130
?
　　500
　　540
　　12943
　　83
?
　　1000
　　17110
　　470
　　250
?
　　1万
　　24796
　　4500
　　140
?
　　10万
　　38326
　　42283
　　1553
?
　　25万
　　28140
　　128720
　　2330
?
　　50万
　　121686
　　127846
　　7168
?

　　从上表中,我们可以看出,三种存储过程在执行100页以下的分页命令时,都是可以信任的,速度都很好。但第一种方案在执行分页1000页以上后,速度就降了下来。第二种方案大约是在执行分页1万页以上后速度开始降了下来。而第三种方案却始终没有大的降势,后劲仍然很足。

　　在确定了第三种分页方案后,我们可以据此写一个存储过程。大家知道SQL?SERVER的存储过程是事先编译好的SQL语句,它的执行效率要比通过WEB页面传来的SQL语句的执行效率要高。下面的存储过程不仅含有分页方案,还会根据页面传来的参数来确定是否进行数据总数统计。

　　--?获取指定页的数据

　　CREATE?PROCEDURE?pagination3

　　@tblName???varchar(255),???????--?表名

　　@strGetFields?varchar(1000)?=?'*',??--?需要返回的列?

　　@fldName?varchar(255)=',??????--?排序的字段名

　　@PageSize???int?=?10,??????????--?页尺寸

　　@PageIndex??int?=?1,???????????--?页码

　　@doCount??bit?=?0,???--?返回记录总数,?非?0?值则返回
@OrderType?bit?=?0,??--?设置排序类型,?非?0?值则降序 　　@strWhere??varchar(1500)?=?'??--?查询条件?(注意:?不要加?where) 　　AS 　　declare?@strSQL???varchar(5000)???????--?主语句 　　declare?@strTmp???varchar(110)????????--?临时变量 　　declare?@strOrder?varchar(400)????????--?排序类型 ? 　　if?@doCount?!=?0 　　begin 　　if?@strWhere?!=' 　　set?@strSQL?=?"select?count(*)?as?Total?from?["?+?@tblName?+?"]?where?"+@strWhere 　　else 　　set?@strSQL?=?"select?count(*)?as?Total?from?["?+?@tblName?+?"]" 　　end?? 　　--以上代码的意思是如果@doCount传递过来的不是0,就执行总数统计。以下的所有代码都是@doCount为0的情况 　　else 　　begin 　　if?@OrderType?!=?0 　　begin 　　set?@strTmp?=?"<(select?min" 　　set?@strOrder?=?"?order?by?["?+?@fldName?+"]?desc" 　　--如果@OrderType不是0,就执行降序,这句很重要！ 　　end 　　else 　　begin 　　set?@strTmp?=?">(select?max" 　　set?@strOrder?=?"?order?by?["?+?@fldName?+"]?asc" 　　end 　　if?@PageIndex?=?1 　　begin 　　if?@strWhere?!=?'??? 　　set?@strSQL?=?"select?top?"?+?str(@PageSize)?+"?"+@strGetFields+?"??from?["?+?@tblName?+?"]?where?"?+?@strWhere?+?"?"?+?@strOrder 　　else 　　set?@strSQL?=?"select?top?"?+?str(@PageSize)?+"?"+@strGetFields+?"??from?["+?@tblName?+?"]?"+?@strOrder 　　--如果是第一页就执行以上代码,这样会加快执行速度 　　end 　　else 　　begin 　　--以下代码赋予了@strSQL以真正执行的SQL代码 　　set?@strSQL?=?"select?top?"?+?str(@PageSize)?+"?"+@strGetFields+?"??from?["+?@tblName?+?"]?where?["?+?@fldName?+?"]"?+?@strTmp+?"(["+@fldName?+?"])?from?(select?top?"?+?str((@PageIndex-1)*@PageSize)?+?"?["+?@fldName?+?"]?from?["?+?@tblName?+?"]"?+?@strOrder?+?")?as?tblTmp)"+?@strOrder ? 　　if?@strWhere?!=?' 　　set?@strSQL?=?"select?top?"?+?str(@PageSize)?+"?"+@strGetFields+?"??from?["+?@tblName?+?"]?where?["?+?@fldName?+?"]"?+?@strTmp?+?"(["+?@fldName?+?"])?from?(select?top?"?+?str((@PageIndex-1)*@PageSize)?+?"?["+?@fldName?+?"]?from?["?+?@tblName?+?"]?where?"?+?@strWhere?+?"?"+@strOrder?+?")?as?tblTmp)?and?"?+?@strWhere?+?"?"?+?@strOrder 　　end? 　　end??? 　　exec?(@strSQL) 　　GO 　　上面的这个存储过程是一个通用的存储过程,其注释已写在其中了。 　　在大数据量的情况下,特别是在查询最后几页的时候,查询时间一般不会超过9秒；而用其他存储过程,在实践中就会导致超时,所以这个存储过程非常适用于大容量数据库的查询。 　　笔者希望能够通过对以上存储过程的解析,能给大家带来一定的启示,并给工作带来一定的效率提升,同时希望同行提出更优秀的实时数据分页算法。 　　四、聚集索引的重要性和如何选择聚集索引 　　在上一节的标题中,笔者写的是：实现小数据量和海量数据的通用分页显示存储过程。这是因为在将本存储过程应用于“办公自动化”系统的实践中时,笔者发现这第三种存储过程在小数据量的情况下,有如下现象： 　　1、分页速度一般维持在1秒和3秒之间。 　　2、在查询最后一页时,速度一般为5秒至8秒,哪怕分页总数只有3页或30万页。 　　虽然在超大容量情况下,这个分页的实现过程是很快的,但在分前几页时,这个1－3秒的速度比起第一种甚至没有经过优化的分页方法速度还要慢,借用户的话说就是“还没有ACCESS数据库速度快”,这个认识足以导致用户放弃使用您开发的系统。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!