CREATE TABLESPACE zlflashback
DATAFILE 'D:\APP\ADMINISTRATOR\ORADATA\ORCL\zlflashback.dbf'
SIZE 10M AUTOEXTEND ON;

Create Flashback Archive fla_zltab Tablespace zlflashback Retention 1 Month;
alter table 病人信息 flashback archive fla_zltab;

SQL> insert into 病人信息(病人id,姓名) values(1,'巴基斯');
1 row inserted
SQL> commit;
Commit Complete
SQL> update 病人信息 set 姓名='卡巴基斯' where 病人id=1;
1 row Updated
SQL> commit;
Commit Complete
SQL> set time on;
17:12:09 SQL> delete 病人信息 where 病人id=1;
1 row deleted
17:12:29 SQL> commit;

SQL>Select * From 病人信息
As Of Timestamp To_Timestamp('02/20/2008 17:12:09', 'mm/dd/yyyy hh24:mi:ss')
Where 病人id = 1;
             病人ID 姓名
------------------- --------------------
                  1 卡巴基斯

查看闪回事务
Select * From flashback_transaction_query Where table_name='病人信息'
查看有哪些闪回归档库
Select * From dba_flashback_archive;
查看哪些表使用了闪回归档
Select * From User_Flashback_Archive_Tables

参考文档:http://www.oracle.com/technology/global/cn/pub/articles/oracle-database-11g-top-features/11g-transactionmanagement.html
注意,该文档这两个表名有错,flashback_archives,user_flashback_archived_tables

在配置流复制环境时，将数据库配置为归档模式后，在执行流配置时卡住了，查日志文件发现是日志文件无法归档，于是手工强制归档，出现了如下错误：

SQL> archive log next

ORA-16014: 日志 3 的序列号 127 未归档, 没有可用的目的地

ORA-00312: 联机日志3线程1: 'D:\ORACLE\PRODUCT\10.2.0\ORADATA\TEST\REDO03.LOG'

于时检查归档文件的参数log_archive_dest，db_recovery_file_dest，没有发现问题，又检查了文件夹的NTFS权限，也没有问题。又执行下面的归档命令发现：

SQL> archive log all

ORA-16020: 可用的目的地少于由 LOG_ARCHIVE_MIN_SUCCEED_DEST 指定的数量

       到后来，数据库重启后根本打不开了，只能启动到Mout状态。

SQL> alter database open;

alter database open

*

第 1 行出现错误:

ORA-16014: 日志 3 的序列号 127 未归档， 没有可用的目的地

ORA-00312: 联机日志 3 线程 1:

’ D:\ORACLE\PRODUCT\10.2.0\ORADATA\TEST\REDO03.LOG’

查看警告日志文件中发现的错误，怀疑是空间不够，于是修改了参数db_recovery_file_dest_size，由1G改为2G，仍然不够，改为3G后，执行归档正常了。

       感到很奇怪，归档日志所在的盘，可用空间不止3G，已用的归档日志删除后也很少，是什么原因导致Oracle认为归档所需的空间不够呢?

       分析警告日志文件发现有下面的信息：

       Errors in file g:\oracle\product\10.2.0\db_1\admin\orcl\bdump\orcl_arc1_5188.trc:

ORA-19815: WARNING: db_recovery_file_dest_size of 2147483648 bytes is 100.00% used, and has 0 remaining bytes available.

       看来，确实Oracle认为归档目录的空间满了，继续分析发现联机日志文件使用的是缺省尺寸50M(Oracle 10G的缺省大小)，回想起有一段时间数据库是运行在归档模式的，这么大的联机日志归档，当然空间增长很快。

       于是，先重建联机日志文件，改为每个文件5M。

       但是，归档日志是删除了的，占用的空间根本就没有2G，Oracle为什么认为空间不够呢？原来，Oracle内部还记录了这些归档文件的信息，物理文件虽然删除了，但是文件相关的信息仍然在Oracle数据库中，需要使用Rman的命令来清除这些信息。

       RMAN>connect target /

       RMAN>crosscheck archivelog all

       RMAN> delete expired archivelog all

       最后，再修改db_recovery_file_dest_size，改为1G，执行强制归档，一切正常了。

    近日在配置Oracle 10G的流复制环境时，遇到一个问题，关闭数据库（shutdown immediate）后，通过SQL Plus连接数据库:conn sys/his@orc0 as sysdba，出现如下错误：

    ORA-12514: TNS: 监听程序当前无法识别连接描述符中请求的服务

通过重启服务的方式启动数据库，再次连接却能成功登录，也就是说在关闭数据库状态下无法连接服务器。

    开始以为是系统环境变量Oracle_SID的配置问题，因为机器有多个实例，一阵折腾后还是不能连接。后来查资料得知：

    Oracle9i以后，后台进程PMON自动在监听器中注册在系统参数SERVICE_NAMES中定义的服务名，SERVICE_NAMES默认为DB_NAME+DOMAIN_NAME。监听配置文件listener.ora中可以不必指定监听的服务名。但是，当数据库处于关闭状态下PMON进程没有启动，也就不会自动注册监听的实例名，所以使用sqlplus sys/his@orc0 as sysdba 会出现ORA-12514错误。

如果在listener.ora文件中指定监听的实例名，则即使数据库处于关闭状态，仍然可以连接。

listener.ora

SID_LIST_LISTENER =

  (SID_LIST =

    (SID_DESC =

      (SID_NAME = PLSExtProc)

      (ORACLE_HOME = G:\oracle\product\10.2.0\db_1)

      (PROGRAM = extproc)

    )

   (SID_DESC =

    (GLOBAL_DBNAME = ORCL)

    (ORACLE_HOME = G:\oracle\product\10.2.0\db_1)  

    (SID_NAME = ORCL)

    )

  )

LISTENER =

  (DESCRIPTION_LIST =

    (DESCRIPTION =

      (ADDRESS = (PROTOCOL = TCP)(HOST = zyk)(PORT = 1521))

    )

  )

以上粗体部件为增加的内容，修改后重启监听服务后即可。

附：通过在lsnrctl中输入set display verbose，然后再通过命令service查看，服务状态为READY表示PMON自动注册的服务名，而UNKNOWN则表示该服务是手工在LISTENER.ORA中配置的数据库服务。

生成10-100的数字：select rownum+(10-1) from dual connect by rownum<=100-(10-1)

生成100以内的基数：select rownum*2-1 from dual connect by rownum<=50

生成100以内的偶数：select rownum*2 from dual connect by rownum<=50

生成100个随机数：Select Dbms_Random.random From dual connect by rownum<=100

Note:292096.1,Note:370633.1这两篇文章有介绍，当导出导入表的时候，如果有主键约束及索引，索引导入的时候没有和主键约束建立依赖，所以删除约束时，索引没有被删除。

另一种情况是Oracle 10G的一项改变,Note:309821.1

提供的解决办法就是加上删除索引的语法：alter table < table > drop constraint < constraint > drop index;
注意：Drop index的语法是9i才支持的。

Subject:	Oracle 10G Does not Drop User Index Associated With Unique/Primary Key Constraints
	Doc ID:	Note:309821.1	Type:	PROBLEM
	Last Revision Date:	31-MAY-2005	Status:	MODERATED

<script language="JavaScript"></script>

The information in this document applies to:

Oracle Server - Enterprise Edition - Version: 10.1.0.2 to 10.2.0.0
This problem can occur on any platform.

Symptoms

Drop constraint does not drop a associated index in 10G

Cause

In 10g, a change was made to an internal function "atbdui" to not to drop the user index when the constraint using the index is dropped.

In 9i, this behavior is different the user index
gets dropped when the constraint is dropped.

Select index_name,generated from dba_indexes where index_name='< ;index_name >';

Generated column would show 'Y' If the index is system generated.If 'N' ,it is user generated.

Solution

This behaviour is because of the code changes made in 10G.

Use the workaround:

alter table < table > drop constraint < constraint > drop index;

Note

If the index is non unique, we can still use them for enforcing primary key constraints or unique constraints.

But dropping the constraint does not drop the non-unique index.
This behaviour is seen from 8174 to 10.2.0.0.

Sample Output

SQL> create table test( a number );

Table created.

SQL> create index ind on test ( a );

Index created.

SQL> alter table test add constraint c1_pk primary key(a) using index;

Table altered.

SQL> select index_name from user_indexes where table_name='TEST';

INDEX_NAME
------------------------------
IND

SQL> alter table test drop constraint c1_pk;

Table altered.

SQL> select index_name from user_indexes where table_name='TEST';

INDEX_NAME
------------------------------
IND

References

Note 292096.1 - Encountering ora-00955 when trying to create primary key on an imported table in 10g

Keywords

'USING~INDEX'  

实现方法：
SQL> conn sys/oracle
SQL> select password from dba_users where username='USER1';(用户名大写)
记录该用户在数据库存储的密码:035DFA98F036A771

SQL> alter user USER1 identified by aaa;
SQL> conn user1/aaa
SQL> 执行你想要的操作...

SQL> conn sys/oracle
SQL> alter user USER1 identified by values '035DFA98F036A771';

通过这种方式,管理员可以用某个用户的名字进行数据库操作.

专用服务器

一个客户端连接对应一个服务器进程

共享服务器

多个客户端连接对应一个服务器进程，服务器端存在一个进程调度器来管理。

Oracle缺省用的是专用服务器模式，Oracle可以同时支持共享服务器和专用服务器模式，可以指定一个会话使用专用服务器，另一个会话使用共享服务器。

MTS具有以下一些缺点：

1) 共享服务器的代码路径比专用服务器长，所以它天生就比专用服务器慢。

2) 存在人为死锁的可能，因为它是串行的，只要一个连接阻塞，则该服务器进程上的所有用户都被阻塞，并且极可能死锁。

3) 存在独占事务的可能，因为如果一个会话的事务运行时间过长，它独占共享资源，其它用户只能等待，而专用服务器，每个客户端是一个会话。

4) 共享服务器模式限制了某些数据库特性，例如：不能单独启动和关闭实例，不能进行介质恢复，不能使用Log Miner，并且SQL_TRACE没有意义(因为是共享而不是当前会话的)。

MTS减少的内存实际上是专用服务器模式下每个用户连接到操作系统进程所需的内存，但它却使用SGA的Large_Pool来分配UGA，拆东墙补西墙，所减少的内存是很少的。

如果用户会话的连接和断开很频繁，数据库进程的创建和删除的开销会非常大，这种情况最好采用共享服务器模式(否则，应该使用连接池技术)。

如果客户端一次连接终身使用(会话生命周期内)，使用共享服务器模式的意义不大。因为大部分时间，一个会话就连接到一个服务器进程，无法共享服务器进程。

后来,找了一个9i的数据库测试,发现没有报错.
于是去查文档:Oracle Administrator's Guide,发现这项功能确实是9i以上的版本才增加的.
通过查询权限视图,可以看到这种方式授权后,授权人仍然是UserA,相关于Sys转授.

8i的该文档上记录了需要先用UserA将Grant Option的权限给Sys后才能由Sys转授.
先用UserA连接
Grant Select On Table1 to Sys With Grant Option;
然后,再用Sys连接
Grant Select On UserA.Table1 to UserB;

2. Logon SQLPLUS as user SYS or SYSTEM, and drop the sysman account and mangement objects:
a. drop user sysman cascade;
b. drop role MGMT_USER;
c. drop user MGMT_VIEW cascade;
d. drop public synonym MGMT_TARGET_BLACKOUTS;
e. drop public synonym SETEMVIEWUSERCONTEXT;

3.Create configuration files and repository run
emca -config dbcontrol db -repos create

创建EM时,提示的端口号,应为实例的断口号,比如1521,不是EM的端口号(比如1158)
EM的端口号在这个文件中可以查到10.2.0\db_1\sysman\config\emca.properties

如果是在Vista操作系统上，则需要用管理员帐号或者关闭UAC功能，否则创建时会报错。

然后,进行em后,界面出来了,但报了一个错:
java.lang.Exception: Exception in sending Request :: null
很多功能不能用,提示重新登录.
在Oracle论坛上查到了解决办法:
http://forums.oracle.com/forums/thread.jspa?threadID=320574&tstart=0&messageID=1374397
找到下面的文件
10.2.0\db_1\ZYKNET_ORC2\sysman\config\emd.properties
其中的agentTZRegion缺省是GMT,改为你所在的时区即可,例如:
agentTZRegion=Asia/Chungking
关于时区的列表参考：10.2.0\db_1\sysman\admin\supportedtzs.lst
然后，重启OracleDBConsole<SID>

Oracle提供了一个包dbms_utility.comma_to_table可以将参数列表转换为一个类型表，但是由于结果是通过参数传出的,无法用于应用程序的SQL语句中。

于是,我们仍然选择通过创建SQL表类型和相关函数来实现,Type：t_StrList, t_NumList， 函数：f_Str2List, f_Num2List，如下:

Create Or Replace type zltools.t_StrList as table of varchar2(4000)
/
Create Or Replace Function zltools.f_Str2List(Str_In In Varchar2) Return zltools.t_StrList As
 v_Str   Long Default Str_In || ',';
 v_Index Number;
 v_List  zltools.t_StrList := zltools.t_StrList();
--功能：将由逗号分隔的不带引号的字符序列转换为数据表
--参数：Str_In如:G0000123,G0000124,G0000125...
Begin
 Loop
  v_Index := Instr(v_Str, ',');
  Exit When(Nvl(v_Index, 0) = 0);
  v_List.Extend;
  v_List(v_List.Count) := Trim(Substr(v_Str, 1, v_Index - 1));
  v_Str := Substr(v_Str, v_Index + 1);
 End Loop;
 Return v_List;
End;
/
Create Or Replace type zltools.t_NumList as table of number
/
Create Or Replace Function zltools.f_Num2List(Str_In In Varchar2) Return zltools.t_NumList As
 v_Str   Long Default Str_In || ',';
 v_Index Number;
 v_List  zltools.t_NumList := zltools.t_NumList();
--功能：将由逗号分隔的数字序列转换为数据表
--参数：Str_In如:73265,73266,73267....
Begin
 Loop
  v_Index := Instr(v_Str, ',');
  Exit When(Nvl(v_Index, 0) = 0);
  v_List.Extend;
  v_List(v_List.Count) := To_Number(Trim(Substr(v_Str, 1, v_Index - 1)));
  v_Str := Substr(v_Str, v_Index + 1);
 End Loop;
 Return v_List;
End;
/

 
但是这种方法有一个问题：
如果用户使用CBO,使用这种方式的SQL语句，不加处理的话一般(要根据具体SQL分析)会错误的使用Hash连接来产生执行计划，不能正确使用索引从而引发性能问题，
因为Type Table不具备统计信息，在计算成本时，Oracle始终认为它有8168行，在基于成本的优化器模式下，多表连接时一般就会选择Hash连接，一般比使用索引的嵌套连接效率差。

目前，已知的解决办法有两种：
http://www.cnoug.org/viewthread.php?tid=1533&highlight=DROP%2B%2BCONSTRAINT%2Bindex
1. 对构造表的返回记录集加RowNum条件，通过子查询的实体化视图来改变执行计划，例如：
select * from table(Cast(zlTools.f_Str2List (v_str) as zlTools.t_StrList)) where rownum<5
2. 在SQL中加入优化器提示，例如：/*+ rule*/，或者/*+ ordered use_nl(t)*/，或者/*+ index(t ind_object_id)*/

第1种方式，需要对rownum的条件赋值，如果条件值采用动态的值，那么就达不到使用绑定变量的效果，如果采用固定值，有两种方案：
一种是使用一个固定的极限值，例如：99999，另一种是使用绑定变量。
试验结果见文末，这两种方式产生的执行计划采用了Hash连接，执行计划比不使用RowNum实体化视图更差。
 
第2种方式，如果使用指定嵌套连接提示或指定索引提示则需要对每个SQL针对性处理，需要分析具体的SQL。所以，一般情况建议在SQL中使用/*+ rule*/提示来固定执行计划。

--0.准备
--先创建表类型及转换函数: t_StrList,f_Str2List和t_NumList,f_Num2List
SQL> alter session set optimizer_mode=all_rows;
Session altered
SQL> var v_str varchar2(4000);
SQL> exec :v_str :='H0000005,H0000006,H0000007';

PL/SQL 过程已成功完成。

--1.当类型表不使用Rownum实体化视图时，错误地采用了Hash连接的执行计划，产生了6575块逻辑读+6909块物理读
SQL> Select a.No, a.结算方式, Nvl(b.性质, 1) As 性质, a.金额, a.摘要, a.结算号码
  2  From (Select b.No, Decode(a.记录性质, 3, a.结算方式, Null) As 结算方式, a.摘要, a.结算号码, Sum
(1 * a.冲预交) As 金额
  3      From 病人预交记录 a,
  4        (Select Distinct No, 结帐id
  5         From 病人费用记录
  6         Where 记录性质 = 1 And No In (
  7                Select * From Table(Cast(f_Str2List(:v_str) as t_StrList))
  8                ) And 记录状态 In (1, 3)) b
  9      Where a.结帐id = b.结帐id And a.记录性质 In (1, 11, 3) And Nvl(a.冲预交, 0) <> 0
 10      Group By b.No, Decode(a.记录性质, 3, a.结算方式, Null), a.摘要, a.结算号码) a, 结算方式 b
 11  Where a.结算方式 = b.名称(+);

执行计划
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=ALL_ROWS (Cost=23 Card=1 Bytes=100)
   1    0   NESTED LOOPS (OUTER) (Cost=23 Card=1 Bytes=100)
   2    1     VIEW (Cost=22 Card=1 Bytes=75)
   3    2       SORT (GROUP BY) (Cost=22 Card=1 Bytes=94)
   4    3         VIEW (Cost=21 Card=1 Bytes=94)
   5    4           SORT (UNIQUE) (Cost=21 Card=1 Bytes=149)
   6    5             TABLE ACCESS (BY INDEX ROWID) OF '病人预交记录' (Cost=1 Card=1 Bytes=102)
   7    6               NESTED LOOPS (Cost=19 Card=1 Bytes=149)
   8    7                 HASH JOIN (SEMI) (Cost=17 Card=4 Bytes=188)
   9    8                   INDEX (FAST FULL SCAN) OF '病人费用记录_UQ_NO' (UNIQUE) (Cost=4 Card=399 Bytes=17955)
  10    8                   COLLECTION ITERATOR (PICKLER FETCH) OF 'f_Str2List'
  11    7                 INDEX (RANGE SCAN) OF '病人预交记录_IX_结帐ID' (NON-UNIQUE)
  12    1     TABLE ACCESS (BY INDEX ROWID) OF '结算方式' (Cost=1 Card=1 Bytes=25)
  13   12       INDEX (UNIQUE SCAN) OF '结算方式_UQ_名称' (UNIQUE)

统计信息
----------------------------------------------------------
          0  recursive calls
          0  db block gets
       6575  consistent gets
       6909  physical reads
          0  redo size
        720  bytes sent via SQL*Net to client
        372  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          3  rows processed

--2.当类型表的查询条件中Rownum使用固定值时,正确地采用了嵌套连接的执行计划，仅仅产生了29块逻辑读
SQL> Select a.No, a.结算方式, Nvl(b.性质, 1) As 性质, a.金额, a.摘要, a.结算号码
  2  From (Select b.No, Decode(a.记录性质, 3, a.结算方式, Null) As 结算方式, a.摘要, a.结算号码, Sum
(1 * a.冲预交) As 金额
  3      From 病人预交记录 a,
  4        (Select Distinct No, 结帐id
  5         From 病人费用记录
  6         Where 记录性质 = 1 And No In (
  7                Select * From Table(Cast(f_Str2List(:v_str) as t_StrList)) Where Rownum<4
  8                ) And 记录状态 In (1, 3)) b
  9      Where a.结帐id = b.结帐id And a.记录性质 In (1, 11, 3) And Nvl(a.冲预交, 0) <> 0
 10      Group By b.No, Decode(a.记录性质, 3, a.结算方式, Null), a.摘要, a.结算号码) a, 结算方式 b
 11  Where a.结算方式 = b.名称(+);

执行计划
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=ALL_ROWS (Cost=23 Card=4 Bytes=400)
   1    0   NESTED LOOPS (OUTER) (Cost=23 Card=4 Bytes=400)
   2    1     VIEW (Cost=21 Card=4 Bytes=300)
   3    2       SORT (GROUP BY) (Cost=21 Card=4 Bytes=376)
   4    3         VIEW (Cost=20 Card=4 Bytes=376)
   5    4           SORT (UNIQUE) (Cost=20 Card=4 Bytes=8596)
   6    5             TABLE ACCESS (BY INDEX ROWID) OF '病人预交记录' (Cost=1 Card=1 Bytes=102)
   7    6               NESTED LOOPS (Cost=17 Card=4 Bytes=8596)
   8    7                 NESTED LOOPS (Cost=13 Card=12 Bytes=24564)
   9    8                   VIEW OF 'VW_NSO_1' (Cost=11 Card=3 Bytes=6006)
  10    9                     COUNT (STOPKEY)
  11   10                       COLLECTION ITERATOR (PICKLER FETCH) OF 'f_Str2List'
  12    8                   INLIST ITERATOR
  13   12                     INDEX (RANGE SCAN) OF '病人费用记录_UQ_NO' (UNIQUE) (Cost=1 Card=4 Bytes=180)
  14    7                 INDEX (RANGE SCAN) OF '病人预交记录_IX_结帐ID' (NON-UNIQUE)
  15    1     TABLE ACCESS (BY INDEX ROWID) OF '结算方式' (Cost=1 Card=1 Bytes=25)
  16   15       INDEX (UNIQUE SCAN) OF '结算方式_UQ_名称' (UNIQUE)

统计信息
----------------------------------------------------------
          0  recursive calls
          0  db block gets
         29  consistent gets
          0  physical reads
          0  redo size
        720  bytes sent via SQL*Net to client
        372  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          3  rows processed

--3.当类型表的查询条件中Rownum使用变量时，执行计划虽然有变化，但是仍然认为类型表返回的记录集数为8168,
--  错误地采用了Hash连接的执行计划，产生了374369块逻辑读和11192块物理读
SQL> var v_count number;
SQL>  exec :v_count:=4;

PL/SQL 过程已成功完成。

SQL> Select a.No, a.结算方式, Nvl(b.性质, 1) As 性质, a.金额, a.摘要, a.结算号码
  2  From (Select b.No, Decode(a.记录性质, 3, a.结算方式, Null) As 结算方式, a.摘要, a.结算号码, Sum
(1 * a.冲预交) As 金额
  3      From 病人预交记录 a,
  4        (Select Distinct No, 结帐id
  5         From 病人费用记录
  6         Where 记录性质 = 1 And No In (
  7                Select * From Table(Cast(f_Str2List(:v_str) as t_StrList)) Where Rownum<:v_count
  8                ) And 记录状态 In (1, 3)) b
  9      Where a.结帐id = b.结帐id And a.记录性质 In (1, 11, 3) And Nvl(a.冲预交, 0) <> 0
 10      Group By b.No, Decode(a.记录性质, 3, a.结算方式, Null), a.摘要, a.结算号码) a, 结算方式 b
 11  Where a.结算方式 = b.名称(+);

执行计划
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=ALL_ROWS (Cost=16306 Card=10945 Bytes=1094500)
   1    0   HASH JOIN (OUTER) (Cost=16306 Card=10945 Bytes=1094500)
   2    1     VIEW (Cost=16264 Card=10945 Bytes=820875)
   3    2       SORT (GROUP BY) (Cost=16264 Card=10945 Bytes=1028830)
   4    3         VIEW (Cost=16148 Card=10945 Bytes=1028830)
   5    4           SORT (UNIQUE) (Cost=16148 Card=10945 Bytes=23520805)
   6    5             HASH JOIN (Cost=238 Card=10945 Bytes=23520805)
   7    6               TABLE ACCESS (BY INDEX ROWID) OF '病人预交记录' (Cost=1 Card=1 Bytes=102)
   8    7                 NESTED LOOPS (Cost=164 Card=134 Bytes=19698)
   9    8                   INDEX (FAST FULL SCAN) OF '病人费用记录_UQ_NO' (UNIQUE) (Cost=4 Card=399 Bytes=17955)
  10    8                   INDEX (RANGE SCAN) OF '病人预交记录_IX_结帐ID' (NON-UNIQUE)
  11    6               VIEW OF 'VW_NSO_1' (Cost=11 Card=8168 Bytes=16352336)
  12   11                 COUNT (STOPKEY)
  13   12                   COLLECTION ITERATOR (PICKLER FETCH) OF 'f_Str2List'
  14    1     TABLE ACCESS (FULL) OF '结算方式' (Cost=2 Card=82 Bytes=2050)

统计信息
----------------------------------------------------------
         28  recursive calls
          0  db block gets
     374369  consistent gets
      11192  physical reads
          0  redo size
        720  bytes sent via SQL*Net to client
        372  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          3  rows processed

--4.当类型表的查询条件中Rownum使用一个固定的极限值时(例如：99999)，情况与使用变量一样遭，错误地采用了Hash连接的执行计划，产生了374354块逻辑读和10756块物理读
SQL> Select a.No, a.结算方式, Nvl(b.性质, 1) As 性质, a.金额, a.摘要, a.结算号码
  2  From (Select b.No, Decode(a.记录性质, 3, a.结算方式, Null) As 结算方式, a.摘要, a.结算号码, Sum
(1 * a.冲预交) As 金额
  3      From 病人预交记录 a,
  4        (Select Distinct No, 结帐id
  5         From 病人费用记录
  6         Where 记录性质 = 1 And No In (
  7                Select * From Table(Cast(f_Str2List(:v_str) as t_StrList)) Where Rownum<99999
  8                ) And 记录状态 In (1, 3)) b
  9      Where a.结帐id = b.结帐id And a.记录性质 In (1, 11, 3) And Nvl(a.冲预交, 0) <> 0
 10      Group By b.No, Decode(a.记录性质, 3, a.结算方式, Null), a.摘要, a.结算号码) a, 结算方式 b
 11  Where a.结算方式 = b.名称(+);

执行计划
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=ALL_ROWS (Cost=16306 Card=10945 Bytes=1094500)
   1    0   HASH JOIN (OUTER) (Cost=16306 Card=10945 Bytes=1094500)
   2    1     VIEW (Cost=16264 Card=10945 Bytes=820875)
   3    2       SORT (GROUP BY) (Cost=16264 Card=10945 Bytes=1028830)
   4    3         VIEW (Cost=16148 Card=10945 Bytes=1028830)
   5    4           SORT (UNIQUE) (Cost=16148 Card=10945 Bytes=23520805)
   6    5             HASH JOIN (Cost=238 Card=10945 Bytes=23520805)
   7    6               TABLE ACCESS (BY INDEX ROWID) OF '病人预交记录' (Cost=1 Card=1 Bytes=102)
   8    7                 NESTED LOOPS (Cost=164 Card=134 Bytes=19698)
   9    8                   INDEX (FAST FULL SCAN) OF '病人费用记录_UQ_NO' (UNIQUE) (Cost=4 Card=399 Bytes=17955)
  10    8                   INDEX (RANGE SCAN) OF '病人预交记录_IX_结帐ID' (NON-UNIQUE)
  11    6               VIEW OF 'VW_NSO_1' (Cost=11 Card=8168 Bytes=16352336)
  12   11                 COUNT (STOPKEY)
  13   12                   COLLECTION ITERATOR (PICKLER FETCH) OF 'f_Str2List'
  14    1     TABLE ACCESS (FULL) OF '结算方式' (Cost=2 Card=82 Bytes=2050)

统计信息
----------------------------------------------------------
          0  recursive calls
          0  db block gets
     374354  consistent gets
      10756  physical reads
          0  redo size
        720  bytes sent via SQL*Net to client
        372  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          3  rows processed

--5.强制使用基于规则的优化器模式
SQL> Select /*+ rule*/ a.No, a.结算方式, Nvl(b.性质, 1) As 性质, a.金额, a.摘要, a.结算号码
  2  From (Select b.No, Decode(a.记录性质, 3, a.结算方式, Null) As 结算方式, a.摘要, a.结算号码, Sum
(1 * a.冲预交) As 金额
  3      From 病人预交记录 a,
  4        (Select Distinct No, 结帐id
  5         From 病人费用记录
  6         Where 记录性质 = 1 And No In (
  7                Select * From Table(Cast(f_Str2List(:v_str) as t_StrList))
  8                ) And 记录状态 In (1, 3)) b
  9      Where a.结帐id = b.结帐id And a.记录性质 In (1, 11, 3) And Nvl(a.冲预交, 0) <> 0
 10      Group By b.No, Decode(a.记录性质, 3, a.结算方式, Null), a.摘要, a.结算号码) a, 结算方式 b
 11  Where a.结算方式 = b.名称(+);

执行计划
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=HINT: RULE
   1    0   NESTED LOOPS (OUTER)
   2    1     VIEW
   3    2       SORT (GROUP BY)
   4    3         VIEW
   5    4           SORT (UNIQUE)
   6    5             TABLE ACCESS (BY INDEX ROWID) OF '病人预交记录'
   7    6               NESTED LOOPS
   8    7                 NESTED LOOPS
   9    8                   COLLECTION ITERATOR (PICKLER FETCH) OF 'f_Str2List'
  10    8                   INDEX (RANGE SCAN) OF '病人费用记录_UQ_NO' (UNIQUE)
  11    7                 INDEX (RANGE SCAN) OF '病人预交记录_IX_结帐ID' (NON-UNIQUE)
  12    1     TABLE ACCESS (BY INDEX ROWID) OF '结算方式'
  13   12       INDEX (UNIQUE SCAN) OF '结算方式_UQ_名称' (UNIQUE)

统计信息
----------------------------------------------------------
          0  recursive calls
          0  db block gets
         25  consistent gets
          0  physical reads
          0  redo size
        720  bytes sent via SQL*Net to client
        372  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          3  rows processed