PLSQL_解析过程及硬解析和软解析的区别（案例）

2014-08-11 Created By BaoXinjian

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAABcAAAAYCAIAAACeHvEiAAABKElEQVQ4jdXTP0sCcRzH8e+gj0Cfg5A+A5faRcjRoeBGQaih7s41Ua5zqcHCIUHBWgTFB+ByttogKC62dZuSQU2+Wzz6R915GtSHz/zi9/3AT9hEZJPKYvHor/9UERGfCnchBhGGcSaKiGAbzNrMLZ5HKylhBhFGce4VEeHBYNbyoYSWyuSd8mTxso5iG0xbzHurKuHPiseLKJfJ5chm2dtfKkNnF/uUqUelVqNQQFPJZEgm2dkOBohFEZHULpqGaVKtctvjR6XZ5Oyc/AlHx6TTJBLBALEtR1EpmVSv6LkolsXNNZUKpRKHByjKB0XzqPT7dDo0GlxeiFu+V8Zjul3abep1ikV0PRgg6uyiO29x2eVr39ZNoauYXi7a/G/02F9Q1sxfUl4B0Tm4khj4iNYAAAAASUVORK5CYII=" alt="" />一、摘要

Oracle硬解析和软解析是我们经常遇到的问题，所以需要考虑何时产生软解析何时产生硬解析，如何判断

1. SQL的执行过程

当发布一条SQL或PL/SQL命令时，Oracle会自动寻找该命令是否存在于共享池中来决定对当前的语句使用硬解析或软解析。

通常情况下，SQL语句的执行过程如下：

Step1. SQL代码的语法(语法的正确性)及语义检查(对象的存在性与权限)。

Step2. 将SQL代码的文本进行哈希得到哈希值。

Step3. 如果共享池中存在相同的哈希值，则对这个命令进一步判断是否进行软解析，否则到e步骤。

Step4. 对于存在相同哈希值的新命令行，其文本将与已存在的命令行的文本逐个进行比较。

这些比较包括大小写，字符串是否一致，空格，注释等，如果一致，则对其进行软解析，转到步骤Step6，无需再次硬解析。

否则到步骤Step5。

Step5. 硬解析，生成执行计划。

Step6. 执行SQL代码，返回结果。

2. Oracle对此sql将进行几个步骤的处理过程：

aaarticlea/png;base64,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" alt="" />

2.1 解析

Step1：检查共享池中是否有之前解析相同的SQL语句后所存储的SQL文本、解析树和执行计划。

如果能从共享池的缓存库中找到之前解析过生成的执行计划，则SQL语句则不需要再次解析，便可以直接由库缓存得到之前所产生的执行计划，从而直接跳到绑定或执行阶段，这种解析称作软解析。

但是如果在共享池的库缓存中找不到对应的执行计划，则必须继续解析SQL、生成执行计划，这种解析称作硬解析

Step2：语法分析，分析SQL语句的语法是否符合规范，衡量语句中各表达式的意义

Step3：检查是否存在语义错误和权限。语义分析，检查语句中设计的所有数据库对象是否存在，且用户有相应的权限。

Step4：视图转换和表达式转换将涉及视图的查询语句转换为相应的对基表查询语句。将复杂表达式转化较为简单的等效连接表达式。

Step5：决定最佳执行计划。优化器会生成多个执行计划，在按统计信息带入，找出执行成本最小的执行计划，作为执行此SQL语句的执行计划

Step6：将SQL文本、解析树、执行计划缓存到库缓存，存放地址以及SQL语句的哈希值。

2.2 绑定

如果SQL语句中使用了绑定变量，扫描绑定变量的声明，给绑定变量赋值。则此时将变量值带入执行计划。

2.3 执行

此阶段按照执行计划执行SQL，产生执行结果。不同类型的SQL语句，执行过程也不同。

(1). SELECT查询

检查所需的数据块是否已经在缓冲区缓存中，如果已经在缓冲区缓存中，直接读取器内容即可。

这种读取方式称为逻辑读取。如果所需数据不在缓冲区缓存中，则服务器进程需要先扫描数据块，读取相应数据块到缓冲区缓存，这种读取方式称为物理读。和逻辑读相比较，它更加耗费CPU和IO资源。

(2). 修改操作（INSERT、UPDATE、DELETE）

Step 1：检查所需的数据库是否已经被读取到缓冲区缓存中。如果已经存在缓冲区缓存，则执行Step 3

Step 2：若所需的数据库并不在缓冲区缓存中，则服务器将数据块从数据文件读取到缓冲区缓存中

Step 3：对想要修改的表取得的数据行锁定（Row Exclusive Lock），之后对所需要修改的数据行取得独占锁

Step 4：将撤销数据的Redo记录复制到日志缓冲区，产生数据行的撤销数据，将数据行修改的Redo记录复制到日志缓冲区，修改数据行。

Step 5: 产生数据修改的撤销数据

Step 6：复制数据修改的Redo记录到日志缓冲区

Step 7：修改数据行的内容，如果之前的缓冲为干净缓冲，则此时将变为脏缓冲。

2.4 提取

提取只有SELECT查询语句才有的步骤。获取查询的记录行，必要的时候对查询结果排序。

3. 简而言之

Step1. 语法检查(syntax check)

　　检查此sql的拼写是否语法。

Step2. 语义检查(semantic check)

　　诸如检查sql语句中的访问对象是否存在及该用户是否具备相应的权限。

Step3、对sql语句进行解析(parse)

　　利用内部算法对sql进行解析，生成解析树(parse tree)及执行计划(execution plan)。

Step4、执行sql，返回结果(execute and return)

4. 总结

其中，软、硬解析就发生在第三个过程里（对sql语句进行解析parse）。

　　Oracle利用内部的hash算法来取得该sql的hash值，然后在library cache里查找是否存在该hash值；

　　假设存在，则将此sql与cache中的进行比较；

　　假设“相同”，就将利用已有的解析树与执行计划，而省略了优化器的相关工作。这也就是软解析的过程。

　　诚然，如果上面的2个假设中任有一个不成立，那么优化器都将进行创建解析树、生成执行计划的动作。这个过程就叫硬解析。

　　创建解析树、生成执行计划对于sql的执行来说是开销昂贵的动作，所以，应当极力避免硬解析，尽量使用软解析。

1.下面的三个查询语句，不能使用相同的共享SQL区。尽管查询的表对象使用了大小写，但Oracle为其生成了不同的执行计划

select * from emp;

select * from Emp;

select * from EMP;

2.类似的情况，下面的查询中，尽管其where子句empno的值不同，Oracle同样为其生成了不同的执行计划

select * from emp where empno=7369

select * from emp where empno=7788

3.在判断是否使用硬解析时，所参照的对象及schema应该是相同的，如果对象相同，而schema不同，则需要使用硬解析,生成不同的执行计划

sys@ASMDB> select owner,table_name from dba_tables where table_name like 'TB_OBJ%';

        OWNER                          TABLE_NAME

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

        USR1                           TB_OBJ               --两个对象的名字相同，当所有者不同

        SCOTT                          TB_OBJ

usr1@ASMDB> select * from tb_obj;

scott@ASMDB> select * from tb_obj;      --此时两者都需要使用硬解析以及走不同的执行计划

硬解析即整个SQL语句的执行需要完完全全的解析，生成执行计划。而硬解析，生成执行计划需要耗用CPU资源，以及SGA资源。在此不得不提的是对库缓存中闩的使用。闩是锁的细化，可以理解为是一种轻量级的串行化设备。当进程申请到闩后，则这些闩用于保护共享内存的数在同一时刻不会被两个以上的进程修改。在硬解析时，需要申请闩的使用，而闩的数量在有限的情况下需要等待。大量的闩的使用由此造成需要使用闩的进程排队越频繁，性能则逾低下。

1. 下面对上面的两种情形进行演示

在两个不同的session中完成，一个为sys帐户的session，一个为scott账户的session，不同的session，其SQL命令行以不同的帐户名开头

如" sys@ASMDB> " 表示使用时sys帐户的session，" scott@ASMDB> "表示scott帐户的session

sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

NAME                      CLASS      VALUE

-------------------- ---------- ----------           --当前的硬解析值为569

parse count (hard)           64        569

scott@ASMDB> select * from emp;    

        sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

        NAME                      CLASS      VALUE

        -------------------- ---------- ----------           --执行上一个查询后硬解析值为570，解析次数增加了一次

        parse count (hard)           64        570

scott@ASMDB> select * from Emp;

        sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

        NAME                      CLASS      VALUE

        -------------------- ---------- ----------           --执行上一个查询后硬解析值为571

        parse count (hard)           64        571

scott@ASMDB> select * from EMP;

        sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

        NAME                      CLASS      VALUE

        -------------------- ---------- ----------           --执行上一个查询后硬解析值为572

        parse count (hard)           64        572   

scott@ASMDB> select * from emp where empno=7369;       

        sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

        NAME                      CLASS      VALUE

        -------------------- ---------- ----------           --执行上一个查询后硬解析值为573

        parse count (hard)           64        573

scott@ASMDB> select * from emp where empno=7788;   --此处原来empno=7369，复制错误所致，现已更正为7788@20130905   

        sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

        NAME                      CLASS      VALUE

        -------------------- ---------- ----------          --执行上一个查询后硬解析值为574

        parse count (hard)           64        574

从上面的示例中可以看出，尽管执行的语句存在细微的差别，但Oracle还是为其进行了硬解析，生成了不同的执行计划。即便是同样的SQL语句，而两条语句中空格的多少不一样，Oracle同样会进行硬解析。

1. 更改参数cursor_sharing

参数cursor_sharing决定了何种类型的SQL能够使用相同的SQL area

CURSOR_SHARING = { SIMILAR | EXACT | FORCE }

EXACT --只有当发布的SQL语句与缓存中的语句完全相同时才用已有的执行计划。

FORCE --如果SQL语句是字面量，则迫使Optimizer始终使用已有的执行计划,无论已有的执行计划是不是最佳的。

SIMILAR --如果SQL语句是字面量，则只有当已有的执行计划是最佳时才使用它，如果已有执行计划不是最佳则重新对这个SQL

--语句进行分析来制定最佳执行计划。

可以基于不同的级别来设定该参数，如ALTER SESSION, ALTER SYSTEM

sys@ASMDB> show parameter cursor_shar             --查看参数cursor_sharing

            NAME                                 TYPE        VALUE

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

            cursor_sharing                       string      EXACT

sys@ASMDB> alter system set cursor_sharing='similar';    --将参数cursor_sharing的值更改为similar

sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

            NAME                      CLASS      VALUE

            -------------------- ---------- ----------        --当前硬解析的值为865

            parse count (hard)           64        865

scott@ASMDB> select * from dept where deptno=10;

sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

            NAME                      CLASS      VALUE

            -------------------- ---------- ----------        --执行上一条SQL查询后，硬解析的值变为866

            parse count (hard)           64        866

scott@ASMDB> select * from dept where deptno=20;

sys@ASMDB> select name,class,value from v$sysstat where statistic#=331;

            NAME                      CLASS      VALUE

            -------------------- ---------- ----------        --执行上一条SQL查询后，硬解析的值没有发生变化还是866

            parse count (hard)           64        866

sys@ASMDB> select sql_text,child_number from v$sql   -- 在下面的结果中可以看到SQL_TEXT列中使用了绑定变量:"SYS_B_0"

         2  where sql_text like 'select * from dept where deptno%';

            SQL_TEXT                                           CHILD_NUMBE

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

            select * from dept where deptno=:"SYS_B_0"                    0

sys@ASMDB> alter system set cursor_sharing='exact';       --将cursor_sharing改回为exact

            --接下来在scott的session 中执行deptno=40 和的查询后再查看sql_text，当cursor_sharing改为exact后，每执行那个一次

            --也会在v$sql中增加一条语句

sys@ASMDB> select sql_text,child_number from v$sql

         2  where sql_text like 'select * from dept where deptno%';

            SQL_TEXT                                           CHILD_NUMBER

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

            select * from dept where deptno=50                            0      

            select * from dept where deptno=40                            0

            select * from dept where deptno=:"SYS_B_0"                    0

2. 使用绑定变量的方式

绑定变量要求变量名称，数据类型以及长度是一致，否则无法使用软解析

(1). 绑定变量（bind variable）是指在DML语句中使用一个占位符，即使用冒号后面紧跟变量名的形式，如下

select * from emp where empno=7788 --未使用绑定变量

select * from emp where empono=:eno --:eno即为绑定变量

在第二个查询中，变量值在查询执行时被提供。该查询只编译一次，随后会把查询计划存储在一个共享池（库缓存）中，以便以后获取和重用这个查询计划。

(2). 下面使用了绑定变量，但两个变量其实质是不相同的，对这种情形，同样使用硬解析

select * from emp where empno=:eno;

select * from emp where empno=:emp_no

使用绑定变量时要求不同的会话中使用了相同的回话环境，以及优化器的规则等

scott@ASMDB> create table tb_test(col int);     --创建表tb_test

scott@ASMDB> create or replace procedure proc1  --创建存储过程proc1使用绑定变量来插入新记录

          2  as

          3  begin

          4      for i in 1..10000

          5      loop

          6          execute immediate 'insert into tb_test values(:n)' using i;

          7      end loop;

          8  end;

          9  /

Procedure created.

scott@ASMDB> create or replace procedure proc2 --创建存储过程proc2，未使用绑定变量，因此每一个SQL插入语句都会硬解析

          2  as

          3  begin

          4      for i in 1..10000

          5      loop

          6          execute immediate 'insert into tb_test values('||i||')';

          7      end loop;

          8  end;

          9  /

Procedure created.

scott@ASMDB> exec runstats_pkg.rs_start

PL/SQL procedure successfully completed.

scott@ASMDB> exec proc1;

PL/SQL procedure successfully completed.

scott@ASMDB> exec runstats_pkg.rs_middle;

PL/SQL procedure successfully completed.

scott@ASMDB> exec proc2;

PL/SQL procedure successfully completed.

scott@ASMDB> exec runstats_pkg.rs_stop(1000);

            Run1 ran in 1769 hsecs

            Run2 ran in 12243 hsecs             --run2运行的时间是run1的/1769≈倍

            run 1 ran in 14.45% of the time   

            Name                                Run1      Run2      Diff

            LATCH.SQL memory manager worka       410     2,694     2,284

            LATCH.session allocation             532     8,912     8,380

            LATCH.simulator lru latch             33     9,371     9,338

            LATCH.simulator hash latch            51     9,398     9,347

            STAT...enqueue requests               31    10,030     9,999

            STAT...enqueue releases               29    10,030    10,001

            STAT...parse count (hard)              4    10,011    10,007    --硬解析的次数，前者只有四次

            STAT...calls to get snapshot s        55    10,087    10,032

            STAT...parse count (total)            33    10,067    10,034

            STAT...consistent gets               247    10,353    10,106

            STAT...consistent gets from ca       247    10,353    10,106

            STAT...recursive calls            10,474    20,885    10,411

            STAT...db block gets from cach    10,408    30,371    19,963

            STAT...db block gets              10,408    30,371    19,963

            LATCH.enqueues                       322    21,820    21,498    --闩的队列数比较

            LATCH.enqueue hash chains            351    21,904    21,553

            STAT...session logical reads      10,655    40,724    30,069

            LATCH.library cache pin           40,348    72,410    32,062    --库缓存pin

            LATCH.kks stats                        8    40,061    40,053

            LATCH.library cache lock             318    61,294    60,976

            LATCH.cache buffers chains        51,851   118,340    66,489

            LATCH.row cache objects              351   123,512   123,161

            LATCH.library cache               40,710   234,653   193,943

            LATCH.shared pool                 20,357   243,376   223,019

            Run1 latches total versus runs -- difference and pct

            Run1      Run2      Diff     Pct

            157,159   974,086   816,927  16.13%          --proc2使用闩的数量也远远多于proc1，其比值是.13%  

PL/SQL procedure successfully completed.

(3). 使用绑定变量的好处

由上面的示例可知，在未使用绑定变量的情形下，不论是解析次数，闩使用的数量，队列，分配的内存，库缓存，行缓存远远高于绑定
变量的情况。因此尽可能的使用绑定变量避免硬解析产生所需的额外的系统资源。
绑定变量的优点
减少SQL语句的硬解析，从而减少因硬解析产生的额外开销(CPU,Shared pool,latch)。其次提高编程效率，减少数据库的访问次数。
绑定变量的缺点
优化器就会忽略直方图的信息，在生成执行计划的时候可能不够优化。SQL优化相对比较困难

1.尽可能的避免硬解析，因为硬解析需要更多的CPU资源，闩等。

2.cursor_sharing参数应权衡利弊，需要考虑使用similar与force带来的影响。

3.尽可能的使用绑定变量来避免硬解析。

Thanks and Regards

参考：乐沙弥大神 http://blog.csdn.net/leshami/article/details/6195483

参考：乐沙弥大神 http://10.61.208.50:15871/cgi-bin/blockpage.cgi?ws-session=18446744072512592920

参考：乐沙弥大神 http://czmmiao.iteye.com/category/143940

参考：潇湘隐者 http://www.cnblogs.com/kerrycode/p/3356845.html

aaarticlea/png;base64,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" alt="" />

秒客网

PLSQL_解析过程及硬解析和软解析的区别（案例）

相关文章