唯一索引vs非唯一索引 cbc latch

测试目的

通过一个简单的测试,对比了一下唯一索引和非唯一索引在做等值谓词查询情况下,对于cache buffers chains latch和consistent gets两个指标的影响。

测试结论:

如果表上的列符合建立唯一索引的条件,那么为了避免cache buffers chains latch的争用,最好建立唯一索引。唯一索引不但可以减少cache buffers chains latch争用,还可以一定程度上减少逻辑读。

唯一索引在等值谓词查询时,根节点、分支节点、叶节点、数据块都只需要以共享模式获得一次cache buffers chains latch(简称cbc latch),在cbc latch的保护下读取buffer,加共享模式buffer pin。

唯一索引访问情况下读取数据块的大体步骤:

  1. 依据数据块的地址计算出数据块所在的Hash Bucket
  2. 获得保护这个Hash Bucket的cbc latch(共享模式获取)
  3. 在这个链表上找寻需要的数据块,找到后,步骤4)
  4. 读取数据块的内容
  5. 释放cbc latch

上面的读取方式在oracle里有一个单独的统计量来体现:consistent gets - examination,consistent gets - examination的值最终也会被汇总到consistent gets里。

非唯一索引在等值谓词查询时,根节点、分支节点都只需要获得一次共享cbc latch,叶节点、数据块需要以排他模式获得两次cbc latch。之所以根节点和分支节点只需要获得一次cbc latch,是因为oracle做了优化,根节点和分支节点的读取量要远远大于叶节点,非常可能会引起cbc latch的争用,因此oracle对于跟节点和分支节点的操作,都使用了获取共享cbc latch不加buffer pin的方式。

叶块和数据块的大体访问步骤:

  1. 依据数据块的地址计算出数据块所在的Hash Bucket
  2. 获得保护这个Hash Bucket的cbc latch(排他模式获取)
  3. 在这个链表上查找需要的数据块,找到后,pin这个buffer
  4. 释放cbc latch
  5. 在buffer pin的保护下读取数据块的内容,读取完成后步骤6)
  6. 再次获取cbc latch(排他模式获取)
  7. unpin这个buffer
  8. 释放cbc latch

上面的读取方式在oracle里有一个单独的统计量来体现:consistent gets。

由上面的步骤可以看出,唯一索引的代码路径比非唯一索引短,而且持有的cbc latch的模式是共享模式,而非唯一索引需要持有排他模式的cbc latch(这是为了在buffer上增加buffer pin)。如果表上的列符合唯一索引的创建条件,建议创建唯一索引来最小化cbc latch可能引起的争用。

测试过程

我们来看下具体的测试例子:

create table test as select * from dba_ocache bjects;

场景一 非唯一索引下,cbc latch的持有次数

在object_id上创建非唯一索引

create index tt on test(object_id);

索引的blevel为1,也就是根块和分支块是一个。


execute snap_latch.start_snap

select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;

execute snap_latch.end_snap

---------------------------------
Latch waits:-   05-Aug 13:17:21
Interval:-      0 seconds
---------------------------------
Latch                              Gets      Misses     Sp_Get     Sleeps     Im_Gets   Im_Miss Holding Woken Time ms
-----                              ----      ------     ------     ------     -------   ------- ------- ----- -------
cache buffers chains                 71           0          0          0           0         0       0     0      .0

上面的代码对一个同样的SQL做了10次查询。并且打印出了这期间会话cache buffers chains latch的统计量(增量)。
cache buffers chains的获取次数为71次。

我们上面已经提到,根节点,分支节点(这里分支节点和跟节点是同一个)的cbc latch每次只需持有一次。而叶节点和数据块节点,每次读取需要持有2次。

那么执行一次SQL,需要的cbc latch数为:
【根节点】1+【叶块】2+【数据块】2=5

执行十次:
5*10=50次

但是我们看到的cbc latch是持有了71次,多了21次,其实21次中的20次,是叶节点产生的,由于是非唯一索引,ORACLE从叶块取出第一个符合的值回表取出这条记录后,还需要再读取索引块一次,因为它不确认是不是下一个索引entry是不是也符合记录,但是唯一索引就没这个问题。通过逻辑读取数也可以验证这一点:

execute snap_my_stats.start_snap

select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;
select object_name  from test where object_id=46;

execute snap_my_stats.end_snap

---------------------------------
Session stats - 05-Aug 13:25:07
Interval:-  0 seconds
---------------------------------
Name                                                                     Value
----                                                                     -----
consistent gets                                                             40
consistent gets from cache                                                  40
consistent gets from cache (fastpath)                                       30
consistent gets - examination                                               10

40次逻辑读,每次SQL的逻辑读是4,4=1次根块+2次索引块+1次数据块
如果是唯一索引的话,只需要读取一次索引块就OK了。
consistent gets - examination为10,是因为10次SQL执行,读取了10次索引根块(分支块)。

场景二 唯一索引下,cbc latch的持有次数

在object_id上创建非唯一索引

drop index tt;

create unique index tt on test(object_id);

-----执行代码,略

---------------------------------
Latch waits:-   05-Aug 13:27:11
Interval:-      0 seconds
---------------------------------
Latch                              Gets      Misses     Sp_Get     Sleeps     Im_Gets   Im_Miss Holding Woken Time ms
-----                              ----      ------     ------     ------     -------   ------- ------- ----- -------
cache buffers chains                 31           0          0          0           0         0       0     0      .0

【根节点】1+【叶块】1+【数据块】1=3

执行十次,共30次的cbc latch获取。多余的一次为????

cbc latch的获取次数比上一个场景减少了71-31=40次。这个非常棒!

同理逻辑读取数:

---------------------------------
Session stats - 05-Aug 13:27:46
Interval:-  0 seconds
---------------------------------
Name                                                                     Value
----                                                                     -----
consistent gets                                                             30
consistent gets from cache                                                  30
consistent gets - examination                                               30

一次SQL的逻辑读取数:

1次根块+1次索引块+1次数据块=3

10次执行的逻辑读就为:10*3=30

由于是唯一索引,所以查询一次叶块后,不需要再次回索引块做check。
逻辑读取数也比上一个场景少了40-30=10次。

魏兴华 [email protected]
沃趣科技高级数据库专家、项目经理
公司网站:http://www.woqutech.com
杭州市滨江区长河街道滨安路1190号3幢智汇领地科技园A区A楼10层1004室(310053)

你可能感兴趣的:(唯一索引vs非唯一索引 cbc latch)