数据库SQL优化大总结之 百万级数据库优化方案

网上关于SQL优化的教程不少，可是比较杂乱。近日有空整理了一下，写出来跟你们分享一下，其中有错误和不足的地方，还请你们纠正补充。

这篇文章我花费了大量的时间查找资料、修改、排版，但愿你们阅读以后，感受好的话推荐给更多的人，让更多的人看到、纠正以及补充。

 

1.对查询进行优化，要尽可能避免全表扫描，首先应考虑在 where 及 order by 涉及的列上创建索引。

2.应尽可能避免在 where 子句中对字段进行 null 值判断，不然将致使引擎放弃使用索引而进行全表扫描，如：

select id from t where num is null

最好不要给数据库留NULL，尽量的使用 NOT NULL填充数据库.

备注、描述、评论之类的能够设置为 NULL，其余的，最好不要使用NULL。

不要觉得 NULL 不须要空间，好比：char(100) 型，在字段创建时，空间就固定了， 无论是否插入值（NULL也包含在内），都是占用 100个字符的空间的，若是是varchar这样的变长字段， 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 Name = 'admin'

能够这样查询：

select id from t where num = 10
union all
select id from t where Name = 'admin'

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

不少时候用 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)

 

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

.应尽可能避免在 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.Update 语句，若是只更改一、2个字段，不要Update所有字段，不然频繁调用会引发明显的性能消耗，同时带来大量日志。

14.对于多张大数据量（这里几百条就算大了）的表JOIN，要先分页再JOIN，不然逻辑读会很高，性能不好。

15.select count(*) from table；这样不带任何条件的count会引发全表扫描，而且没有任何业务意义，是必定要杜绝的。

16.索引并非越多越好，索引当然能够提升相应的 select 的效率，但同时也下降了 insert 及 update 的效率，由于 insert 或 update 时有可能会重建索引，因此怎样建索引须要慎重考虑，视具体状况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

17.应尽量的避免更新 clustered 索引数据列，由于 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将致使整个表记录的顺序的调整，会耗费至关大的资源。若应用系统须要频繁更新 clustered 索引数据列，那么须要考虑是否应将该索引建为 clustered 索引。

18.尽可能使用数字型字段，若只含数值信息的字段尽可能不要设计为字符型，这会下降查询和链接的性能，并会增长存储开销。这是由于引擎在处理查询和连 接时会逐个比较字符串中每个字符，而对于数字型而言只须要比较一次就够了。

19.尽量的使用 varchar/nvarchar 代替 char/nchar ，由于首先变长字段存储空间小，能够节省存储空间，其次对于查询来讲，在一个相对较小的字段内搜索效率显然要高些。

20.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

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.尽可能避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

 

实际案例分析：拆分大的 DELETE 或INSERT 语句，批量提交SQL语句
　　若是你须要在一个在线的网站上去执行一个大的 DELETE 或 INSERT 查询，你须要很是当心，要避免你的操做让你的整个网站中止相应。由于这两个操做是会锁表的，表一锁住了，别的操做都进不来了。
　　Apache 会有不少的子进程或线程。因此，其工做起来至关有效率，而咱们的服务器也不但愿有太多的子进程，线程和数据库连接，这是极大的占服务器资源的事情，尤为是内存。
　　若是你把你的表锁上一段时间，好比30秒钟，那么对于一个有很高访问量的站点来讲，这30秒所积累的访问进程/线程，数据库连接，打开的文件数，可能不只仅会让你的WEB服务崩溃，还可能会让你的整台服务器立刻挂了。
　　因此，若是你有一个大的处理，你必定把其拆分，使用 LIMIT oracle(rownum),sqlserver(top)条件是一个好的方法。下面是一个mysql示例：

while(1){

 　　//每次只作1000条

　　 mysql_query(“delete from logs where log_date <= ’2012-11-01’ limit 1000”);

 　　if(mysql_affected_rows() == 0){

　　 　　//删除完成，退出！
　　 　　break；
　　}

//每次暂停一段时间，释放表让其余进程/线程访问。
usleep(50000)

}

 

 

好了，到这里就写完了。我知道还有不少没有写到的，还请你们补充。后面有空会介绍一些SQL优化工具给你们。让咱们一块儿学习，一块儿进步吧！

 

--------------------------------------------------------------------------------------

1、问题的提出

在应用系统开发初期，因为开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各类写法的性能优劣，可是若是将应用系统提交实际应用后，随着数据库中数据的增长，系统的响应速度就成为目前系统须要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差异能够达到上百倍，可见对于一个系统不是简单地能实现其功能就可，而是要写出高质量的SQL语句，提升系统的可用性。

在多数状况下，Oracle使用索引来更快地遍历表，优化器主要根据定义的索引来提升性能。可是，若是在SQL语句的where子句中写的SQL代码不合理，就会形成优化器删去索引而使用全表扫描，通常就这种SQL语句就是所谓的劣质SQL语句。在编写SQL语句时咱们应清楚优化器根据何种原则来删除索引，这有助于写出高性能的SQL语句。

2、SQL语句编写注意问题

下面就某些SQL语句的where子句编写中须要注意的问题做详细介绍。在这些where子句中，即便某些列存在索引，可是因为编写了劣质的SQL，系统在运行该SQL语句时也不能使用该索引，而一样使用全表扫描，这就形成了响应速度的极大下降。

1. 操做符优化

(a) IN 操做符

用IN写出来的SQL的优势是比较容易写及清晰易懂，这比较适合现代软件开发的风格。可是用IN的SQL性能老是比较低的，从Oracle执行的步骤来分析用IN的SQL与不用IN的SQL有如下区别：

ORACLE试图将其转换成多个表的链接，若是转换不成功则先执行IN里面的子查询，再查询外层的表记录，若是转换成功则直接采用多个表的链接方式查询。因而可知用IN的SQL至少多了一个转换的过程。通常的SQL均可以转换成功，但对于含有分组统计等方面的SQL就不能转换了。

推荐方案：在业务密集的SQL当中尽可能不采用IN操做符，用EXISTS 方案代替。

(b) NOT IN操做符

此操做是强列不推荐使用的，由于它不能应用表的索引。

推荐方案：用NOT EXISTS 方案代替

(c) IS NULL 或IS NOT NULL操做（判断字段是否为空）

判断字段是否为空通常是不会应用索引的，由于索引是不索引空值的。不能用null做索引，任何包含null值的列都将不会被包含在索引中。即便索引有多列这样的状况下，只要这些列中有一列含有null，该列就会从索引中排除。也就是说若是某列存在空值，即便对该列建索引也不会提升性能。任何在where子句中使用is null或is not null的语句优化器是不容许使用索引的。

推荐方案：用其它相同功能的操做运算代替，如：a is not null 改成 a>0 或a>’’等。不容许字段为空，而用一个缺省值代替空值，如申请中状态字段不容许为空，缺省为申请。

(d) > 及 < 操做符（大于或小于操做符）

大于或小于操做符通常状况下是不用调整的，由于它有索引就会采用索引查找，但有的状况下能够对它进行优化，如一个表有100万记录，一个数值型字段A，30万记录的A=0，30万记录的A=1，39万记录的A=2，1万记录的A=3。那么执行A>2与A>=3的效果就有很大的区别了，由于A>2时ORACLE会先找出为2的记录索引再进行比较，而A>=3时ORACLE则直接找到=3的记录索引。

(e) LIKE操做符

LIKE操做符能够应用通配符查询，里面的通配符组合可能达到几乎是任意的查询，可是若是用得很差则会产生性能上的问题，如LIKE ‘%5400%’ 这种查询不会引用索引，而LIKE ‘X5400%’则会引用范围索引。

一个实际例子：用YW_YHJBQK表中营业编号后面的户标识号可来查询营业编号 YY_BH LIKE ‘%5400%’ 这个条件会产生全表扫描，若是改为YY_BH LIKE ’X5400%’ OR YY_BH LIKE ’B5400%’ 则会利用YY_BH的索引进行两个范围的查询，性能确定大大提升。

带通配符(%)的like语句：

一样以上面的例子来看这种状况。目前的需求是这样的，要求在职工表中查询名字中包含cliton的人。能够采用以下的查询SQL语句:

1	select * from employee where last_name like '%cliton%';

这里因为通配符(%)在搜寻词首出现，因此Oracle系统不使用last_name的索引。在不少状况下可能没法避免这种状况，可是必定要心中有底，通配符如此使用会下降查询速度。然而当通配符出如今字符串其余位置时，优化器就能利用索引。在下面的查询中索引获得了使用:

1	select * from employee where last_name like 'c%';

(f) UNION操做符

UNION在进行表连接后会筛选掉重复的记录，因此在表连接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最多见的是过程表与历史表UNION。如：

1 2 3

select * from gc_dfys  union  select * from ls_jg_dfys

这个SQL在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，最后返回结果集，若是表数据量大的话可能会致使用磁盘进行排序。

推荐方案：采用UNION ALL操做符替代UNION，由于UNION ALL操做只是简单的将两个结果合并后就返回。

1 2 3

select * from gc_dfys  union all  select * from ls_jg_dfys

(g) 联接列

对于有联接的列，即便最后的联接值为一个静态值，优化器是不会使用索引的。咱们一块儿来看一个例子，假定有一个职工表(employee)，对于一个职工的姓和名分红两列存放(FIRST_NAME和LAST_NAME)，如今要查询一个叫比尔.克林顿(Bill Cliton)的职工。

下面是一个采用联接查询的SQL语句：

1	select * from employss where first_name||''||last_name ='Beill Cliton';

上面这条语句彻底能够查询出是否有Bill Cliton这个员工，可是这里须要注意，系统优化器对基于last_name建立的索引没有使用。当采用下面这种SQL语句的编写，Oracle系统就能够采用基于last_name建立的索引。

1	where first_name ='Beill' and last_name ='Cliton';

(h) Order by语句

ORDER BY语句决定了Oracle如何将返回的查询结果排序。Order by语句对要排序的列没有什么特别的限制，也能够将函数加入列中(象联接或者附加等)。任何在Order by语句的非索引项或者有计算表达式都将下降查询速度。

仔细检查order by语句以找出非索引项或者表达式，它们会下降性能。解决这个问题的办法就是重写order by语句以使用索引，也能够为所使用的列创建另一个索引，同时应绝对避免在order by子句中使用表达式。

(i) NOT

咱们在查询时常常在where子句使用一些逻辑表达式，如大于、小于、等于以及不等于等等，也可使用and(与)、or(或)以及not(非)。NOT可用来对任何逻辑运算符号取反。下面是一个NOT子句的例子:

1	where not (status ='VALID')

若是要使用NOT，则应在取反的短语前面加上括号，并在短语前面加上NOT运算符。NOT运算符包含在另一个逻辑运算符中，这就是不等于(<>)运算符。换句话说，即便不在查询where子句中显式地加入NOT词，NOT仍在运算符中，见下例:

1	where status <>'INVALID';

对这个查询，能够改写为不使用NOT：

1	select * from employee where salary<3000 or salary>3000;

虽然这两种查询的结果同样，可是第二种查询方案会比第一种查询方案更快些。第二种查询容许Oracle对salary列使用索引，而第一种查询则不能使用索引。

2. SQL书写的影响

(a) 同一功能同一性能不一样写法SQL的影响。

如一个SQL在A程序员写的为  Select * from zl_yhjbqk

B程序员写的为 Select * from dlyx.zl_yhjbqk（带表全部者的前缀）

C程序员写的为 Select * from DLYX.ZLYHJBQK（大写表名）

D程序员写的为 Select *  from DLYX.ZLYHJBQK（中间多了空格）

以上四个SQL在ORACLE分析整理以后产生的结果及执行的时间是同样的，可是从ORACLE共享内存SGA的原理，能够得出ORACLE对每一个SQL 都会对其进行一次分析，而且占用共享内存，若是将SQL的字符串及格式写得彻底相同，则ORACLE只会分析一次，共享内存也只会留下一次的分析结果，这不只能够减小分析SQL的时间，并且能够减小共享内存重复的信息，ORACLE也能够准确统计SQL的执行频率。

(b) WHERE后面的条件顺序影响

WHERE子句后面的条件顺序对大数据量表的查询会产生直接的影响。如：

1 2	Select * from zl_yhjbqk where dy_dj = '1KV如下' and xh_bz=1  Select * from zl_yhjbqk where xh_bz=1 and dy_dj = '1KV如下'

以上两个SQL中dy_dj（电压等级）及xh_bz（销户标志）两个字段都没进行索引，因此执行的时候都是全表扫描，第一条SQL的dy_dj = ’1KV如下’条件在记录集内比率为99%，而xh_bz=1的比率只为0.5%，在进行第一条SQL的时候99%条记录都进行dy_dj及xh_bz的比较，而在进行第二条SQL的时候0.5%条记录都进行dy_dj及xh_bz的比较，以此能够得出第二条SQL的CPU占用率明显比第一条低。

(c) 查询表顺序的影响

在FROM后面的表中的列表顺序会对SQL执行性能影响，在没有索引及ORACLE没有对表进行统计分析的状况下，ORACLE会按表出现的顺序进行连接，因而可知表的顺序不对时会产生十分耗服物器资源的数据交叉。（注：若是对表进行了统计分析，ORACLE会自动先进小表的连接，再进行大表的连接）

3. SQL语句索引的利用

(a) 对条件字段的一些优化

采用函数处理的字段不能利用索引，如：

1 2	substr(hbs_bh,1,4)=’5400’，优化处理：hbs_bh like ‘5400%’ trunc(sk_rq)=trunc(sysdate)， 优化处理：sk_rq>=trunc(sysdate) and sk_rq<trunc(sysdate+1)

进行了显式或隐式的运算的字段不能进行索引，如：ss_df+20>50，优化处理：ss_df>30

1 2	‘X’ || hbs_bh>’X5400021452’，优化处理：hbs_bh>’5400021542’ sk_rq+5=sysdate，优化处理：sk_rq=sysdate-5

hbs_bh=5401002554，优化处理：hbs_bh=’ 5401002554’，注：此条件对hbs_bh 进行隐式的to_number转换，由于hbs_bh字段是字符型。

条件内包括了多个本表的字段运算时不能进行索引，如：

1 2	ys_df>cx_df，没法进行优化  qc_bh || kh_bh=’5400250000’，优化处理：qc_bh=’5400’ and kh_bh=’250000’

4. 更多方面SQL优化资料分享

（1） 选择最有效率的表名顺序(只在基于规则的优化器中有效)：

ORACLE 的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最早处理，在FROM子句中包含多个表的状况下,你必须选择记录条数最少的表做为基础表。若是有3个以上的表链接查询, 那就须要选择交叉表(intersection table)做为基础表, 交叉表是指那个被其余表所引用的表.

（2） WHERE子句中的链接顺序：

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的链接必须写在其余WHERE条件以前, 那些能够过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

（3） SELECT子句中避免使用 ‘ * ‘：

ORACLE在解析的过程当中, 会将’*’ 依次转换成全部的列名, 这个工做是经过查询数据字典完成的, 这意味着将耗费更多的时间。

（4） 减小访问数据库的次数：

ORACLE在内部执行了许多工做: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等。

（5） 在SQL*Plus , SQL*Forms和Pro*C中从新设置ARRAYSIZE参数, 能够增长每次数据库访问的检索数据量 ,建议值为200。

（6） 使用DECODE函数来减小处理时间：

使用DECODE函数能够避免重复扫描相同记录或重复链接相同的表.

（7） 整合简单,无关联的数据库访问：

若是你有几个简单的数据库查询语句,你能够把它们整合到一个查询中(即便它们之间没有关系) 。

（8） 删除重复记录：

最高效的删除重复记录方法 ( 由于使用了ROWID)例子：

1	DELETE  FROM  EMP E  WHERE  E.ROWID > (SELECT MIN(X.ROWID) FROM  EMP X  WHERE  X.EMP_NO = E.EMP_NO)。

（9） 用TRUNCATE替代DELETE：

当删除表中的记录时,在一般状况下, 回滚段(rollback segments ) 用来存放能够被恢复的信息. 若是你没有COMMIT事务,ORACLE会将数据恢复到删除以前的状态(准确地说是恢复到执行删除命令以前的情况) 而当运用TRUNCATE时, 回滚段再也不存听任何可被恢复的信息.当命令运行后,数据不能被恢复.所以不多的资源被调用,执行时间也会很短. (译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML) 。

（10） 尽可能多使用COMMIT：

只要有可能,在程序中尽可能多使用COMMIT, 这样程序的性能获得提升,需求也会由于COMMIT所释放的资源而减小，COMMIT所释放的资源:

a. 回滚段上用于恢复数据的信息.

b. 被程序语句得到的锁

c. redo log buffer 中的空间

d. ORACLE为管理上述3种资源中的内部花费

（11） 用Where子句替换HAVING子句：

避免使用HAVING子句, HAVING 只会在检索出全部记录以后才对结果集进行过滤. 这个处理须要排序,总计等操做. 若是能经过WHERE子句限制记录的数目,那就能减小这方面的开销. (非oracle中)on、where、having这三个均可以加条件的子句中，on是最早执行，where次之，having最后，由于on是先把不符合条件的记录过滤后才进行统计，它就能够减小中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，由于它过滤数据后才进行sum，在两个表联接时才用on的，因此在一个表的时候，就剩下where跟having比较了。在这单表查询统计的状况下，若是要过滤的条件没有涉及到要计算字段，那它们的结果是同样的，只是where可使用rushmore技术，而having就不能，在速度上后者要慢若是要涉及到计算的字 段，就表示在没计算以前，这个字段的值是不肯定的，根据上篇写的工做流程，where的做用时间是在计算以前就完成的，而having就是在计算后才起做 用的，因此在这种状况下，二者的结果会不一样。在多表联接查询时，on比where更早起做用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表 后，再由where进行过滤，而后再计算，计算完后再由having进行过滤。因而可知，要想过滤条件起到正确的做用，首先要明白这个条件应该在何时起做用，而后再决定放在那里。

（12） 减小对表的查询：

在含有子查询的SQL语句中,要特别注意减小对表的查询.例子：

1	SELECT  TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT TAB_NAME,DB_VER FROM  TAB_COLUMNS  WHERE  VERSION = 604)

（13） 经过内部函数提升SQL效率：

复杂的SQL每每牺牲了执行效率. 可以掌握上面的运用函数解决问题的方法在实际工做中是很是有意义的。

（14） 使用表的别名(Alias)：

当在SQL语句中链接多个表时, 请使用表的别名并把别名前缀于每一个Column上.这样一来,就能够减小解析的时间并减小那些由Column歧义引发的语法错误。

（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：

在许多基于基础表的查询中,为了知足一个条件,每每须要对另外一个表进行联接.在这种状况下, 使用EXISTS(或NOT EXISTS)一般将提升查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 不管在哪一种状况下,NOT IN都是最低效的 (由于它对子查询中的表执行了一个全表遍历). 为了不使用NOT IN ,咱们能够把它改写成外链接(Outer Joins)或NOT EXISTS。

例子：

1 2	（高效）SELECT * FROM  EMP (基础表)  WHERE  EMPNO > 0  AND  EXISTS (SELECT ‘X'  FROM DEPT  WHERE  DEPT.DEPTNO = EMP.DEPTNO  AND  LOC = ‘MELB')  (低效)SELECT  * FROM  EMP (基础表)  WHERE  EMPNO > 0  AND  DEPTNO IN(SELECT DEPTNO  FROM  DEPT  WHERE  LOC = ‘MELB')

（16） 识别’低效执行’的SQL语句：

虽然目前各类关于SQL优化的图形化工具层出不穷,可是写出本身的SQL工具来解决问题始终是一个最好的方法：

1 2 3 4 5 6 7 8 9

SELECT  EXECUTIONS , DISK_READS, BUFFER_GETS,  ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,  ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,  SQL_TEXT  FROM  V$SQLAREA  WHERE  EXECUTIONS>0  AND  BUFFER_GETS > 0  AND  (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8  ORDER BY  4 DESC;

（17） 用索引提升效率：

索引是表的一个概念部分,用来提升检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 一般,经过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 一样在联结多个表时使用索引也能够提升效率. 另外一个使用索引的好处是,它提供了主键(primary key)的惟一性验证.。那些LONG或LONG RAW数据类型, 你能够索引几乎全部的列. 一般, 在大型表中使用索引特别有效. 固然,你也会发现, 在扫描小表时,使用索引一样能提升效率. 虽然使用索引能获得查询效率的提升,可是咱们也必须注意到它的代价. 索引须要空间来存储,也须要按期维护, 每当有记录在表中增减或索引列被修改时, 索引自己也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 由于索引须要额外的存储空间和处理,那些没必要要的索引反而会使查询反应时间变慢.。按期的重构索引是有必要的：

1	ALTER  INDEX <INDEXNAME> REBUILD <TABLESPACENAME>

（18） 用EXISTS替换DISTINCT：

当提交一个包含一对多表信息(好比部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 通常能够考虑用EXIST替换, EXISTS 使查询更为迅速,由于RDBMS核心模块将在子查询的条件一旦知足后,马上返回结果. 例子：

1 2 3 4

(低效):  SELECT  DISTINCT  DEPT_NO,DEPT_NAME  FROM  DEPT D , EMP E WHERE  D.DEPT_NO = E.DEPT_NO  (高效):  SELECT  DEPT_NO,DEPT_NAME  FROM  DEPT D  WHERE  EXISTS ( SELECT ‘X'  FROM  EMP E  WHERE E.DEPT_NO = D.DEPT_NO);

（19） sql语句用大写的；由于oracle老是先解析sql语句，把小写的字母转换成大写的再执行。

（20） 在java代码中尽可能少用链接符“＋”链接字符串！

（21） 避免在索引列上使用NOT，一般咱们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就会中止使用索引转而执行全表扫描。

（22） 避免在索引列上使用计算

WHERE子句中，若是索引列是函数的一部分．优化器将不使用索引而使用全表扫描．举例:

1 2 3 4

低效：  SELECT … FROM  DEPT  WHERE SAL * 12 > 25000;  高效:  SELECT … FROM DEPT WHERE SAL > 25000/12;

（23） 用>=替代>

1 2 3 4

高效:  SELECT * FROM  EMP  WHERE  DEPTNO >=4  低效:  SELECT * FROM EMP WHERE DEPTNO >3

二者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录然后者将首先定位到DEPTNO=3的记录而且向前扫描到第一个DEPT大于3的记录。

（24） 用UNION替换OR (适用于索引列)

一般状况下, 用UNION替换WHERE子句中的OR将会起到较好的效果. 对索引列使用OR将形成全表扫描. 注意, 以上规则只针对多个索引列有效. 若是有column没有被索引, 查询效率可能会由于你没有选择OR而下降. 在下面的例子中, LOC_ID 和REGION上都建有索引.

1 2 3 4 5 6 7 8 9 10 11 12

高效:  SELECT LOC_ID , LOC_DESC , REGION  FROM LOCATION  WHERE LOC_ID = 10  UNION  SELECT LOC_ID , LOC_DESC , REGION  FROM LOCATION  WHERE REGION = “MELBOURNE”  低效:  SELECT LOC_ID , LOC_DESC , REGION  FROM LOCATION  WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

若是你坚持要用OR, 那就须要返回记录最少的索引列写在最前面.

（25） 用IN来替换OR

这是一条简单易记的规则，可是实际的执行效果还须检验，在ORACLE8i下，二者的执行路径彷佛是相同的．

1 2 3 4

低效:  SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30  高效  SELECT… FROM LOCATION WHERE LOC_IN  IN (10,20,30);

（26） 避免在索引列上使用IS NULL和IS NOT NULL

避免在索引中使用任何能够为空的列，ORACLE将没法使用该索引．对于单列索引，若是列包含空值，索引中将不存在此记录. 对于复合索引，若是每一个列都为空，索引中一样不存在此记录. 若是至少有一个列不为空，则记录存在于索引中．举例: 若是惟一性索引创建在表的A列和B列上, 而且表中存在一条记录的A,B值为(123,null) , ORACLE将不接受下一条具备相同A,B值（123,null）的记录(插入). 然而若是全部的索引列都为空，ORACLE将认为整个键值为空而空不等于空. 所以你能够插入1000 条具备相同键值的记录,固然它们都是空! 由于空值不存在于索引列中,因此WHERE子句中对索引列进行空值比较将使ORACLE停用该索引.

1 2 3 4

低效: (索引失效)  SELECT … FROM  DEPARTMENT  WHERE  DEPT_CODE IS NOT NULL;  高效: (索引有效)  SELECT … FROM  DEPARTMENT  WHERE  DEPT_CODE >=0;

（27） 老是使用索引的第一个列：

若是索引是创建在多个列上, 只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引. 这也是一条简单而重要的规则，当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引。

（28） 用UNION-ALL 替换UNION ( 若是有可能的话)：

当SQL 语句须要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并, 而后在输出最终结果前进行排序. 若是用UNION ALL替代UNION, 这样排序就不是必要了. 效率就会所以获得提升. 须要注意的是，UNION ALL 将重复输出两个结果集合中相同记录. 所以各位仍是要从业务需求分析使用UNION ALL的可行性. UNION 将对结果集合排序,这个操做会使用到SORT_AREA_SIZE这块内存. 对于这块内存的优化也是至关重要的. 下面的SQL能够用来查询排序的消耗量

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

低效：  SELECT  ACCT_NUM, BALANCE_AMT  FROM  DEBIT_TRANSACTIONS  WHERE TRAN_DATE = '31-DEC-95'  UNION  SELECT ACCT_NUM, BALANCE_AMT  FROM DEBIT_TRANSACTIONS  WHERE TRAN_DATE = '31-DEC-95'  高效:  SELECT ACCT_NUM, BALANCE_AMT  FROM DEBIT_TRANSACTIONS  WHERE TRAN_DATE = '31-DEC-95'  UNION ALL  SELECT ACCT_NUM, BALANCE_AMT  FROM DEBIT_TRANSACTIONS  WHERE TRAN_DATE = '31-DEC-95'

（29） 用WHERE替代ORDER BY：

ORDER BY 子句只在两种严格的条件下使用索引.

ORDER BY中全部的列必须包含在相同的索引中并保持在索引中的排列顺序.

ORDER BY中全部的列必须定义为非空.

WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.

例如:

表DEPT包含如下列:

1 2 3

DEPT_CODE PK NOT NULL  DEPT_DESC NOT NULL  DEPT_TYPE NULL

1 2 3 4

低效: (索引不被使用)  SELECT DEPT_CODE FROM  DEPT  ORDER BY  DEPT_TYPE  高效: (使用索引)  SELECT DEPT_CODE  FROM  DEPT  WHERE  DEPT_TYPE > 0

（30） 避免改变索引列的类型:

当比较不一样数据类型的数据时, ORACLE自动对列进行简单的类型转换.

假设 EMPNO是一个数值类型的索引列.

1	SELECT …  FROM EMP  WHERE  EMPNO = ‘123'

实际上,通过ORACLE类型转换, 语句转化为:

1	SELECT …  FROM EMP  WHERE  EMPNO = TO_NUMBER(‘123')

幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变.

如今,假设EMP_TYPE是一个字符类型的索引列.

1	SELECT …  FROM EMP  WHERE EMP_TYPE = 123

这个语句被ORACLE转换为:

1	SELECT …  FROM EMP  WHERE TO_NUMBER(EMP_TYPE)=123

由于内部发生的类型转换, 这个索引将不会被用到! 为了不ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型。

分析

1	select   emp_name   form   employee   where   salary   >   3000

在此语句中若salary是Float类型的，则优化器对其进行优化为Convert(float,3000)，由于3000是个整数，咱们应在编程时使用3000.0而不要等运行时让DBMS进行转化。一样字符和整型数据的转换。

（31） 须要小心的WHERE子句:

某些SELECT 语句中的WHERE子句不使用索引. 这里有一些例子.

在下面的例子里, (1)‘!=’ 将不使用索引. 记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中. (2) ‘ ¦ ¦’是字符链接函数. 就象其余函数那样, 停用了索引. (3) ‘+’是数学函数. 就象其余数学函数那样, 停用了索引. (4)相同的索引列不能互相比较,这将会启用全表扫描.

（32） a. 若是检索数据量超过30%的表中记录数.使用索引将没有显著的效率提升. b. 在特定状况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的区别. 而一般状况下,使用索引比全表扫描要块几倍乃至几千倍!

（33） 避免使用耗费资源的操做：

带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎执行耗费资源的排序(SORT)功能. DISTINCT须要一次排序操做, 而其余的至少须要执行两次排序. 一般, 带有UNION, MINUS , INTERSECT的SQL语句均可以用其余方式重写. 若是你的数据库的SORT_AREA_SIZE调配得好, 使用UNION , MINUS, INTERSECT也是能够考虑的, 毕竟它们的可读性很强。

（34） 优化GROUP BY：

提升GROUP BY 语句的效率, 能够经过将不须要的记录在GROUP BY 以前过滤掉.下面两个查询返回相同结果但第二个明显就快了许多.

1 2 3 4 5 6 7 8 9 10 11 12

低效:  SELECT JOB , AVG(SAL)  FROM EMP  GROUP by JOB  HAVING JOB = ‘PRESIDENT'  OR JOB = ‘MANAGER'  高效:  SELECT JOB , AVG(SAL)  FROM EMP  WHERE JOB = ‘PRESIDENT'  OR JOB = ‘MANAGER'  GROUP by JOB