关于SQL查询效率，100w数据，查询只要1秒1.关于SQL查询效率，100w数据，查询只要1秒，与您分享:
机器情况
p4: 2.4
内存: 1 G
os: windows 2003
数据库: ms sql server 2000
⽬的: 查询性能测试,⽐较两种查询的性能
SQL查询效率 step by step
-- setp 1.
-- 建表
create table t_userinfo
(
userid int identity(1,1) primary key nonclustered,
nick varchar(50) not null default '',
classid int not null default 0,
writetime datetime not null default getdate()
)
go
-- 建索引
create clustered index ix_userinfo_classid on t_userinfo(classid)
go
-- step 2.
declare @i int
declare @k int
declare @nick varchar(10)
set @i = 1
while @i<1000000
begin
set @k = @i % 10
set @nick = convert(varchar,@i)
insert into t_userinfo(nick,classid,writetime) values(@nick,@k,getdate())
set @i = @i + 1
end
-
- 耗时 08:27 ，需要耐⼼等待
-- step 3.
select top 20 userid,nick,classid,writetime from t_userinfo
where userid not in
(
select top 900000 userid from t_userinfo order by userid asc
)
-- 耗时 8 秒 ，够长的
-- step 4.
select a.userid,b.nick,b.classid,b.writetime from
(
select top 20 a.userid from
(
select top 900020 userid from t_userinfo order by userid asc
) a order by a.userid desc
) a inner join t_userinfo b on a.userid = b.userid
order by a.userid asc
-- 耗时 1 秒，太快了吧，不可以思议
-- step 5 where 查询
select top 20 userid,nick,classid,writetime from t_userinfo
where classid = 1 and userid not in
(
select top 90000 userid from t_userinfo
where classid = 1
order by userid asc
)
-- 耗时 2 秒
-- step 6 where 查询
select a.userid,b.nick,b.classid,b.writetime from
(
select top 20 a.userid from
(
select top 90000 userid from t_userinfo
where classid = 1
order by userid asc
) a order by a.userid desc
) a inner join t_userinfo b on a.userid = b.userid
order by a.userid asc
-- 查询分析器显⽰不到 1 秒.
查询效率分析：
⼦查询为确保消除重复值，必须为外部查询的每个结果都处理嵌套查询。在这种情况下可以考虑⽤联接查询来取代。
如果要⽤⼦查询，那就⽤EXISTS替代IN、⽤NOT EXISTS替代NOT IN。因为EXISTS引⼊的⼦查询只是测试是否存在符合⼦查询中指定条件的⾏，效率较⾼。⽆论在哪种情况下,NOT IN都是最低效的。因为它对⼦查询中的表执⾏了⼀个全表遍历。
建⽴合理的索引，避免扫描多余数据，避免表扫描！
⼏百万条数据，照样⼏⼗毫秒完成查询.
2.
SQL提⾼查询效率
2008-05-12 21:20
1.对查询进⾏优化，应尽量避免全表扫描，⾸先应考虑在 where 及 order by 涉及的列上建⽴索引。
2.应尽量避免在 where ⼦句中对字段进⾏ null 值判断，否则将导致引擎放弃使⽤索引⽽进⾏全表扫描，如：
select id from t where num is null
可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：
select id from t where num=0
3.应尽量避免在 where ⼦句中使⽤!=或<>操作符，否则将引擎放弃使⽤索引⽽进⾏全表扫描。
4.应尽量避免在 where ⼦句中使⽤ or 来连接条件，否则将导致引擎放弃使⽤索引⽽进⾏全表扫描，如：
select id from t where num=10 or num=20
可以这样查询：
select id from t where num=10
union all
select id from t where num=20
5.in 和 not in 也要慎⽤，否则会导致全表扫描，如：
select id from t where num in(1,2,3)
对于连续的数值，能⽤ between 就不要⽤ in 了：
select id from t where num between 1 and 3
6.下⾯的查询也将导致全表扫描：
select id from t where name like '%abc%'
若要提⾼效率，可以考虑全⽂检索。
7.如果在 where ⼦句中使⽤参数，也会导致全表扫描。因为SQL只有在运⾏时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运⾏时；它必须在编译时进⾏选择。然⽽，如果在编译时建⽴访问计划，变量的值还是未知的，因⽽⽆法作为索引选择的输⼊项。如下⾯语句将进⾏全表扫描：
select id from t where num=@num
可以改为强制查询使⽤索引：
select id from t with(index(索引名)) where num=@num
8.应尽量避免在 where ⼦句中对字段进⾏表达式操作，这将导致引擎放弃使⽤索引⽽进⾏全表扫描。如：
select id from t where num/2=100
应改为:
select id from t where num=100*2
9.应尽量避免在where⼦句中对字段进⾏函数操作，这将导致引擎放弃使⽤索引⽽进⾏全表扫描。如：
select id from t where substring(name,1,3)='abc'--name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’⽣成的id
应改为:
select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'
10.不要在 where ⼦句中的“=”左边进⾏函数、算术运算或其他表达式运算，否则系统将可能⽆法正确使⽤索引。
11.在使⽤索引字段作为条件时，如果该索引是复合索引，那么必须使⽤到该索引中的第⼀个字段作为条件时才能保证系统使⽤该索引，否则该索引将不会被使⽤，并且应尽可能的让字段顺序与索引顺序相⼀致。
12.不要写⼀些没有意义的查询，如需要⽣成⼀个空表结构：
select col1,col2 into #t from t where 1=0
这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：
create table #t(...)
13.很多时候⽤ exists 代替 in 是⼀个好的选择：
select num from a where num in(select num from b)
⽤下⾯的语句替换：
select num from a where exists(select 1 from b where num=a.num)
14.并不是所有索引对查询都有效，SQL是根据表中数据来进⾏查询优化的，当索引列有⼤量数据重复时，SQL查询可能不会去利⽤索引，如⼀表中有字段sex，male、female⼏乎各⼀半，那么即使在sex上建了索引也对查询效率起不了作⽤。
15.索引并不是越多越好，索引固然可以提⾼相应的 select 的效率，但同时也降低了 insert 及 update
的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况⽽定。⼀个表的索引数最好不要超过6个，若太多则应考虑⼀些不常使⽤到的列上建的索引是否有必要。
16.应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，⼀旦该列值改变将导致整个表记录的顺序的调整，会耗费相当⼤的资源。若应⽤系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。
17.尽量使⽤数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个⽐较字符串中每⼀个字符，⽽对于数字型⽽⾔只需要⽐较⼀次就够了。
18.尽可能的使⽤ varchar/nvarchar 代替 char/nchar ，因为⾸先变长字段存储空间⼩，可以节省存储空间，其次对于查询来说，在⼀个相对较⼩的字段内搜索效率显然要⾼些。
19.任何地⽅都不要使⽤ select * from t ，⽤具体的字段列表代替“*”，不要返回⽤不到的任何字段。
20.尽量使⽤表变量来代替临时表。如果表变量包含⼤量数据，请注意索引⾮常有限（只有主键索引）。
21.避免频繁创建和删除临时表，以减少系统表资源的消耗。
22.临时表并不是不可使⽤，适当地使⽤它们可以使某些例程更有效，例如，当需要重复引⽤⼤型表或常⽤表中的某个数据集时。但是，对于⼀次性事件，最好使⽤导出表。
23.在新建临时表时，如果⼀次性插⼊数据量很⼤，那么可以使⽤ select into 代替 create table，避免造成⼤量 log ，以提⾼速度；如果数据量不⼤，为了缓和系统表的资源，应先create table，然后insert。
24.如果使⽤到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。
25.尽量避免使⽤游标，因为游标的效率较差，如果游标操作的数据超过1万⾏，那么就应该考虑改写。
26.使⽤基于游标的⽅法或临时表⽅法之前，应先寻基于集的解决⽅案来解决问题，基于集的⽅法通常更有效。
27.与临时表⼀样，游标并不是不可使⽤。对⼩型数据集使⽤ FAST_FORWARD 游标通常要优于其他逐⾏处理⽅法，尤其是在必须引⽤⼏个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要⽐使⽤游标执⾏的速度快。如果开发时间允许，基于游标的⽅法和基于集的⽅法都可以尝试⼀下，看哪⼀种⽅法的效果更好。
28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。⽆需在执⾏存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。
29.尽量避免⼤事务操作，提⾼系统并发能⼒。
30.尽量避免向客户端返回⼤数据量，若数据量过⼤，应该考虑相应需求是否合理
1、避免将字段设为“允许为空”
2、数据表设计要规范
3、深⼊分析数据操作所要对数据库进⾏的操作
4、尽量不要使⽤临时表
5、多多使⽤事务
6、尽量不要使⽤游标
7、避免死锁
8、要注意读写锁的使⽤
9、不要打开⼤的数据集
10、不要使⽤服务器端游标
11、在程序编码时使⽤⼤数据量的数据库
12、不要给“性别”列创建索引
13、注意超时问题
14、不要使⽤Select *
15、在细节表中插⼊纪录时，不要在主表执⾏Select MAX(ID)
16、尽量不要使⽤TEXT数据类型
17、使⽤参数查询join和in哪个查询更快
18、不要使⽤Insert导⼊⼤批的数据
19、学会分析查询
20、使⽤参照完整性
21、⽤INNER JOIN 和LEFT JOIN代替Where
提⾼SQL查询效率（要点与技巧）：
· 技巧⼀：
问题类型：ACCESS数据库字段中含有⽇⽂⽚假名或其它不明字符时查询会提⽰内存溢出。
解决⽅法：修改查询语句
sql="select * from tablename where column like '%"&word&"%'"
改为
sql="select * from tablename"
rs.filter = " column like '%"&word&"%'"
===========================================================
技巧⼆：
问题类型：如何⽤简易的办法实现类似百度的多关键词查询（多关键词⽤空格或其它符号间隔）。
解决⽅法：
'//⽤空格分割查询字符串
ck=split(word," ")
'//得到分割后的数量
sck=UBound(ck)
sql="select * tablename where"
在⼀个字段中查询
For i = 0 To sck
SQL = SQL & tempJoinWord & "(" & _
"column like '"&ck(i)&"%')"
tempJoinWord = " and "
Next
在⼆个字段中同时查询
For i = 0 To sck
SQL = SQL & tempJoinWord & "(" & _
"column like '"&ck(i)&"%' or " & _
"column1 like '"&ck(i)&"%')"
tempJoinWord = " and "
Next
===========================================================
技巧三：⼤⼤提⾼查询效率的⼏种技巧
1. 尽量不要使⽤ or，使⽤or会引起全表扫描，将⼤⼤降低查询效率。
2. 经过实践验证，charindex()并不⽐前⾯加%的like更能提⾼查询效率，并且charindex()会使索引失去作⽤（指sqlserver数据库）
3. column like '%"&word&"%' 会使索引不起作⽤
column like '"&word&"%' 会使索引起作⽤（去掉前⾯的%符号）
（指sqlserver数据库）
4. '%"&word&"%' 与'"&word&"%' 在查询时的区别：
⽐如你的字段内容为⼀个容易受伤的⼥⼈
'%"&word&"%' ：会通配所有字符串，不论查“受伤”还是查“⼀个”，都会显⽰结果。
'"&word&"%' ：只通配前⾯的字符串，例如查“受伤”是没有结果的，只有查“⼀个”，才会显⽰结果。
5. 字段提取要按照“需多少、提多少”的原则，避免“select *”，尽量使⽤“select 字段1，字段2，字段3........”。实践证明：每少提取⼀个字段，数据的提取速度就会有相应的提升。提升的速度还要看您舍弃的字段的⼤⼩来判断。
6. order by按聚集索引列排序效率最⾼。⼀个sqlserver数据表只能建⽴⼀个聚集索引，⼀般默认为ID，也可以改为其它的字段。
7. 为你的表建⽴适当的索引，建⽴索引可以使你的查询速度提⾼⼏⼗⼏百倍。（指sqlserver数据库）
· 以下是建⽴索引与不建⽴索引的⼀个查询效率分析：
Sqlserver索引与查询效率分析。
表 News
字段
Id：⾃动编号
Title：⽂章标题
Author：作者
Content：内容
Star：优先级
Addtime：时间
记录：100万条
测试机器：P4 2.8/1G内存/IDE硬盘
=======================================================
⽅案1：
主键Id，默认为聚集索引，不建⽴其它⾮聚集索引
select * from News where Title like '%"&word&"%' or Author like '%"&word&"%' order by Id desc
从字段Title和Author中模糊检索，按Id排序
查询时间：50秒
=======================================================
⽅案2：
主键Id，默认为聚集索引
在Title、Author、Star上建⽴⾮聚集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%' order by Id desc
从字段Title和Author中模糊检索，按Id排序
查询时间：2 - 2.5秒
=======================================================
⽅案3：
主键Id，默认为聚集索引
在Title、Author、Star上建⽴⾮聚集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%' order by Star desc
从字段Title和Author中模糊检索，按Star排序
查询时间：2 秒
=======================================================
⽅案4：
主键Id，默认为聚集索引
在Title、Author、Star上建⽴⾮聚集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%'
从字段Title和Author中模糊检索，不排序
查询时间：1.8 - 2 秒
=======================================================
⽅案5：
主键Id，默认为聚集索引
在Title、Author、Star上建⽴⾮聚集索引
select * from News where Title like '"&word&"%'
或
select * from News where Author like '"&word&"%'
从字段Title 或 Author中检索，不排序
查询时间：1秒
· 如何提⾼SQL语⾔的查询效率?
问：请问我如何才能提⾼SQL语⾔的查询效率呢？
答：这得从头说起：
由于SQL是⾯向结果⽽不是⾯向过程的查询语⾔，所以⼀般⽀持SQL语⾔的⼤型关系型数据库都使⽤⼀个基于查询成本的优化器，为即时查询提供⼀个最佳的执⾏策略。对于优化器，输⼊是⼀条查询语句，输出是⼀个执⾏策略。
⼀条SQL查询语句可以有多种执⾏策略，优化器将估计出全部执⾏⽅法中所需时间最少的所谓成本最低的那⼀种⽅法。所有优化都是基于⽤记所使⽤的查询语句中的where⼦句，优化器对where⼦句中的优化主要⽤搜索参数(Serach Argument)。
搜索参数的核⼼思想就是数据库使⽤表中字段的索引来查询数据，⽽不必直接查询记录中的数据。
带有 =、<、<=、>、>= 等操作符的条件语句可以直接使⽤索引，如下列是搜索参数：
emp_id = "10001" 或 salary > 3000 或  a =1 and c = 7
⽽下列则不是搜索参数：
salary = emp_salary 或 dep_id != 10 或 salary * 12 >= 3000 或 a=1 or c=7
应当尽可能提供⼀些冗余的搜索参数，使优化器有更多的选择余地。请看以下3种⽅法：
第⼀种⽅法：
p_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (department.dep_code="01") and (employee.dep_code="01");
它的搜索分析结果如下：
Estimate 2 I/O operations

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。