• oracle 执行计划

    Oracle性能优化-读懂执行计划

    查看ORACLE的实际执行计划

    如果要分析某条SQL的性能问题，通常我们要先看SQL的执行计划，看看SQL的每一步执行是否存在问题。 如果一条SQL平时执行的好好的，却有一天突然性能很差，如果排除了系统资源和阻塞的原因，那么基本可以断定是执行计划出了问题。

           看懂执行计划也就成了SQL优化的先决条件。 这里的SQL优化指的是SQL性能问题的定位，定位后就可以解决问题。

    一．         查看执行计划的三种方法

    1.1 设置autotrace

    序号

    命令

    解释

    1

    SET AUTOTRACE OFF

    此为默认值，即关闭Autotrace 

    2

    SET AUTOTRACE ON EXPLAIN

    只显示执行计划

    3

    SET AUTOTRACE ON STATISTICS

     只显示执行的统计信息

    4

    SET AUTOTRACE ON

     包含2,3两项内容

    5

    SET AUTOTRACE TRACEONLY

     与ON相似，但不显示语句的执行结果

    SQL> set autotrace on

    SQL> select * from dave;

            ID NAME

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

             8 安庆

             1 dave

             2 bl

             1 bl

             2 dave

             3 dba

             4 sf-express

             5 dmm

    已选择8行。

    执行计划

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

    Plan hash value: 3458767806

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

    | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT  |      |     8 |    64 |     2   (0)| 00:00:01 |

    |   1 |  TABLE ACCESS FULL| DAVE |     8 |    64 |     2   (0)| 00:00:01 |

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

    统计信息

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

              0  recursive calls

              0  db block gets

              4  consistent gets

              0  physical reads

              0  redo size

            609  bytes sent via SQL*Net to client

            416  bytes received via SQL*Net from client

              2  SQL*Net roundtrips to/from client

              0  sorts (memory)

              0  sorts (disk)

              8  rows processed

    1.2 使用SQL

    SQL>EXPLAIN PLAN FOR sql语句;

    SQL>SELECT plan_table_output FROM TABLE(DBMS_XPLAN.DISPLAY('PLAN_TABLE'));

    示例：

    SQL> EXPLAIN PLAN FOR SELECT * FROM DAVE;

    已解释。

    SQL> SELECT plan_table_output FROM TABLE(DBMS_XPLAN.DISPLAY('PLAN_TABLE'));

    或者：

    SQL>  select * from table(dbms_xplan.display);

    PLAN_TABLE_OUTPUT

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

    Plan hash value: 3458767806

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

    | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT  |      |     8 |    64 |     2   (0)| 00:00:01 |

    |   1 |  TABLE ACCESS FULL| DAVE |     8 |    64 |     2   (0)| 00:00:01 |

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

    已选择8行。

    执行计划

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

    Plan hash value: 2137789089

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

    | Id  | Operation                         | Name    | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT                  |         |  8168 | 16336 |    29   (0)| 00:00:01 |

    |   1 |  COLLECTION ITERATOR PICKLER FETCH| DISPLAY |  8168 | 16336 |    29   (0)| 00:00:01 |

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

    统计信息

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

             25  recursive calls

             12  db block gets

            168  consistent gets

              0  physical reads

              0  redo size

            974  bytes sent via SQL*Net to client

            416  bytes received via SQL*Net from client

              2  SQL*Net roundtrips to/from client

              1  sorts (memory)

              0  sorts (disk)

              8  rows processed

    1.3 使用Toad,PL/SQL Developer工具

     选择执行计划的语句，按F5或点击解释计划图标即打开解释计划窗口。

    二．         Cardinality（基数）/ rows

    Cardinality值表示CBO预期从一个行源（row source）返回的记录数，这个行源可能是一个表，一个索引，也可能是一个子查询。   在Oracle 9i中的执行计划中，Cardinality缩写成Card。 在10g中，Card值被rows替换。

     这是9i的一个执行计划，我们可以看到关键字Card：

           执行计划

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

       0      SELECT STATEMENT Optimizer=CHOOSE (Cost=2 Card=1 Bytes=402)

       1    0   TABLE ACCESS (FULL) OF 'TBILLLOG8' (Cost=2 Card=1 Bytes=402)

    Oracle 10g的执行计划，关键字换成了rows：

    执行计划

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

    Plan hash value: 2137789089

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

    | Id  | Operation                         | Name    | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT                  |         |  8168 | 16336 |    29   (0)| 00:00:01 |

    |   1 |  COLLECTION ITERATOR PICKLER FETCH| DISPLAY |  8168 | 16336 |    29   (0)| 00:00:01 |

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

    Cardinality的值对于CBO做出正确的执行计划来说至关重要。 如果CBO获得的Cardinality值不够准确（通常是没有做分析或者分析数据过旧造成），在执行计划成本计算上就会出现偏差，从而导致CBO错误的制定出执行计划。

           在多表关联查询或者SQL中有子查询时，每个关联表或子查询的Cardinality的值对主查询的影响都非常大，甚至可以说，CBO就是依赖于各个关联表或者子查询Cardinality值计算出最后的执行计划。

           对于多表查询，CBO使用每个关联表返回的行数（Cardinality）决定用什么样的访问方式来做表关联（如Nested loops Join 或 hash Join）。

              多表连接的三种方式详解 HASH JOIN MERGE JOIN NESTED LOOP

                  http://blog.csdn.net/tianlesoftware/archive/2010/08/20/5826546.aspx

    对于子查询，它的Cardinality将决定子查询是使用索引还是使用全表扫描的方式访问数据。

    三． SQL 的执行计划

           生成SQL的执行计划是Oracle在对SQL做硬解析时的一个非常重要的步骤，它制定出一个方案告诉Oracle在执行这条SQL时以什么样的方式访问数据：索引还是全表扫描，是Hash Join还是Nested loops Join等。 比如说某条SQL通过使用索引的方式访问数据是最节省资源的，结果CBO作出的执行计划是全表扫描，那么这条SQL的性能必然是比较差的。

           Oracle SQL的硬解析和软解析

           http://blog.csdn.net/tianlesoftware/archive/2010/04/08/5458896.aspx

    示例：

    SQL> SET AUTOTRACE TRACEONLY;  -- 只显示执行计划，不显示结果集

    SQL> select * from scott.emp a,scott.emp b where a.empno=b.mgr;

    已选择13行。

    执行计划

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

    Plan hash value: 992080948

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

    | Id  | Operation                    | Name   | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT             |        |    13 |   988 |     6  (17)| 00:00:01 |

    |   1 |  MERGE JOIN                  |        |    13 |   988 |     6  (17)| 00:00:01 |

    |   2 |   TABLE ACCESS BY INDEX ROWID| EMP    |    14 |   532 |     2   (0)| 00:00:01 |

    |   3 |    INDEX FULL SCAN           | PK_EMP |    14 |       |     1   (0)| 00:00:01 |

    |*  4 |   SORT JOIN                  |        |    13 |   494 |     4  (25)| 00:00:01 |

    |*  5 |    TABLE ACCESS FULL         | EMP    |    13 |   494 |     3   (0)| 00:00:01 |

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

    Predicate Information (identified by operation id):

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

       4 - access("A"."EMPNO"="B"."MGR")

           filter("A"."EMPNO"="B"."MGR")

       5 - filter("B"."MGR" IS NOT NULL)

    统计信息

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

              0  recursive calls

              0  db block gets

             11  consistent gets

              0  physical reads

              0  redo size

           2091  bytes sent via SQL*Net to client

            416  bytes received via SQL*Net from client

              2  SQL*Net roundtrips to/from client

              1  sorts (memory)

              0  sorts (disk)

             13  rows processed

    图片是Toad工具查看的执行计划。 在Toad 里面，很清楚的显示了执行的顺序。 但是如果在SQLPLUS里面就不是那么直接。 但我们也可以判断：一般按缩进长度来判断，缩进最大的最先执行，如果有2行缩进一样，那么就先执行上面的。

    3.1 执行计划中字段解释：

           ID: 一个序号，但不是执行的先后顺序。执行的先后根据缩进来判断。

           Operation： 当前操作的内容。

           Rows： 当前操作的Cardinality，Oracle估计当前操作的返回结果集。

           Cost（CPU）：Oracle 计算出来的一个数值（代价），用于说明SQL执行的代价。

           Time：Oracle 估计当前操作的时间。

    3.2 谓词说明：

    Predicate Information (identified by operation id):

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

       4 - access("A"."EMPNO"="B"."MGR")

           filter("A"."EMPNO"="B"."MGR")

       5 - filter("B"."MGR" IS NOT NULL)

           Access: 表示这个谓词条件的值将会影响数据的访问路劲（表还是索引）。

           Filter：表示谓词条件的值不会影响数据的访问路劲，只起过滤的作用。

    在谓词中主要注意access，要考虑谓词的条件，使用的访问路径是否正确。

    3.3 统计信息说明：

    db block gets ： 从buffer cache中读取的block的数量    

    consistent gets： 从buffer cache中读取的undo数据的block的数量    

    physical reads： 从磁盘读取的block的数量    

    redo size： DML生成的redo的大小    

    sorts (memory) ：在内存执行的排序量    

    sorts (disk) ：在磁盘上执行的排序量    

           Physical Reads通常是我们最关心的，如果这个值很高，说明要从磁盘请求大量的数据到Buffer Cache里，通常意味着系统里存在大量全表扫描的SQL语句，这会影响到数据库的性能，因此尽量避免语句做全表扫描，对于全表扫描的SQL语句，建议增 加相关的索引，优化SQL语句来解决。

    关于physical reads ，db block gets 和consistent gets这三个参数之间有一个换算公式：

           数据缓冲区的使用命中率=1 - ( physical reads / (db block gets + consistent gets) )。

    用以下语句可以查看数据缓冲区的命中率：

           SQL>SELECT name, value FROM v$sysstat WHERE name IN ('db block gets', 'consistent gets','physical reads');

           查询出来的结果Buffer Cache的命中率应该在90％以上，否则需要增加数据缓冲区的大小。

    Recursive Calls：  Number of recursive calls generated at both the user and system level.    

    Oracle Database maintains tables used for internal processing. When it needs to change these tables, Oracle Database generates an internal SQL statement, which in turn generates a recursive call. In short, recursive calls are basically SQL performed on behalf of your SQL. So, if you had to parse the query, for example, you might have had to run some other queries to get data dictionary information. These would be recursive calls. Space management, security checks, calling PL/SQL from SQL—all incur recursive SQL calls。

    DB Block Gets： Number of times a CURRENT block was requested.

    Current mode blocks are retrieved as they exist right now, not in a consistent read fashion. Normally, blocks retrieved for a query are retrieved as they existed when the query began. Current mode blocks are retrieved as they exist right now, not from a previous point in time. During a SELECT, you might see current mode retrievals due to reading the data dictionary to find the extent information for a table to do a full scan (because you need the "right now" information, not the consistent read). During a modification, you will access the blocks in current mode in order to write to them. (DB Block Gets:请求的数据块在buffer能满足的个数)
           当前模式块意思就是在操作中正好提取的块数目，而不是在一致性读的情况下而产生的块数。正常的情况下，一个查询提取的块是在查询开始的那个时间点上存在的数据块，当前块是在这个时刻存在的数据块，而不是在这个时间点之前或者之后的数据块数目。

    Consistent Gets： Number of times a consistent read was requested for a block.

    This is how many blocks you processed in "consistent read" mode. This will include counts of blocks read from the rollback segment in order to roll back a block. This is the mode you read blocks in with a SELECT, for example. Also, when you do a searched UPDATE/DELETE, you read the blocks in consistent read mode and then get the block in current mode to actually do the modification. (Consistent Gets: 数据请求总数在回滚段Buffer中的数据一致性读所需要的数据块)
           这里的概念是在处理你这个操作的时候需要在一致性读状态上处理多少个块，这些块产生的主要原因是因为由于在你查询的过程中，由于其他会话对数据块进行操 作，而对所要查询的块有了修改，但是由于我们的查询是在这些修改之前调用的，所以需要对回滚段中的数据块的前映像进行查询，以保证数据的一致性。这样就产 生了一致性读。

    Physical Reads： Total number of data blocks read from disk. This number equals the value of "physical reads direct" plus all reads into buffer cache. (Physical Reads:实例启动后，从磁盘读到Buffer Cache数据块数量)

    就是从磁盘上读取数据块的数量，其产生的主要原因是：
           （1） 在数据库高速缓存中不存在这些块
           （2） 全表扫描
           （3） 磁盘排序
    它们三者之间的关系大致可概括为：
           逻辑读指的是Oracle从内存读到的数据块数量。一般来说是'consistent gets' + 'db block gets'。当在内存中找不到所需的数据块的话就需要从磁盘中获取，于是就产生了'physical reads'。

    Sorts(disk):

        Number of sort operations that required at least one disk write. Sorts that require I/O to disk are quite resource intensive. Try increasing the size of the initialization parameter SORT_AREA_SIZE.

    bytes sent via SQL*Net to client:
        Total number of bytes sent to the client from the foreground processes.

    bytes received via SQL*Net from client:
        Total number of bytes received from the client over Oracle Net.

    SQL*Net roundtrips to/from client:
        Total number of Oracle Net messages sent to and received from the client.

    更多内容参考Oracle联机文档：

           Statistics Descriptions

           http://download.oracle.com/docs/cd/E11882_01/server.112/e10820/stats002.htm#i375475

    3.4 动态分析

           如果在执行计划中有如下提示：

                  Note

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

                         -dynamic sampling used for the statement

          

           这提示用户CBO当前使用的技术，需要用户在分析计划时考虑到这些因素。 当出现这个提示，说明当前表使用了动态采样。 我们从而推断这个表可能没有做过分析。

    这里会出现两种情况：

    （1）       如果表没有做过分析，那么CBO可以通过动态采样的方式来获取分析数据，也可以或者正确的执行计划。

    （2）       如果表分析过，但是分析信息过旧，这时CBO就不会在使用动态采样，而是使用这些旧的分析数据，从而可能导致错误的执行计划。

    总结：

           在看执行计划的时候，除了看执行计划本身，还需要看谓词和提示信息。 通过整体信息来判断SQL 效率。

    一．相关的概念

    　　Rowid的概念：rowid 是一个伪列，既然是伪列，那么这个列就不是用户定义，而是系统自己给加上的。 对每个表都有一个rowid的伪列，但是表中并不物理存储ROWID列的值。不过你可以像使用其它列那样使用它，但是不能删除改列，也不能对该列的值进行 修改、插入。一旦一行数据插入数据库，则rowid在该行的生命周期内是唯一的，即即使该行产生行迁移，行的rowid也不会改变。
    　　Recursive SQL概念    ： 有时为了执行用户发出的一个sql语句，Oracle必须执行一些额外的语句，我们将这些额外的语句称之为''recursive calls''或''recursive SQL statements''.如当一个DDL语句发出后，ORACLE总是隐含的发出一些recursive SQL语句，来修改数据字典信息，以便用户可以成功的执行该DDL语句。当需要的数据字典信息没有在共享内存中时，经常会发生Recursive calls，这些Recursive calls会将数据字典信息从硬盘读入内存中。用户不比关心这些recursive SQL语句的执行情况，在需要的时候，ORACLE会自动的在内部执行这些语句。当然DML语句与SELECT都可能引起recursive SQL.简单的说，我们可以将触发器视为recursive SQL.
    　　Row Source（行源）：用在查询中，由上一操作返回的符合条件的行的集合，即可以是表的全部行数据的集合；也可以是表的部分行数据的集合；也可以为对上2个row source进行连接操作（如join连接）后得到的行数据集合。
    　　Predicate（谓词）    ：一个查询中的WHERE限制条件
    　　Driving Table（驱动表）    ： 该表又称为外层表（OUTER TABLE）。这个概念用于嵌套与HASH连接中。如果该row source返回较多的行数据，则对所有的后续操作有负面影响。注意此处虽然翻译为驱动表，但实际上翻译为驱动行源（driving row source）更为确切。一般说来，是应用查询的限制条件后，返回较少行源的表作为驱动表，所以如果一个大表在WHERE条件有有限制条件（如等值限 制），则该大表作为驱动表也是合适的，所以并不是只有较小的表可以作为驱动表，正确说法应该为应用查询的限制条件后，返回较少行源的表作为驱动表。在执行 计划中，应该为靠上的那个row source，后面会给出具体说明。在我们后面的描述中，一般将该表称为连接操作的row source 1.
    　　Probed Table（被探查表）    ： 该表又称为内层表（INNER TABLE）。在我们从驱动表中得到具体一行的数据后，在该表中寻找符合连接条件的行。所以该表应当为大表（实际上应该为返回较大row source的表）且相应的列上应该有索引。在我们后面的描述中，一般将该表称为连接操作的row source 2.
    　　组合索引（concatenated index）    ： 由多个列构成的索引，如create index idx_emp on emp（col1， col2， col3， ……），则我们称idx_emp索引为组合索引。在组合索引中有一个重要的概念：引导列（leading column），在上面的例子中，col1列为引导列。当我们进行查询时可以使用“where col1 = ？ ”，也可以使用“where col1 = ？ and col2 = ？”，这样的限制条件都会使用索引，但是“where col2 = ？ ”查询就不会使用该索引。所以限制条件中包含先导列时，该限制条件才会使用该组合索引。
    　　可选择性（selectivity）： 比较一下列中唯一键的数量和表中的行数，就可以判断该列的可选择性。 如果该列的“唯一键的数量/表中的行数”的比值越接近1，则该列的可选择性越高，该列就越适合创建索引，同样索引的可选择性也越高。在可选择性高的列上进 行查询时，返回的数据就较少，比较适合使用索引查询。

    　　二．oracle访问数据的存取方法

    　　1） 全表扫描（Full Table Scans， FTS）
    　 　为实现全表扫描，Oracle读取表中所有的行，并检查每一行是否满足语句的WHERE限制条件一个多块读操作可以使一次I/O能读取多块数据块 （db_block_multiblock_read_count参数设定），而不是只读取一个数据块，这极大的减 少了I/O总次数，提高了系统的吞吐量，所以利用多块读的方法可以十分高效地实现全表扫描，而且只有在全表扫描的情况下才能使用多块读操作。在这种访问模 式下，每个数据块只被读一次。
    　　使用FTS的前提条件：在较大的表上不建议使用全表扫描，除非取出数据的比较多，超过总量的5% —— 10%，或你想使用并行查询功能时。
    　　使用全表扫描的例子：     
    　　SQL> explain plan for select * from dual;
    　　Query Plan
    　　-----------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=
    　　TABLE ACCESS FULL DUAL

    　　2） 通过ROWID的表存取（Table Access by ROWID或rowid lookup）
    　　行的ROWID指出了该行所在的数据文件、数据块以及行在该块中的位置，所以通过ROWID来存取数据可以快速定位到目标数据上，是Oracle存取单行数据的最快方法。
    　　这种存取方法不会用到多块读操作，一次I/O只能读取一个数据块。我们会经常在执行计划中看到该存取方法，如通过索引查询数据。
    　　使用ROWID存取的方法： 
    　　SQL> explain plan for select * from dept where rowid = ''AAAAyGAADAAAAATAAF''；
    　　Query Plan
    　　------------------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=1
    　　TABLE ACCESS BY ROWID DEPT [ANALYZED]

    　　3）索引扫描（Index Scan或index lookup）
    　 　我们先通过index查找到数据对应的rowid值（对于非唯一索引可能返回多个rowid值），然后根据rowid直接从表中得到具体的数据，这 种查找方式称为索引扫描或索引查找（index lookup）。一个rowid唯一的表示一行数据，该行对应的数据块是通过一次i/o得到的，在此情况下该次i/o只会读取一个数据库块。
    　　在索引中，除了存储每个索引的值外，索引还存储具有此值的行对应的ROWID值。
    　　索引扫描可以由2步组成：
    　　（1） 扫描索引得到对应的rowid值。
    　　（2） 通过找到的rowid从表中读出具体的数据。
    　 　每步都是单独的一次I/O，但是对于索引，由于经常使用，绝大多数都已经CACHE到内存中，所以第1步的 I/O经常是逻辑I/O，即数据可以从内存中得到。但是对于第2步来说，如果表比较大，则其数据不可能全在内存中，所以其I/O很有可能是物理I/O，这 是一个机械操作，相对逻辑I/O来说，是极其费时间的。所以如果多大表进行索引扫描，取出的数据如果大于总量的5% —— 10%，使用索引扫描会效率下降很多。如下列所示：
    　　SQL> explain plan for select empno， ename from emp where empno=10；
    　　Query Plan
    　　------------------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=1
    　　TABLE ACCESS BY ROWID EMP [ANALYZED]
    　　INDEX UNIQUE SCAN EMP_I1
    　　但是如果查询的数据能全在索引中找到，就可以避免进行第2步操作，避免了不必要的I/O，此时即使通过索引扫描取出的数据比较多，效率还是很高的
    　　SQL> explain plan for select empno from emp where empno=10;-- 只查询empno列值
    　　Query Plan
    　　------------------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=1
    　　INDEX UNIQUE SCAN EMP_I1

    　　进一步讲，如果sql语句中对索引列进行排序，因为索引已经预先排序好了，所以在执行计划中不需要再对索引列进行排序
    　　SQL> explain plan for select empno, ename from emp
    　　where empno > 7876 order by empno;
    　　Query Plan
    　　--------------------------------------------------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=1
    　　TABLE ACCESS BY ROWID EMP [ANALYZED]
    　　INDEX RANGE SCAN EMP_I1 [ANALYZED]

    　　从这个例子中可以看到：因为索引是已经排序了的，所以将按照索引的顺序查询出符合条件的行，因此避免了进一步排序操作。
    　　根据索引的类型与where限制条件的不同，有4种类型的索引扫描：
    　　索引唯一扫描（index unique scan）
    　　索引范围扫描（index range scan）
    　　索引全扫描（index full scan）
    　　索引快速扫描（index fast full scan）
    　　（1） 索引唯一扫描（index unique scan）
    　　通过唯一索引查找一个数值经常返回单个ROWID.如果存在UNIQUE 或PRIMARY KEY 约束（它保证了语句只存取单行）的话，Oracle经常实现唯一性扫描。
    　　使用唯一性约束的例子：
    　　SQL> explain plan for
    　　select empno，ename from emp where empno=10；
    　　Query Plan
    　　------------------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=1
    　　TABLE ACCESS BY ROWID EMP [ANALYZED]
    　　INDEX UNIQUE SCAN EMP_I1
    　　（2） 索引范围扫描（index range scan）
    　　使用一个索引存取多行数据，在唯一索引上使用索引范围扫描的典型情况下是在谓词（where限制条件）中使用了范围操作符（如>、<、<>、>=、<=、between）
    　　使用索引范围扫描的例子：
    　　SQL> explain plan for select empno，ename from emp
    　　where empno > 7876 order by empno；
    　　Query Plan
    　　--------------------------------------------------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=1
    　　TABLE ACCESS BY ROWID EMP [ANALYZED]
    　　INDEX RANGE SCAN EMP_I1 [ANALYZED]
    　　在非唯一索引上，谓词col = 5可能返回多行数据，所以在非唯一索引上都使用索引范围扫描。
    　　使用index rang scan的3种情况：
    　　（a） 在唯一索引列上使用了range操作符（> < <> >= <= between）
    　　（b） 在组合索引上，只使用部分列进行查询，导致查询出多行
    　　（c） 对非唯一索引列上进行的任何查询。
    　　（3） 索引全扫描（index full scan）
    　　与全表扫描对应，也有相应的全索引扫描。而且此时查询出的数据都必须从索引中可以直接得到。
    　　全索引扫描的例子：
    　　An Index full scan will not perform. single block i/o''s and so it may prove to be inefficient.
    　　e.g.
    　　Index BE_IX is a concatenated index on big_emp （empno， ename）
    　　SQL> explain plan for select empno， ename from big_emp order by empno，ename；
    　　Query Plan
    　　--------------------------------------------------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=26
    　　INDEX FULL SCAN BE_IX [ANALYZED]
    　　（4） 索引快速扫描（index fast full scan）
    　　扫描索引中的所有的数据块，与 index full scan很类似，但是一个显著的区别就是它不对查询出的数据进行排序，即数据不是以排序顺序被返回。在这种存取方法中，可以使用多块读功能，也可以使用并行读入，以便获得最大吞吐量与缩短执行时间。
    　　索引快速扫描的例子：
    　　BE_IX索引是一个多列索引： big_emp （empno，ename）
    　　SQL> explain plan for select empno，ename from big_emp；
    　　Query Plan
    　　------------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=1
    　　INDEX FAST FULL SCAN BE_IX [ANALYZED]

    　　只选择多列索引的第2列：
    　　SQL> explain plan for select ename from big_emp；
    　　Query Plan
    　　------------------------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=1
    　　INDEX FAST FULL SCAN BE_IX [ANALYZED]

    　　三、表之间的连接
    　 　Join是一种试图将两个表结合在一起的谓词，一次只能连接2个表，表连接也可以被称为表关联。在后面的叙 述中，我们将会使用“row source”来代替“表”，因为使用row source更严谨一些，并且将参与连接的2个row source分别称为row source1和row source 2.Join过程的各个步骤经常是串行操作，即使相关的row source可以被并行访问，即可以并行的读取做join连接的两个row source的数据，但是在将表中符合限制条件的数据读入到内存形成row source后，join的其它步骤一般是串行的。有多种方法可以将2个表连接起来，当然每种方法都有自己的优缺点，每种连接类型只有在特定的条件下才会 发挥出其最大优势。
    　　row source（表）之间的连接顺序对于查询的效率有非常大的影响。通过首先存取特定的表，即将该表作为驱动表，这样可以先应用某些限制条件，从而得到一个 较小的row source，使连接的效率较高，这也就是我们常说的要先执行限制条件的原因。一般是在将表读入内存时，应用where子句中对该表的限制条件。
    　 　根据2个row source的连接条件的中操作符的不同，可以将连接分为等值连接（如WHERE A.COL3 = B.COL4）、非等值连接（WHERE A.COL3 > B.COL4）、外连接（WHERE A.COL3 = B.COL4（+））。上面的各个连接的连接原理都基本一样，所以为了简单期间，下面以等值连接为例进行介绍。
    　　在后面的介绍中，都以以下Sql为例进行说明：
    　　SELECT A.COL1， B.COL2
    　　FROM A， B
    　　WHERE A.COL3 = B.COL4；
    　　假设A表为Row Soruce1，则其对应的连接操作关联列为COL 3；
    　  B表为Row Soruce2，则其对应的连接操作关联列为COL 4；

    　　连接类型：
    　　目前为止，无论连接操作符如何，典型的连接类型共有3种：
    　　    排序 - - 合并连接（Sort Merge Join （SMJ） ）
    　　嵌套循环（Nested Loops （NL） ）
    　　哈希连接（Hash Join）
    　　另外，还有一种Cartesian product（笛卡尔积），一般情况下，尽量避免使用。
    　　1，排序 - - 合并连接（Sort Merge Join， SMJ）
    　　内部连接过程：
    　　1） 首先生成row source1需要的数据，然后对这些数据按照连接操作关联列（如A.col3）进行排序。
    　　2） 随后生成row source2需要的数据，然后对这些数据按照与sort source1对应的连接操作关联列（如B.col4）进行排序。
    　　3） 最后两边已排序的行被放在一起执行合并操作，即将2个row source按照连接条件连接起来

    　　下面是连接步骤的图形表示：
    　　MERGE
    　　/
    　　SORTSORT
    　　||
    　　Row Source 1Row Source 2

    　 　如果row source已经在连接关联列上被排序，则该连接操作就不需要再进行sort操作，这样可以大大提高这种连接操作的连接速度，因为排序是个极其费资源的操 作，特别是对于较大的表。预先排序的row source包括已经被索引的列（如a.col3或b.col4上有索引）或row source已经在前面的步骤中被排序了。尽管合并两个row source的过程是串行的，但是可以并行访问这两个row source（如并行读入数据，并行排序）。
    　　SMJ连接的例子：
    　　SQL> explain plan for
    　　select/*+ ordered */    e.deptno， d.deptno
    　　from emp e， dept d
    　　where e.deptno = d.deptno
    　　order by e.deptno， d.deptno；
    　　Query Plan
    　　-------------------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=17
    　　MERGE JOIN
    　　SORT JOIN
    　　TABLE ACCESS FULL EMP [ANALYZED]
    　　SORT JOIN
    　　TABLE ACCESS FULL DEPT [ANALYZED]
     
    　　排序是一个费时、费资源的操作，特别对于大表。基于这个原因，SMJ经常不是一个特别有效的连接方法，但是如果2个row source都已经预先排序，则这种连接方法的效率也是蛮高的。

    　　2，嵌套循环（Nested Loops， NL）
    　 　这个连接方法有驱动表（外部表）的概念。其实，该连接过程就是一个2层嵌套循环，所以外层循环的次数越少越好，这也就是我们为什么将小表或返回较小 row source的表作为驱动表（用于外层循环）的理论依据。但是这个理论只是一般指导原则，因为遵循这个理论并不能总保证使语句产生的I/O次数最少。有时 不遵守这个理论依据，反而会获得更好的效率。如果使用这种方法，决定使用哪个表作为驱动表很重要。有时如果驱动表选择不正确，将会导致语句的性能很差、很 差。
    　　内部连接过程：
    　　Row source1的Row 1 —— Probe ->Row source 2
    　　Row source1的Row 2 —— Probe ->Row source 2
    　　Row source1的Row 3 —— Probe ->Row source 2
    　　……。
    　　Row source1的Row n —— Probe ->Row source 2
    　 　从内部连接过程来看，需要用row source1中的每一行，去匹配row source2中的所有行，所以此时保持row source1尽可能的小与高效的访问row source2（一般通过索引实现）是影响这个连接效率的关键问题。这只是理论指导原则，目的是使整个连接操作产生最少的物理I/O次数，而且如果遵守这 个原则，一般也会使总的物理I/O数最少。但是如果不遵从这个指导原则，反而能用更少的物理I/O实现连接操作，那尽管违反指导原则吧！因为最少的物理 I/O次数才是我们应该遵从的真正的指导原则，在后面的具体案例分析中就给出这样的例子。
    　　在上面的连接过程中，我们称Row source1为驱动表或外部表。Row Source2被称为被探查表或内部表。
    　 　在NESTED LOOPS连接中，Oracle读取row source1中的每一行，然后在row sourc2中检查是否有匹配的行，所有被匹配的行都被放到结果集中，然后处理row source1中的下一行。这个过程一直继续，直到row source1中的所有行都被处理。这是从连接操作中可以得到第一个匹配行的最快的方法之一，这种类型的连接可以用在需要快速响应的语句中，以响应速度为 主要目标。
    　　如果driving row source（外部表）比较小，并且在inner row source（内部表）上有唯一索引，或有高选择性非唯一索引时，使用这种方法可以得到较好的效率。NESTED LOOPS有其它连接方法没有的的一个优点是：可以先返回已经连接的行，而不必等待所有的连接操作处理完才返回数据，这可以实现快速的响应时间。
    　 　如果不使用并行操作，最好的驱动表是那些应用了where 限制条件后，可以返回较少行数据的的表，所以大表也可能称为驱动表，关键看限制条件。对于并行查询，我们经常选择大表作为驱动表，因为大表可以充分利用并 行功能。当然，有时对查询使用并行操作并不一定会比查询不使用并行操作效率高，因为最后可能每个表只有很少的行符合限制条件，而且还要看你的硬件配置是否 可以支持并行（如是否有多个CPU，多个硬盘控制器），所以要具体问题具体对待。
    　　NL连接的例子：
    　　SQL> explain plan for
    　　select a.dname，b.sql
    　　from dept a，emp b
    　　where a.deptno = b.deptno；
    　　Query Plan
    　　-------------------------
    　　SELECT STATEMENT [CHOOSE] Cost=5
    　　NESTED LOOPS
    　　TABLE ACCESS FULL DEPT [ANALYZED]
    　　TABLE ACCESS FULL EMP [ANALYZED]

    　　3，哈希连接（Hash Join， HJ）
    　　这种连接是在oracle 7.3以后引入的，从理论上来说比NL与SMJ更高效，而且只用在CBO优化器中。
    　 　较小的row source被用来构建hash table与bitmap，第2个row source被用来被hansed，并与第一个row source生成的hash table进行匹配，以便进行进一步的连接。Bitmap被用来作为一种比较快的查找方法，来检查在hash table中是否有匹配的行。特别的，当hash table比较大而不能全部容纳在内存中时，这种查找方法更为有用。这种连接方法也有NL连接中所谓的驱动表的概念，被构建为hash table与bitmap的表为驱动表，当被构建的hash table与bitmap能被容纳在内存中时，这种连接方式的效率极高。

    　　HASH连接的例子：
    　　SQL> explain plan for
    　　select/*+ use_hash（emp） */    empno
    　　from emp， dept
    　　where emp.deptno = dept.deptno；
    　　Query Plan
    　　----------------------------
    　　SELECT STATEMENT[CHOOSE] Cost=3
    　　HASH JOIN
    　　TABLE ACCESS FULL DEPT
    　　TABLE ACCESS FULL EMP

    　 　要使哈希连接有效，需要设置HASH_JOIN_ENABLED=TRUE，缺省情况下该参数为TRUE，另外，不要忘了还要设置 hash_area_size参数，以使哈希连接高效运行，因为哈希连接会在该参数指定大小的内存中运行，过小的参数会使哈希连接的性能比其他连接方式还 要低。
    　　另外，笛卡儿乘积（Cartesian Product）
    　 　当两个row source做连接，但是它们之间没有关联条件时，就会在两个row source中做笛卡儿乘积，这通常由编写代码疏漏造成（即程序员忘了写关联条件）。笛卡尔乘积是一个表的每一行依次与另一个表中的所有行匹配。在特殊情 况下我们可以使用笛卡儿乘积，如在星形连接中，除此之外，我们要尽量不使用笛卡儿乘积，否则，自己想结果是什么吧！
    　　注意在下面的语句中，在2个表之间没有连接。
    　　SQL> explain plan for
    　　select emp.deptno，dept，deptno
    　　from emp，dept
    　　Query Plan
    　　------------------------
    　　SLECT STATEMENT [CHOOSE] Cost=5
    　　    MERGE JOIN CARTESIAN
    　　TABLE ACCESS FULL DEPT
    　　SORT JOIN
    　　TABLE ACCESS FULL EMP

    　　CARTESIAN关键字指出了在2个表之间做笛卡尔乘积。假如表emp有n行，dept表有m行，笛卡尔乘积的结果就是得到n * m行结果。
    　　最后，总结一下，在哪种情况下用哪种连接方法比较好：

    　　排序 - - 合并连接（Sort Merge Join， SMJ）：
    　　a） 对于非等值连接，这种连接方式的效率是比较高的。
    　　b） 如果在关联的列上都有索引，效果更好。
    　　c） 对于将2个较大的row source做连接，该连接方法比NL连接要好一些。
    　　d） 但是如果sort merge返回的row source过大，则又会导致使用过多的rowid在表中查询数据时，数据库性能下降，因为过多的I/O.

    　　嵌套循环（Nested Loops， NL）：
    　　a） 如果driving row source（外部表）比较小，并且在inner row source（内部表）上有唯一索引，或有高选择性非唯一索引时，使用这种方法可以得到较好的效率。
    　　b） NESTED LOOPS有其它连接方法没有的的一个优点是：可以先返回已经连接的行，而不必等待所有的连接操作处理完才返回数据，这可以实现快速的响应时间。

    　哈希连接（Hash Join， HJ）：
    　　a） 这种方法是在oracle7后来引入的，使用了比较先进的连接理论，一般来说，其效率应该好于其它2种连接，但是这种连接只能用在CBO优化器中，而且需要设置合适的hash_area_size参数，才能取得较好的性能。
    　　b） 在2个较大的row source之间连接时会取得相对较好的效率，在一个row source较小时则能取得更好的效率。
    　　c） 只能用于等值连接中

     看懂Oracle执行计划是优化的第一步，让我们从下面的例子开始吧。
            下面为补充内容
    1、创建测试表

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> create table t as select 1 id,object_name from dba_objects;    
    3.      
    4. Table created    
    5.      
    6. SQL> update t set id=99 where rownum=1;    
    7.      
    8. 1 row updated    
    9.      
    10. SQL> commit;    
    11.      
    12. Commit complete    
    13.      
    14. SQL> create index t_ind on t(id);    
    15.      
    16. Index created    


            oracle优化器：RBO和CBO两种， 从oracle10g开始优化器已经抛弃了RBO，下面的列子说明CBO大概是怎样的

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL>  select /*+dynamic_sampling(t 0) */* from t where id=1;    
    3.     
    4. 50819 rows selected.    
    5.     
    6.     
    7. Execution Plan    
    8. ----------------------------------------------------------    
    9. Plan hash value: 1376202287    
    10.     
    11. -------------------------------------------------------------------------------------    
    12. | Id  | Operation                   | Name  | Rows  | Bytes | Cost (%CPU)| Time     |    
    13. -------------------------------------------------------------------------------------    
    14. |   0 | SELECT STATEMENT            |       |   195 | 15405 |    51   (0)| 00:00:01 |    
    15. |   1 |  TABLE ACCESS BY INDEX ROWID| T     |   195 | 15405 |    51   (0)| 00:00:01 |    
    16. |*  2 |   INDEX RANGE SCAN          | T_IND |    78 |       |    50   (0)| 00:00:01 |    
    17. -------------------------------------------------------------------------------------    
    18.     
    19. Predicate Information (identified by operation id):    
    20. ---------------------------------------------------   
    21.     
    22.    2 - access("ID"=1)     


           现象t表还没有被分析，提示/*+dynamic_sampling(t 0) */*的目的是让CBO无法通过动态采样获取表中的实际数据情况，此时CBO只能根据T表中非常有限的信息（比如表中的extents数量，数据块的数 量）来猜测表中的数据。从结果中可以看到CBO猜出表中id=1的有195条，这个数值对于表的总数来说，是一个非常小的值，所以CBO选择了索引而不是 全表扫描。
          而实际情况如下所示：

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> select * from  t where id=1    
    3.   2  ;    
    4.     
    5. 50819 rows selected.    
    6.     
    7.     
    8. Execution Plan    
    9. ----------------------------------------------------------    
    10. Plan hash value: 1601196873    
    11.     
    12. --------------------------------------------------------------------------    
    13. | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |    
    14. --------------------------------------------------------------------------    
    15. |   0 | SELECT STATEMENT  |      | 49454 |  3815K|    67   (2)| 00:00:01 |    
    16. |*  1 |  TABLE ACCESS FULL| T    | 49454 |  3815K|    67   (2)| 00:00:01 |    
    17. --------------------------------------------------------------------------    
    18.     
    19. Predicate Information (identified by operation id):    
    20. ---------------------------------------------------    
    21.     
    22.    1 - filter("ID"=1)    



           通过动态取样，CBO估算出行数为49454，非常接近于真实50820数目。选择了全表扫描。
           我们来收集一下统计信息

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> exec dbms_stats.gather_table_stats(user,'t',cascade => true);    
    3.     
    4. SQL> select * from  t where id=1;    
    5.     
    6. 50819 rows selected.    
    7.     
    8.     
    9. Execution Plan    
    10. ----------------------------------------------------------    
    11. Plan hash value: 1601196873    
    12.     
    13. --------------------------------------------------------------------------    
    14. | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |    
    15. --------------------------------------------------------------------------    
    16. |   0 | SELECT STATEMENT  |      | 50815 |  1339K|    67   (2)| 00:00:01 |    
    17. |*  1 |  TABLE ACCESS FULL| T    | 50815 |  1339K|    67   (2)| 00:00:01 |    
    18. --------------------------------------------------------------------------    
    19.     
    20. Predicate Information (identified by operation id):    
    21. ---------------------------------------------------    
    22.     
    23.    1 - filter("ID"=1)    



    现在扫描过的行数为50815。

    如果我们更新了所有的id为99看看。

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> update t set id=99;    
    3.      
    4. 50820 rows updated    
    5.     
    6. SQL> select * from  t where id=99;    
    7.     
    8.     
    9. Execution Plan    
    10. ----------------------------------------------------------    
    11. Plan hash value: 1376202287    
    12.     
    13. -------------------------------------------------------------------------------------    
    14. | Id  | Operation                   | Name  | Rows  | Bytes | Cost (%CPU)| Time     |    
    15. -------------------------------------------------------------------------------------    
    16. |   0 | SELECT STATEMENT            |       |     1 |    27 |     2   (0)| 00:00:01 |    
    17. |   1 |  TABLE ACCESS BY INDEX ROWID| T     |     1 |    27 |     2   (0)| 00:00:01 |    
    18. |*  2 |   INDEX RANGE SCAN          | T_IND |     1 |       |     1   (0)| 00:00:01 |    
    19. -------------------------------------------------------------------------------------    
    20.     
    21. Predicate Information (identified by operation id):    
    22. ---------------------------------------------------    
    23.     
    24.    2 - access("ID"=99)    



            因为没有对表进行分析，所以表中的分析数据还是之前的信息，CBO并不知道。我们可以看出Rows值为1，也就是说CBO人为表T中的ID=99的值只有1条，所有选择仍然是索引。

           我们收集一把统计信息。

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> exec dbms_stats.gather_table_stats(user,'t',cascade => true);    
    3.      
    4. PL/SQL procedure successfully completed    
    5.     
    6. SQL> select * from  t where id=99;    
    7.     
    8. 50820 rows selected.    
    9.     
    10.     
    11. Execution Plan    
    12. ----------------------------------------------------------    
    13. Plan hash value: 1601196873    
    14.     
    15. --------------------------------------------------------------------------    
    16. | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |    
    17. --------------------------------------------------------------------------    
    18. |   0 | SELECT STATEMENT  |      | 50815 |  1339K|    67   (2)| 00:00:01 |    
    19. |*  1 |  TABLE ACCESS FULL| T    | 50815 |  1339K|    67   (2)| 00:00:01 |    
    20. --------------------------------------------------------------------------    
    21.     
    22. Predicate Information (identified by operation id):    
    23. ---------------------------------------------------    
    24.     
    25.    1 - filter("ID"=99)    


          上面为补充内容，下面正式开始

    1、 sql的执行计划

    创建测试表

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> create table t1(id int,name varchar2(1000));    
    3.      
    4. Table created    
    5.      
    6. SQL> create table t2(id int,name varchar2(1000));    
    7.      
    8. Table created    
    9.      
    10. SQL> create index ind_t1 on t1(id);    
    11.      
    12. Index created    
    13.      
    14. SQL> create index ind_t2 on t2(id);    
    15.      
    16. Index created    
    17.      
    18. SQL> create index ind_t2_name on t2(name);    
    19.      
    20. Index created    
    21.      
    22. SQL> insert into t1 select  a.OBJECT_ID,a.OBJECT_NAME from all_objects a;    
    23.      
    24. 50206 rows inserted    
    25.     
    26. SQL> insert into t2 select  a.OBJECT_ID,a.OBJECT_NAME from all_objects a where rownum<=20;    
    27.      
    28. 20 rows inserted    
    29.      
    30. SQL> commit;    
    31.      
    32. Commit complete    
    33.      
    34. SQL> exec dbms_stats.gather_table_stats(user,'t1',cascade => true);    
    35.      
    36. PL/SQL procedure successfully completed    
    37.     
    38. SQL> exec dbms_stats.gather_table_stats(user,'t2',cascade => true);    
    39.      
    40. PL/SQL procedure successfully completed    



    2、产生执行计划

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> select * from t1,t2 where t1.id= t2.id;    
    3.     
    4. 20 rows selected.    
    5.     
    6.     
    7. Execution Plan    
    8. ----------------------------------------------------------    
    9. Plan hash value: 828990364    
    10.     
    11. --------------------------------------------------------------------------------------    
    12. | Id  | Operation                   | Name   | Rows  | Bytes | Cost (%CPU)| Time     |    
    13. --------------------------------------------------------------------------------------    
    14. |   0 | SELECT STATEMENT            |        |    20 |   780 |    43   (0)| 00:00:01 |    
    15. |   1 |  TABLE ACCESS BY INDEX ROWID| T1     |     1 |    28 |     2   (0)| 00:00:01 |    
    16. |   2 |   NESTED LOOPS              |        |    20 |   780 |    43   (0)| 00:00:01 |    
    17. |   3 |    TABLE ACCESS FULL        | T2     |    20 |   220 |     3   (0)| 00:00:01 |    
    18. |*  4 |    INDEX RANGE SCAN         | IND_T1 |     1 |       |     1   (0)| 00:00:01 |    
    19. --------------------------------------------------------------------------------------    
    20.     
    21. Predicate Information (identified by operation id):    
    22. ---------------------------------------------------    
    23.     
    24.    4 - access("T1"."ID"="T2"."ID")    
    25.     
    26.     
    27. Statistics    
    28. ----------------------------------------------------------    
    29.           1  recursive calls    
    30.           0  db block gets    
    31.          37  consistent gets    
    32.           0  physical reads    
    33.           0  redo size    
    34.        1452  bytes sent via SQL*Net to client    
    35.         503  bytes received via SQL*Net from client    
    36.           3  SQL*Net roundtrips to/from client    
    37.           0  sorts (memory)    
    38.           0  sorts (disk)    
    39.          20  rows processed    



             看执行计划时，我们首先从缩进最大的行读取，它是最先被执行的步骤。在执行计划中：id=3和id=4是最先被执行的，

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. |   3 |    TABLE ACCESS FULL        | T2     |    20 |   220 |     3   (0)| 00:00:01 |    
    3. |*  4 |    INDEX RANGE SCAN         | IND_T1 |     1 |       |     1   (0)| 00:00:01 |    


              两行缩进一样的，最上面的最先被执行，在这里就是id=3

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. |   3 |    TABLE ACCESS FULL        | T2     |    20 |   220 |     3   (0)| 00:00:01 |   


             选择次之缩进的行数id=2，表连接方式为NESTED LOOPS。

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. |   2 |   NESTED LOOPS              |        |    20 |   780 |    43   (0)| 00:00:01 |   

      
            然后是id=1，扫描表的方式为TABLE ACCESS BY INDEX ROWID

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. |   1 |  TABLE ACCESS BY INDEX ROWID| T1     |     1 |    28 |     2   (0)| 00:00:01 |  

     
           最后是id=0

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. |   0 | SELECT STATEMENT            |        |    20 |   780 |    43   (0)| 00:00:01 |   


           我们翻译成语言大概如下，
          从t2表第一行读取，查看每一行是否符合下面条件：
    "T1"."ID"="T2"."ID"
           如果符合就拿出一行来，扫描整个t2表，这个过程就叫NESTED LOOPS
           当整个t2表被扫描完之后，会产生一个结果集，这个结果集是IND_T1的一个索引集，然后oracle根据索引键值上的rowid去T1表中找到相应的记录，就是这一步：TABLE ACCESS BY INDEX ROWID
            然后将结果返回：SELECT STATEMENT
           id列为：id=3->id=4->id=2->id=1->id=0
    让我们再看一看表中每一行表示什么含义：
    1）Operation 列：当前操作的内容。
    2）Rows 列 ：就是当前操作的 cardinality ，Oracle估算当前操作的返回结果集。
    3）Cost (%CPU) : Oracle计算出来的一个数值（代价），用于说明sql执行的代价。
    4）Time 列：Oracle估算当前操作的时间。

    Predicate Information (identified by operation id):
    ---------------------------------------------------

       4 - access("T1"."ID"="T2"."ID")

    这里有access和filter区别，access就表示这个谓词的条件的值将会影响数据的访问路径（一般针对索引），filter只起过滤作用。
    举个例子

    Sql代码  收藏代码
    1. [sql] view plaincopy  
    2. SQL> select * from t1 where t1.name='AA';    
    3.     
    4. no rows selected    
    5.     
    6.     
    7. Execution Plan    
    8. ----------------------------------------------------------    
    9. Plan hash value: 3617692013    
    10.     
    11. --------------------------------------------------------------------------    
    12. | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |    
    13. --------------------------------------------------------------------------    
    14. |   0 | SELECT STATEMENT  |      |     2 |    56 |    69   (2)| 00:00:01 |    
    15. |*  1 |  TABLE ACCESS FULL| T1   |     2 |    56 |    69   (2)| 00:00:01 |    
    16. --------------------------------------------------------------------------    
    17.     
    18. Predicate Information (identified by operation id):    
    19. ---------------------------------------------------    
    20.     
    21.    1 - filter("T1"."NAME"='AA')    



    懂了吧。
    下面我们来仔细分析Operation里面的内容

    Sql代码  收藏代码
    1. [sql] view plaincopy   


    a、表访问方式
    1.Full Table Scan (FTS) 全表扫描
    In a FTS operation, the whole table is read up to the high water mark (HWM). The HWM marks the last block in the table that has ever had data written to it. If you have deleted all the rows then you will still read up to the HWM. Truncate resets the HWM back to the start of the table. FTS uses multiblock i/o to read the blocks from disk. 
    --全表扫描模式下会读数据到表的高水位线（HWM即表示表曾经扩展的最后一个数据块），读取速度依赖于Oracle初始化参 db_block_multiblock_read_count(我觉得应该这样翻译:FTS扫描会使表使用上升到高水位(HWM),HWM标识了表最后 写入数据的块,如果你用DELETE删除了所有的数据表仍然处于高水位(HWM),只有用TRUNCATE才能使表回归,FTS使用多IO从磁盘读取数据 块)Query Plan 
    ------------------------------------ 

    Sql代码  收藏代码
    1. SELECT STATEMENT [CHOOSE] Cost=1    
    2. **INDEX UNIQUE SCAN EMP_I1   


    --如果索引里就找到了所要的数据，就不会再去访问表
    2.Index Lookup 索引扫描
    There are 5 methods of index lookup:   
    1）index unique scan   --索引唯一扫描 
    Method for looking up a single key value via a unique index. always returns a single value, You must supply AT LEAST the leading column of the index to access data via the index.
    eg:

    Sql代码  收藏代码
    1. SQL> select empno,ename from emp where empno=10  
    2. SQL> select empno,ename from emp where empno=10;    
    3.     
    4. no rows selected    
    5.     
    6.     
    7. Execution Plan    
    8. ----------------------------------------------------------    
    9. Plan hash value: 2949544139    
    10.     
    11. --------------------------------------------------------------------------------------    
    12. | Id  | Operation                   | Name   | Rows  | Bytes | Cost (%CPU)| Time     |    
    13. --------------------------------------------------------------------------------------    
    14. |   0 | SELECT STATEMENT            |        |     1 |    20 |     1   (0)| 00:00:01 |    
    15. |   1 |  TABLE ACCESS BY INDEX ROWID| EMP    |     1 |    20 |     1   (0)| 00:00:01 |    
    16. |*  2 |   INDEX UNIQUE SCAN         | PK_EMP |     1 |       |     1   (0)| 00:00:01 |    
    17. --------------------------------------------------------------------------------------    
    18.     
    19. Predicate Information (identified by operation id):    
    20. ---------------------------------------------------    
    21.     
    22.    2 - access("EMPNO"=10)    
    23.     
    24.     
    25. Statistics    
    26. ----------------------------------------------------------    
    27.          24  recursive calls    
    28.           0  db block gets    
    29.           3  consistent gets    
    30.           0  physical reads    
    31.           0  redo size    
    32.         385  bytes sent via SQL*Net to client    
    33.         481  bytes received via SQL*Net from client    
    34.           1  SQL*Net roundtrips to/from client    
    35.           0  sorts (memory)    
    36.           0  sorts (disk)    
    37.           0  rows processed   



    2）index range scan   --索引局部扫描
    Index range scan is a method for accessing a range values of a particular column. AT LEAST the leading column of the index must be supplied to access data via the index. Can be used for range operations (e.g. >  

    Sql代码  收藏代码
    1. SQL> select empno from emp where EMPNO>=7902;    
    2.     
    3.     
    4. Execution Plan    
    5. ----------------------------------------------------------    
    6. Plan hash value: 1567865628    
    7.     
    8. ---------------------------------------------------------------------------    
    9. | Id  | Operation        | Name   | Rows  | Bytes | Cost (%CPU)| Time     |    
    10. ---------------------------------------------------------------------------    
    11. |   0 | SELECT STATEMENT |        |     2 |    26 |     2   (0)| 00:00:01 |    
    12. |*  1 |  INDEX RANGE SCAN| PK_EMP |     2 |    26 |     2   (0)| 00:00:01 |    
    13. ---------------------------------------------------------------------------    
    14.     
    15. Predicate Information (identified by operation id):    
    16. ---------------------------------------------------    
    17.     
    18.    1 - access("EMPNO">=7902)    
    19.     
    20. Note    
    21. -----    
    22.    - dynamic sampling used for this statement    
    23.     
    24.     
    25. Statistics    
    26. ----------------------------------------------------------    
    27.           0  recursive calls    
    28.           0  db block gets    
    29.           2  consistent gets    
    30.           0  physical reads    
    31.           0  redo size    
    32.         569  bytes sent via SQL*Net to client    
    33.         492  bytes received via SQL*Net from client    
    34.           2  SQL*Net roundtrips to/from client    
    35.           0  sorts (memory)    
    36.           0  sorts (disk)    
    37.           2  rows processed    


    3）index full scan   --索引全局扫描 
    Full index scans are only available in the CBO as otherwise we are unable to determine whether a full scan would be a good idea or not. We choose an index Full Scan when we have statistics that indicate that it is going to be more efficient than a Full table 
    scan and a sort. For example we may do a Full index scan when we do an unbounded scan of an index and want the data to be ordered in the index order. 

    Sql代码  收藏代码
    1. SQL> select empno from emp order by empno;    
    2.     
    3. 14 rows selected.    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 179099197    
    9.     
    10. ---------------------------------------------------------------------------    
    11. | Id  | Operation        | Name   | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. ---------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT |        |    14 |   182 |     2   (0)| 00:00:01 |    
    14. |   1 |  INDEX FULL SCAN | PK_EMP |    14 |   182 |     2   (0)| 00:00:01 |    
    15. ---------------------------------------------------------------------------    
    16.     
    17. Note    
    18. -----    
    19.    - dynamic sampling used for this statement    
    20.     
    21.     
    22. Statistics    
    23. ----------------------------------------------------------    
    24.           4  recursive calls    
    25.           0  db block gets    
    26.          11  consistent gets    
    27.           0  physical reads    
    28.           0  redo size    
    29.         676  bytes sent via SQL*Net to client    
    30.         492  bytes received via SQL*Net from client    
    31.           2  SQL*Net roundtrips to/from client    
    32.           0  sorts (memory)    
    33.           0  sorts (disk)    
    34.          14  rows processed   


    4）index fast full scan   --索引快速全局扫描，不带order by情况下常发生
    Scans all the block in the index, Rows are not returned in sorted order, Introduced in 7.3 and requires V733_PLANS_ENABLED=TRUE and CBO, may be hinted using INDEX_FFS hint, uses multiblock i/o, can be executed in parallel, can be used to access second column 
    of concatenated indexes. This is because we are selecting all of the index. 

    Sql代码  收藏代码
    1. SQL> select empno from emp;    
    2.     
    3. 14 rows selected.    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 366039554    
    9.     
    10. -------------------------------------------------------------------------------    
    11. | Id  | Operation            | Name   | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. -------------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT     |        |    14 |   182 |     2   (0)| 00:00:01 |    
    14. |   1 |  INDEX FAST FULL SCAN| PK_EMP |    14 |   182 |     2   (0)| 00:00:01 |    
    15. -------------------------------------------------------------------------------    
    16.     
    17. Note    
    18. -----    
    19.    - dynamic sampling used for this statement    
    20.     
    21.     
    22. Statistics    
    23. ----------------------------------------------------------    
    24.           4  recursive calls    
    25.           0  db block gets    
    26.          13  consistent gets    
    27.           0  physical reads    
    28.           0  redo size    
    29.         676  bytes sent via SQL*Net to client    
    30.         492  bytes received via SQL*Net from client    
    31.           2  SQL*Net roundtrips to/from client    
    32.           0  sorts (memory)    
    33.           0  sorts (disk)    
    34.          14  rows processed   


    5）index skip scan   --索引跳跃扫描，where条件列是非索引的前导列情况下常发生
    Index skip scan finds rows even if the column is not the leading column of a concatenated index. It skips the first column(s) during the search. 

    Sql代码  收藏代码
    1. SQL> create index i_emp on emp(empno, ename);    
    2.     
    3. Index created.    
    4. SQL> select /*+ index_ss(emp i_emp)*/ job from emp where ename='SMITH';    
    5.     
    6.     
    7. Execution Plan    
    8. ----------------------------------------------------------    
    9. Plan hash value: 98078853    
    10.     
    11. -------------------------------------------------------------------------------------    
    12. | Id  | Operation                   | Name  | Rows  | Bytes | Cost (%CPU)| Time     |    
    13. -------------------------------------------------------------------------------------    
    14. |   0 | SELECT STATEMENT            |       |     1 |    13 |     5   (0)| 00:00:01 |    
    15. |   1 |  TABLE ACCESS BY INDEX ROWID| EMP   |     1 |    13 |     5   (0)| 00:00:01 |    
    16. |*  2 |   INDEX SKIP SCAN           | I_EMP |     1 |       |     4   (0)| 00:00:01 |    
    17. -------------------------------------------------------------------------------------    
    18.     
    19. Predicate Information (identified by operation id):    
    20. ---------------------------------------------------    
    21.     
    22.    2 - access("ENAME"='SMITH')    
    23.        filter("ENAME"='SMITH')    
    24.     
    25. Note    
    26. -----    
    27.    - dynamic sampling used for this statement    
    28.     
    29.     
    30. Statistics    
    31. ----------------------------------------------------------    
    32.           5  recursive calls    
    33.           0  db block gets    
    34.          11  consistent gets    
    35.           0  physical reads    
    36.           0  redo size    
    37.         513  bytes sent via SQL*Net to client    
    38.         492  bytes received via SQL*Net from client    
    39.           2  SQL*Net roundtrips to/from client    
    40.           0  sorts (memory)    
    41.           0  sorts (disk)    
    42.           1  rows processed    


    3.Rowid 物理ID扫描
    This is the quickest access method available.Oracle retrieves the specified block and extracts the rows it is interested in.  
    --Rowid扫描是最快的访问数据方式

    Sql代码  收藏代码
    1. SQL> select * from emp where rowid='AAAjFUAAEAAABZ1AAM';    
    2.     
    3.     
    4. Execution Plan    
    5. ----------------------------------------------------------    
    6. Plan hash value: 1116584662    
    7.     
    8. -----------------------------------------------------------------------------------    
    9. | Id  | Operation                  | Name | Rows  | Bytes | Cost (%CPU)| Time     |    
    10. -----------------------------------------------------------------------------------    
    11. |   0 | SELECT STATEMENT           |      |     1 |    99 |     1   (0)| 00:00:01 |    
    12. |   1 |  TABLE ACCESS BY USER ROWID| EMP  |     1 |    99 |     1   (0)| 00:00:01 |    
    13. -----------------------------------------------------------------------------------    
    14.     
    15.     
    16. Statistics    
    17. ----------------------------------------------------------    
    18.           1  recursive calls    
    19.           0  db block gets    
    20.           1  consistent gets    
    21.           0  physical reads    
    22.           0  redo size    
    23.         983  bytes sent via SQL*Net to client    
    24.         492  bytes received via SQL*Net from client    
    25.           2  SQL*Net roundtrips to/from client    
    26.           0  sorts (memory)    
    27.           0  sorts (disk)    
    28.           1  rows processed    


     
    b、运算符
    1.sort    --排序，很消耗资源
    There are a number of different operations that promote sorts: 
    (1)order by clauses (2)group by (3)sort merge join –-这三个会产生排序运算

    2.filter    --过滤，如not in、min函数等容易产生
    Has a number of different meanings, used to indicate partition elimination, may also indicate an actual filter step where one row source is filtering, another, functions such as min may introduce filter steps into query plans.

    3.view    --视图，大都由内联视图产生(可能深入到视图基表)
    When a view cannot be merged into the main query you will often see a projection view operation. This indicates that the 'view' will be selected from directly as opposed to being broken down into joins on the base tables. A number of constructs make a view 
    non mergeable. Inline views are also non mergeable. 

    Sql代码  收藏代码
    1. SQL> select ename,tot from emp,(select empno,sum(empno) tot from emp group by empno) tmp where emp.empno = tmp.empno;    
    2.     
    3. 14 rows selected.    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 138960760    
    9.     
    10. -----------------------------------------------------------------------------------------    
    11. | Id  | Operation                    | Name     | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. -----------------------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT             |          |    14 |   644 |     4  (25)| 00:00:01 |    
    14. |   1 |  MERGE JOIN                  |          |    14 |   644 |     4  (25)| 00:00:01 |    
    15. |   2 |   TABLE ACCESS BY INDEX ROWID| EMP      |    14 |   280 |     2   (0)| 00:00:01 |    
    16. |   3 |    INDEX FULL SCAN           | PK_EMPNO |    14 |       |     1   (0)| 00:00:01 |    
    17. |*  4 |   SORT JOIN                  |          |    14 |   364 |     2  (50)| 00:00:01 |    
    18. |   5 |    VIEW                      |          |    14 |   364 |     1   (0)| 00:00:01 |    
    19. |   6 |     HASH GROUP BY            |          |    14 |   182 |     1   (0)| 00:00:01 |    
    20. |   7 |      INDEX FULL SCAN         | PK_EMPNO |    14 |   182 |     1   (0)| 00:00:01 |    
    21. -----------------------------------------------------------------------------------------    
    22.     
    23. Predicate Information (identified by operation id):    
    24. ---------------------------------------------------    
    25.     
    26.    4 - access("EMP"."EMPNO"="TMP"."EMPNO")    
    27.        filter("EMP"."EMPNO"="TMP"."EMPNO")    
    28.     
    29. Note    
    30. -----    
    31.    - dynamic sampling used for this statement    
    32.     
    33.     
    34. Statistics    
    35. ----------------------------------------------------------    
    36.          43  recursive calls    
    37.           0  db block gets    
    38.          61  consistent gets    
    39.           0  physical reads    
    40.           0  redo size    
    41.         821  bytes sent via SQL*Net to client    
    42.         492  bytes received via SQL*Net from client    
    43.           2  SQL*Net roundtrips to/from client    
    44.           5  sorts (memory)    
    45.           0  sorts (disk)    
    46.          14  rows processed    



    4.partition view     --分区视图
    Partition views are a legacy technology that were superceded by the partitioning option. This section of the article is provided as reference for such legacy systems.
    3、让我们再看看统计信息部分

    Sql代码  收藏代码
    1. SQL> set autotrace traceonly;    
    2. SQL> select count(*) from emp;    
    3.     
    4.     
    5. Execution Plan    
    6. ----------------------------------------------------------    
    7. Plan hash value: 2083865914    
    8.     
    9. -------------------------------------------------------------------    
    10. | Id  | Operation          | Name | Rows  | Cost (%CPU)| Time     |    
    11. -------------------------------------------------------------------    
    12. |   0 | SELECT STATEMENT   |      |     1 |     3   (0)| 00:00:01 |    
    13. |   1 |  SORT AGGREGATE    |      |     1 |            |          |    
    14. |   2 |   TABLE ACCESS FULL| EMP  |    14 |     3   (0)| 00:00:01 |    
    15. -------------------------------------------------------------------    
    16.     
    17. Note    
    18. -----    
    19.    - dynamic sampling used for this statement    
    20.     
    21. Statistics    
    22. ----------------------------------------------------------    
    23.           5  recursive calls  (归调用次数)    
    24.           0  db block gets  (从磁盘上读取的块数,即通过update/delete/select for update读的次数)    
    25.          15  consistent gets (从内存里读取的块数,即通过不带for update的select 读的次数)    
    26.           0  physical reads (物理读—从磁盘读到数据块数量,一般来说是'consistent gets' + 'db block gets')    
    27.           0  redo size (重做数——执行SQL的过程中，产生的重做日志的大小)    
    28.         515  bytes sent via SQL*Net to client    
    29.         492  bytes received via SQL*Net from client    
    30.           2  SQL*Net roundtrips to/from client    
    31.           0  sorts (memory) (在内存中发生的排序)    
    32.           0  sorts (disk) (在硬盘中发生的排序)    
    33.           1  rows processed    


    说明：Cost=（Single block I/O cost+ Multiblock I/O cost+   CPU cost）/sreadtim

    序号 列名 解释
    1 db block gets 从buffer cache中读取的block的数量
    2 consistent gets 从buffer cache中读取的undo数据的block的数量
    3 physical reads 从磁盘读取的block的数量
    4 redo siz DML生成的redo的大小
    5 sorts (memory) 在内存执行的排序量
    6 sorts (disk) 在磁盘上执行的排序量



    原文URL：http://blog.csdn.net/rulev5/article/details/6984560

    现在我们讲讲oracle执行计划里面每个参数的含义
    我们以下面的一个例子来讲解
    这里做个补充：trace的类型一共有以下几种

    序号 命令 解释
    1 SET AUTOTRACE OFF 此为默认值，即关闭Autotrace
    2 SET AUTOTRACE ON EXPLAIN 只显示执行计划
    3 SET AUTOTRACE ON STATISTICS 只显示执行的统计信息
    4 SET AUTOTRACE ON 包含2,3两项内容
    5 SET AUTOTRACE TRACEONLY 与ON相似，但不显示语句的执行结果


    我喜欢SET AUTOTRACE TRACEONLY，我们以后的例子都是基于这种方式的
    view plaincopy

    Sql代码  收藏代码
    1. SQL> select * from departments a where a.department_id in (select b.department_id from employees b where b.employee_id=205);    
    2.     
    3.     
    4. Execution Plan    
    5. ----------------------------------------------------------    
    6. Plan hash value: 2782876085    
    7.     
    8. ----------------------------------------------------------------------------------------------    
    9. | Id  | Operation                    | Name          | Rows  | Bytes | Cost (%CPU)| Time     |    
    10. ----------------------------------------------------------------------------------------------    
    11. |   0 | SELECT STATEMENT             |               |     1 |    27 |     2   (0)| 00:00:01 |    
    12. |   1 |  NESTED LOOPS                |               |     1 |    27 |     2   (0)| 00:00:01 |    
    13. |   2 |   TABLE ACCESS BY INDEX ROWID| EMPLOYEES     |     1 |     7 |     1   (0)| 00:00:01 |    
    14. |*  3 |    INDEX UNIQUE SCAN         | EMP_EMP_ID_PK |     1 |       |     0   (0)| 00:00:01 |    
    15. |   4 |   TABLE ACCESS BY INDEX ROWID| DEPARTMENTS   |    27 |   540 |     1   (0)| 00:00:01 |    
    16. |*  5 |    INDEX UNIQUE SCAN         | DEPT_ID_PK    |     1 |       |     0   (0)| 00:00:01 |    
    17. ----------------------------------------------------------------------------------------------    
    18.     
    19. Predicate Information (identified by operation id):    
    20. ---------------------------------------------------    
    21.     
    22.    3 - access("B"."EMPLOYEE_ID"=205)    
    23.    5 - access("A"."DEPARTMENT_ID"="B"."DEPARTMENT_ID")    
    24.     
    25.     
    26. Statistics    
    27. ----------------------------------------------------------    
    28.           1  recursive calls    
    29.           0  db block gets    
    30.           4  consistent gets    
    31.           0  physical reads    
    32.           0  redo size    
    33.         749  bytes sent via SQL*Net to client    
    34.         492  bytes received via SQL*Net from client    
    35.           2  SQL*Net roundtrips to/from client    
    36.           0  sorts (memory)    
    37.           0  sorts (disk)    
    38.           1  rows processed   


      
    让我们来一行一行的看：
    一、表部分
    1、Plan hash value:
    [sql] view plaincopy
    Plan hash value: 2782876085 
    这一行是这一条语句的hash值，我们知道oracle对每条语句产生的执行计划放在share pool里面，第一次要经过硬解析，产生hash值。下次再执行该语句时候比较hash值，如果相同就不要执行硬解析。
    2、Operation（ 操作）
    这里的东西就多了，就是把sql进行分解，让我一起看看上的sql，这段sql的第一步是employee_id=25，这里我们 employee_id上面建了主键，建主键默认创建唯一索引。这里是用“=”进行限制的，所以走的unique scan方式。其他方式参考Oracle执行计划 讲解（一）内容
    还有一个知识点，就是要知道表链接操作，见我的另外一篇文章（）
    3、Name（被操作的对象）
    比如上例中的第二行operation（TABLE ACCESS BY INDEX ROWID）这里的TABLE对象为EMPLOYEES
    4、Row，有的地方也叫Cardinality（用plsqldev里面解释计划窗口）
    这里是数据查询的行数，比如说上个例子第4行，  departments 这张表就要扫描27行，然后和子查询（select b.department_id from employees b where b.employee_id=205）的值进行比较。如果使用=（注：大部分时候是不能用=来替换，这里是特例）就不一样了。
    [sql] view plaincopy

    Sql代码  收藏代码
    1. SQL> select * from departments a where a.department_id = (select b.department_id from employees b where b.employee_id=205);    
    2.     
    3.     
    4. Execution Plan    
    5. ----------------------------------------------------------    
    6. Plan hash value: 3449260133    
    7.     
    8. -----------------------------------------------------------------------------------------------    
    9. | Id  | Operation                     | Name          | Rows  | Bytes | Cost (%CPU)| Time     |    
    10. -----------------------------------------------------------------------------------------------    
    11. |   0 | SELECT STATEMENT              |               |     1 |    20 |     2   (0)| 00:00:01 |    
    12. |   1 |  TABLE ACCESS BY INDEX ROWID  | DEPARTMENTS   |     1 |    20 |     1   (0)| 00:00:01 |    
    13. |*  2 |   INDEX UNIQUE SCAN           | DEPT_ID_PK    |     1 |       |     0   (0)| 00:00:01 |    
    14. |   3 |    TABLE ACCESS BY INDEX ROWID| EMPLOYEES     |     1 |     7 |     1   (0)| 00:00:01 |    
    15. |*  4 |     INDEX UNIQUE SCAN         | EMP_EMP_ID_PK |     1 |       |     0   (0)| 00:00:01 |    
    16. -----------------------------------------------------------------------------------------------    
    17.     
    18. Predicate Information (identified by operation id):    
    19. ---------------------------------------------------    
    20.     
    21.    2 - access("A"."DEPARTMENT_ID"= (SELECT /*+ */ "B"."DEPARTMENT_ID" FROM "EMPLOYEES"    
    22.               "B" WHERE "B"."EMPLOYEE_ID"=205))    
    23.    4 - access("B"."EMPLOYEE_ID"=205)    
    24.     
    25.     
    26. Statistics    
    27. ----------------------------------------------------------    
    28.           0  recursive calls    
    29.           0  db block gets    
    30.           4  consistent gets    
    31.           0  physical reads    
    32.           0  redo size    
    33.         749  bytes sent via SQL*Net to client    
    34.         492  bytes received via SQL*Net from client    
    35.           2  SQL*Net roundtrips to/from client    
    36.           0  sorts (memory)    
    37.           0  sorts (disk)    
    38.           1  rows processed    
    39.      


    5、Byte
    扫描的数据的字节数
    6、Cost
    这里上次讲过了，这里简单说下吧。
    cost没有单位，是一个相对值，是sql文以cbo方式解析执行时，供oracle用来评估cbo成本，选择执行计划用的。
    公式：Cost=（Single block I/O cost+ Multiblock I/O cost+   CPU cost）/sreadtim
    没有明确的含义，不过对比时就非常有用了。
    7、Time
    每段执行的时间

    二、Predicate Information
    这里列出的是过滤条件，一共有两种：
    1、索引（access）
    如上例中的access("B"."EMPLOYEE_ID"=205)，这里使用索引作为过滤条件
    2、非索引（filter），看下面这里例子
    [sql] view plaincopy

    Sql代码  收藏代码
    1. SQL> select employee_id    
    2.                   from employees c    
    3.                  where c.first_name = 'Steven'   2    3  ;    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 1445457117    
    9.     
    10. -------------------------------------------------------------------------------    
    11. | Id  | Operation         | Name      | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. -------------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT  |           |     1 |    11 |     3   (0)| 00:00:01 |    
    14. |*  1 |  TABLE ACCESS FULL| EMPLOYEES |     1 |    11 |     3   (0)| 00:00:01 |    
    15. -------------------------------------------------------------------------------    
    16.     
    17. Predicate Information (identified by operation id):    
    18. ---------------------------------------------------    
    19.     
    20.    1 - filter("C"."FIRST_NAME"='Steven')    
    21.     
    22.     
    23. Statistics    
    24. ----------------------------------------------------------    
    25.           1  recursive calls    
    26.           0  db block gets    
    27.           8  consistent gets    
    28.           0  physical reads    
    29.           0  redo size    
    30.         574  bytes sent via SQL*Net to client    
    31.         492  bytes received via SQL*Net from client    
    32.           2  SQL*Net roundtrips to/from client    
    33.           0  sorts (memory)    
    34.           0  sorts (disk)    
    35.           2  rows processed   



    这里的过滤条件是FIRST_NAME，但是FIRST_NAME没有建立索引，这个时候使用filter，做标记。
    三、Statistics（统计信息）
    这里是重点要说的，如果看累了，可以去喝口水。O(∩_∩)O~
    AUTOTRACE Statistics列解释

    序号 列名 解释
    1 recursive calls 递归调查
    2 db block gets 从buffer cache中读取的block的数量
    3 consistent gets 从buffer cache中读取的undo数据的block的数量
    4 physical reads 从磁盘读取的block的数量
    5 redo size DML生成的redo的大小
    6 sorts (memory) 在内存执行的排序量
    7 sorts (disk) 在磁盘上执行的排序量



    1、recursive calls（重点讲解）
    官网对recursive calls 的解释如下：

           Recursive Calls：  Number of recursive calls generated at both the user and system level.   

           Oracle Database maintains tables used for internal processing. When it needs to change these tables, Oracle Database generates an internal SQL statement, which in turn generates a recursive call.In short, recursive calls are basically SQL performed on behalf of your SQL. So, if you had to parse the query, for example, you might have had to run some other queries to get data dictionary information. These would be recursive calls. Space management, security checks, calling PL/SQL from SQL—all incur recursive SQL calls。
           IBM上面也有一篇讲解，有兴趣可以看看
           http://publib.boulder.ibm.com/tividd/td/ITMD/SC23-4724-00/en_US/HTML/oraclepac510rg59.htm
           总结一下：
           当执行一条SQL语句时，产生的对其他SQL语句的调用，这些额外的语句称之为''recursive calls''或''recursive SQL statements''.
           在IBM 的那片文档里讲了触发Recursive Call的6种情况： 　

           如：

           （1）我们做一条insert 时，没有足够的空间来保存row记录，Oracle 通过Recursive Call 来动态的分配空间。

           （2）执行DDL语句时，ORACLE总是隐含的发出一些recursive SQL语句，来修改数据字典信息，以便成功的执行该DDL语句。

           （3）当Shared Pool过小，data dictionary cache 也会相应的过小，没有足够的空间存储ORACLE的系统数据字典信息时，会发生Recursive calls，这些Recursive calls会将数据字典信息从硬盘读入内存中。

           （4）存储过程、触发器内如果有SQL调用的话，也会产生recursive SQL。
           在这些情况中，主要是对数据字典的查询，通常发生在第一次执行时，第二次执行一般可显著降低。递归需要消耗大量的资源,如果操作复杂,很容易出现问题!
         现在让我们举例说明：
    [sql] view plaincopy

    Sql代码  收藏代码
    1. SQL> select * from employees;    
    2.     
    3. 107 rows selected.    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 1445457117    
    9.     
    10. -------------------------------------------------------------------------------    
    11. | Id  | Operation         | Name      | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. -------------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT  |           |   107 |  7276 |     3   (0)| 00:00:01 |    
    14. |   1 |  TABLE ACCESS FULL| EMPLOYEES |   107 |  7276 |     3   (0)| 00:00:01 |    
    15. -------------------------------------------------------------------------------    
    16.     
    17.     
    18. Statistics    
    19. ----------------------------------------------------------    
    20.           1  recursive calls    
    21.           0  db block gets    
    22.          15  consistent gets    
    23.           0  physical reads    
    24.           0  redo size    
    25.        9997  bytes sent via SQL*Net to client    
    26.         569  bytes received via SQL*Net from client    
    27.           9  SQL*Net roundtrips to/from client    
    28.           0  sorts (memory)    
    29.           0  sorts (disk)    
    30.         107  rows processed    


      

    让我们再执行一遍
    [sql] view plaincopy

    Sql代码  收藏代码
    1. SQL> select * from employees;    
    2.     
    3. 107 rows selected.    
    4.     
    5.     
    6. Execution Plan    
    7. ----------------------------------------------------------    
    8. Plan hash value: 1445457117    
    9.     
    10. -------------------------------------------------------------------------------    
    11. | Id  | Operation         | Name      | Rows  | Bytes | Cost (%CPU)| Time     |    
    12. -------------------------------------------------------------------------------    
    13. |   0 | SELECT STATEMENT  |           |   107 |  7276 |     3   (0)| 00:00:01 |    
    14. |   1 |  TABLE ACCESS FULL| EMPLOYEES |   107 |  7276 |     3   (0)| 00:00:01 |    
    15. -------------------------------------------------------------------------------    
    16.     
    17.     
    18. Statistics    
    19. ----------------------------------------------------------    
    20.           0  recursive calls    
    21.           0  db block gets    
    22.          15  consistent gets    
    23.           0  physical reads    
    24.           0  redo size    
    25.        9997  bytes sent via SQL*Net to client    
    26.         569  bytes received via SQL*Net from client    
    27.           9  SQL*Net roundtrips to/from client    
    28.           0  sorts (memory)    
    29.           0  sorts (disk)    
    30.         107  rows processed   


    在第一次查询employees时，产生了1次recursive Call，第二次查询的时候，因为数据字典的信息信息已经放在cache里，所以第二次的recursive call 为0. 如果第二次也没有完全cache，那么也是会产生recursive call，但次数比第一次少。
    其他的从字面上面就可以看出来了，不需要多解释了吧。

    原文URL：http://blog.csdn.net/rulev5/article/details/6988180

    关于ORACLE的两种group by 方式：hash group by 与 sort group by

    Oracle10g在distinct操作时作了算法改进，使用Hash Unique 代理了以前的Sort Unique.该行为由隐藏参数”_gby_hash_aggregation_enabled”决 定，optimizer_features_enable设置为10.2.0.1时默认为TRUE.

    HASH UNIQUE 的CPU COST应该比SORT UNIQUE要低，同理常用HASH JOIN而少用SORT MERGE JOIN。

    RBO模式下，仍然要做SORT,使用的是 SORT UNIQUE。

    HASH UNIQUE避免了排序，在数据量很大的时候应该能够看到较低的%CPU COST。
  • 相关阅读:
    How Many Tables 并查集（求有几个集合）
    Spell checker 字典树&&普通查找（加计数）
    昂贵的聘礼 dijstra算法（要枚举源点）
    All in All 找子串 水题
    Ultra-QuickSort 求逆序对 归并排序
    Snowflake Snow Snowflakes 根据相似度排序，有点暴力
    Gold Balanced Lineup hash函数，第一次接触，借鉴了大神的博客思想，看了很久才看懂，弱菜啦
    Stockbroker Grapevine 裸的floyd算法，求最大中的最小
    Check the difficulty of problems 概率dp，概率知识很重要
    [leetcode] Valid Anagram 、 Find All Anagrams in a String
  • 原文地址：https://www.cnblogs.com/bolang100/p/6370193.html
Copyright © 2020-2023  润新知