PLSQL性能优化建议

了解PLSQL程序性能

影响性能常见原因

1.尽量使用存储过程，避免使用PL/SQL匿名块

存储过程创建后，oracle会对其进行语法句法分析，以编译的形式存储在数据库中，当客户端调用时，只需要发送一条调用指令，避免了匿名块在网上传送大量源代码，降低了网络通信的负担，同时因为仅在创建时编译一次，因此提升了程序运行的性能.

2.编写共享SQL语句

oracle在执行SQL语句时，在第一次解析后，会将SQL语句放在位于系统全局区SGA中的共享池中,这块内存区域可以被所有的数据库用户共享，因此在执行一个SQL语句时，比如在PL/SQL语句中的游标执行SQL语句,如果oracle检测到它和以前已运行过的语句相同,就会使用已经被解析的语句,使用最优的执行路径.

oracle在执行一条SQL语句时，总是会先从共享内存区中查找相同的sql语句，但是由于oracle只对简单表进行缓存，因此对于多表连接查询并不适用.

SELECT * FROM EMP;

SELECT * from EMP;

Select * from Emp;

SELECT * FROM EMP;

为了避免这类SQL语句，在编写SQL语句时，必须注意采用大小写一致的约定，关键字，保留字大写，用户声明的标识符小写，通过设计自己的编写约定并遵守这些约定，使要处理的语句与共享池中的相一致，有助于运行性能的提高.

3.使用BINARY_INTEGER 和 PLS_INTEGER声明整型

在PLSQL编程中要声明变量类型时，应该总是使用BINARY_INTEGER 和 PLS_INTEGER，避免过多地依赖于number类型，因为前者提供了较快的性能.

4.在过程中传递大数据参数时使用NOCOPY编译提示

当创建过程或函数时，IN模式总是传递指针，而OUT和IN OUT传递的则是值的副本,也称为传值传递。当涉及较大容量的参数传递时，会严重降低性能，此时应该考虑使用NOCOPY编译提示来按引用传递参数，参数的大小越大，效果就越明显.

例如，假定有过程具有一个IN OUT类型的参数，默认情况下会按值进行传递，下面的例子演示对这个过程进行多次调用，并传递一个较大的索引表参数，如果不使用NOCOPY，则会严重降低性能。

使用NOCOPY提升性能

declare

type test_tb1 is table of pls_integer index by pls_integer;  --定义索引表类型

test_tb1 test_tb1_type;   --定义索引表类型的变量

--定义内嵌子程序，在IN OUT 参数中使用NOCOPY提示来按引用传递

procedure test (arg_cnt in pls_integer，arg_tb1 in out nocopy test_tb1_type)

is

begin

for cnt_test in test_tb1.first .. arg_tb1.last --依循环索引表

loop

arg_tb1 (cnt_test):=arg_tb1 (cnt_test) + arg_cnt;

end loop; --为形式参数表赋值

end;

begin

for cnt in 0 .. 10000

loop

test_tb1 (cnt) := cnt;

end loop;

for cnt in 0 .. 10000

loop

test (cnt,test_tb1);

end loop;

end;

5.使用returning获取返回值

在使用DML语句处理对象行的数据时，如果要获取行的返回值，应该总是使用returning子句，以便减少对SQL的执行次数，提高执行的效率:

insert into .. value (..) returning col1 into :col1;

update .. set .. returning col1 into :col1;

delete .. returning col1 into :col1;

使用returning 不仅可以返回多列数据,也可以返回数据保存到数组等数据类型中:

returning col1，col2 into :col1，:col2;

returning col1 into :col1_array;

6.避免使用动态SQL语句

动态sql语句虽然提供了编程上的便利性，但是过多的使用动态sql语句会严重的降低PLSQL应用程序的性能，因此如无必要，应该总是考虑使用静态的sql语句。如果不得不使用动态sql语句，则应该总是选择使用本地动态sql语句，即execute immediate 或open for 而不要使用dbms_sql，因为dbms_sql不光编写代码较复杂，而且性能不如本地动态sql语句。

7.尽量使用bulk批处理

如果操作涉及大量的数据，则可以通过把大量的数据进行一次性处理来提升性能，比如可以将数据放到索引表，嵌套表和变长数组中，通过forall或bulk collect into 等批处理语句，一次性处理大的数据量，提升性能。

使用bulk collect into语句将emp表中所有的数据一次性插入到索引表变量中，当数据量特别大时，能显著的提高性能

.

使用批处理一次性获取所有数据

declare

type emp_tb1 is table of emp%ROWTYPE index by pls_integer; --定义索引表类型

        emp_tb1 emp_tb1_type;

cursor emp_cur

is

select * from emp;

begin

open emp_cur;

fetch emp_cur

bulk collect into emp_tb1;

close emp_cur;

end;

通过使用bulk collect into子句，一次性将所有的游标数据提取到索引表变量中，提升了程序的执行性能，也节省了代码的编写量。因此只要有可能，应尽量使用批处理来完成数据的处理工作。

使用DBMS_PROFILER包

1.安装DBMS_PROFILER包

在使用DBMS_PROFILER之前，必须要以管理员身份进入数据库系统进行安装。

conn system/manager as sysdba;

desc dbms_profiler;

如果desc命令提示dbms_profiler包不存在，则需要使用如下命令进行安装:

sql>@?/rdbms/admin/profload.sql

再次运行desc dbms_profiler，可以看到这个包中包含的子程序的信息，使用的函数主要有两个:

start_profiler  启动profiler

stop_profiler   停止profiler

2.配置profiler方案

创建一个用来存放跟踪信息的用户，以及profiler相关的表的同义词:

create user profiler indentified by 123456;

grant connect，resource to profiler;

create public synonym plsql_profiler_runs for profiler.plsql_profiler_runs;

create public synonym plsql_profiler_units for profiler.plsql_profiler_units;

create public synonym plsql_profiler_data for profiler.plsql_profiler_data;

create public synonym plsql_profiler_runnumber for profiler.plsql_profiler_runnumber;

3.配置profiler表

conn profiler/123456

@?/rdbms/admin/proftab.sql

grant select on plsql_profile_runnumber to public;

grant select，insert，update，delete on plsql_profiler_data to public;

grant select，insert，update，delete on plsql_profiler_units to public;

grant select，insert，update，delete on plsql_profiler_runs to public;

plsql_profile_runnumber    保存了profiler的运行信息

plsql_profiler_data   保存每个单元的profiler信息

plsql_profiler_units   保存了每个单元的详细数据

plsql_profiler_runs   用来生成profiler唯一运行编号的序列

4.执行profiler获取配置信息

在创建了过程之后，就可以使用profiler来检测程序代码。

创建要被测试的过程

create table pro_tst_table (a int);

create or replace procedure sp_test

as

begin

for i in 1 .. 10000

loop

insert into pro_tst_table values(i);

end loop;

commit;

end;

使用dbms_profiler来测试包

declare

v_run_number integer;

v_temp1 integer;

begin

--启动profiler

sys.DBMS_PROFILER.start_profiler(run_number => v_run_number);

--显示当前跟踪的运行序号(后面查询要用)

dbms_output.put_line('run_number:'||v_run_number);

--运行要跟踪的PLSQL

sp_test;

--停止profiler

sys.DBMS_PROFILER.stop_profiler;

end;

5.查询profiler获取结果

要使用sql语句查询本次执行的信息，可以先查询plsql_profiler_runs获取本次执行的基本信息:

select runid，run_owner，run_date,run_total_time from plsql_profiler_runs;

笔者运行了两次代码，因此具有两个runid的记录，ID值是通过序列号生成的，最大ID值表示最近一次的执行.

RUN_TOTAL_TIME表示执行的时间，可以看到两次执行的时间具有明显的不同.

通过查询plsql_profiler_units表可以得到本次profile时的单元信息。

通过查询plsql_profiler_data表，可以根据行号和单元号获得执行的存储过程的每一行的统计信息。

使用DBMS_TRACE包

比如看到子程序的执行顺序，则可以使用DBMS_TRACE包，该包的使用过程与使用DBMS_PROFILER类似，一个主要区别在于dbms_trace可以设定需要跟踪的事件:调用，异常，SQL甚至每一个PLSQL代码的可运行。有了这些信息的辅助，可以非常迅速地定位后台程序流程的异常.

包中有如下两个函数:

set_plsql_trace:开启跟踪统计数据的收集。

clear_plsql_trace:停止跟踪统计数据的收集

1.配置与使用DBMS_TRACE

在使用之前，需要先配置一下dbms_trace所使用的数据表，并使得所有的用户都能够向这些表中写入数据，

conn system/manager as sysdba

@？/rdbms/admin/tracetab.sql

脚本创建了两个表和一个序列

plsql_trace_runs表:用来记录每一次的跟踪信息。

plsql_trace_events表:用来记录所有跟踪的详细数据

plsql_trace_runnumber序列:用于生成唯一运行号的序列.

2.在成功地创建了所需要的表之后，接下来需要为相应的表创建同义词，并为之分配可访问的权限，以便于public角色的用户能够对相应的表进行操作。

create or replace public synonym plsql_trace_runs for sys.plsql_trace_runs;

create or replace public synonym plsql_trace_events for sys.plsql_trace_events;

create or replace public synonym plsql_trace_runnumber for sys.plsql_trace_runnumber;

grant select,insert,update,delete on plsql_trace_events to public;

grant select,insert,update,delete on plsql_trace_runs to public;

grant select on plsql_trace_runnumber to public;

创建dbms_trace测试程序

create or replace procedure do_something (p_times in number)

as

1_dummy number;

begin

for i in 1 .. p_times

loop

select 1_dummy + 1 into 1_dummy from dual;

end loop;

end;

使用dbms_trace跟踪程序

declare

1_result binary_integer;

begin

--跟踪所有的调用

dbms_trace.set_plsql_trace(dbms_trace.trace_all_calls);

do_something(100);

--停止PLSQL跟踪

dbms_trace.clear_plsql_trace;

--跟踪所有的sql语句

dbms_trace.set_plsql_trace(dbms_trace.trace_all_sql);

do_something(100);

--停止跟踪

dbms_trace.clear_plsql_trace;

--跟踪所有行数据

dbms_trace.set_plsql_trace(dbms_trace.trace_all_lines);

do_something(100);

dbms_trace.clear_plsql_trace;

end;

对于每一次调用，都首先使用set_plsql_trace开始跟踪的过程，该过程的参数DBMS_TRACE_trace_all_calls是指定用来跟踪调用或返回值的常量。

在DBMS_TRACE包的包规范中包含了set_plsql_trace可供使用的常量的列表及详细的解释。

通过查询plsql_trace_runs表，来获取每一次跟踪的信息。 

PLSQL性能优化技巧

oracle数据库在执行sql语句时，oracle的优化器会根据一定的规则确定sql语句的执行路径，以确保sql语句能以最优性能执行.在oracle数据库系统中为了执行sql语句，oracle可能需要实现多个步骤，这些步骤中的每一步可能是从数据库中物理检索数据行，或者用某种方法准备数据行，让编写sql语句的用户使用，oracle用来执行语句的这些步骤的组合被称为执行计划。

当执行一个sql语句时oracle经过了4个步骤:

解析sql语句:主要在共享池中查询相同的sql语句，检查安全性和sql语法与语义。

创建执行计划及执行:包括创建sql语句的执行计划及对表数据的实际获取。

显示结果集:对字段数据执行所有必要的排序，转换和重新格式化。

转换字段数据:对已通过内置函数进行转换的字段进行重新格式化处理和转换.

查看sql语句的执行计划，比如一些第三方工具  需要先执行utlxplan.sql脚本创建explain_plan表。

@？/rdbms/admin/utlxplan.sql

set autotrace on explain:执行sql，且仅显示执行计划

set autotrace on statistics:执行sql 且仅显示执行统计信息

set autotrace on :执行sql，且显示执行计划与统计信息，无执行结果

set autotrace traceonly:仅显示执行计划与统计信息，无执行结果

set autotrace off:关闭跟踪显示计划与统计

set autotrace on explain

col ename format a20;

select empno，ename from emp where empno=7369;

理解执行计划

1.全表扫描:这种方式会读取表中的每一条记录，顺序地读取每一个数据块直到结尾标志，对于一个大的数据表来说，使用全表扫描会降低性能，但有些时候，比如查询的结果占全表的数据量的比例比较高时，全表扫描相对于索引选择又是一种较好的办法。

2.通过ROWID值获取：行的rowid指出了该行所在的数据文件，数据块及行在该块中的位置，所以通过rowid来存取数据可以快速定位到目标数据上，是oracle存取单行数据的最快方法。

3.索引扫描：先通过索引找到对象的rowid值，然后通过rowid值直接从表中找到具体的数据，能大大提高查找的效率。

连接查询的表顺序

默认情况下，优化器会使用all_rows优化方式，也就是基于成本的优化器CBO生成执行计划，CBO方式会根据统计信息来产生执行计划.

统计信息给出表的大小，多少行，每行的长度等信息，这些统计信息起初在库内是没有的，是做analyee后才发现的，很多时候过期统计信息会令优化器做出一个错误的执行计划，因此应及时更新这些信息。

在CBO模式下，当对多个表进行连接查询时，oracle分析器会按照从右到左的顺序处理from子句中的表名。例如：

select a.empno，a.ename，c.deptno，c.dname，a.log_action from emp_log a,emp b,dept c

在执行时，oracle会先查询dept表，根据dept表查询的行作为数据源串行连接emp表继续执行，因此dept表又称为基础表或驱动表。由于连接的顺序对于查询的效率有非常大的影响。因此在处理多表连接时，必须选择记录条数较少的表作为基础表，oracle会使用排序与合并的方式进行连接。比如先扫描dept表，然后对dept表进行排序，再扫描emp表，最后将所有检索出来的记录与第一个表中的记录进行合并。

如果有3个以上的表连接查询，就需要选择交叉表作为基础表。交叉表是指那个被其他表所引用的表，由于emp_log是dept与emp表中的交叉表，既包含dept的内容又包含emp的内容。

select a.empno，a.ename，c.deptno，c.dname，a.log_action from emp b,dept c,emp_log a;

指定where条件顺序

在查询表时，where子句中条件的顺序往往影响了执行的性能。默认情况下，oracle采用自下而上的顺序解析where子句，因此在处理多表查询时，表之间的连接必须写在其他的where条件之前，但是过滤数据记录的条件则必须写在where子句的尾部，以便在过滤了数据之后再进行连接处理，这样可以提升sql语句的性能。

避免使用*符号

使用decode函数

比如统计emp表中部门编号为20和部门编号为30的员工的人数和薪资汇总，如果不使用decode那么就必须用两条sql语句

select count(*)，SUM(sal) from emp where deptno=20;

union

select count(*)，SUM(sal) from emp where deptno=30;

上面进行了两次全表扫描

通过decode语句，可以再一个sql查询中获取到相同的结果，并且将两行结果显示为单行。

select count (decode (deptno，20，'X'，NULL)) dept20_count，

count (decode (deptno，30，'X'，NULL)) dept30_count，

SUM (decode (deptno，20，sal，NULL)) dept20_sal，

sum (decode (deptno，30，sal，NULL)) dept30_sal from emp;

上面只进行了一次全表扫描

通过灵活的运用decode函数，可以得到很多意想不到的结果，比如在group by 或order by子句中使用decode函数，或者在decode块中嵌套另一个decode块。

使用where而非having

where子句和having子句都可以过滤数据，但是where子句不能使用聚集函数，如count max min avg sum等函数。

例子：

select empno,deptno，sum(sal) from emp group by empno，deptno

having sum(sal) > 1000 and deptno in (20，30);

在having子句中，过滤出部门编号为20或30的记录，实际上这将导致查询取出所有部门的员工记录，在进行分组计算，最后才根据分组的结果过滤出部门 20和30的记录。这非常低效，好的算法是先使用where子句取出部门编号为20和30的记录，再进行过滤。

select empno，deptno，sum(sal) from emp where deptno in （20,30）

group by empno，deptno having sum (sal) > 1000;

使用UNION而非OR

如果要进行OR运算的两个列都是索引列，可以考虑使用union来提升性能。

例子：比如emp表中，empno和ename都创建了索引列，当需要在empno和ename之间进行OR操作查询时，可以考虑将这两个查询更改为union来提升性能。

select empno，ename，job，sal from emp where empno > 7500 OR ename LIKE 'S%';

使用UNION

select empno，ename，job，sal from emp where empno > 7500 

UNION

select empno，ename，job，sal from emp where ename LIKE 'S%';

但这种方式要确保两个列都是索引列。

如果坚持使用OR语句，需要记住尽量将返回记录最少的索引列写在最前面，这样能获得较好的性能，例如empno > 7500 返回的记录要少于对ename的查询，因此在OR语句中将其放到前面能获得较好的性能。另外一个建议是在要对单个字段值进行OR计算的时候，可以考虑使用IN来代替

例如下面的

select empno，ename，job，sal from emp where deptno=20 OR deptno=30;

使用exists而非IN

比如查询位于芝加哥的所有员工列表可以考虑使用IN

select * from emp where deptno IN (

select deptno from dept where loc='CHICAGO');

替换成

select * from emp where exists (

select deptno from dept where loc='CHICAGO');

同样的替换页发生在not in 和not exists之间，not in 子句将执行一个内部的排序和合并，实际上它对子查询中的表执行了一次全表扫描，因此效率低，在需要使用NOT IN的场合，英爱总是考虑把它更改成外连接或NOT EXISTS

select * from emp where deptno NOT IN (

select deptno from dept where loc='CHICAGO');

为了提高较好的性能，可以使用连接查询

select a.* from emp a，dept b where a.deptno=b.deptno and b.loc <> 'CHICAGO';

最有效率的

select a.* from emp a where NOT EXISTS (

select 1 from dept b where a.deptno =b.deptno and loc='CHICAGO');

避免低效的PL/SQL流程控制语句

PLSQL在处理逻辑表达式值的时候，使用的是短路径的计算方式。

declare

v_sal number:=&sal;

v_job varchar2(20):=&job;

begin

if (v_sal > 5000 ) OR (v_job = '销售')

then

dbms_output.put_line('符合匹配的OR条件');

end if;

end;

首先对第一个条件进行判断，如果v_sal大于5000，就不会再对v_job条件进行判断，灵活的运用这种短路计算方式可以提升性能。应该总是将开销较低的判断语句放在前面，这样当前面的判断失败时，就不会再执行后面的具有较高开销的语句，能提升PL/SQL应用程序的性能.

举个例子，对于and逻辑运算符来说，只有左右两边的运算为真，结果才为真。如果前面的结果第一个运算时false值，就不会进行第二个运算、

declare

v_sal number:=&sal;

v_job varchar2(20):=&job;

begin

if (check_sal(v_sal) > 5000) AND (v_job = '销售') --判断执行条件

then

dbms_output.put_line('符合匹配的and条件');

end if;

end;

这段代码有一个性能隐患，check_sal涉及一些业务逻辑的检查，如果让check_sal函数的调用放在前面，这个函数总是被调用，因此处于性能方面的考虑，应该总是将v_job的判断放到and语句的前面.

declare

v_sal number:=&sal;

v_job varchar2(20):=&job;

begin

if (v_job='销售') and (check_sal(v_sal) > 5000)

then

dbms_output.put_line('符合匹配的and条件');

end if;

end;

避免隐式类型转换