数据库优化建议（1）

最新推荐文章于 2022-05-16 08:14:03 发布

搬码日记

最新推荐文章于 2022-05-16 08:14:03 发布

阅读量480

点赞数 13

文章标签： SQL优化 Oracle数据库优化数据库优化

本文链接：https://blog.csdn.net/KamRoseLee/article/details/79588815

版权

1、不要让编译器做太多。

select … 
from user_files uf,    df_money_files  dmf,  cw_charge_record ccr
where 
uf.user_no = dmf.user_no
and dmf.user_no = ccr.user_no
and ……
and not exists(select …)

上述SQL查询

很难优化，随着数据量的增加性能的风险很大。

带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎执行耗费资源的排序(SORT)功能.DISTINCT需要一次排序操作,而其他的至少需要执行两次排序.
例如,一个UNION查询,其中每个查询都带有GROUPBY子句,GROUPBY会触发嵌入排序(NESTEDSORT) ; 这样,每个查询需要执行一次排序,然后在执行UNION时,又一个唯一排序(SORTUNIQUE)操作被执行而且它只能在前面的嵌入排序结束后才能开始执行.嵌入的排序的深度会大大影响查询的效率.

通常,带有UNION,MINUS , INTERSECT的SQL语句都可以用其他方式重写.

当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT.一般可以考虑用EXIST替换.

例如:

低效:

   SELECT DISTINCT D.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);

EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果.

当SQL语句需要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并, 然后在输出最终结果前进行排序.

举例:

   低效：

SELECTACCT_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-96’

高效:

       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-96’

2、给优化器更明确的命令

连接列上创建索引

一般会在表的连接列上建立索引，尤其是该表频繁参与连接操作。对于一个比较大的连接操作，如果被驱动表的连接列上没有索引的话，会造成多次扫描被驱动表，对数据库造成的压力和开销是巨大的。

在很多时候，where子句中的过滤条件并不是只针对某一个字段，经常会有多个字段一起作为查询过滤条件存在于where子句中。在这时候，就需要判断是该仅仅为过滤性最好的(选择度最大)的列建立索引，还是在所有过滤条件中所有列上建立组合索引。对于这个问题，需要衡量两种方案各自的优劣。当where子句中的这些字段组成的联合索引过滤性远大于其中过滤性最高的单列，就适合建联合索引。这样就意味着where子句中对应的每个列过滤性都不高，但是这些单列的过滤性乘在一起后过滤性就高了。

例如：要从存储着学籍信息的表中查找来自中国，大连的女性学生，使用的SQL的where子句如下：

where country = ‘china’and city= ‘dalian’andgender = female；

country和city的联合（country，city）的选择性会比country和city各自的选择性高，同时因为gender本身的选择性低，将其加入对于提高总体选择性贡献不大，所以在此情境下适合建立（country，city）的联合索引。

如果索引是建立在多个列上, 只有在它的第一个列(leadingcolumn)被where子句引用时,优化器才会选择使用该索引.

SQL> create table multiindexusage ( inda number , indb number , descr varchar2(10));

Table created.

SQL> create index multindex on multiindexusage(inda,indb);

Index created.

SQL> set autotracetraceonly

SQL> select * from multiindexusage where inda = 1;

Execution Plan

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

0 SELECT STATEMENTOptimizer=CHOOSE

1 0 TABLE ACCESS (BY INDEX ROWID) OF'MULTIINDEXUSAGE'

2 1 INDEX (RANGE SCAN) OF 'MULTINDEX'(NON-UNIQUE)

SQL> select * from multiindexusage where indb = 1;

Execution Plan

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

0 SELECT STATEMENTOptimizer=CHOOSE

1 0 TABLE ACCESS (FULL) OF 'MULTIINDEXUSAGE'

很明显,当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引

如果表中有两个以上（包括两个）索引，其中有一个唯一性索引，而其他是非唯一性．

在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引．

举例:

SELECT ENAME

FROM EMP

WHERE EMPNO = 2326

AND DEPTNO = 20 ;

这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录．

TABLE ACCESS BY ROWID ON EMP

INDEX UNIQUE SCAN ON EMP_NO_IDX

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

举例:

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

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

WHERE子句中, 如果索引列所对应的值的第一个字符由通
配符(WILDCARD)开始, 索引将不被采用.
 	
SELECT USER_NO,USER_NAME,ADDRESS
	
FROM USER_FILES
	
WHERE USER_NO LIKE ‘%109204421';


 在这种情况下，ORACLE将使用全表扫描.

所以尽量优化通配符的位置。通常，我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就

会停止使用索引转而执行全表扫描.

举例:
   低效: (这里,不使用索引)
   SELECT …
   FROM DEPT
   WHERE DEPT_CODE != 0;
   
   高效: (这里,使用了索引)
   SELECT …
   FROM DEPT
   WHERE DEPT_CODE > 0 OR DEPT_CODE < 0 ;

• 避免在索引中使用任何可以为空的列， ORACLE 将无法使用该索引．对于单列索引，如果列包含空值，索引中将不存在此记录 . 对于复合索引，如果每个列都为空，索引中同样不存在此记录 . 　如果至少有一个列不为空，则记录存在于索引中．

• 如果唯一性索引建立在表的 A 列和 B 列上 , 并且表中存在一条记录的 A,B 值为 (123,null), ORACLE 将不接受下一条具有相同 A,B 值（ 123,null ）的记录 ( 插入 ). 然而如果所有的索引列都为空， ORACLE 将认为整个键值为空而空不等于空 . 因此你可以插入 1000 条具有相同键值的记录 , 当然它们都是空 !

• 因为空值不存在于索引列中 , 所以 WHERE 子句中对索引列进行空值比较将使 ORACLE 停用该索引 .

• 任何在 where 子句中使用 isnull 或 isnot null 的语句优化器是不允许使用索引的。

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

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

SELECT USER_NO,USER_NAME,ADDRESS
FROM USER_FILES
WHERE USER_NO = 109204421

这个语句被ORACLE转换为:
SELECT USER_NO,USER_NAME,ADDRESS
FROM USER_FILES
WHERE TO_NUMBER(USER_NO) = 109204421

因为内部发生的类型转换, 这个索引将不会被用到!

如用 WHERE a.order_no = b.order_no 

不用 

WHERE TO_NUMBER (substr(a.order_no, instr(b.order_no, '.') - 1) 

= TO_NUMBER (substr(a.order_no, instr(b.order_no, '.') - 1)

• 当在 SQL 语句中连接多个表时 , 请使用表的别名并把别名前缀于每个 Column 上 . 这样一来 , 就可以减少解析的时间并减少那些由 Column 歧义引起的语法错误 .

• Column 歧义指的是由于 SQL 中不同的表具有相同的 Column 名 , 当 SQL 语句中出现这个 Column 时 ,SQL 解析器无法判断这个 Column 的归属 .

3、减少访问次数

当执行每条SQL语句时,ORACLE在内部执行了许多工作:

解析SQL语句,估算索引的利用率,绑定变量 ,读数据块等等.

由此可见,减少访问数据库的次数 ,就能实际上减少

ORACLE的工作量.

例如, 以下有三种方法可以检索出雇员号等于0342或0291的职员. 
方法1 (最低效) 
SELECT EMP_NAME , SALARY , GRADE 
FROM EMP 
WHERE EMP_NO = 342; 
SELECT EMP_NAME , SALARY , GRADE 
FROM EMP 
WHERE EMP_NO = 291;

方法2 (次低效) 
DECLARE CURSOR C1 (E_NO NUMBER) 
IS 
	SELECT EMP_NAME,SALARY,GRADE 
	FROM EMP 
	WHERE EMP_NO = E_NO; 
BEGIN 
	OPEN C1(342); FETCH C1 INTO …,..,.. ; ….. 
	OPEN C1(291); FETCH C1 INTO …,..,.. ; 
CLOSE C1; 
END;

方法3 (高效) 

SELECT A.EMP_NAME , A.SALARY , A.GRADE, B.EMP_NAME , B.SALARY , B.GRADE FROM EMP A,EMP B 
WHERE A.EMP_NO = 342 
AND B.EMP_NO = 291;

在含有子查询的SQL语句中,要特别注意减少对表的查询. 例如: 
低效:
SELECT TAB_NAME 
FROM TABLES 
WHERE TAB_NAME = ( SELECT TAB_NAME 
			 FROM TAB_COLUMNS 
			WHERE VERSION = 604) 
AND DB_VER= ( SELECT DB_VER 
		  FROM TAB_COLUMNS 
		  WHERE VERSION = 604)
高效: (多列子查询)
SELECT TAB_NAME 
FROM TABLES 
WHERE (TAB_NAME,DB_VER) = ( SELECT TAB_NAME,DB_VER) FROM TAB_COLUMNS WHERE VERSION = 604)

例子: 
低效: 
UPDATE EMP 
SET EMP_CAT = (SELECT MAX(CATEGORY) 
		   FROM EMP_CATEGORIES), 
SAL_RANGE = (SELECT MAX(SAL_RANGE) 
		FROM EMP_CATEGORIES) 
WHERE EMP_DEPT = 0020; 
高效: 
UPDATE EMP 
SET (EMP_CAT, SAL_RANGE) = (SELECT MAX(CATEGORY) , MAX(SAL_RANGE) FROM EMP_CATEGORIES) WHERE EMP_DEPT = 0020;

4、细节上的影响

为了不重复解析相同的SQL语句,在第一次解析之后, ORACLE将SQL语句存放在内存中,可以被所有的数据库用户共享. 因此,当你执行一个SQL语句(有时被称为一个游标)时,如果它和之前的执行过的语句完全相同, ORACLE就能很快获得已经被解析的语句以及最好的执行方案. ORACLE的这个功能大大地提高了SQL的执行性能并节省了内存的使用. 可惜的是ORACLE只对简单的表提供高速缓冲(cache buffering) ,这个功能并不适用于多表连接查询

这里需要注明的是,ORACLE对两者采取的是一种严格匹配,要达成共享,SQL语句必须完全相同(包括空格,换行等).共享的语句必须满足三个条件: A. 字符级的比较: 当前被执行的语句和共享池中的语句必须完全相同. 例如: SELECT * FROM EMP; 和下列每一个都不同 SELECT* from EMP; Select * From Emp; SELECT * FROM EMP;

ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名,因此FROM子句中写在最后的表(基础表 drivingtable)将被最先处理.

在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表.当ORACLE处理多个表时,会运用排序及合并的方式连接它们.首先,扫描第一个表(FROM子句中最后的那个表)并对记录进行派序,然后扫描第二个表(FROM子句中最后第二个表),最后将所有从第二个表中检索出的记录与第一个表中合适记录进行合并.

例如:表 TAB116,384 条记录,表 TAB21 条记录.

选择TAB2作为基础表 (最好的方法)select count(*) from tab1,tab2 执行时间0.96秒

选择TAB2作为基础表 (不佳的方法)select count(*) from tab2,tab1 执行时间26.09秒

同样因为ORACLE采用自右到左的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前,

同时那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.例如:   (低效,执行时间156.3秒) 
SELECT … FROM EMP E 
WHERE SAL > 50000 AND JOB = ‘MANAGER’ 
AND 25 < (SELECT COUNT(*) 
	     FROM EMP 
	     WHERE MGR=E.EMPNO); 
(高效,执行时间10.6秒) 
SELECT … 
FROM EMP E 
WHERE 25 < (SELECT COUNT(*) 
	           FROM EMP 
	           WHERE MGR=E.EMPNO)
AND SAL > 50000 AND JOB = ‘MANAGER’;

•如：设从emp表查到的数据比较少或该表的过滤条件比较确定，
能大大缩小查询范围，则将最具有选择性部分放在WHERE子句中的最后：
  select * from empe,dept d

  where d.deptno >10 and e.deptno =30 ;

•如果dept表返回的记录数较多的话，上面的查询语句会比下面的查询语句响应快得多。
  select * from empe,dept d

  where e.deptno =30 and d.deptno >10 ;

最好不要在WHERE子句中使用函数或表达式，如果要使用的话，最好统一使用相同的表达式或函数，这样便于以后使用合理的索引。

使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.
例如:
SELECT COUNT(*)，SUM(SAL)
FROM　EMP
WHERE DEPT_NO = 0020
AND ENAME LIKE　‘SMITH%’;

   
你可以用DECODE函数高效地得到相同结果

SELECT COUNT(DECODE(DEPT_NO,0020,’X’,NULL)) D0020_COUNT,
             COUNT(DECODE(DEPT_NO,0030,’X’,NULL)) D0030_COUNT,
             SUM(DECODE(DEPT_NO,0020,SAL,NULL)) D0020_SAL,
             SUM(DECODE(DEPT_NO,0030,SAL,NULL)) D0030_SAL
FROM EMP 
WHERE ENAME LIKE ‘SMITH%’;

类似的,DECODE函数也可以运用于GROUPBY 和ORDERBY子句中.

• ORDERBY 语句决定了 Oracle 如何将返回的查询结果排序。 Orderby 语句对要排序的列没有什么特别的限制，也可以将函数加入列中（像联接或者附加等）。任何在 Orderby 语句的非索引项或者有计算表达式都将降低查询速度。

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

对于有联接的列，即使最后的联接值为一个静态值，优化器

是不会使用索引的。

  select* from employss 
　  where 
　  first_name||''||last_name ='BeillCliton';

系统优化器对基于last_name创建的索引没有使用。

当采用下面这种SQL语句的编写，Oracle系统就可以采用基

于last_name创建的索引。

　  select * from employee 
where 
  first_name ='Beill' and last_name='Cliton';

通配符（%）在搜寻词首出现，Oracle系统不使用
last_name的索引。
	select * from employee where last_name like '%cliton%'; 

在很多情况下可能无法避免这种情况，但是一定要心中有底
，通配符如此使用会降低查询速度。然而当通配符出现在字
符串其他位置时，优化器就能利用索引。在下面的查询中索
引得到了使用： 
  	select * from employee where last_name like 'c%';

避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作.

如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销.
例如:
     低效:
     SELECT REGION，AVG(LOG_SIZE)
       FROM LOCATION
       GROUP BY REGION
       HAVING REGION != ‘SYDNEY’
       AND REGION != ‘PERTH’

顺序
	  WHERE > GROUP > HAVING

在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率. 
低效: 
SELECT * FROM EMP (基础表) 
WHERE EMPNO > 0 
AND DEPTNO IN (SELECT DEPTNO 
		     FROM DEPT 
		     WHERE LOC = ‘MELB’) 
高效: 
SELECT * FROM EMP (基础表) 
WHERE EMPNO > 0 
AND EXISTS (SELECT ‘X’ FROM DEPT 
	WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB’) 
注：相对来说,用NOT EXISTS替换NOT IN 将更显著地提高效率

在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的

(因为它对子查询中的表执行了一个全表遍历).  为了避免使用NOT IN,我们可以把它改成外联接(OUTER JOINS)或

NOT EXISTS.使用NOT EXISTS 子句可以有效地利用索引。尽可能使用NOT EXISTS来代替NOT IN，尽管二者都使用了NOT

（不能使用索引而降低速度），NOT EXISTS要比NOT IN查询效率更高。
例如:
语句1 
SELECT dname, deptno FROM dept WHERE 
	deptno NOT IN (SELECT deptno FROM emp); 
语句2 
SELECT dname, deptno FROM dept WHERE 
	NOT EXISTS 
    (SELECT deptno FROM emp WHERE dept.deptno = emp.deptno); 
	2要比1的执行性能好很多。
	因为1中对emp进行了full table scan,这是很浪费时间的操作。而且1中没有用到emp的index，

因为没有where子句。而2中的语句对emp进行的是缩小范围的查询。

通常来说 , 采用表连接的方式比EXISTS更有效率

SELECT ENAME 
FROM EMP E 
WHERE EXISTS (SELECT ‘X’ 
		  FROM DEPT 
		  WHERE DEPT_NO = E.DEPT_NO 
		  AND DEPT_CAT = ‘A’); 
(更高效) 
SELECT ENAME 
FROM DEPT D,EMP E 
WHERE E.DEPT_NO = D.DEPT_NO 
AND DEPT_CAT = ‘A’ ;

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

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

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

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

通常,在大型表中使用索引特别有效.当然,你也会发现,在扫描小表时,使用索引同样能提高效率.虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价.索引需要空间来存储,也需要定期维护,每当有记录在表中增减或索引列被修改时,索引本身也会被修改.这意味着每条记录的INSERT, DELETE , UPDATE将为此多付出4 , 5次的磁盘I/O. 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢。定期的重构索引是有必要的。

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

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

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

如果DEPTNO上有一个索引。

  高效:

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

   SELECT *
   FROM EMP
   WHERE DEPTNO >3

例子：

select * from employee where salary != 3000; 

对这个查询，可以改写为不使用NOT：

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

虽然这两种查询的结果一样，但是第二种查询方案会比第一种查询方案更快些。

第二种查询允许Oracle对salary列使用索引，而第一种查询则不能使用索引。

如果有其它办法，不要使用子查询。

外部联接"+"按其在"="的左边或右边分左联接和右联接。若不带"+"运算符的表中的一个行不直接匹配于带"+"预算符的表中的任何行，

则前者的行与后者中的一个空行相匹配并被返回。利用外部联接"+"，可以替代效率十分低下的 not in 运算，大大提高运行速度。例如，

下面这条命令执行起来很慢：

select a.empno from emp a where a.empno not in

	(select empno from emp1 where job='SALE');

利用外部联接，改写命令如下: 

select a.empno from emp a ,emp1 b 
where a.empno=b.empno(+) 
and b.empno is null 
and b.job='SALE';

这样运行速度明显提高.

• 事务是消耗资源的，大事务还容易引起死锁

• 只要有可能 , 在程序中尽量多使用 COMMIT, 这样程序的性能得到提高 , 需求也会因为 COMMIT 所释放的资源而减少

COMMIT所释放的资源:

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

被程序语句获得的锁

redo log buffer 中的空间

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

• 在使用 COMMIT 时必须要注意到事务的完整性 , 现实中效率和事务完整性往往是鱼和熊掌不可得兼

• 当删除表中的记录时 , 在通常情况下 , 回滚段 (rollback

segments) 用来存放可以被恢复的信息.如果你没有

COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准

确地说是恢复到执行删除命令之前的状况)

• 而当运用 TRUNCATE 时 , 回滚段不再存放任何可被恢复的

信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,

执行时间也会很短.

• TRUNCATE 只在删除全表适用 ,TRUNCATE 是 DDL 不是 DML

和一般的观点相反,count(*) 比count(1)稍快 ,当然如果可以通过索引检索,对索引列的计数仍旧是最快的.

注：在CSDN论坛中,曾经对此有过相当热烈的讨论,但通过实际的测试,上述三种方法并没有显著的性能差别

比如有的表PHONE_NO字段是CHAR型,而且创建有索引，

但在WHERE条件中忘记了加引号，就不会用到索引。

WHERE PHONE_NO=‘13920202022’

WHERE PHONE_NO=13920202022

1、语法检测。判断一条SQL语句的语法是否符合SQL的规范，比如执行：SQL> selet * from emp；我们就可以看出由于Select关键字少了一个“c”，这条语句就无法通过语法检验的步骤了。 2、语义检查。语法正确的SQL语句在解析的第二个步骤就是判断该SQL语句所访问的表及列是否准确？用户是否有权限访问或更改相应的表或列？比如如下语句：　　SQL> select * from emp;　　select * from emp　　*　　ERROR at line 1:　　ORA-00942: table or view does not exist　　由于查询用户没有可供访问的 emp对象，因此该SQL语句无法通过语义检查。

3、 Oracle根据提交的SQL语句获得最优化后的执行计划（sqlplan),并在内存中分配一定的空间保存该语句与对应的执行计划等信息。

4、检查共享池中是否有相同的语句存在.当用户第二次请求或多次请求时，Oracle会自动找到先前的语句与执行计划，而不会进行硬解析,而是直接进行软解析(把语句对应的执行计划调出，然后执行）,从而减少数据库的分析时间。

注意的是：Oracle中只能完全相同的语句，包大小写、空格、换行都要求一样时，才会重复使用以前的分析结果与执行计划。

声明：感谢业界IT良心培训机构：尚硅谷的SQL优化ppt学习资料。

搬码日记

关注

13
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据库优化建议（1）

1、不要让编译器做太多。select … from user_files uf, df_money_files dmf, cw_charge_record ccrwhere uf.user_no = dmf.user_noand dmf.user_no = ccr.user_noand ……and not exists(select …)上述SQL查询很难优化，随着数据量的...
复制链接

扫一扫