精华内容
下载资源
问答
  • 主要介绍了php动态绑定变量的用法,涉及php变量的判定与动态定义的相关技巧,需要的朋友可以参考下
  • labview创建和绑定变量共享io变量编程示例程序源码 This VI programmatically discovers all I/O variables being published by the CompactRIO controller specified below. Shared variables are created and ...
  • 动态SQL与绑定变量

    2013-04-24 20:39:22
    动态SQL与绑定变量 动态SQL与绑定变量
  • sql自动绑定变量

    2018-07-01 08:51:54
    注意如何查询sql自动绑定变量,执行以上sql分析执行情况
  • Oracle 绑定变量详解

    千次阅读 2018-06-19 11:50:03
    之前整理过一篇有关绑定变量的文章,不太详细,重新补充一下。 Oracle 绑定变量 http://www.cndba.cn/Dave/article/1275 一.绑定变量 bind variable: A variable in a SQL statement that must be ...
    

    之前整理过一篇有关绑定变量的文章,不太详细,重新补充一下。

             Oracle 绑定变量

             http://www.cndba.cn/Dave/article/1275

     

     

    一.绑定变量

             bind variable A variable in a SQL statement that must be replaced with a valid value, or the address of a value, in order for the statement to successfully execute.

     

    变量绑定是OLTP系统中一个非常值得关注的技术。良好的变量绑定会使OLTP系统数据库中的SQL 执行速度飞快,内存效率极高;不使用绑定变量可能会使OLTP 数据库不堪重负,资源被SQL解析严重耗尽,系统运行缓慢。

     

             当一个用户与数据库建立连接后,会向数据库发出操作请求,即向数据库送过去SQL语句。 Oracle 在接收到这些SQL后,会先对这个SQL做一个hash 函数运算,得到一个Hash值,然后到共享池中寻找是否有和这个hash 值匹配的SQL存在。 如果找到了,Oracle将直接使用已经存在的SQL 的执行计划去执行当前的SQL,然后将结果返回给用户。 如果在共享池中没有找到相同Hash 值的SQLoracle 会认为这是一条新的SQL 会进行解析。

     

     

    Oracle 解析的步骤如下:

    (1)       语法解析

    (2)       语义解析

    (3)       生成执行计划,这里分软解析和硬解析。硬解析是非常耗资源的。

    (4)       SQL的执行

     

    关于SQL的解析,详见Blog

             Oracle SQL的硬解析和软解析

             http://www.cndba.cn/Dave/article/1185

     

    了解了SQL 的执行过程,在来看一些绑定变量,绑定变量的本质就是本来需要做Oracle 硬解析的SQL 变成软解析,以减少ORACLE 花费在SQL解析上的时间和资源。

     

    加入有两条SQL:    

             Select salary from user where name=’A’;

             Select salary from user where name=’B’;

     

    如果没有用绑定变量,那么这2SQL 会被解析2次,因为他们的谓词部分不一样。 如果我们用了绑定变量,如:

             Select salary from user where name=:X;

     

    这时,之前的2SQL就变成了一种SQL Oracle 只需要对每一种SQL做一次硬解析,之后类似的SQL 都使用这条SQL产生的执行计划,这样就可以大大降低数据库花费在SQL解析上的资源开销。 这种效果当SQL执行的越多,就越明显。

     

             简单的说,绑定变量就是拿一个变量来代替谓词常量,让Oracle每次对用户发来的SQLhash 运算时,运算出的结果都是同样的Hash值,于是将所有的用户发来的SQL看作是同一个SQL来对象。

     

     

    二. OLAP OLTP 系统中的绑定变量

             OLAP OLTP 系统是有很大差异的。 他们之间的区别,详细参考Blog

             Oracle OLAP OLTP 介绍

             http://www.cndba.cn/Dave/article/1462

     

    OLTP系统中,我们可以使用绑定变量是因为在OLTP中,SQL语句大多是比较简单或者操作的结果集都很小。当一个表上创建了索引,那么这种极小结果集的操作使用索引最合适,并且几乎所有的SQL的执行计划的索引都会被选择,因为这种情况下,索引可能只需要扫描几个数据块就可以定位到数据,而全表扫描将会相当耗资源。 因此,这种情况下,即使每个用户的谓词条件不一样,执行计划也是一样的,就是都用索引来访问数据,基本不会出现全表扫描的情况。 在这种执行计划几乎唯一的情况下,使用绑定变量来代替谓词常量,是合适的。

     

    OLAP系统中,SQL的操作就复杂很多,OLAP数据库上大多数时候运行的一些报表SQL,这些SQL经常会用到聚合查询(如:group by),而且结果集也是非常庞大,在这种情况下,索引并不是必然的选择,甚至有时候全表扫描的性能会更优于索引,即使相同的SQL,如果谓词不同,执行计划都可能不同。

     

     

    对于OLAP系统中的绑定变量,有以下原则:

    (1)       OLAP 系统完全没有必要绑定变量,那样只会带来负面的影响,比如导致SQL选择错误的执行,这个代价有时是灾难性的;Oracle对每条SQL做硬分析,确切的知道谓词条件的值,这对执行计划的选择至关重要,这样做的原因是,在OLAP系统中,SQL硬分析的代价是可以忽略的,系统的资源基本上是用于做大的SQL查询,和查询比起来,SQL解析消耗的资源显得微不足道。所以得到一个最优的执行计划就非常重要。

    (2)       OLAP系统中,让Oracle确切地知道谓词的数值至关重要,它直接决定了SQL执行计划的选择,这样做的方式就是不要绑定变量。

    (3)       OLAP系统中,表,索引的分析显得直观重要,因为它是Oracle SQL做出正确的执行计划的信息的来源和依据,所以需要建立一套能够满足系统需求的对象分析的执行Job

     

     

    三.Bind peaking

            

    先看一段官网的说明:

             The query optimizer peeks at the values of user-defined bind variables on the first invocation of a cursor. This feature enables the optimizer to determine the selectivity of any WHERE clause condition as if literals have been used instead of bind variables.

    To ensure the optimal choice of cursor for a given bind value, Oracle Database uses bind-aware cursor matching. The system monitors the data access performed by the query over time, depending on the bind values. If bind peeking takes place, and if the database uses a histogram to compute selectivity of the predicate containing the bind variable, then the database marks the cursor as bind-sensitive.

    Whenever the database determines that a cursor produces significantly different data access patterns depending on the bind values, the database marks this cursor as bind-aware. Oracle Database switches to bind-aware cursor matching to select the cursor for this statement. When bind-aware cursor matching is enabled, the database selects plans based on the bind value and the optimizer estimate of its selectivity. With bind-aware cursor matching, a SQL statement with user-defined bind variable can have multiple execution plans, depending on the bind values.

    When bind variables appear in a SQL statement, the database assumes that cursor sharing is intended and that different invocations use the same execution plan. If different invocations of the cursor significantly benefit from different execution plans, then bind-aware cursor matching is required. Bind peeking does not work for all clients, but a specific set of clients.

     

    Fromhttp://download.oracle.com/docs/cd/E11882_01/server.112/e10821/optimops.htm#PFGRF94588

     

    Bind PeekingOracle 9i中引入的新特性,它的作用就是在SQL语句硬分析的时候,查看一下当前SQL谓词的值,以便生成最佳的执行计划。 而在oracle 9i之前的版本中,Oracle 只根据统计信息来做出执行计划。

     

    要注意的是,Bind Peeking只发生在硬分析的时候,即SQL被第一次执行的时候,之后的变量将不会在做peeking我们可以看出,Bind peeking并不能最终解决不同谓词导致选择不同执行计划的问题,它只能让SQL第一次执行的时候,执行计划选择更加准确,并不能帮助OLAP系统解决绑定变量导致执行计划选择错误的问题。这也是OLAP不应该使用绑定变量的一个原因。

     

     

     

    总结:

             对于OLTP系统,相同的SQL重复频率非常高,如果优化器反复解析SQL,必然会极大的消耗系统资源,另外,OLTP系统用户请求的结果集都非常小,所以基本上都考虑使用索引。 Bind Peeking 在第一次获得了一个正确的执行计划之后,后续的所有SQL都按照这个执行计划来执行,这样就极大的改善了系统的性能。

     

             对于OLAP系统,SQL执行计划和谓词关系极大,谓词值不同,可能执行计划就不同,如果采用相同的执行计划,SQL的执行效率必然很低。另外,一个OLAP系统数据库每天执行的SQL数量远远比OLTP少,并且SQL重复频率也远远低于OLTP系统,在这种条件下,SQL解析花费的代价和SQL执行花费的代价相比,解析的代价可以完全忽略。

     

    所以,对于OLAP系统,不需要绑定变量,如果使用可能导致执行计划选择错误。 并且,如果用了绑定变量,Bind Peeking也只能保证第一条硬分析SQL能正确的选择执行计划,如果后面的谓词改变,很可能还是会选择错误的执行计划。 因此在OLAP系统中,不建议使用绑定变量。

     

     

     

     

     

    整理自《让Oracle 跑的更快》

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

    QQ: 492913789
    Email: ahdba@qq.com
    Blog: http://www.cndba.cn/dave

    网上资源: http://tianlesoftware.download.csdn.net

    相关视频:http://blog.csdn.net/tianlesoftware/archive/2009/11/27/4886500.aspx

    DBA1 群:62697716(); DBA2 群:62697977()

    DBA3 群:63306533;     聊天 群:40132017

    展开全文
  • oracle 的绑定变量

    2020-12-14 20:22:29
    绑定变量  变量绑定是OLTP系统中一个非常值得关注的技术。良好的变量绑定会使OLTP系统数据库中的SQL 执行速度飞快,内存效率极高;不使用绑定变量可能会使OLTP 数据库不堪重负,资源被SQL解析严重耗尽,系统运行...
  • Java中Oracle操作绑定变量使用用户工具模块解决方案
  • 二 不使用绑定变量 VS 使用绑定变量 1 不使用绑定变量 1)创建表并测试 SQL> set timing on SQL> create table t1(id int); Table created. Elapsed: 00:00:01.18 SQL> begin 2 for i in 1 .. 100000 3 loop 4 ...

    一 硬解析和软解析

    说到软解析 (soft prase) 和硬解析 (hard prase) ,就不能不说一下 Oracle sql 的处理过程。当你发出一条 sql 语句交付 Oracle ,在执行和获取结果前, Oracle 对此 sql 将进行几个步骤的处理过程:
    1 )语法检查 (syntax check)
    检查此 sql 的拼写是否语法。
    2 )语义检查 (semantic check)
    诸如检查 sql 语句中的访问对象是否存在及该用户是否具备相应的权限。
    3 )对 sql 语句进行解析 (prase)
    利用内部算法对 sql 进行解析,生成解析树 (parse tree) 及执行计划 (execution plan)
    4 )执行 sql ,返回结果 (execute and return)

    其中,软、硬解析就发生在第三个过程里:
    Oracle 利用内部的 hash 算法来取得该 sql hash 值,然后在 library cache 里查找是否存在该 hash 值;
    假设存在,则将此 sql cache 中的进行比较;
    假设 " 相同 " ,就将利用已有的解析树与执行计划,而省略了优化器的相关工作。这也就是软解析的过程。
    诚然,如果上面的 2 个假设中任有一个不成立,那么优化器都将进行创建解析树、生成执行计划的动作。这个过程就叫硬解析。
    创建解析树、生成执行计划对于 sql 的执行来说是开销昂贵的动作,所以,应当极力避免硬解析,尽量使用软解析。
    这就是在很多项目中,倡导开发设计人员对功能相同的代码要努力保持代码的一致性,以及要在程序中多使用绑定变量的原因。

    二 不使用绑定变量 VS 使用绑定变量

    1 不使用绑定变量

    1)创建表并测试
    SQL> set timing on
    SQL> create table t1(id int);
    
    Table created.
    
    Elapsed: 00:00:01.18
    SQL> begin
      2    for i in 1 .. 100000
      3   loop
      4     execute immediate 'insert into t1 values('||i||')';
      5    end loop;
      6    commit;
      7  end;
      8  /
    
    PL/SQL procedure successfully completed.
    
    Elapsed: 00:01:34.06
    2)查看硬解析次数以及执行次数
    SQL> set linesize 200
    SQL> col sql_text for a40
    SQL> col sql_id for a15
    SQL> select sql_text,sql_id,executions,parse_calls from v$sql
      2  where sql_text like 'insert into t1 values%'
      3  and rownum <= 10;
    
    SQL_TEXT				 SQL_ID 	 EXECUTIONS PARSE_CALLS
    ---------------------------------------- --------------- ---------- -----------
    insert into t1 values(99739)		 4hwu069b7w058		  1	      1
    insert into t1 values(99795)		 c3wc2p1y440n6		  1	      1
    insert into t1 values(99600)		 ggxrmk462s138		  1	      1
    insert into t1 values(99610)		 8m3jrkgshh1bj		  1	      1
    insert into t1 values(99857)		 a8wn2bw9cw1ck		  1	      1
    insert into t1 values(99809)		 87uzu2cggw1hq		  1	      1
    insert into t1 values(99714)		 bddx0bx62n1qz		  1	      1
    insert into t1 values(99559)		 cbgyw5tudc1yq		  1	      1
    insert into t1 values(99745)		 2xngw3w9b829n		  1	      1
    insert into t1 values(99826)		 7s29ajyy3h2nh		  1	      1
    
    10 rows selected.
    
    Elapsed: 00:00:00.01
    SQL> select count(*) from v$sql
      2  where sql_text like 'insert into t1 values%';
    
      COUNT(*)
    ----------
           461
    
    Elapsed: 00:00:00.15
    SQL> 
    思考:为何只有461次?
    shared_pool大小有限,无法保存每条解析过的sql,会通过LRU算法踢出冷块。

    2 使用绑定变量

    1)清空缓存,测试
    SQL> alter system flush shared_pool;     
    
    System altered.
    
    Elapsed: 00:00:00.07
    SQL> alter system flush buffer_cache;
    
    System altered.
    
    Elapsed: 00:00:00.46
    SQL> begin
      2      for i in 1 .. 100000
      3      loop
      4        execute immediate 'insert into t1 values (:X)' using i;
      5      end loop;
      6      commit;
      7  end;
      8  /
    
    PL/SQL procedure successfully completed.
    
    Elapsed: 00:00:12.06
    2)查看硬解析次数以及执行次数
    SQL> select sql_text,sql_id,executions,parse_calls from v$sql
      2  where sql_text like 'insert into t1 values%';
    
    SQL_TEXT				 SQL_ID 	 EXECUTIONS PARSE_CALLS
    ---------------------------------------- --------------- ---------- -----------
    insert into t1 values (:X)		 d1f3fv8rt9j8t	     100000	      1
    
    Elapsed: 00:00:00.11
    

    展开全文
  • 实现动态SQL有两种方式:DBMS_SQL和本地动态SQL(EXECUTE IMMEIDATE) 。oracle从8代开始就提供了新的执行...本地动态SQLEXECUTE IMMEDIATE ‘语句’[INTO {变量1, 变量2, … 变量N | 记录体}][USING [IN | OUT | I...

    实现动态SQL有两种方式:DBMS_SQL和本地动态SQL(EXECUTE IMMEIDATE) 。

    oracle从8代开始就提供了新的执行动态sql的功能:execute immeidate v_sql using *** into ***;

    本地动态SQL

    EXECUTE IMMEDIATE ‘语句’

    [INTO {变量1, 变量2, … 变量N | 记录体}]

    [USING [IN | OUT | IN OUT] 绑定变量1, … 绑定变量N]

    [{RETURNING | RETURN} INTO 输出1 [, …, 输出N]…];

    注意本地动态SQL仅支持弱类型REF CURSOR,即对于REF CURSOR,不支持BULK COLLECT.

    动态SQL的使用:1、执行dml语句,在pl/sql中不能直接执行dml语句;2、执行的语句是在程序执行前不可估计的,就比如在运行时该sql才会被按照不同的条件进行拼接等。

    该方法引用动态SQL的最大缺憾就是返回的结果集最多只能有一行,即使是ref cursor也只能包含一行的结果集。但是可以使用临时表的方法,把结果集存储起来,动态SQL执行完毕后再取数据就可以了。也就是说,这个动态SQL可以是一个块,里面的语句可以足够复杂,只要写作者认为自己有能力调试。

    说到调试,也是动态SQL的一个很大的缺憾吧,在pl/sql中,一个varchar2的长度超过一定的大小后就自动转化为 long value,无法打印,无法查看,至少对于目前的我的能力,还没有找到方法,即使使用substr的方法来分解串再打印的方法都会失败。

    绑定变量:动态SQL的形成一般使用的拼串和榜定变量两种方法,而普遍认为绑定变量有利于提高效率,其效率甚至与拼串的方式不可同日而语,这是可以理解的,绑定变量的使用,可以在多次执行sql时只使用一次语句分析、优化,而拼接则被认为是每次执行的sql都是不同的,每次执行都需要重新分析、优化,这往往是sql执行中最费时的操作。

    动态sql高深莫测,如同指针一样,但为什么要使用那么晦涩的语法呢,除非不得已。

    本文转自

    http://hi.baidu.com/programcg/blog/item/7def5f02c3bcd20a4bfb515c.html

    展开全文
  • oracle绑定变量使用方法总结

    万次阅读 2018-06-20 16:30:57
    转自:https://blog.csdn.net/gumengkai/article/details/53130449在Oracle中,对于一个提交的sql语句,存在两种可选的解析过程,硬解析和软解析。...唯一使得oracle能够重复利用执行计划的方法就是采用绑定变量。绑...

    转自:https://blog.csdn.net/gumengkai/article/details/53130449

    在Oracle中,对于一个提交的sql语句,存在两种可选的解析过程,硬解析和软解析。

    一个硬解析需要经解析,制定执行路径,优化访问计划等步骤。硬解析不仅仅会耗费大量的cpu,更重要的是会占据重要的闩(latch)资源。唯一使得oracle能够重复利用执行计划的方法就是采用绑定变量。绑定变量的实质就是使用变量来代替sql语句中的常量。绑定变量能够使得每次提交的sql语句都完全一样。


    1. sqlplus中使用variable来定义

    [sql]  view plain  copy
    1. SQL> select * from t where id=1;  
    2.   
    3.         ID NAME  
    4. ---------- --------------------------------  
    5.          1 test  
    6.   
    7. SQL> select * from t where id=2;  
    8.   
    9.         ID NAME  
    10. ---------- --------------------------------  
    11.          2 test2  
    12.   
    13. SQL> variable i number;  
    14. SQL> exec :i :=1;  
    15.   
    16. PL/SQL procedure successfully completed.  
    17.   
    18. SQL> select * from t where id=:i;  
    19.   
    20.         ID NAME  
    21. ---------- --------------------------------  
    22.          1 test  
    23.   
    24. SQL> exec :i :=2;  
    25.   
    26. PL/SQL procedure successfully completed.  
    27.   
    28. SQL> select * from t where id=:i;  
    29.   
    30.         ID NAME  
    31. ---------- --------------------------------  
    32.          2 test2  
    33. SQL> select sql_text,parse_calls from v$sql where sql_text like 'select * from t where id=%';  
    34.   
    35. SQL_TEXT  
    36. --------------------------------------------------------------------------------  
    37. PARSE_CALLS  
    38. -----------  
    39. select * from t where id=2  
    40.           1  
    41.   
    42. select * from t where id=1  
    43.           1  
    44.   
    45. select * from t where id=:i  --可以看到这条sql被调用了两次,这两次的使用就包括了一次soft parse  

    2.  (误区)sqlplus中通过define定义的并不是变量,而只是字符常量,define定义之后,再通过&或&&引用的时候就不需要再输入了,oracle在执行的时候回自动用定义的值进行替换,仅此而已,并不是绑定变量。

    [sql]  view plain  copy
    1. SQL> define a=1  
    2. SQL> define  
    3. DEFINE _DATE           = "30-OCT-16" (CHAR)  
    4. DEFINE _CONNECT_IDENTIFIER = "ORCL" (CHAR)  
    5. DEFINE _USER           = "SYS" (CHAR)  
    6. DEFINE _PRIVILEGE      = "AS SYSDBA" (CHAR)  
    7. DEFINE _SQLPLUS_RELEASE = "1102000400" (CHAR)  
    8. DEFINE _EDITOR         = "ed" (CHAR)  
    9. DEFINE _O_VERSION      = "Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production  
    10. With the Partitioning, OLAP, Data Mining and Real Application Testing options" (CHAR)  
    11. DEFINE _O_RELEASE      = "1102000400" (CHAR)  
    12. DEFINE A               = "1" (CHAR)  
    13. SQL> select * from t where id=&a;  
    14. old   1: select * from t where id=&a  
    15. new   1: select * from t where id=1  
    16.   
    17.         ID NAME  
    18. ---------- --------------------------------  
    19.          1 test  

    &&和&一样的功能,不过&&替代过一次之后就不需要再输入了,可以多次替代。

    [sql]  view plain  copy
    1. SQL> select * from t where id=&b;  
    2. Enter value for b: 2  
    3. old   1: select * from t where id=&b  
    4. new   1: select * from t where id=2  
    5.   
    6.         ID NAME  
    7. ---------- --------------------------------  
    8.          2 test2  
    9.   
    10. SQL> select * from t where id=&b;   
    11. Enter value for b: 2  
    12. old   1: select * from t where id=&b  
    13. new   1: select * from t where id=2  
    14.   
    15.         ID NAME  
    16. ---------- --------------------------------  
    17.          2 test2  
    18.   
    19. SQL> select * from t where id=&&b;  
    20. Enter value for b: 2  
    21. old   1: select * from t where id=&&b  
    22. new   1: select * from t where id=2  
    23.   
    24.         ID NAME  
    25. ---------- --------------------------------  
    26.          2 test2  
    27.   
    28. SQL> select * from t where id=&&b;  
    29. old   1: select * from t where id=&&b  
    30. new   1: select * from t where id=2  
    31.   
    32.         ID NAME  
    33. ---------- --------------------------------  
    34.          2 test2  

    另外,如果define定义的是字符类型,在引用时需要加上单引号

    [sql]  view plain  copy
    1. SQL> select * from t where name=&c;  
    2. old   1: select * from t where name=&c  
    3. new   1: select * from t where name=test  
    4. select * from t where name=test  
    5.                            *  
    6. ERROR at line 1:  
    7. ORA-00904: "TEST": invalid identifier  
    8.   
    9.   
    10. SQL> select * from t where name='&c';  
    11. old   1: select * from t where name='&c'  
    12. new   1: select * from t where name='test'  
    13.   
    14.         ID NAME  
    15. ---------- --------------------------------  
    16.          1 test  
    可以看到,在执行sql的时候oracle自动进行了替换

    [sql]  view plain  copy
    1. SQL> select sql_text from v$sql where sql_text like 'select * from t where name=%';  
    2.   
    3. SQL_TEXT  
    4. --------------------------------------------------------------------------------  
    5. select * from t where name='test'  

    3. oracle在解析sql时会把plsql中定义的变量转为绑定变量

    [sql]  view plain  copy
    1. SQL> create table tt(id int,name varchar2(10));  
    2.   
    3. Table created.  
    4.   
    5. SQL> alter session set sql_trace=true;  
    6.   
    7. Session altered.  
    8.   
    9. SQL> declare  
    10.   2  begin  
    11.   3  for i in 1 .. 100 loop  
    12.   4  insert into tt values(i,'test');  
    13.   5  end loop;  
    14.   6  commit;  
    15.   7  end;  
    16.   8  /  
    17.   
    18. PL/SQL procedure successfully completed.  
    19.   
    20. SQL> alter session set sql_trace=false;  
    21.   
    22. Session altered.  


    trace文件内容:

    [sql]  view plain  copy
    1. *** 2016-10-30 12:11:22.815  
    2. CLOSE #140170997623912:c=0,e=6,dep=0,type=0,tim=1477800682815427  
    3. =====================  
    4. PARSING IN CURSOR #140170997623912 len=92 dep=0 uid=0 oct=47 lid=0 tim=1477800682817922 hv=218581220 ad='8c89d9b0' sqlid='6pdgqjs6hfk74'  
    5. declare  
    6. begin  
    7. for i in 1 .. 100 loop  
    8. insert into tt values(i,'test');  
    9. end loop;  
    10. commit;  
    11. end;  
    12. END OF STMT  
    13. PARSE #140170997623912:c=1999,e=2431,p=0,cr=0,cu=0,mis=1,r=0,dep=0,og=1,plh=0,tim=1477800682817921  
    14. =====================  
    15. PARSING IN CURSOR #140170996439488 len=34 dep=1 uid=0 oct=2 lid=0 tim=1477800682818383 hv=1299226876 ad='86bc23a8' sqlid='9j06ydd6r187w'  
    16. INSERT INTO TT VALUES(:B1 ,'test')  
    17. END OF STMT  

    从硬解析的增长也可以看出:

    [sql]  view plain  copy
    1. SQL> select a.*,b.name   
    2.   
    3.   2   from v$sesstat a , v$statname b  
    4.   3   where a.statistic#=b.statistic#  
    5.   4   and a.sid=(select distinct sid from v$mystat)  
    6.   5   and b.name like '%parse%';  
    7.   
    8. SQL> col name format a30  
    9. SQL> /  
    10.   
    11.        SID STATISTIC#      VALUE NAME  
    12. ---------- ---------- ---------- ------------------------------  
    13.         29        264          0 ADG parselock X get attempts  
    14.         29        265          0 ADG parselock X get successes  
    15.         29        622          4 parse time cpu  
    16.         29        623          8 parse time elapsed  
    17.         29        624        238 parse count (total)  
    18.         29        625        155 parse count (hard)  
    19.         29        626          0 parse count (failures)  
    20.         29        627          0 parse count (describe)  
    21.   
    22. rows selected.  

    执行前的硬解析数为155

    [sql]  view plain  copy
    1. SQL> declare  
    2.   2  begin  
    3.   3  for i in 1 .. 100 loop  
    4.   4  insert into tt values(i,'test');  
    5.   5  end loop;  
    6.   6  commit;  
    7.   7  end;  
    8.   8  /  
    9.   
    10. PL/SQL procedure successfully completed.  
    11.   
    12. SQL> select a.*,b.name  
    13.   2   from v$sesstat a , v$statname b  
    14.   3   where a.statistic#=b.statistic#  
    15.   4   and a.sid=(select distinct sid from v$mystat)  
    16.   5   and b.name like '%parse%';  
    17.   
    18.        SID STATISTIC#      VALUE NAME  
    19. ---------- ---------- ---------- ------------------------------  
    20.         29        264          0 ADG parselock X get attempts  
    21.         29        265          0 ADG parselock X get successes  
    22.         29        622          4 parse time cpu  
    23.         29        623          8 parse time elapsed  
    24.         29        624        242 parse count (total)  
    25.         29        625        157 parse count (hard)  
    26.         29        626          0 parse count (failures)  
    27.         29        627          0 parse count (describe)  
    28.   
    29. rows selected.  

    执行后的为157,只增长了两个,如果不是使用了绑定变量,硬解析数绝对不止两个

    4. 存储过程中的参数会自动转化为绑定变量

    [sql]  view plain  copy
    1. SQL> create or replace procedure proc_test(p_id int,p_name varchar2)  
    2.   2  is  
    3.   3  begin  
    4.   4  insert into tt values(p_id,p_name);  
    5.   5  commit;  
    6.   6  end;  
    7.   7  /  
    8.   
    9. Procedure created.  
    10.   
    11. SQL> alter session set sql_trace=true;  
    12.   
    13. Session altered.  
    14.   
    15. SQL> exec proc_test(200,'test');  
    16.   
    17. PL/SQL procedure successfully completed.  
    18.   
    19. SQL> alter session set sql_trace=false;  
    20.   
    21. Session altered.  

    trace文件内容:

    [sql]  view plain  copy
    1. *** 2016-10-31 04:11:23.421  
    2. CLOSE #140585231805712:c=0,e=6,dep=0,type=0,tim=1477858283421964  
    3. =====================  
    4. PARSING IN CURSOR #140585231805712 len=35 dep=0 uid=0 oct=47 lid=0 tim=1477858283423073 hv=526484776 ad='86b57878' sqlid='asc6yd8gq3198'  
    5. BEGIN proc_test(200,'test'); END;  
    6. END OF STMT  
    7. PARSE #140585231805712:c=999,e=1047,p=0,cr=0,cu=0,mis=1,r=0,dep=0,og=1,plh=0,tim=1477858283423072  
    8. =====================  
    9. PARSING IN CURSOR #140585233135112 len=32 dep=1 uid=0 oct=2 lid=0 tim=1477858283423304 hv=1422618771 ad='8697d9b8' sqlid='1yqc845acqw4m'  
    10. INSERT INTO TT VALUES(:B2 ,:B1 )  
    11. END OF STMT  
    12. PARSE #140585233135112:c=0,e=100,p=0,cr=0,cu=0,mis=1,r=0,dep=1,og=1,plh=0,tim=1477858283423304  
    其实从存储过程的调用过程也可以看出是使用了绑定变量

    [sql]  view plain  copy
    1. begin  
    2. -- Call the procedure  
    3. proc_test(p_id => :p_id,  
    4. p_name => :p_name);  
    5. end;  

    5. 动态sql中使用绑定变量

    a. 直接使用游标中的值拼接

    [sql]  view plain  copy
    1. [oracle@centos6 scripts]$ cat sql_parse1.sql  
    2. declare  
    3. cursor test_cur is select id,name from tt;  
    4. begin  
    5. for i in test_cur loop  
    6. execute immediate 'insert into tt values('||i.id||','||chr(39)||i.name||chr(39)||')';  
    7. end loop;  
    8. commit;  
    9. end;  
    这样直接使用游标中的值拼接是属于非绑定变量,为硬解析

    [sql]  view plain  copy
    1. SQL> alter system flush shared_pool;  
    2.   
    3. System altered.  
    4.   
    5. SQL> @sql_parse1.sql  
    6.   
    7. PL/SQL procedure successfully completed.  
    8.   
    9. SQL> set linesize 200  
    10. SQL> col hash_value format 9999999999  
    11. SQL> col sql_id format 99  
    12. SQL> col child_latch format 99  
    13. SQL> col version_count format 99  
    14. SQL> col sql_text format a40  
    15. SQL> col parse_calls format 999  
    16. SQL> select hash_value,sql_id,child_latch,version_count,sql_text,parse_calls from v$sqlarea where sql_text like 'insert into tt%';  
    17.  HASH_VALUE SQL_ID        CHILD_LATCH VERSION_COUNT          SQL_TEXT                                           PARSE_CALLS  
    18. ----------- ------------- ----------- ------------- -------------------------------------------------- -----------  
    19.  3161064081 196c4s2y6n0nj           0             1 insert into tt values(45,'test')                             1  
    20.  3718124844 6hfpagbftw59c           0             1 insert into tt values(70,'test')                             1  
    21.  4046592725 c5txty7sm46qp           0             1 insert into tt values(28,'test')                             1  
    22.   961289967 4n0n3dnwns7rg           0             1 insert into tt values(30,'test')                             1  
    23.  2124685404 g70mmhxza882w           0             1 insert into tt values(26,'test')                             1  
    24.   608576974 3nm07v4k4c9ff           0             1 insert into tt values(31,'test')                             1  
    25.  3770952793 2xcry8ghc8b2t           0             1 insert into tt values(1,'test')                              1  

    b. 绑定变量写法

    [sql]  view plain  copy
    1. [oracle@centos6 scripts]$ cat sql_parse2.sql  
    2. declare  
    3. cursor test_cur is select id,name from tt;  
    4. begin  
    5. for i in test_cur loop  
    6. execute immediate 'insert into tt values(:a,:b)' using i.id,i.name;  
    7. end loop;  
    8. commit;  
    9. end;  
    10. /  
    11.   
    12. SQL> alter system flush shared_pool;  
    13.   
    14. System altered.  
    15.   
    16. SQL> @sql_parse2.sql  
    17.   
    18. PL/SQL procedure successfully completed.  
    19.   
    20. SQL> select hash_value,sql_id,child_latch,version_count,sql_text,parse_calls from v$sqlarea where sql_text like 'insert into tt%';  
    21.   
    22.  HASH_VALUE SQL_ID        CHILD_LATCH VERSION_COUNT SQL_TEXT                                           PARSE_CALLS  
    23. ----------- ------------- ----------- ------------- -------------------------------------------------- -----------  
    24.  2034333845 gbkazctwn2y4p           0             1 insert into tt values(:a,:b)                                 1  
    展开全文
  • SQL调优之绑定变量用法简介

    千次阅读 2019-09-20 17:24:15
    介绍绑定变量之前,先介绍SQL执行过程和硬解析的概念: 执行sql的过程,会将sql的文本进行hash运算,得到对象的hash值,然后拿hash值,去Hash Buckets里遍历缓存对象句柄链表,找到对应的缓存对象句柄,然后就可以...
  • sql绑定变量

    2012-11-20 00:24:13
    绑定变量
  • execute immediate 不会走绑定变量模式,切记在批量数据处理中使用这种方法   测试二: --修改procedure 改成execute immediate 带变量执行 create or replace PROCEDURE P_test_execute is  v_sql ...
  • 查找未使用绑定变量sql.sql
  • 绑定变量与非绑定变量sql的查询

    千次阅读 2016-10-14 15:46:41
    force_matching_signature 可以找到相同的语句的非绑定变量的sql。  非绑定变量sql exact_matching_signature != force_matching_signature 绑定变量的sql :  绑定变量的sql...
  • MySQL优化系列11-MySQL游标和绑定变量

    千次阅读 2021-07-07 13:58:36
    绑定变量2.1 绑定变量的优化2.2 SQL接口的绑定变量2.3 绑定变量的限制参考: 一. MySQL游标简介 MySQL在服务器端提供只读的、单向的游标,而且只能在存储过程或者更底层的客户端API中使用。因为MySQL游标中指向的对象...
  • ORA-01745: 无效的主机/绑定变量

    千次阅读 2020-05-15 14:23:25
    oracle在新增数据的时候提示: ORA-01745: 无效的主机/绑定变量名 执行语句如下: insert into AS_SMS_REMIND_PERSON(ID,NAME,PHONENO,CORPNO,REMIND_LEVEL,ISENABLE,CREATE_USERID,CREATE_DATE,UPDATE_USERID,...
  • wpf 给控件绑定静态变量,静态变理改变后控件上的值随着变量的demo,这只是个demo,具体应用场景可以根据实际的情况进行调整,本demo使用 vs2019进行编写。
  • css 绑定变量

    2020-12-22 11:36:23
    // 绑定 style="--shadowColor:{{shadowColor}};--background:{{background}}" // 使用 .css{ background:var(--background); box-shadow: 1px 2px 3px var(--shadowColor); }
  • 预编译sql语句就sql绑定变量

    千次阅读 2018-05-31 23:52:00
    1. 认识绑定变量绑定变量是为了减少解析的,比如你有个语句这样 select aaa,bbb from ccc where ddd=eee; 如果经常通过改变eee这个谓词赋值来查询,像如下 select aaa,bbb from ccc where ddd=fff; sel...
  • 以下的文章讲述的是Oracle执行SQL语句时如何绑定变量的实际相关操作步骤,以及用Oracle执行绑定变量SQL语句的实例子的介绍,以下就是文章的相关内容的介绍,望你浏览完后会有所了解 。1. 接收和定义变量的SQL*PLUS...
  • 绑定变量

    千次阅读 2012-07-29 09:28:37
    1、认识绑定变量:  绑定变量是为了减少解析,比如你有个语句这样的:  select aaa,bbb from ccc where ddd=eee;  如果经常通过改变eee这个谓词赋值来查询,如下:  select aaa,bbb from ccc where ...
  • 如何绑定变量

    2012-11-06 17:35:16
    在oltp系统中提倡使用绑定变量,使用绑定变量可以减少hard parse
  • ORACLE 参数设置绑定变量

    千次阅读 2019-07-29 20:04:10
    使用 CURSOR_SHARING 参数 ...SIMIAR 当替换不会影响到执行计划时,才会将字面量替换成绑定变量 FORCE 只要有可能,字面量会被替换为绑定变量 转载于:https://www.cnblogs.com/jzbml/p/6041847.html...
  • 1、Object.freeze(obj)语句 obj={ foo:"nan" } Object.freeze(obj); 用该语句固定变量后,之后对这个变量的更改都会无效,并在console中报错。...以上这篇浅谈vue的几种绑定变量的值 防止其改变
  • 1 什么绑定变量绑定变量是为了减少解析的,比如有个语句: Select aaa,bbb from cc where ddd=eee; Select aaa,bbb from cc where ddd=fff; Select aaa,bbb from cc where ddd=ggg; 这样,每条语句都要被数据库...
  • 先说下问题起源,算奖确认订单,需要批量update订单,查了相关资料,是mybatis一次性绑定变量超过65535(这个数值并不准,因为后来绑定变量超过一万一又导致Oracle挂掉一次),引发了Oracle的一个bug,导致数据库宕...
  • WPF的数据绑定功能非常强大,在控件中使用数据绑定功能会为你节省大量的处理...本示例中,将一个变量绑定到一个控件上,在代码中改变变量值,并立刻引起控件值的变化。此代码经过删减,仅仅保留精简内容,一看就懂。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 558,757
精华内容 223,502
关键字:

绑定变量

友情链接: 神龙通道.rar