技术博客 数据库、运维与工程实践笔记

深入分析direct path read 11G

2026-04-21Oracle / RAC

传统读取数据的方式是服务器进程通过读取磁盘，然后把数据加载到共享内存中，这样后面的进程就可以通过共享内存访问这些数据，不用再通过缓慢的磁盘读取来完成。direct path read读取数据块方式，是指服务器进程直接读取数据文件，不经过buffer cache，这种方式读取的数据块会加载到服务器进程的PGA内中当中，不会进入buffer cache中。11G之前的direct path read主要用于并行查询中，此等待事件的三个参数p1,p2,p3分别代表：file#：文件号，first block#：读取的起始块号，block count：以first block为起点，连续读取的物理块数。而从11G之后，direct path read不仅可用于并行查询，在符合某些条件后，串行的全表扫描也可以利用direct path read方式来完成。这里主要介绍11G direct path read相关的特性。

      有一次经历让我印象深刻，那是要对一张大表上一个核心索引进行重建，表的大小几十个G是有的。当时预估了时间（全表扫描+排序）应该十几分钟可以搞定，但是让我吃惊的是整个重建过程足足搞了快1个小时。不停的查看重新索引会话的等待事件，大多数时候都是db file sequential read，零星的能看到几次db file scattered read，虽然指定的多块读大小为128，但是观察到的p3参数小的可怜。导致索引重建慢的原因不难分析，是由于这个表的不少数据被缓存进了buffer cache中，虽然设置的多块读参数为128，但是由于总是无法读取到符合要求的连续的数据块而让性能大打折扣，这里所谓的符合要求指的是读取的数据块都不在buffer cache之中。例如：
1756815335673-d64a66b9-ee23-4151-bffb-8aed98031e48.jpg
   上面的12个块为一个extent，假设都不在buffer cache中的话，一次物理IO就可以完成，但是由于部分块被cache，而导致总共需要6次的物理IO才行。因此在做全表扫描的情况下，表里的数据一部分被cache并不见得总是好事。当时我在想，如果可以绕过buffer cache，直接路径读取就好了。11G以后，ORACLE终于推出了这个功能，在全表扫描的时候，如果ORACLE认为这个表足够大，就会启用直接路径读取，而不需要像11G之前，必须先把数据加载到buffer cache。

采用direct path read完成读取的条件1）表大于_small_table_threshold的参数值设置 Oracle通过隐含参数_small_table_threshold来界定大表小表的临界，Oracle认为对于大表执行直接路径读取的意义比较大，对于小表通过将其缓存可能受益更大。_small_table_threshold的单位为block。默认为db cache size的2%大小，在实例启动过程中动态决定。11GR2之前，表的大小要是_small_table_threshold参数值的5倍才会采取直接路径读取方式，11GR2后只需要满足_small_table_threshold定义的大小就会采取直接路径读取。我们可以简单的看一下11GR2下的一个测试： [html]view plaincopy

  1. create tablespace test datafile '+DG_DATA/test/test.dbf' size 64m segment space management manual;
  2. create table t (v varchar2(100)) pctused 1 pctfree 99 tablespace test;
  3. show parameter small

    4. 4. 5.

  4. NAME TYPE VALUE
  5. ———————————— ———————- ——————————
  6. _small_table_threshold integer 3000

    7. 9. 10.

  7. CREATE OR REPLACE FUNCTION GET_ADR_TRSH(P_STEP IN NUMBER,
  8. P_START IN NUMBER DEFAULT 0,
  9. P_STOP IN NUMBER DEFAULT NULL)
  10. RETURN NUMBER IS
  11. L_PRD NUMBER;
  12. L_CNT NUMBER;
  13. L_BLOCKS NUMBER := 0;
  14. L_START NUMBER := P_START;
  15. BEGIN
  16. EXECUTE IMMEDIATE 'truncate table t';
  17. LOOP
  18. INSERT /*+ append */
  19. INTO T
  20. SELECT RPAD('*', 100, '*')
  21. FROM DUAL
  22. CONNECT BY LEVEL <= P_STEP + L_START;
  23. COMMIT;
  24. L_BLOCKS := L_BLOCKS + P_STEP + L_START;
  25. L_START := 0;
  26. EXECUTE IMMEDIATE 'alter system flush buffer_cache';
  27. SELECT /*+ full(t) */
  28. COUNT(*)
  29. INTO L_CNT
  30. FROM T;
  31. SELECT VALUE
  32. INTO L_PRD
  33. FROM V$SEGMENT_STATISTICS
  34. WHERE OWNER = USER
  35. AND OBJECT_NAME = 'T'
  36. AND STATISTIC_NAME = 'physical reads direct';
  37. EXIT WHEN(L_PRD > 0 OR L_BLOCKS > NVL(P_STOP, L_BLOCKS));
  38. END LOOP;
  39. RETURN L_BLOCKS – P_STEP;
  40. END;
  41. /

    42. 46. 47.

  42. set serveroutput on
  43. DECLARE
  44. L_TRSH NUMBER;
  45. BEGIN
  46. L_TRSH := GET_ADR_TRSH(10, 1500, 4000);
  47. DBMS_OUTPUT.PUT_LINE(L_TRSH);
  48. END;
  49. /
  50. 3000
   以上的代码大家可以研究一下，我不做详细说明了，大体的意思是不断的增加表大小，观察增加到表上的block有多少时，会采取直接路径读取。我们测试的结果是3000，刚好和我们定义的_small_table_threshold参数值完全吻合。11GR1的话，经过测试是_small_table_threshold的5倍的时候才会出现直接路径读取。但是表的大小并不仅仅是唯一决定是否采用直接路径读取的因素，还有其他两个因素：脏块的比例、表中数据被cache的比例

2）表上的脏块小于表总block数的25% 下面的代码通过不断增加表的脏块数，当达到表脏块数的25%的时候，不在发生直接路径读取事件了。

[html]view plaincopy

  1. CREATE OR REPLACE FUNCTION GET_DIRTY_TRSH(P_STEP IN NUMBER,
  2. P_START IN NUMBER DEFAULT 0,
  3. P_STOP IN NUMBER DEFAULT NULL)
  4. RETURN NUMBER IS
  5. L_TRSH NUMBER := 0;
  6. L_PRD NUMBER := 0;
  7. L_CNT NUMBER := 0;
  8. L_START NUMBER := P_START;
  9. BEGIN
  10. EXECUTE IMMEDIATE 'alter system flush buffer_cache';
  11. LOOP
  12. L_TRSH := L_TRSH + P_STEP + L_START;
  13. UPDATE T SET V = V WHERE ROWNUM <= L_TRSH;
  14. COMMIT;
  15. L_START := 0;
  16. SELECT /*+ full(t) */
  17. COUNT(*)
  18. INTO L_CNT
  19. FROM T;
  20. SELECT VALUE
  21. INTO L_CNT
  22. FROM V$SEGMENT_STATISTICS
  23. WHERE OWNER = USER
  24. AND OBJECT_NAME = 'T'
  25. AND STATISTIC_NAME = 'physical reads direct';
  26. EXIT WHEN L_CNT = L_PRD OR L_TRSH > NVL(P_STOP, L_TRSH);
  27. L_PRD := L_CNT;
  28. END LOOP;
  29. RETURN L_TRSH;
  30. END;
  31. /

    32. 32. 33.

  32. DECLARE
  33. L_TRSH NUMBER;
  34. BEGIN
  35. L_TRSH := GET_DIRTY_TRSH(1, 350, 4000);
  36. DBMS_OUTPUT.PUT_LINE(L_TRSH);
  37. END;
  38. /
  39. 739

我们看到脏块的比例大约达到表块的25%（共3000个表块）的时候，直接路径读消失了。

3）表中的块被cache的比例小于50%的时候

[html]view plaincopy

  1. CREATE OR REPLACE FUNCTION GET_CACHED_TRSH(P_START IN NUMBER DEFAULT 0,
  2. P_STEP IN NUMBER DEFAULT 1)
  3. RETURN NUMBER IS
  4. CURSOR L_CUR IS
  5. SELECT /*+ index(t i_t) */
  6. t
  7. FROM T WHERE v='****************************************************************************************************';
  8. L_V VARCHAR2(100);
  9. L_TRSH NUMBER := 0;
  10. L_PRD NUMBER := 0;
  11. L_CNT NUMBER := 0;
  12. L_START NUMBER := P_START;
  13. BEGIN
  14. EXECUTE IMMEDIATE 'alter system flush buffer_cache';
  15. OPEN L_CUR;
  16. LOOP
  17. FOR I IN 1 .. P_STEP + L_START LOOP
  18. FETCH L_CUR
  19. INTO L_V;
  20. END LOOP;
  21. L_TRSH := L_TRSH + P_STEP + L_START;
  22. L_START := 0;
  23. SELECT /*+ full(t) */
  24. COUNT(*)
  25. INTO L_CNT
  26. FROM T;
  27. SELECT VALUE
  28. INTO L_CNT
  29. FROM V$SEGMENT_STATISTICS
  30. WHERE OWNER = USER
  31. AND OBJECT_NAME = 'T'
  32. AND STATISTIC_NAME = 'physical reads direct';
  33. EXIT WHEN L_CNT = L_PRD OR L_CUR%NOTFOUND;
  34. L_PRD := L_CNT;
  35. END LOOP;
  36. CLOSE L_CUR;
  37. RETURN L_TRSH;
  38. END;
  39. /
  40. create index i_t on t (v);
  41. DECLARE
  42. L_TRSH NUMBER;
  43. BEGIN
  44. L_TRSH := GET_CACHED_TRSH(500, 1);
  45. DBMS_OUTPUT.PUT_LINE(L_TRSH);
  46. END;
  47. /

    48. 48.

  48. 1497

在接近50%（共3000个表块）的表块被cache的时候，直接路径读消失了。

1756815335814-c8a14914-1838-4bb5-96b2-cefc150de63c.jpg

满足以上条件时，Oracle会进行直接路径读取。Oracle为直接路径读取设置的三个“门槛”，非常的合理：

第一个阀值：表大小，太小的表从direct path read中的获益太小。但是特别需要引起你的警惕，如果表上存在统计信息，那么ORACLE会采取表的统计信息中记录的block与_small_table_threshold的设定值来做比较，而不是表的真实大小（dba_segments中记录的值）。这可能导致一些不是你预期的情况发生。如果你的统计信息与表的真实情况差异很大，那么你应该仔细考虑可能发生什么样的结果。如果你的表没有统计信息，ORACLE会依据表的真实大小来决定是否进行direct path read。

第二个阀值：脏块阀值，由于direct path read需要出发一个段的检查点，因此脏块太多，刷新脏块可能会导致IO繁忙

第三个阀值：表在内存里的cache率,如果cache率很高，那么还是走传统路径更快。direct path read的出现，需要让ORACLE公司的开发人员设计一个单独的结构来存储每个表有多少数据是脏数据，有多少数据被cache。不过这个结构目前还并未暴露给我们查询。在flush buffer cache后，这个结构被清空。（flush shared_pool并不会被清空）

 当你预期一个查询应该会走direct path read，但是却走了传统的路径扫描的时候，应该检查是否违背了这三个前置条件中的一个或几个。不过很多时候，当一个查询“应该”走direct path read但是却没有的时候，你往往无能为力，你能在数据库运行过程中修改表的数据的cache比例吗？不能！你能修改表的脏数据的比例吗？往往也不能，通过修改表的统计信息中的表块数，可以满足第一个条件，但是如果不满足其他两个条件，依然不能有效。你可以通过flush buffer cache来满足后两个条件，但往往在生产环境中不被允许。我曾经在个人微博(新浪微博：魏兴华-DBA)发布过一个关于索引创建走不上direct path read的微博，现在终于想明白了，不满足第三个条件，表被cache的内容需要低于50%。

direct path read的优势

 1、我认为非常重要的，参照我文章开头举得例子，采用直接路径读取后，总能保证读取的块数是多块读参数设置的大小，提高了读取的效率     2、大大的降低了对于latch的使用，进而避免了可能导致的latch竞争（cbc latch等）    3、降低了全表扫描对buffer cache的冲击    4、降低了buffer pin的开销，有可能降低buffer busy waits等相关等待

如何控制direct path read的开关 有两种方法来启用、禁用这个特性。event 10949或者设置隐含参数_serial_direct_read。两种方式都可以在session或system级别设置。 1、event 10949设置后，可以禁用direct path read。

每次测试前为了避免脏块和缓冲块对测试的影响，都先将buffer cache清空。我们在session级别测试，system级别的测试方法是一样的，这里就不再赘述。[html]view plaincopy

  1. SQL> alter system flush buffer_cache;
  2. System altered.

    3. 3.

  3. SQL> ALTER session SET EVENTS '10949 TRACE NAME CONTEXT FOREVER';

    4. 5. 6.

  4. Session altered.

    5. 8.

  5. SQL> execute snap_events.start_snap

    6. 10.

  6. PL/SQL procedure successfully completed.

    7. 12. 13.

  7. SQL> select count(*) from t;

    8. 15. 16.

  8. COUNT(*)
  9. ———-
  10. 10090944

    11. 20. 21.

  11. SQL> set serveroutput on
  12. SQL> execute snap_events.end_snap
  13. ———————————————————
  14. SID: 2929:DLSP – oracle
  15. Session Events – 08-Sep 10:58:50
  16. Interval:- 18 seconds
  17. ———————————————————
  18. Event Waits Time_outs Csec Avg Csec Max Csec
  19. —– —– ——— —- ——– ——–
  20. Disk file operations I/O 17 0 0 .012 0
  21. db file scattered read 1,115 0 96 .086 1
  22. SQL*Net message to client 6 0 0 .000 0
  23. SQL*Net message from client 6 0 1,323 220.444 2,350

    24. 35. 36.

  24. PL/SQL procedure successfully completed.

    25. 38. 39.

  25. SQL> alter system flush buffer_cache;

    26. 41. 42.

  26. System altered.
  27. SQL> ALTER session SET EVENTS '10949 TRACE NAME CONTEXT off';

    28. 45.

  28. Session altered.

    29. 47.

  29. SQL> execute snap_events.start_snap

    30. 49. 50.

  30. PL/SQL procedure successfully completed.

    31. 52. 53.

  31. SQL> select count(*) from t;

    32. 55. 56.

  32. COUNT(*)
  33. ———-
  34. 10090944

    35. 60. 61.

  35. SQL> execute snap_events.end_snap
  36. ———————————————————
  37. SID: 2929:DLSP – oracle
  38. Session Events – 08-Sep 10:59:56
  39. Interval:- 8 seconds
  40. ———————————————————
  41. Event Waits Time_outs Csec Avg Csec Max Csec
  42. —– —– ——— —- ——– ——–
  43. db file sequential read 1 0 0 .024 0
  44. direct path read 1113 0 300 .232 1
  45. SQL*Net message to client 5 0 0 .001 0
  46. SQL*Net message from client 5 0 445 89.034 2,673
   我们通过snap_events脚本获取了会话执行语句前后等待事件的差值，启用10949事件后，执行了db file scattered read，关闭10949事件后，以direct path read方式进行了表扫描。
     2、通过设置隐含参数_serial_direct_read来设置是否启用direct path read，同样我们只在session级别做测试，system级别可以由读者自己来完成。

[html]view plaincopy

  1. SQL>alter session set "_serial_direct_read"=never;
  2. Session altered.

    3. 3.

  3. SQL> execute snap_events.start_snap

    4. 5.

  4. PL/SQL procedure successfully completed.

    5. 7.

  5. SQL> select count(*) from t;

    6. 9. 10.

  6. COUNT(*)
  7. ———-
  8. 10090944
  9. SQL>execute snap_events.end_snap
  10. SQL> ———————————————————
  11. SID: 2641:DLSP – oracle
  12. Session Events – 08-Sep 10:49:46
  13. Interval:- 9 seconds
  14. ———————————————————
  15. Event Waits Time_outs Csec Avg Csec Max Csec
  16. —– —– ——— —- ——– ——–
  17. Disk file operations I/O 6 0 0 .001 0
  18. db file sequential read 1 0 0 .030 1
  19. db file scattered read 1,115 0 154 .138 4
  20. SQL*Net message to client 5 0 0 .000 0
  21. SQL*Net message from client 5 0 228 45.510 1,912

    22. 27.

  22. PL/SQL procedure successfully completed.

    23. 29.

  23. SQL> alter session set "_serial_direct_read"=auto;

    24. 31.

  24. Session altered.

    25. 33.

  25. SQL> alter system flush buffer_cache;

    26. 35.

  26. System altered.

    27. 37.

  27. SQL> execute snap_events.start_snap

    28. 39.

  28. PL/SQL procedure successfully completed.

    29. 41.

  29. SQL> select count(*) from t;

    30. 43. 44.

  30. COUNT(*)
  31. ———-
  32. 10090944
  33. SQL>execute snap_events.end_snap
  34. SQL> ———————————————————
  35. SID: 2641:DLSP – oracle
  36. Session Events – 08-Sep 10:50:21
  37. Interval:- 10 seconds
  38. ———————————————————
  39. Event Waits Time_outs Csec Avg Csec Max Csec
  40. —– —– ——— —- ——– ——–
  41. db file sequential read 1 0 0 .028 1
  42. direct path read 1112 0 42 .164 0
  43. SQL*Net message to client 5 0 0 .000 0
  44. SQL*Net message from client 5 0 730 146.016 1,912

    45. 60.

  45. PL/SQL procedure successfully completed.

_serial_direct_read设置为never后，系统采取了传统的扫描路径，出现了db file scattered read等待时间，_serial_direct_read为auto后，采用了direct path read的等待事件。

direct path read可能的副作用 1、会发生段一级的检查点（后面详细介绍），因此在查询真正开始执行前，会做这个额外的准备工作。而且可能会造成IO抖动，因为要写脏数据。 2、如果你的表需要频繁的全表扫描读取，还是用传统的读取方式比较好。 3、在MOS中搜索direct path read，会发现它可能会导致多次的延迟块清除（后面详细介绍）

直接路径读为什么要发生检查点？ Oracle的一致性读取代表的是：读取到的数据是查询开始时刻的数据，在你对一个大表发出查询前，首先需要发生一个段级别的检查点来保证这个段上的脏数据已经被刷新到了磁盘，如果不这样做会发生什么情况？ 举个例子就会很容易明白：查询发生时，某条记录的id值在磁盘上的值为5，内存中的值为6。如果不发生段一级的检查点就开始直接路径读取，那么进程在读取到这个记录所在的数据块后发现，块上的scn是小于查询scn的，读取是安全的，因此直接把5作为结果返回给用户。完全违背了数据库（块）的一致性读取。因此Oracle在直接路径读取之前，都会发生一个段一级的检查点来保证一致性的读取。通过10046很容易看到发生的段级别的检查点。 [html]view plaincopy

  1. PARSING IN CURSOR #4573489040 len=22 dep=0 uid=45 oct=3 lid=45 tim=1735265030575 hv=2763161912 ad='70000036058fd08' sqlid='cyzznbykb509s'
  2. select count(*) from t
  3. END OF STMT
  4. PARSE #4573489040:c=60,e=101,p=0,cr=0,cu=0,mis=0,r=0,dep=0,og=1,plh=1842905362,tim=1735265030574
  5. EXEC #4573489040:c=51,e=84,p=0,cr=0,cu=0,mis=0,r=0,dep=0,og=1,plh=1842905362,tim=1735265030719
  6. WAIT #4573489040: nam='SQL*Net message to client' ela= 9 driver id=1650815232 #bytes=1 p3=0 obj#=-1 tim=1735265030759
  7. WAIT #4573489040: nam='reliable message' ela= 89 channel context=504403173615444552 channel handle=504403173661108944 broadcast message=504403173662264424 obj#=-1 tim=1
  8. 735265031335
  9. WAIT #4573489040: nam='enq: KO – fast object checkpoint' ela= 10064 name|mode=1263468550 2=65588 0=1 obj#=-1 tim=1735265041430

说明： 1）直接路径读取如果有必要，也会去构造CR块，不过这里的CR块是在PGA中构造的，而不是在buffer cache中构造的。 2）如果表上没有任何的脏数据，并不会触发段上的检查点，这一点也很容易用10046跟踪出来，因此如果你想通过10046跟踪到段检查点，需要保证这个表上在内存中有脏数据。

延迟块清除与直接路径读 由于直接路径读取是发生在进程的PGA中的，如果读取过程中，ORACLE发现一些块没有做块清除，会在PGA中进行延迟块清除的操作，但是这个清除的操作并不会记录日志，且被清除过的块并不会被刷回到磁盘。正是由于延迟清除过的块不被写回到磁盘，因此如果有比较多的进程来进行直接路径读取，就会导致各个进程反复的进行块清除的操作，一定程度上浪费了CPU资源。（我们下面的测试用到的 snap_my_stats包，可以采样两次会话的统计信息差值，来获取两次采样间的信息增量） 1）我们先看看传统路径扫描下，延迟块清除的情况update t set object_id=1 where rownum<10000;

另开一个session对buffer_cache进行刷新。SQL> commmit;

禁用direct path read [html]view plaincopy

  1. SQL> alter session set "_serial_direct_read"=never;

    2. 2.

  2. Session altered.

    3. 4.

  3. SQL> execute snap_my_stats.start_snap

    4. 6. 7.

  4. PL/SQL procedure successfully completed.

    5. 9.

  5. SQL> select count(*) from t;

    6. 11.

  6. COUNT(*)
  7. ———-
  8. 10090944

    9. 15.

  9. SQL> execute snap_my_stats.end_snap
  10. SQL> ———————————
  11. Session stats – 08-Sep 11:51:00
  12. Interval:- 11 seconds
  13. ———————————
  14. Name Value
  15. —- —–
  16. redo size 9,764
  17. cleanouts only – consistent read gets 135
  18. immediate (CR) block cleanout applications 135
  19. commit txn count during cleanout 135
  20. cleanout – number of ktugct calls 135

    21. 28. 29.

  21. PL/SQL procedure successfully completed.
   可以看到，相关延迟块清除的工作，都有了相应的指标，而且清除过程中产生了redo。我们来看看第二次读取还会不会发生延迟块清除。

[html]view plaincopy

  1. SQL> execute snap_my_stats.start_snap

    2. 2. 3.

  2. PL/SQL procedure successfully completed.

    3. 5. 6.

  3. SQL> select count(*) from t;

    4. 8. 9.

  4. COUNT(*)
  5. ———-
  6. 10090944

    7. 13.

  7. SQL> execute snap_my_stats.end_snap
  8. SQL> ———————————
  9. Session stats – 08-Sep 11:51:24
  10. Interval:- 3 seconds
  11. ———————————
  12. Name Value
  13. —- —–
  14. DB time 343
  15. non-idle wait count 5
  16. consistent gets 140,109
  17. consistent gets from cache 140,109

    18. [html]view plaincopy

  18. PL/SQL procedure successfully completed.

没有任何延迟块清除的统计信息了采用传统的路径读取，延迟块清除只需要进行一次，后续如果再有会话读取，不需要再做任何有关块清除的工作。

2）直接路径扫描下延迟块清除的情况准备工作略（update,flush buffer cache，commit）

[html]view plaincopy

  1. SQL> alter session set "_serial_direct_read"=auto;

    2. 2.

  2. Session altered.

    3. 4.

  3. SQL> execute snap_my_stats.start_snap

    4. 6. 7.

  4. PL/SQL procedure successfully completed.

    5. 9. 10.

  5. SQL> select count(*) from t;

    6. 12.

  6. COUNT(*)
  7. ———-
  8. 10090944

    9. 16.

  9. SQL>execute snap_my_stats.end_snap
  10. SQL> ———————————
  11. Session stats – 08-Sep 11:53:39
  12. Interval:- 4 seconds
  13. ———————————
  14. Name Value
  15. —- —–
  16. cleanouts only – consistent read gets 135
  17. immediate (CR) block cleanout applications 135
  18. commit txn count during cleanout 135
  19. cleanout – number of ktugct calls 135

    20. 28.

  20. PL/SQL procedure successfully completed.

第一次读取发生了延迟块清除。但是由于redo size 没发生任何变化，因此没有结果显示。

[html]view plaincopy

  1. SQL> execute snap_my_stats.start_snap

    2. 2. 3.

  2. PL/SQL procedure successfully completed.

    3. 5. 6.

  3. SQL> select count(*) from t;

    4. 8.

  4. COUNT(*)
  5. ———-
  6. 10090944

    7. 12.

  7. SQL>execute snap_my_stats.end_snap
  8. SQL> ———————————
  9. Session stats – 08-Sep 11:53:52
  10. Interval:- 3 seconds
  11. ———————————
  12. Name Value
  13. —- —–
  14. cleanouts only – consistent read gets 135
  15. immediate (CR) block cleanout applications 135
  16. commit txn count during cleanout 135
  17. cleanout – number of ktugct calls 135

    18. 24. 25.

  18. PL/SQL procedure successfully completed.

第一次读取发生了延迟块清除。但是由于redo size 没发生任何变化，因此没有结果显示。

第二次查询依然会进行延迟块清除，一定程度上多消耗了CPU时间。

参考文章：http://afatkulin.blogspot.com/2009/01/11g-adaptive-direct-path-reads-what-is.htmlhttp://afatkulin.blogspot.com/2012/07/serial-direct-path-reads-in-11gr2-and.html

补充：表中的数据块被cache的数量，可以从X$KCBOQH.NUM_BUF来查看。11GR2依据统计信息来决定表的大小。通过隐含参数 _direct_read_decision_statistics_driven 来控制。http://blog.tanelpoder.com/2012/09/03/optimizer-statistics-driven-direct-path-read-decision-for-full-table-scans-_direct_read_decision_statistics_driven/

如果是online创建索引，即使指定并行，也无法使用direct path read，具体原因还不清楚。