关于“好的东西似乎总不是那么好用（初看起来如此）”的一个笑话：在参加 IBM DB2 512、513培训前，在校园网上下载到了安装程序，不过任凭我们几个同学研究个半天，也不知哪个文件是安装文件，竟没有安装成功。最后，一致认为：看来这个培训真是太有必要了！事后，才知道－－我们下载的是4linux的！

 [以8.1.6为例]：

1、ORA－12541：TNS：没有监听器

　　原因：没有启动监听器或者监听器损坏。如果是前者，使用命令net start OracleOraHome81TNSListener（名字可能有出入）即可；如果是后者，则使用“Net8 Configuration Assistant”工具向导之“监听程序配置”增加一个监听器即可（基本不用写任何信息，一路OK。在添加之前可能需要把所有的监听器先删除！）

2、ORA－12500：TNS：监听程序无法启动专用服务器进程
　　或
　 ORA－12560：TNS：协议适配器错误

　　原因：ORACLE的数据库服务没有启动。使用命令net start ORACLESERVICEORADB（ORADB为数据库名字）即可。如果仍没有解决，请继续向下看。

3、如果数据库服务启动失败，则很有可能是其注册表项值损坏，最好的做法是以下两步：

　　1）ORADIM -DELETE -SID oradb 删除数据库服务项
　　2）ORADIM -NEW -SID oradb 新增数据库服务项
　　注：这个过程中如果出错，就重启计算机！

4、ORA－12154：TNS：能解析服务名

　　原因：ORACLE的网络服务名没有正确配置。请使用“Net8 Configuration Assistant”工具向导之“本地网络服务名配置”配置TNS即可。如果仍没有解决，请继续向下看。

5、ORA－1034 ：TNS：ORACLE不可用

　　原因：ORACLE的数据库服务正确启动，但是数据库没有打开！

　　使用命令：

　　1）svrmgrl  启动服务管理器
　　2）connect internal 以internal身份登陆
　　3）startup  打开数据库

6、ORA－12560：TNS：协议适配器错误（顽固性的）

　　原因：未知。

　　解决：必杀技－－打开“Windows任务管理器”，杀死ORACLE.exe及ORADIM.exe进程，书写自己的ora_startup.bat，执行之！

PS：

1、我的ora_startup.bat：

net start OracleOraHome81TNSListener
net start ORACLESERVICEORADB
svrmgrl 一般情况下不用，不过有时少不了它的，具体步骤见第5步。

2、我的ora_shutdown.bat：

net stop OracleOraHome81TNSListener
net stop ORACLESERVICEORADB

3、ORACLE相关服务名请参见“管理工具”之“服务”中以ORACLE开头的服务名。

43.       用WHERE替代ORDER BY

ORDER BY 子句只在两种严格的条件下使用索引.

ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序.

ORDER BY中所有的列必须定义为非空.

WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.

例如:

      表DEPT包含以下列:

        DEPT_CODE    PK    NOT NULL

        DEPT_DESC           NOT NULL

        DEPT_TYPE           NULL

       非唯一性的索引(DEPT_TYPE)

     低效: (索引不被使用)

            SELECT DEPT_CODE

            FROM DEPT

            ORDER BY DEPT_TYPE

       EXPLAIN PLAN:

            SORT ORDER BY

                  TABLE ACCESS FULL

     高效: (使用索引)

           SELECT DEPT_CODE

           FROM DEPT

        WHERE DEPT_TYPE > 0

 EXPLAIN PLAN:

      TABLE ACCESS BY ROWID ON EMP

             INDEX RANGE SCAN ON DEPT_IDX

译者按:

      ORDER BY 也能使用索引! 这的确是个容易被忽视的知识点. 我们来验证一下:

SQL>  select * from emp order by empno;

Execution Plan

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

   0      SELECT STATEMENT Optimizer=CHOOSE

   1    0   TABLE ACCESS (BY INDEX ROWID) OF 'EMP'

   2    1     INDEX (FULL SCAN) OF 'EMPNO' (UNIQUE)

44.       避免改变索引列的类型.

当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换.

假设 EMPNO是一个数值类型的索引列.

SELECT …

FROM EMP

WHERE EMPNO = ‘123’

实际上,经过ORACLE类型转换, 语句转化为:

SELECT …

FROM EMP

WHERE EMPNO = TO_NUMBER(‘123’)

幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变.

现在,假设EMP_TYPE是一个字符类型的索引列.

SELECT …

FROM EMP

WHERE EMP_TYPE = 123

这个语句被ORACLE转换为:

SELECT …

FROM EMP

WHERE TO_NUMBER(EMP_TYPE)=123

因为内部发生的类型转换, 这个索引将不会被用到!

译者按:

为了避免ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型.

45.       需要当心的WHERE子句

某些SELECT 语句中的WHERE子句不使用索引. 这里有一些例子.

在下面的例子里, ‘!=’ 将不使用索引. 记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中.

不使用索引:

SELECT ACCOUNT_NAME

FROM TRANSACTION

WHERE AMOUNT !=0;

使用索引:

SELECT ACCOUNT_NAME

FROM TRANSACTION

WHERE AMOUNT >0;

下面的例子中, ‘||’是字符连接函数. 就象其他函数那样, 停用了索引.

不使用索引:

SELECT ACCOUNT_NAME,AMOUNT

FROM TRANSACTION

WHERE ACCOUNT_NAME||ACCOUNT_TYPE=’AMEXA’;

使用索引:

SELECT ACCOUNT_NAME,AMOUNT

FROM TRANSACTION

WHERE ACCOUNT_NAME = ‘AMEX’

AND  ACCOUNT_TYPE=’ A’;

下面的例子中, ‘+’是数学函数. 就象其他数学函数那样, 停用了索引.

不使用索引:

SELECT ACCOUNT_NAME, AMOUNT

FROM TRANSACTION

WHERE AMOUNT + 3000 >5000;

使用索引:

SELECT ACCOUNT_NAME, AMOUNT

FROM TRANSACTION

WHERE AMOUNT > 2000 ;

下面的例子中,相同的索引列不能互相比较,这将会启用全表扫描.

不使用索引:

SELECT ACCOUNT_NAME, AMOUNT

FROM TRANSACTION

WHERE ACCOUNT_NAME = NVL(:ACC_NAME,ACCOUNT_NAME);

使用索引:

SELECT ACCOUNT_NAME, AMOUNT

FROM TRANSACTION

WHERE ACCOUNT_NAME LIKE NVL(:ACC_NAME,’%’);

译者按:

如果一定要对使用函数的列启用索引, ORACLE新的功能: 基于函数的索引(Function-Based Index) 也许是一个较好的方案.

 CREATE INDEX EMP_I ON EMP (UPPER(ename)); /*建立基于函数的索引*/

 SELECT * FROM emp WHERE UPPER(ename) = ‘BLACKSNAIL’; /*将使用索引*/

31.       强制索引失效

如果两个或以上索引具有相同的等级,你可以强制命令ORACLE优化器使用其中的一个(通过它,检索出的记录数量少) .

举例:

SELECT ENAME

FROM EMP

WHERE EMPNO = 7935 

AND DEPTNO + 0 = 10    /*DEPTNO上的索引将失效*/

AND EMP_TYPE || ‘’ = ‘A’  /*EMP_TYPE上的索引将失效*/

这是一种相当直接的提高查询效率的办法. 但是你必须谨慎考虑这种策略,一般来说,只有在你希望单独优化几个SQL时才能采用它.

这里有一个例子关于何时采用这种策略,

假设在EMP表的EMP_TYPE列上有一个非唯一性的索引而EMP_CLASS上没有索引.

SELECT ENAME

FROM EMP

WHERE EMP_TYPE = ‘A’

AND EMP_CLASS = ‘X’;

优化器会注意到EMP_TYPE上的索引并使用它. 这是目前唯一的选择. 如果,一段时间以后, 另一个非唯一性建立在EMP_CLASS上,优化器必须对两个索引进行选择,在通常情况下,优化器将使用两个索引并在他们的结果集合上执行排序及合并. 然而,如果其中一个索引（EMP_TYPE）接近于唯一性而另一个索引（EMP_CLASS）上有几千个重复的值. 排序及合并就会成为一种不必要的负担. 在这种情况下,你希望使优化器屏蔽掉EMP_CLASS索引.

用下面的方案就可以解决问题.

SELECT ENAME

FROM EMP

WHERE EMP_TYPE = ‘A’

AND EMP_CLASS||’’ = ‘X’;

32.       避免在索引列上使用计算．

WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描．

举例:

低效：

SELECT …

FROM DEPT

WHERE SAL * 12 > 25000;

高效:

SELECT …

FROM DEPT

WHERE SAL  > 25000/12;

译者按:

这是一个非常实用的规则，请务必牢记

33.       自动选择索引

如果表中有两个以上（包括两个）索引，其中有一个唯一性索引，而其他是非唯一性．

在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引．

举例:

SELECT ENAME

FROM EMP

WHERE EMPNO = 2326 

AND DEPTNO  = 20 ;

这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录．

TABLE ACCESS BY ROWID ON EMP

       INDEX UNIQUE SCAN ON EMP_NO_IDX

34.       避免在索引列上使用NOT

通常，　我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的

影响. 当ORACLE”遇到”NOT,他就会停止使用索引转而执行全表扫描.

   举例:

   低效: (这里,不使用索引)

   SELECT …

   FROM DEPT

   WHERE DEPT_CODE NOT = 0;

   高效: (这里,使用了索引)

  SELECT …

   FROM DEPT

   WHERE DEPT_CODE > 0;

   需要注意的是,在某些时候, ORACLE优化器会自动将NOT转化成相对应的关系操作符.

   NOT >  to  <=

   NOT >=  to  <

   NOT <  to  >=

   NOT <=  to  >

译者按:

     在这个例子中,作者犯了一些错误. 例子中的低效率SQL是不能被执行的.

我做了一些测试:

SQL> select * from emp where NOT empno > 1;

no rows selected

Execution Plan

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

   0      SELECT STATEMENT Optimizer=CHOOSE

   1    0   TABLE ACCESS (BY INDEX ROWID) OF 'EMP'

   2    1     INDEX (RANGE SCAN) OF 'EMPNO' (UNIQUE)    

SQL> select * from emp where empno <= 1;

no rows selected

Execution Plan

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

   0      SELECT STATEMENT Optimizer=CHOOSE

   1    0   TABLE ACCESS (BY INDEX ROWID) OF 'EMP'

   2    1     INDEX (RANGE SCAN) OF 'EMPNO' (UNIQUE)

      两者的效率完全一样，也许这符合作者关于” 在某些时候, ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点．

35.       用>=替代>

如果DEPTNO上有一个索引,

高效:

   SELECT *

   FROM EMP

   WHERE DEPTNO >=4

   低效:

   SELECT *

   FROM EMP

   WHERE DEPTNO >3

      两者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录.

25.       用索引提高效率

索引是表的一个概念部分,用来提高检索数据的效率. 实际上,ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.

除了那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率.

虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来

存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.

译者按:

定期的重构索引是有必要的.

ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>

26.       索引的操作

ORACLE对索引有两种访问模式.

索引唯一扫描 ( INDEX UNIQUE SCAN)

大多数情况下, 优化器通过WHERE子句访问INDEX.

例如:

表LODGING有两个索引 : 建立在LODGING列上的唯一性索引LODGING_PK和建立在MANAGER列上的非唯一性索引LODGING$MANAGER.

SELECT *

FROM LODGING

WHERE LODGING = ‘ROSE HILL’;

   在内部 , 上述SQL将被分成两步执行, 首先 , LODGING_PK 索引将通过索引唯一扫描的方式被访问 , 获得相对应的ROWID, 通过ROWID访问表的方式 执行下一步检索.

   如果被检索返回的列包括在INDEX列中,ORACLE将不执行第二步的处理(通过ROWID访问表). 因为检索数据保存在索引中, 单单访问索引就可以完全满足查询结果.

   下面SQL只需要INDEX UNIQUE SCAN 操作.

        SELECT LODGING

        FROM  LODGING

WHERE LODGING = ‘ROSE HILL’;

  索引范围查询(INDEX RANGE SCAN)

      适用于两种情况:

1.       基于一个范围的检索

2.       基于非唯一性索引的检索

 例1:

      SELECT LODGING

      FROM  LODGING

WHERE LODGING LIKE ‘M%’;

WHERE子句条件包括一系列值, ORACLE将通过索引范围查询的方式查询LODGING_PK . 由于索引范围查询将返回一组值, 它的效率就要比索引唯一扫描

低一些.

例2:

      SELECT LODGING

      FROM  LODGING

WHERE MANAGER = ‘BILL GATES’;

  这个SQL的执行分两步, LODGING$MANAGER的索引范围查询(得到所有符合条件记录的ROWID) 和下一步同过ROWID访问表得到LODGING列的值. 由于LODGING$MANAGER是一个非唯一性的索引,数据库不能对它执行索引唯一扫描.

  由于SQL返回LODGING列,而它并不存在于LODGING$MANAGER索引中, 所以在索引范围查询后会执行一个通过ROWID访问表的操作.

  WHERE子句中, 如果索引列所对应的值的第一个字符由通配符(WILDCARD)开始, 索引将不被采用.

 SELECT LODGING

      FROM  LODGING

WHERE MANAGER LIKE ‘％HANMAN’;

 在这种情况下，ORACLE将使用全表扫描.

(待续)

27.       基础表的选择

基础表(Driving Table)是指被最先访问的表(通常以全表扫描的方式被访问). 根据优化器的不同, SQL语句中基础表的选择是不一样的.

如果你使用的是CBO (COST BASED OPTIMIZER),优化器会检查SQL语句中的每个表的物理大小,索引的状态,然后选用花费最低的执行路径.

如果你用RBO (RULE BASED OPTIMIZER) , 并且所有的连接条件都有索引对应, 在这种情况下, 基础表就是FROM 子句中列在最后的那个表.

举例:

     SELECT A.NAME , B.MANAGER

     FROM　WORKER A,

             LODGING B

     WHERE　A.LODGING = B.LODING;

由于LODGING表的LODING列上有一个索引, 而且WORKER表中没有相比较的索引, WORKER表将被作为查询中的基础表.

28.       多个平等的索引

当SQL语句的执行路径可以使用分布在多个表上的多个索引时, ORACLE会同时使用多个索引并在运行时对它们的记录进行合并, 检索出仅对全部索引有效的记录.

在ORACLE选择执行路径时,唯一性索引的等级高于非唯一性索引. 然而这个规则只有

当WHERE子句中索引列和常量比较才有效.如果索引列和其他表的索引类相比较. 这种子句在优化器中的等级是非常低的.

如果不同表中两个想同等级的索引将被引用, FROM子句中表的顺序将决定哪个会被率先使用. FROM子句中最后的表的索引将有最高的优先级.

如果相同表中两个想同等级的索引将被引用, WHERE子句中最先被引用的索引将有最高的优先级.

举例:

     DEPTNO上有一个非唯一性索引,EMP_CAT也有一个非唯一性索引.

     SELECT ENAME,

     FROM EMP

     WHERE DEPT_NO = 20

     AND EMP_CAT = ‘A’;

这里,DEPTNO索引将被最先检索,然后同EMP_CAT索引检索出的记录进行合并. 执行路径如下:

TABLE ACCESS BY ROWID ON EMP

    AND-EQUAL

        INDEX RANGE SCAN ON DEPT_IDX

        INDEX RANGE SCAN ON CAT_IDX

29.        等式比较和范围比较

     当WHERE子句中有索引列, ORACLE不能合并它们,ORACLE将用范围比较.

     举例:

     DEPTNO上有一个非唯一性索引,EMP_CAT也有一个非唯一性索引.

     SELECT ENAME

     FROM EMP

     WHERE DEPTNO > 20

     AND EMP_CAT = ‘A’;

     这里只有EMP_CAT索引被用到,然后所有的记录将逐条与DEPTNO条件进行比较. 执行路径如下:

     TABLE ACCESS BY ROWID ON EMP

           INDEX RANGE SCAN ON CAT_IDX

30.       不明确的索引等级

当ORACLE无法判断索引的等级高低差别,优化器将只使用一个索引,它就是在WHERE子句中被列在最前面的.

     举例:

     DEPTNO上有一个非唯一性索引,EMP_CAT也有一个非唯一性索引.

     SELECT ENAME

     FROM EMP

     WHERE DEPTNO > 20

     AND EMP_CAT > ‘A’;

     这里, ORACLE只用到了DEPT_NO索引. 执行路径如下:

     TABLE ACCESS BY ROWID ON EMP

          INDEX RANGE SCAN ON DEPT_IDX

译者按:

我们来试一下以下这种情况:

SQL> select index_name, uniqueness from user_indexes where table_name = 'EMP';

INDEX_NAME                     UNIQUENES

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

EMPNO                          UNIQUE

EMPTYPE                        NONUNIQUE

SQL> select * from emp where empno >= 2 and emp_type = 'A' ;

no rows selected

Execution Plan

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

   0      SELECT STATEMENT Optimizer=CHOOSE

   1    0   TABLE ACCESS (BY INDEX ROWID) OF 'EMP'

   2    1     INDEX (RANGE SCAN) OF 'EMPTYPE' (NON-UNIQUE)

虽然EMPNO是唯一性索引,但是由于它所做的是范围比较, 等级要比非唯一性索引的等式比较低!

24.       用EXPLAIN PLAN 分析SQL语句

EXPLAIN PLAN 是一个很好的分析SQL语句的工具,它甚至可以在不执行SQL的情况下分析语句. 通过分析,我们就可以知道ORACLE是怎么样连接表,使用什么方式扫描表(索引扫描或全表扫描)以及使用到的索引名称.

你需要按照从里到外,从上到下的次序解读分析的结果. EXPLAIN PLAN分析的结果是用缩进的格式排列的, 最内部的操作将被最先解读, 如果两个操作处于同一层中,带有最小操作号的将被首先执行.

NESTED LOOP是少数不按照上述规则处理的操作, 正确的执行路径是检查对NESTED LOOP提供数据的操作,其中操作号最小的将被最先处理.

译者按:

通过实践, 感到还是用SQLPLUS中的SET TRACE 功能比较方便.

举例:

SQL> list

  1  SELECT *

  2  FROM dept, emp

  3* WHERE emp.deptno = dept.deptno

SQL> set autotrace traceonly /*traceonly 可以不显示执行结果*/

SQL> /

14 rows selected.

Execution Plan

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

   0      SELECT STATEMENT Optimizer=CHOOSE

   1    0   NESTED LOOPS

   2    1     TABLE ACCESS (FULL) OF 'EMP'

   3    1     TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'

   4    3       INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)

Statistics

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

          0  recursive calls

          2  db block gets

         30  consistent gets

          0  physical reads

          0  redo size

       2598  bytes sent via SQL*Net to client

        503  bytes received via SQL*Net from client

          2  SQL*Net roundtrips to/from client

          0  sorts (memory)

          0  sorts (disk)

         14  rows processed

通过以上分析,可以得出实际的执行步骤是:

1.       TABLE ACCESS (FULL) OF 'EMP'

2.       INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)

3.       TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'

4.       NESTED LOOPS (JOINING 1 AND 3)

注: 目前许多第三方的工具如TOAD和ORACLE本身提供的工具如OMS的SQL Analyze都提供了极其方便的EXPLAIN PLAN工具.也许喜欢图形化界面的朋友们可以选用它们.

17.       使用表的别名(Alias)

当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.

(译者注: Column歧义指的是由于SQL中不同的表具有相同的Column名,当SQL语句中出现这个Column时,SQL解析器无法判断这个Column的归属)

18.       用EXISTS替代IN

在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率.

低效:

SELECT *

FROM EMP (基础表)

WHERE EMPNO > 0

AND DEPTNO IN (SELECT DEPTNO

FROM DEPT

WHERE LOC = ‘MELB’)

高效:

SELECT *

FROM EMP (基础表)

WHERE EMPNO > 0

AND EXISTS (SELECT ‘X’

FROM DEPT

WHERE DEPT.DEPTNO = EMP.DEPTNO

AND LOC = ‘MELB’)

 (译者按: 相对来说,用NOT EXISTS替换NOT IN 将更显著地提高效率,下一节中将指出)

19.       用NOT EXISTS替代NOT IN

在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历).  为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.

例如:

SELECT …

FROM EMP

WHERE DEPT_NO NOT IN (SELECT DEPT_NO

                         FROM DEPT

                         WHERE DEPT_CAT=’A’);

为了提高效率.改写为:

(方法一: 高效)

SELECT ….

FROM EMP A,DEPT B

WHERE A.DEPT_NO = B.DEPT(+)

AND B.DEPT_NO IS NULL

AND B.DEPT_CAT(+) = ‘A’

(方法二: 最高效)

SELECT ….

FROM EMP E

WHERE NOT EXISTS (SELECT ‘X’

                    FROM DEPT D

                    WHERE D.DEPT_NO = E.DEPT_NO

                    AND DEPT_CAT = ‘A’);

(待续)

     和一般的观点相反, count(*) 比count(1)稍快 , 当然如果可以通过索引检索,对索引列的计数仍旧是最快的. 例如 COUNT(EMPNO)

(译者按: 在CSDN论坛中,曾经对此有过相当热烈的讨论, 作者的观点并不十分准确,通过实际的测试,上述三种方法并没有显著的性能差别)

14.       用Where子句替换HAVING子句

     避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销.

例如:

     低效:

     SELECT REGION，AVG(LOG_SIZE)

     FROM LOCATION

     GROUP BY REGION

     HAVING REGION REGION != ‘SYDNEY’

     AND REGION != ‘PERTH’

     高效

     SELECT REGION，AVG(LOG_SIZE)

     FROM LOCATION

     WHERE REGION REGION != ‘SYDNEY’

     AND REGION != ‘PERTH’

     GROUP BY REGION

(译者按: HAVING 中的条件一般用于对一些集合函数的比较,如COUNT() 等等. 除此而外,一般的条件应该写在WHERE子句中)

15.       减少对表的查询

在含有子查询的SQL语句中,要特别注意减少对表的查询.

例如:

     低效

          SELECT TAB_NAME

          FROM TABLES

          WHERE TAB_NAME = ( SELECT TAB_NAME

                                FROM TAB_COLUMNS

                                WHERE VERSION = 604)

          AND　DB_VER= ( SELECT DB_VER

                           FROM TAB_COLUMNS

                           WHERE VERSION = 604)

     高效

          SELECT TAB_NAME

          FROM TABLES

          WHERE  (TAB_NAME,DB_VER)

 = ( SELECT TAB_NAME,DB_VER)

                   FROM TAB_COLUMNS

                   WHERE VERSION = 604)

     Update 多个Column 例子:

     低效:

           UPDATE EMP

           SET EMP_CAT = (SELECT MAX(CATEGORY) FROM EMP_CATEGORIES),

              SAL_RANGE = (SELECT MAX(SAL_RANGE) FROM EMP_CATEGORIES)

           WHERE EMP_DEPT = 0020;

     高效:

           UPDATE EMP

           SET (EMP_CAT, SAL_RANGE)

 = (SELECT MAX(CATEGORY) , MAX(SAL_RANGE)

 FROM EMP_CATEGORIES)

           WHERE EMP_DEPT = 0020;

16.       通过内部函数提高SQL效率.

     SELECT H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC,COUNT(*)

     FROM HISTORY_TYPE T,EMP E,EMP_HISTORY H

     WHERE H.EMPNO = E.EMPNO

AND H.HIST_TYPE = T.HIST_TYPE

GROUP BY H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC;

通过调用下面的函数可以提高效率.

FUNCTION LOOKUP_HIST_TYPE(TYP IN NUMBER) RETURN VARCHAR2

AS

    TDESC VARCHAR2(30);

    CURSOR C1 IS 

        SELECT TYPE_DESC

        FROM HISTORY_TYPE

        WHERE HIST_TYPE = TYP;

BEGIN

    OPEN C1;

    FETCH C1 INTO TDESC;

    CLOSE C1;

    RETURN (NVL(TDESC,’?’));

END;

FUNCTION LOOKUP_EMP(EMP IN NUMBER) RETURN VARCHAR2

AS

    ENAME VARCHAR2(30);

    CURSOR C1 IS 

        SELECT ENAME

        FROM EMP

        WHERE EMPNO=EMP;

BEGIN

    OPEN C1;

    FETCH C1 INTO ENAME;

    CLOSE C1;

    RETURN (NVL(ENAME,’?’));

END;

SELECT H.EMPNO,LOOKUP_EMP(H.EMPNO),

H.HIST_TYPE,LOOKUP_HIST_TYPE(H.HIST_TYPE),COUNT(*)

FROM EMP_HISTORY H

GROUP BY H.EMPNO , H.HIST_TYPE;

(译者按: 经常在论坛中看到如 ’能不能用一个SQL写出….’ 的贴子, 殊不知复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的)

 (待续)

8.       使用DECODE函数来减少处理时间

使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.

例如:

   SELECT COUNT(*)，SUM(SAL)

   FROM　EMP

   WHERE DEPT_NO = 0020

   AND ENAME LIKE　‘SMITH%’;

   SELECT COUNT(*)，SUM(SAL)

   FROM　EMP

   WHERE DEPT_NO = 0030

   AND ENAME LIKE　‘SMITH%’;

你可以用DECODE函数高效地得到相同结果

SELECT COUNT(DECODE(DEPT_NO,0020,’X’,NULL)) D0020_COUNT,

        COUNT(DECODE(DEPT_NO,0030,’X’,NULL)) D0030_COUNT,

        SUM(DECODE(DEPT_NO,0020,SAL,NULL)) D0020_SAL,

        SUM(DECODE(DEPT_NO,0030,SAL,NULL)) D0030_SAL

FROM EMP WHERE ENAME LIKE ‘SMITH%’;

类似的,DECODE函数也可以运用于GROUP BY 和ORDER BY子句中.

9.       整合简单,无关联的数据库访问

如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)

例如:

SELECT NAME

FROM EMP

WHERE EMP_NO = 1234;

SELECT NAME

FROM DPT

WHERE DPT_NO = 10 ;

SELECT NAME

FROM CAT

WHERE CAT_TYPE = ‘RD’;

上面的3个查询可以被合并成一个:

SELECT E.NAME , D.NAME , C.NAME

FROM CAT C , DPT D , EMP E,DUAL X

WHERE NVL(‘X’,X.DUMMY) = NVL(‘X’,E.ROWID(+))

AND NVL(‘X’,X.DUMMY) = NVL(‘X’,D.ROWID(+))

AND NVL(‘X’,X.DUMMY) = NVL(‘X’,C.ROWID(+))

AND E.EMP_NO(+) = 1234

AND D.DEPT_NO(+) = 10

AND C.CAT_TYPE(+) = ‘RD’;

(译者按: 虽然采取这种方法,效率得到提高,但是程序的可读性大大降低,所以读者 还是要权衡之间的利弊)

10.       删除重复记录

最高效的删除重复记录方法 ( 因为使用了ROWID)

DELETE FROM EMP E

WHERE E.ROWID > (SELECT MIN(X.ROWID)

                   FROM EMP X

                   WHERE X.EMP_NO = E.EMP_NO);

11.       用TRUNCATE替代DELETE

当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是

恢复到执行删除命令之前的状况)

而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短.

(译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)

12.       尽量多使用COMMIT

只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:

 COMMIT所释放的资源:

a.       回滚段上用于恢复数据的信息.

b.       被程序语句获得的锁

c.       redo log buffer 中的空间

d.       ORACLE为管理上述3种资源中的内部花费

(译者按: 在使用COMMIT时必须要注意到事务的完整性,现实中效率和事务完整性往往是鱼和熊掌不可得兼)

4. 选择最有效率的表名顺序(只在基于规则的优化器中有效)

ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名,因此FROM子句中写在最后的表(基础表 driving table)将被最先处理. 在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表.当ORACLE处理多个表时, 会运用排序及合并的方式连接它们.首先,扫描第一个表(FROM子句中最后的那个表)并对记录进行派序,然后扫描第二个表(FROM子句中最后第二个表),最后将所有从第二个表中检索出的记录与第一个表中合适记录进行合并.

例如:

     表 TAB1 16,384 条记录

     表 TAB2 1      条记录

     选择TAB2作为基础表 (最好的方法)

     select count(*) from tab1,tab2   执行时间0.96秒

    选择TAB2作为基础表 (不佳的方法)

     select count(*) from tab2,tab1   执行时间26.09秒

如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.

例如:

   EMP表描述了LOCATION表和CATEGORY表的交集.

 SELECT *

FROM LOCATION L ,

      CATEGORY C,

      EMP E

WHERE E.EMP_NO BETWEEN 1000 AND 2000

AND E.CAT_NO = C.CAT_NO

AND E.LOCN = L.LOCN

将比下列SQL更有效率

SELECT *

FROM EMP E ,

LOCATION L ,

      CATEGORY C

WHERE  E.CAT_NO = C.CAT_NO

AND E.LOCN = L.LOCN

AND E.EMP_NO BETWEEN 1000 AND 2000

5.       WHERE子句中的连接顺序．

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

例如:

(低效,执行时间156.3秒)

SELECT …

FROM EMP E

WHERE  SAL > 50000

AND    JOB = ‘MANAGER’

AND    25 < (SELECT COUNT(*) FROM EMP

             WHERE MGR=E.EMPNO);

(高效,执行时间10.6秒)

SELECT …

FROM EMP E

WHERE 25 < (SELECT COUNT(*) FROM EMP

             WHERE MGR=E.EMPNO)

AND    SAL > 50000

AND    JOB = ‘MANAGER’;

6.     SELECT子句中避免使用 ‘ * ‘

当你想在SELECT子句中列出所有的COLUMN时,使用动态SQL列引用 ‘*’ 是一个方便的方法.不幸的是,这是一个非常低效的方法. 实际上,ORACLE在解析的过程中, 会将’*’ 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间.

7.     减少访问数据库的次数

当执行每条SQL语句时, ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等等. 由此可见, 减少访问数据库的次数 , 就能实际上减少ORACLE的工作量.

例如,

    以下有三种方法可以检索出雇员号等于0342或0291的职员.

方法1 (最低效)

    SELECT EMP_NAME , SALARY , GRADE

    FROM EMP

    WHERE EMP_NO = 342;

    SELECT EMP_NAME , SALARY , GRADE

    FROM EMP

    WHERE EMP_NO = 291;

方法2 (次低效)

    DECLARE

        CURSOR C1 (E_NO NUMBER) IS

        SELECT EMP_NAME,SALARY,GRADE

        FROM EMP

        WHERE EMP_NO = E_NO;

    BEGIN

        OPEN C1(342);

        FETCH C1 INTO …,..,.. ;

        …..

        OPEN C1(291);

       FETCH C1 INTO …,..,.. ;

         CLOSE C1;

      END;

方法3 (高效)

    SELECT A.EMP_NAME , A.SALARY , A.GRADE,

            B.EMP_NAME , B.SALARY , B.GRADE

    FROM EMP A,EMP B

    WHERE A.EMP_NO = 342

    AND   B.EMP_NO = 291;

注意:

    在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200

(待续)

   ORACLE的优化器共有3种:

   a.  RULE (基于规则)   b. COST (基于成本)  c. CHOOSE (选择性)

   设置缺省的优化器,可以通过对init.ora文件中OPTIMIZER_MODE参数的各种声明,如RULE,COST,CHOOSE,ALL_ROWS,FIRST_ROWS . 你当然也在SQL句级或是会话(session)级对其进行覆盖.

   为了使用基于成本的优化器(CBO, Cost-Based Optimizer) , 你必须经常运行analyze 命令,以增加数据库中的对象统计信息(object statistics)的准确性.

   如果数据库的优化器模式设置为选择性(CHOOSE),那么实际的优化器模式将和是否运行过analyze命令有关. 如果table已经被analyze过, 优化器模式将自动成为CBO , 反之,数据库将采用RULE形式的优化器.

   在缺省情况下,ORACLE采用CHOOSE优化器, 为了避免那些不必要的全表扫描(full table scan) , 你必须尽量避免使用CHOOSE优化器,而直接采用基于规则或者基于成本的优化器.

2.       访问Table的方式

ORACLE 采用两种访问表中记录的方式:

a.       全表扫描

            全表扫描就是顺序地访问表中每条记录. ORACLE采用一次读入多个数据块(database block)的方式优化全表扫描.

b.       通过ROWID访问表

       你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高.

3.       共享SQL语句

为了不重复解析相同的SQL语句,在第一次解析之后, ORACLE将SQL语句存放在内存中.这块位于系统全局区域SGA(system global area)的共享池(shared buffer pool)中的内存可以被所有的数据库用户共享. 因此,当你执行一个SQL语句(有时被称为一个游标)时,如果它

和之前的执行过的语句完全相同, ORACLE就能很快获得已经被解析的语句以及最好的

执行路径. ORACLE的这个功能大大地提高了SQL的执行性能并节省了内存的使用.

     可惜的是ORACLE只对简单的表提供高速缓冲(cache buffering) ,这个功能并不适用于多表连接查询.

数据库管理员必须在init.ora中为这个区域设置合适的参数,当这个内存区域越大,就可以保留更多的语句,当然被共享的可能性也就越大了.

当你向ORACLE 提交一个SQL语句,ORACLE会首先在这块内存中查找相同的语句.

 这里需要注明的是,ORACLE对两者采取的是一种严格匹配,要达成共享,SQL语句必须

完全相同(包括空格,换行等).

     共享的语句必须满足三个条件:

A.      字符级的比较:

当前被执行的语句和共享池中的语句必须完全相同.

      例如:

          SELECT * FROM EMP;

      和下列每一个都不同

          SELECT * from EMP;

          Select * From Emp;

          SELECT      *     FROM EMP;

B.      两个语句所指的对象必须完全相同:

例如:

   用户     对象名           如何访问

Jack       sal_limit          private synonym

             Work_city      public synonym

             Plant_detail     public synonym

Jill         sal_limit          private synonym

             Work_city      public synonym

             Plant_detail     table owner

    考虑一下下列SQL语句能否在这两个用户之间共享.

C.      两个SQL语句中必须使用相同的名字的绑定变量(bind variables)

例如：

第一组的两个SQL语句是相同的(可以共享),而第二组中的两个语句是不同的(即使在运行时,赋于不同的绑定变量相同的值)

a.

select pin , name from people where pin = :blk1.pin;

select pin , name from people where pin = :blk1.pin;

b.

select pin , name from people where pin = :blk1.ot_ind;

select pin , name from people where pin = :blk1.ov_ind;

   (待续)

　　这里会讨论令Oracle停机时间最小化的步骤。各种形式的停机--计划的或者是非计划的--总是不断地发生，一个DBA应该有正确的备份策略，这样在数据库出现问题时就可以更快地恢复。

　　以下是假定的备份策略和数据库的运作条件

　　　控制文件是镜像的
　　　数据库运行在archivelog模式
　　　每个星期都进行冷备份
　　　每日都进行热备份
　　　每日都进行一次全数据库导出

　　事件1：完整的数据库重构

　　在这种情形下，你可以使用全数据库导出或者冷热备份结合的方式来重构数据库。要注意的是无论你选择哪种方式，在线redo log中的事务都会丢失。

　　事件2：恢复部分的表空间

　　可以使用以下的步骤来恢复：

　　　1、以restrict模式启动数据库
　　　2、重新创建表空间
　　　3、使用最新的全数据库导出来导入，并且使用ignore=y的选项；
　　　4.关闭并且重新以normal的模式启动数据库实例

　　事件3：丢失一般的数据文件

　　丢失一般数据文件的恢复步骤根据所丢失的数据文件包含的表空间类型而定；例如：回滚段，用户表空间，索引表空间或者是只读的表空间、你可能会遇到以下的错误：

　　　. 尝试启动数据库并且碰到错误的信息ORA-1157, ORA-1110，可能还有一个操作系统的错误
　　　. 尝试以normal或者immediate的模式关闭数据库，可能会碰到ORA-1116, ORA-1110的错误信息，还有一个系统错误

　　以下的步骤可以用作恢复：

　　　1、关闭数据库
　　　2、由热备份中恢复丢失的数据文件
　　　3、Startup mount数据库
　　　4、执行以下的查询来得到所有你的在线redo log文件和它们相应的次序和首次修改号：

SELECT X.GROUP#, MEMBER, SEQUENCE#, FIRST_CHANGE#
FROM V$LOG X, V$LOGILE Y
WHERE X.GROUP# = Y.GROUP#;

　　5、如果得到的CHANGE#比在线redo log最小的FIRST_CHANGE# 还小，那么该文件不能被完全恢复，你可以有两个选择：

　　　.　如果可以接受丢失最近一次冷备份以来的数据库修改，装入备份并且继续恢复
　　　.　如果不能接受丢失数据库的修改，那么必须重新创建表空间

　　6、通过使用存档和在线的redo log来恢复数据文件
　　7、打开数据库

　　事件4：恢复一个特别的表

　　可以采用以下的步骤恢复：
　　　1、使用最近的一次全数据库导出来导入表，并且使用owner=和tables=的选项
　　　2、考虑到性能的原因，可能需要重建表索引

　　事件5：丢失控制文件

　　在数据库起来并且运行时，通常都不能检测到控制文件的问题、如果控制文件丢失或者损坏了，Oracle将不会了解，下次数据库的启动时将会导致ORA-205错误（标识控制文件"%s的错误），还有一个系统级的错误。

　　如果只是丢失了其中的一个控制文件，可以采用下面的步骤来恢复：
　　　1、如果它正在运行的话，先关闭它
　　　2、查找丢失控制文件的原因、是由于硬件的问题吗（磁盘还是控制器）？
　　　3、如果不是硬件的问题，将控制文件的一个好的拷贝复制到丢失的位置，并且跳到步骤5、
　　　4、如果是硬件的问题，复制一个好的控制文件拷贝到一个可靠的位置
　　　5、编辑initsid.ora 或者 configsid.ora，更新CONTROL_FILES以反映最新的控制文件位置
　　　6、启动数据库

　　事件6：丢失全部的控制文件

　　可以采用以下的步骤恢复：

　　　1、关闭数据库
　　　2、进行一次全数据库备份，包括全部的数据文件和redo log文件
　　　3、以NOMOUNT的状态启动数据库
　　　4、使用CREATE CONTROLFILE重新创建控制文件、你也可以备份控制文件到一个trace文件，然后执行该文件
　　　5、在数据库上进行媒体恢复
　　　6、打开数据库
　　　7、使用shutdown normal关闭数据库
　　　8、对数据库进行一次冷备份

　　事件7：丢失一个索引

　　最简单的方法就是重新创建丢失的索引

　　事件8：丢失一个非活动的redo log

　　如果丢失redo数据，恢复将是不完全的，必须重新创建涉及的表空间。要重新创建表空间，可以使用全的数据库导出，这样就可以很容易的导入数据并且重新创建该表空间的对象。可以使用以下的步骤来恢复：
　　　1、通过Alter system来切换redo log文件
　　　2、关闭数据库
　　　3、startup mount数据库
　　　4、离线删除涉及的数据文件
　　　5、打开数据库
　　　6、删除用户的表空间，包括其中的内容、
　　　7、通过全数据库备份重新创建表空间和其中的对象

　　事件9：丢失活动的Redo log

　　如事件8讨论的一样，如果丢失了redo数据，恢复将是不完全的，必须重新创建涉及的表空间、可以采用以下的步骤恢复：
　　　1、关闭数据库
　　　2、startup mount数据库
　　　3、离线删除涉及的数据文件
　　　4、打开数据库
　　　5、删除用户的表空间，包括其中的内容、
　　　6、通过全数据库备份重新创建表空间和其中的对象

　　要注意的是活动的事务将会丢失

　　事件10：丢失存档的Redo log文件

　　如果存档的redo log文件丢失，应该马上进行一次冷备份、最好也进行一次全数据库导出、没有丢失的存档redo log文件的任何恢复都将是不完全的。

　　事件11：丢失活动的回滚段

　　这里指的是丢失一个回滚段的一个数据文件、这是一个危急的恢复过程，它主要是在于保存活动的事务。这里假定数据库已经起来，而你想保存当前运行的事务。要使用以下的恢复过程，数据库必须运行在archivelog模式下。

　　可以使用以下步骤恢复：
　　　1、不要关闭数据库、对于这种事件，数据库启动比关闭更容易解决问题、
　　　2、令属于该数据文件中的全部回滚段离线
　　　3、删除全部离线的回滚段
　　　4、在上面的第2步中，如果回滚段中有活动的事务，你将不能令它离线、可运行以下的查询来查看哪些事物是活动的：

SELECT SEGMENT_NAME, XACTS ACTIVE_TX, V.STATUS
FROM V$ROLLSTAT V, DBA_ROLLBACK_SEGS
WHERE TABLESPACE_NAME = 'tablespace_name' AND
SEGMENT_ID = USN;

　　如果上面的查询没有结果，那么所有的回滚段都是离线的，但是，如果上面的查询返回一行或者多行，并且其状态为PENDING OFFLINE，那么可检查这些回滚段的ACTIVE_TX列、带有0值的回滚段将很快会离线；但是，非0的值表示上面有活动的事务，它们需要被提交或者回滚。

　　　5、处理活动的事务、执行以下的查询来查看哪些用户的事务被指派到该回滚段：

SELECT S.SID, S.SERIAL#, S.USERNAME, R.NAME "ROLLBACK"
FROM V$SESSION S, V$TRANSACTION T, V$ROLLNAME R
WHERE R.NAME IN ('pending_rollback1','pending_rollback2', .... 'pending_rollbackN') AND
S.TADDR = T.ADDR AND
T.XIDUSN = R.USN;

　　在知道哪些用户在“pending offline”的回滚段上有活动的事务后，可以要求他们提交或者回滚他们的事务，或者可以使用以下的命令杀掉它们的进程：

　　　ALTER SYSTEM KILL SESSION sid, serial#;

　　　6、在你处理完所有活动的事务后，执行以下的步骤：

　　　　丢弃表空间及其中的全部内容
　　　　重新创建回滚表空间
　　　　重新创建回滚段，并且令它们在线

　　事件12：丢失全部的回滚段

　　在这种事件下，将丢失全部活动的事务，并且需要重新创建回滚段。这样大的问题可能是由于一个硬件问题造成的，可以采用以下的步骤恢复：
　　　1、关闭数据库
　　　2、使用DBVERIFY验证全部的数据文件
　　　3、解决其它的硬件问题或者数据文件损坏
　　　4、以startup mount的方式启动数据库实例
　　　5、在数据库上执行媒体恢复　
　　　6、打开数据库
　　　7、按需要创建新的回滚段

　　事件13：导出文件损坏

　　如果导出文件不能用了，那么应该冷备份数据库并且进行一个全的数据库导出、这是假定数据库自身没有问题、如果数据库也损坏了，那么应该执行以下的步骤：
　　　1、ORA-1157错误信息通常都表示一个或者多个的数据文件损坏了。查明哪些表受到影响，它们应该是错误信息中指明的数据文件中的表格
　　　2、跳过坏的数据块，将数据由表格中选择到临时表格中、
　　　3、丢弃损坏的表
　　　4、将临时表重命名为丢弃的表
　　　5、重新建立受影响表上的全部索引
　　　6、使用VALIDATE STRUCTURE CASCADE的选项来分析全部损坏的表
　　要注意的是损坏块中数据将会丢失并且不能恢复

　　事件14：在热备份时关机

　　如果在热备份正在进行的时候突然关机，其中的一些表空间将可能处在备份模式、当你尝试打开数据库时，它将只能mount，并且指示某些表空间处于热备份模式、由于数据库不能打开，你将不能让表空间脱离热备份模式、你可以使用以下的步骤恢复：
　　　1、startup mount数据库
　　　2、查询v$backup以查看哪些数据文件处于ACTIVE状态、
　　　3、通过使用命令ALTER DATABASE DATAFILE END BACKUP.来将这些数据文件脱离备份模式
　　　4、打开数据库

　　事件15：恢复到某个特别的时间点

　　以下的步骤可用来执行point-in-time恢复
　　　1、关闭数据库实例
　　　2、以NOMOUNT的状态启动数据库实例
　　　3、使用UNTIL的选项来恢复数据库
　　　4、打开数据库
　　　5、Shutdown NORMAL
　　　6、启动数据库实例

　　事件16：恢复到一个特别的事件或者活动

　　可以使用以下的步骤来恢复：
　　　1、关闭数据库实例
　　　2、以NOMOUNT状态启动数据库实例；
　　　3、使用UNTIL CANCEL来恢复数据库，提供存档的redo log文件请求直到该活动/事件为止
　　　4、输入CANCEL来取消恢复
　　　5、打开数据库；
　　　6、使用NORMAL的模式来关闭数据库
　　　7、启动数据库实例

　　结论

　　高可用性对于任何的商业都是很重要的，ORACLE DBA可以通过一些计划以确保停机时间最小化、这篇文章讨论了不同的策略可以达到这个目的。

Oracle数据库系统根据初始化参数文件init.ora中设置的参数来配置自身的启动，每个实例在启动之前，首先读取这些参数文件中设置的不同参数。Oracle系统中的参数，根据系统使用情况可以简单分为两大类，普通参数，也就是Oracle系统正常使用的一些参数，另外一类就是特殊参数，包括三种，过时参数、强调参数和隐藏参数。随着Oracle数据库新版本的发布，相应每次都会增加或者删除一些参数。如何查询当前版本数据库系统的参数情况以及当前系统版本相对于以前版本增加或者丢弃的那些参数呢？本文将详细介绍如何查询当前系统版本中的各种参数情况。

一、过时参数和强调参数

Oracle数据库中，系统提供了几个视图可以查看系统参数的情况。视图V$OBSOLETE_PARAMETER中含有所有的过时(obsolete)和强调(underscored)参数。这里首先说明一下什么是Oracle的过时(obsolote)和强调(underscored)参数，过时参数，顾名思义就是在Oracle以前的版本中存在，但在新版本中已经淘汰了的参数，已经不再使用；而强调参数，是指那些在新版本中保留了下来，但是除非特殊需要不希望用户使用的那些参数。在视图V$OBSOLETE_PARAMETER中，包含这些参数的名称和一个标志字ISSPECIFIED，该标志字用来指出这个参数是否在init.ora文件中已实际设置。

下面的SQL脚本列出了当前系统中所有的过时参数名称以及它们是否在当前系统中设定。

SQL> COL name format a50;
SQL> SELECT name, isspecified FROM v$obsolete_parameter;

上面谈到，Oracle系统并没有将V$OBSOLETE_PARAMETER视图中的所有参数均丢弃，而是将其中的一部分转换为强调参数，下面就来讨论如何查看这些参数是已被丢弃还是被转换。这可以通过系统视图X$KSPPO来查看，该视图中包含一个名为KSPPOFLAG的字段，用来指明该参数在当前版本中是被丢弃还是被强调，如果该值为1，则表示该参数已被丢弃，该值为2，则表明该参数现为强调参数。

SELECT kspponm,
DECODE(ksppoflg, 1,"Obsolete", 2, "Underscored")
FROM x$ksppo
ORDER BY kspponm;

注：该视图只在sys用户下可以看到。

二、隐藏参数

Oracle系统中还有一类参数称之为隐藏参数(hidden parameters)，是系统中使用，但Oracle官方没有公布的参数，这些参数可能是那些还没有成熟或者是系统开发中使用的参数。这些参数在所有Oracle官方提供的文档中都没有介绍，他们的命名有一个共同特征就是都以"_"作为参数的首字符，诸如Oracle 8i中的_trace_files_public和_lock_sga_areas等等。

下面的查询可以得到当前系统中的所有隐藏参数(以sys身份登录)：

SELECT ksppinm, ksppstvl, ksppdesc
FROM x$ksppi x, x$ksppcv y
WHERE x.indx = y.indx
AND translate(ksppinm,"_","#") like "#%";

三、系统当前参数

下面的脚本以英文字母顺序列出了系统当前使用的所有参数。在列出的参数中，如果参数名称前面有#这个符号，则表示该参数没有明确指定，采用了系统中的默认参数。一般在一个新的Oracle版本安装完成后，首先运行该脚本，则可以生成该版本数据库的标准init.ora文件。

SET pagesize 9000
SET head OFF
SET term OFF
SELECT
DECODE(isdefault, "TRUE", "# ") ||
DECODE(isdefault, "TRUE", RPAD(name,43), RPAD(name,45)) ||
" = " || value
FROM v$parameter
ORDER BY name;  

注意：上面的SQL脚本没有列出系统中的隐藏参数。

使用正规表达式编写更好的 SQL

作者：Alice Rischert

Oracle Database 10g 中的正规表达式特性是一个用于处理文本数据的强大工具

Oracle Database 10g 的一个新特性大大提高了您搜索和处理字符数据的能力。这个特性就是正规表达式，是一种用来描述文本模式的表示方法。很久以来它已在许多编程语言和大量 UNIX 实用工具中出现过了。

Oracle 的正规表达式的实施是以各种 SQL 函数和一个 WHERE 子句操作符的形式出现的。如果您不熟悉正规表达式，那么这篇文章可以让您了解一下这种新的极其强大然而表面上有点神秘的功能。已经对正规表达式很熟悉的读者可以了解如何在 Oracle SQL 语言的环境中应用这种功能。

什么是正规表达式？

正规表达式由一个或多个字符型文字和/或元字符组成。在最简单的格式下，正规表达式仅由字符文字组成，如正规表达式 cat。它被读作字母 c，接着是字母 a 和 t，这种模式匹配 cat、location 和 catalog 之类的字符串。元字符提供算法来确定 Oracle 如何处理组成一个正规表达式的字符。当您了解了各种元字符的含义时，您将体会到正规表达式用于查找和替换特定的文本数据是非常强大的。

验证数据、识别重复关键字的出现、检测不必要的空格，或分析字符串只是正规表达式的许多应用中的一部分。您可以用它们来验证电话号码、邮政编码、电子邮件地址、社会安全号码、IP 地址、文件名和路径名等的格式。此外，您可以查找如 HTML 标记、数字、日期之类的模式，或任意文本数据中符合任意模式的任何事物，并用其它的模式来替换它们。

用 Oracle Database 10g 使用正规表达式

您可以使用最新引进的 Oracle SQL REGEXP_LIKE 操作符和 REGEXP_INSTR、REGEXP_SUBSTR 以及 REGEXP_REPLACE 函数来发挥正规表达式的作用。您将体会到这个新的功能如何对 LIKE 操作符和 INSTR、SUBSTR 和 REPLACE 函数进行了补充。实际上，它们类似于已有的操作符，但现在增加了强大的模式匹配功能。被搜索的数据可以是简单的字符串或是存储在数据库字符列中的大量文本。正规表达式让您能够以一种您以前从未想过的方式来搜索、替换和验证数据，并提供高度的灵活性。

正规表达式的基本例子

在使用这个新功能之前，您需要了解一些元字符的含义。句号 (.) 匹配一个正规表达式中的任意字符（除了换行符）。例如，正规表达式 a.b 匹配的字符串中首先包含字母 a，接着是其它任意单个字符（除了换行符），再接着是字母 b。字符串 axb、xaybx 和 abba 都与之匹配，因为在字符串中隐藏了这种模式。如果您想要精确地匹配以 a 开头和以 b 结尾的一条三个字母的字符串，则您必须对正规表达式进行定位。脱字符号 (^) 元字符指示一行的开始，而美元符号 ($) 指示一行的结尾（参见表 1）。因此， 正规表达式 ^a.b$ 匹配字符串 aab、abb 或 axb。将这种方式与 LIKE 操作符提供的类似的模式匹配 a_b 相比较，其中 (_) 是单字符通配符。

默认情况下，一个正规表达式中的一个单独的字符或字符列表只匹配一次。为了指示在一个正规表达式中多次出现的一个字符，您可以使靡桓隽看剩脖怀莆馗床僮鞣?如果您想要得到从字母 a 开始并以字母 b 结束的匹配模式，则您的正规表达式看起来像这样：^a.*b$。* 元字符重复前面的元字符 (.) 指示的匹配零次、一次或更多次。LIKE 操作符的等价的模式是 a%b，其中用百分号 (%) 来指示任意字符出现零次、一次或多次。

表 2 给出了重复操作符的完整列表。注意它包含了特殊的重复选项，它们实现了比现有的 LIKE 通配符更大的灵活性。如果您用圆括号括住一个表达式，这将有效地创建一个可以重复一定次数的子表达式。例如，正规表达式 b(an)*a 匹配 ba、bana、banana、yourbananasplit 等。

Oracle 的正规表达式实施支持 POSIX （可移植操作系统接口）字符类，参见表 3 中列出的内容。这意味着您要查找的字符类型可以非常特别。假设您要编写一条仅查找非字母字符的 LIKE 条件 — 作为结果的 WHERE 子句可能不经意就会变得非常复杂。

POSIX 字符类必须包含在一个由方括号 ([]) 指示的字符列表中。例如，正规表达式 [[:lower:]] 匹配一个小写字母字符，而 [[:lower:]]{5} 匹配五个连续的小写字母字符。

除 POSIX 字符类之外，您可以将单独的字符放在一个字符列表中。例如，正规表达式 ^ab[cd]ef$ 匹配字符串 abcef 和 abdef。必须选择 c 或 d。

除脱字符 (^) 和连字符 (-) 之外，字符列表中的大多数元字符被认为是文字。正规表达式看起来很复杂，这是因为一些元字符具有随上下文环境而定的多重含义。^ 就是这样一种元字符。如果您用它作为一个字符列表的第一个字符，它代表一个字符列表的非。因此，[^[:digit:]] 查找包含了任意非数字字符的模式，而 ^[[:digit:]] 查找以数字开始的匹配模式。连字符 (-) 指示一个范围，正规表达式 [a-m] 匹配字母 a 到字母 m 之间的任意字母。但如果它是一个字符行中的第一个字符（如在 [-afg] 中），则它就代表连字符。

之前的一个例子介绍了使用圆括号来创建一个子表达式；它们允许您通过输入更替元字符来输入可更替的选项，这些元字符由竖线 (|) 分开。

例如，正规表达式 t(a|e|i)n 允许字母 t 和 n 之间的三种可能的字符更替。匹配模式包括如 tan、ten、tin 和 Pakistan 之类的字，但不包括 teen、mountain 或 tune。作为另一种选择，正规表达式 t(a|e|i)n 也可以表示为一个字符列表 t[aei]n。表 4 汇总了这些元字符。虽然存在更多的元字符，但这个简明的概述足够用来理解这篇文章使用的正规表达式。

REGEXP_LIKE 操作符

REGEXP_LIKE 操作符向您介绍在 Oracle 数据库中使用时的正规表达式功能。表 5 列出了 REGEXP_LIKE 的语法。

下面的 SQL 查询的 WHERE 子句显示了 REGEXP_LIKE 操作符，它在 ZIP 列中搜索满足正规表达式 [^[:digit:]] 的模式。它将检索 ZIPCODE 表中的那些 ZIP 列值包含了任意非数字字符的行。

SELECT zip FROM zipcode WHERE REGEXP_LIKE(zip, '[^[:digit:]]')
 
  ZIP
  -----
  ab123
  123xy
  007ab
  abcxy

这个正规表达式的例子仅由元字符组成，更具体来讲是被冒号和方括号分隔的 POSIX 字符类 digit。第二组方括号（如 [^[:digit:]] 中所示）包括了一个字符类列表。如前文所述，需要这样做是因为您只可以将 POSIX 字符类用于构建一个字符列表。

REGEXP_INSTR 函数

这个函数返回一个模式的起始位置，因此它的功能非常类似于 INSTR 函数。新的 REGEXP_INSTR 函数的语法在表 6 中给出。这两个函数之间的主要区别是，REGEXP_INSTR 让您指定一种模式，而不是一个特定的搜索字符串；因而它提供了更多的功能。接下来的示例使用 REGEXP_INSTR 来返回字符串 Joe Smith, 10045 Berry Lane, San Joseph, CA 91234 中的五位邮政编码模式的起始位置。如果正规表达式被写为 [[:digit:]]{5}，则您将得到门牌号的起始位置而不是邮政编码的，因为 10045 是第一次出现五个连续数字。因此，您必须将表达式定位到该行的末尾，正如 $ 元字符所示，该函数将显示邮政编码的起始位置，而不管门牌号的数字个数。

SELECT REGEXP_INSTR('Joe Smith, 10045 Berry Lane, San Joseph, CA 91234', 
    '[[:digit:]]{5}$') AS rx_instr FROM dual
 
  RX_INSTR
  ----------
  45 

编写更复杂的模式

让我们在前一个例子的邮政编码模式上展开，以便包含一个可选的四位数字模式。您的模式现在可能看起来像这样：[[:digit:]]{5}(-[[:digit:]]{4})?$。如果您的源字符串以 5 位邮政编码或 5 位 + 4 位邮政编码的格式结束，则您将能够显示该模式的起始位置。

SELECT REGEXP_INSTR('Joe Smith, 10045 Berry Lane, San Joseph, CA 91234-1234',
  ' [[:digit:]]{5}(-[[:digit:]]{4})?$') AS starts_at FROM dual
 
  STARTS_AT
  ----------
  44 

在这个示例中，括弧里的子表达式 (-[[:digit:]]{4}) 将按 ? 重复操作符的指示重复零次或一次。此外，企图用传统的 SQL 函数来实现相同的结果甚至对 SQL 专家也是一个挑战。为了更好地说明这个正规表达式示例的不同组成部分，表 7 包含了一个对单个文字和元字符的描述。

REGEXP_SUBSTR 函数

类似于 SUBSTR 函数的 REGEXP_SUBSTR 函数用来提取一个字符串的一部分。表 8 显示了这个新函数的语法。在下面的示例中，匹配模式 [^,]* 的字符串将被返回。该正规表达式搜索其后紧跟着空格的一个逗号；然后按 [^,]* 的指示搜索零个或更多个不是逗号的字符，最后查找另一个逗号。这种模式看起来有点像一个用逗号分隔的值字符串。

SELECT REGEXP_SUBSTR('first field, second field , third field',  ', [^,]*,') FROM dual
 
  REGEXP_SUBSTR('FIR
  ------------------
  , second field , 

REGEXP_REPLACE 函数

让我们首先看一下传统的 REPLACE SQL 函数，它把一个字符串用另一个字符串来替换。假设您的数据在正文中有不必要的空格，您希望用单个空格来替换它们。利用 REPLACE 函数，您需要准确地列出您要替换多少个空格。然而，多余空格的数目在正文的各处可能不是相同的。下面的示例在 Joe 和 Smith 之间有三个空格。REPLACE 函数的参数指定要用一个空格来替换两个空格。在这种情况下，结果在原来的字符串的 Joe 和 Smith 之间留下了一个额外的空格。

SELECT REPLACE('Joe Smith',' ', ' ') AS replace FROM dual
 
  REPLACE
  ---------
  Joe Smith 

REGEXP_REPLACE 函数把替换功能向前推进了一步，其语法在表 9 中列出。以下查询用单个空格替换了任意两个或更多的空格。( ) 子表达式包含了单个空格，它可以按 {2,} 的指示重复两次或更多次。

SELECT REGEXP_REPLACE('Joe Smith',  '( ){2,}', ' ') AS RX_REPLACE FROM dual

  RX_REPLACE
  ----------
  Joe Smith 

正则表达式的一个有用的特性是能够存储子表达式供以后重用；这也被称为后向引用（在表 10 中对其进行了概述）。它允许复杂的替换功能，如在新的位置上交换模式或显示重复出现的单词或字母。子表达式的匹配部分保存在临时缓冲区中。缓冲区从左至右进行编号，并利用 \digit 符号进行访问，其中 digit 是 1 到 9 之间的一个数字，它匹配第 digit 个子表达式，子表达式用一组圆括号来显示。

接下来的例子显示了通过按编号引用各个子表达式将姓名 Ellen Hildi Smith 转变为 Smith, Ellen Hildi。

SELECT REGEXP_REPLACE(
  'Ellen Hildi Smith',
  '(.*) (.*) (.*)', '\3, \1 \2')
  FROM dual
 
  REGEXP_REPLACE('EL
  ------------------
  Smith, Ellen Hildi 

该 SQL 语句显示了用圆括号括住的三个单独的子表达式。每一个单独的子表达式包含一个匹配元字符 (.)，并紧跟着 * 元字符，表示任何字符（除换行符之外）都必须匹配零次或更多次。空格将各个子表达式分开，空格也必须匹配。圆括号创建获取值的子表达式，并且可以用 \digit 来引用。第一个子表达式被赋值为 \1 ，第二个 \2，以此类推。这些后向引用被用在这个函数的最后一个参数 (\3, \1 \2) 中，这个函数有效地返回了替换子字符串，并按期望的格式来排列它们（包括逗号和空格）。表 11 详细说明了该正则表达式的各个组成部分。

后向引用对替换、格式化和代替值非常有用，并且您可以用它们来查找相邻出现的值。接下来的例子显示了使用 REGEP_SUBSTR 函数来查找任意被空格隔开的重复出现的字母数字值。显示的结果给出了识别重复出现的单词 is 的子字符串。

SELECT REGEXP_SUBSTR(
  'The final test is is the implementation',
  '([[:alnum:]]+)([[:space:]]+)\1') AS substr
  FROM dual
 
  SUBSTR
  ------
  is is 

匹配参数选项

您可能已经注意到了正则表达式操作符和函数包含一个可选的匹配参数。这个参数控制是否区分大小写、换行符的匹配和保留多行输入。

正则表达式的实际应用

您不仅可以在队列中使用正则表达式，还可以在使用 SQL 操作符或函数的任何地方（比如说在 PL/SQL 语言中）使用正则表达式。您可以编写利用正则表达式功能的触发器，以验证、生成或提取值。

接下来的例子演示了您如何能够在一次列检查约束条件中应用 REGEXP_LIKE 操作符来进行数据验证。它在插入或更新时检验正确的社会保险号码格式。如 123-45-6789 和 123456789 之类格式的社会保险号码对于这种列约束条件是可接受的值。有效的数据必须以三个数字开始，紧跟着一个连字符，再加两个数字和一个连字符，最后又是四个数字。另一种表达式只允许 9 个连续的数字。竖线符号 (|) 将各个选项分开。

ALTER TABLE students
  ADD CONSTRAINT stud_ssn_ck CHECK
  (REGEXP_LIKE(ssn,
  '^([[:digit:]]{3}-[[:digit:]]{2}-[[:digit:]]{4}|[[:digit:]]{9})$'))

由 ^ 和 $ 指示的开头或结尾的字符都是不可接受的。确保您的正则表达式没有分成多行或包含任何不必要的空格，除非您希望格式如此并相应地进行匹配。表 12 说明了该正则表达式示例的各个组成部分。

将正则表达式与现有的功能进行比较

正则表达式有几个优点优于常见的 LIKE 操作符和 INSTR、SUBSTR 及 REPLACE 函数的。这些传统的 SQL 函数不便于进行模式匹配。只有 LIKE 操作符通过使用 % 和 _ 字符匹配，但 LIKE 不支持表达式的重复、复杂的更替、字符范围、字符列表和 POSIX 字符类等等。此外，新的正则表达式函数允许检测重复出现的单词和模式交换。这里的例子为您提供了正则表达式领域的一个概览，以及您如何能够在您的应用程序中使用它们。

实实在在地丰富您的工具包

因为正则表达式有助于解决复杂的问题，所以它们是非常强大的。正则表达式的一些功能难于用传统的 SQL 函数来仿效。当您了解了这种稍显神秘的语言的基础构建程序块时，正则表达式将成为您的工具包的不可缺少的一部分（不仅在 SQL 环境下也在其它的编程语言环境下）。为了使您的各个模式正确，虽然尝试和错误有时是必须的，但正则表达式的简洁和强大是不容置疑的。

Alice Rischert (ar280@yahoo.com) 是哥伦比亚大学计算机技术与应用系的数据库应用程序开发和设计方向的主席。她编写了 Oracle SQL 交互手册 第 2 版（Prentice Hall，2002）和即将推出的 Oracle SQL 示例 （Prentice Hall，2003）。Rischert 拥有超过 15 年的经验在财富 100 强公司内担任数据库设计师、DBA 和项目主管，并且她自从 Oracle version 5 起就一直使用 Oracle 产品。

表 1：定位元字符

表 2：量词或重复操作符

量词	说明
*	匹配 0 次或更多次
?	匹配 0 次或 1 次
+	匹配 1 次或更多次
{m}	正好匹配 m 次
{m,}	至少匹配 m 次
{m, n}	至少匹配 m 次但不超过 n 次

表 3：预定义的 POSIX 字符类

字符类	说明
[:alpha:]	字母字符
[:lower:]	小写字母字符
[:upper:]	大写字母字符
[:digit:]	数字
[:alnum:]	字母数字字符
[:space:]	空白字符（禁止打印），如回车符、换行符、竖直制表符和换页符
[:punct:]	标点字符
[:cntrl:]	控制字符（禁止打印）
[:print:]	可打印字符

表 4：表达式的替换匹配和分组

元字符		说明
|	替换	分隔替换选项，通常与分组操作符 () 一起使用
( )	分组	将子表达式分组为一个替换单元、量词单元或后向引用单元（参见“后向引用”部分）
[char]	字符列表	表示一个字符列表；一个字符列表中的大多数元字符（除字符类、^ 和 - 元字符之外）被理解为文字

表 5：REGEXP_LIKE 操作符

语法	说明
REGEXP_LIKE(source_string, pattern [, match_parameter])	source_string 支持字符数据类型（CHAR、VARCHAR2、CLOB、NCHAR、NVARCHAR2 和 NCLOB，但不包括 LONG）。pattern 参数是正则表达式的另一个名称。match_parameter 允许可选的参数（如处理换行符、保留多行格式化以及提供对区分大小写的控制）。

表 6：REGEXP_INSTR 函数

语法	说明
REGEXP_INSTR(source_string, pattern [, start_position [, occurrence [, return_option [, match_parameter]]]])	该函数查找 pattern ，并返回该模式的第一个位置。您可以随意指定您想要开始搜索的 start_position。 occurrence 参数默认为 1，除非您指定您要查找接下来出现的一个模式。return_option 的默认值为 0，它返回该模式的起始位置；值为 1 则返回符合匹配条件的下一个字符的起始位置。

表 7： 5 位数字加 4 位邮政编码表达式的说明

语法	说明
	必须匹配的空白
[:digit:]	POSIX 数字类
]	字符列表的结尾
{5}	字符列表正好重复出现 5 次
(	子表达式的开头
-	一个文字连字符，因为它不是一个字符列表内的范围元字符
[	字符列表的开头
[:digit:]	POSIX [:digit:]类
[	字符列表的开头
]	字符列表的结尾
{4}	字符列表正好重复出现 4 次
)	结束圆括号，结束子表达式
?	? 量词匹配分组的子表达式 0 或 1 次，从而使得 4 位代码可选
$	定位元字符，指示行尾

表 8：REGEXP_SUBSTR 函数

语法	说明
REGEXP_SUBSTR(source_string, pattern [, position [, occurrence [, match_parameter]]])	REGEXP_SUBSTR 函数返回匹配模式的子字符串。

表 9： REGEXP_REPLACE 函数

语法	说明
REGEXP_REPLACE(source_string, pattern [, replace_string [, position [,occurrence, [match_parameter]]]])	该函数用一个指定的 replace_string 来替换匹配的模式，从而允许复杂的“搜索并替换”操作。

表 10：后向引用元字符

元字符		说明
\digit	反斜线	紧跟着一个 1 到 9 之间的数字，反斜线匹配之前的用括号括起来的第 digit 个子表达式。 （注意：反斜线在正则表达式中有另一种意义，取决于上下文，它还可能表示 Escape 字符。

表 11：模式交换正则表达式的说明

正则表达式项目	说明
(	第一个子表达式的开头
.	匹配除换行符之外的任意单字符
*	重复操作符，匹配之前的 . 元字符 0 到 n 次
)	第一个子表达式的结尾；匹配结果在 \1 中获取（在这个例子中，结果为 Ellen。）
	必须存在的空白
(	第二个子表达式的开头
.	匹配除换行符之外的任意单个字符
*	重复操作符，匹配之前的 . 元字符 0 到 n 次
)	第二个子表达式的结尾；匹配结果在 \2 中获取（在这个例子中，结果为 Hildi。）
	空白
(	第三个子表达式的开头
.	匹配除换行符之外的任意单字符
*	重复操作符，匹配之前的 . 元字符 0 到 n 次
)	第三个子表达式的结尾；匹配结果在 \3 中获取（在这个例子中，结果为 Smith。）

表 12：社会保险号码正则表达式的说明

正则表达式项目	说明
^	行首字符（正则表达式在匹配之前不能有任何前导字符。）
(	开始子表达式并列出用 | 元字符分开的可替换选项
[	字符列表的开头
[:digit:]	POSIX 数字类
]	字符列表的结尾
{3}	字符列表正好重复出现 3 次
-	连字符
[	字符列表的开头
[:digit:]	POSIX 数字类
]	字符列表的结尾
{2}	字符列表正好重复出现 2 次
-	另一个连字符
[	字符列表的开头
[:digit:]	POSIX 数字类
]	字符列表的结尾
{4}	字符列表正好重复出现 4 次
|	替换元字符；结束第一个选项并开始下一个替换表达式
[	字符列表的开头
[:digit:]	POSIX 数字类
]	字符列表的结尾
{9}	字符列表正好重复出现 9 次
)	结束圆括号，结束用于替换的子表达式组
$	定位元字符，指示行尾；没有额外的字符能够符合模式

Oracle数据库数据对象中最基本的是表和视图，其他还有约束、序列、函数、存储过程、包、触发器等。对数据库的操作可以基本归结为对数据对象的操作,理解和掌握Oracle数据库对象是学习Oracle的捷径。

表和视图

Oracle中表是数据存储的基本结构。ORACLE8引入了分区表和对象表，ORACLE8i引入了临时表，使表的功能更强大。视图是一个或多个表中数据的逻辑表达式。本文我们将讨论怎样创建和管理简单的表和视图。

管理表

表可以看作有行和列的电子数据表，表是关系数据库中一种拥有数据的结构。用CREATE TABLE语句建立表，在建立表的同时，必须定义表名，列，以及列的数据类型和大小。例如：

CREATE TABLE products ( 
  PROD_ID NUMBER(4),
  PROD_NAME VAECHAR2(20),
  STOCK_QTY NUMBER(5,3)
); 

这样我们就建立了一个名为products的表， 关键词CREATE TABLE后紧跟的表名，然后定义了三列，同时规定了列的数据类型和大小。

在创建表的同时你可以规定表的完整性约束，也可以规定列的完整性约束，在列上普通的约束是NOT NULL,关于约束的讨论我们在以后进行。

在建立或更改表时，可以给表一个缺省值。缺省值是在增加行时，增加的数据行中某一项值为null时，oracle即认为该值为缺省值。

下列数据字典视图提供表和表的列的信息：

　　　. DBA_TABLES
　　　. DBA_ALL_TABLES
　　　. USER_TABLES
　　　. USER_ALL_TABLES
　　　. ALL_TABLES
　　　. ALL_ALL_TABLES
　　　. DBA_TAB_COLUMNS
　　　. USER_TAB_COLUMNS
　　　. ALL_TAB_COLUMNS

表的命名规则

表名标识一个表，所以应尽可能在表名中描述表，oracle中表名或列名最长可以达30个字符串。表名应该以字母开始，可以在表名中包含数字、下划线、#、$等。

从其它表中建立表

可以使用查询从基于一个或多个表中建立表，表的列的数据类型和大小有查询结果决定。建立这种形式的表的查询可以选择其他表中所有的列或者只选择部分列。在CREATE TABLE语句中使用关键字AS，例如:

SQL> CREATE TABLE emp AS SELECT * FROM employee
SQL> CREATE TABLE Y AS SELECT * FROM X WHERE no=2 

需要注意的是如果查询涉及LONG数据类型，那么CREATE TABLE....AS SELECT....将不会工作。

更改表定义

在建立表后，有时候我们可能需要修改表，比如更改列的定义，更改缺省值，增加新列，删除列等等。ORACLE使用ALTER TABLE语句来更改表的定义

1、增加列

语法：ALTER TABLE [schema.] table_name ADD column_definition

例：

ALTER TABLE orders ADD order_date DATE;

对于已经存在的数据行，新列的值将是NULL.

2、更改列

语法： ALTER TABLE [schema.] table_name MODIFY column_name new_attributes;

例：

ALTER TABLE orders MODITY (quantity number(10,3),status varchar2(15)); 

这个例子中我们修改了表orders，将STATUS列的长度增加到15,将QUANTITY列减小到10,3;

修改列的规则如下：
　　　. 可以增加字符串数据类型的列的长度，数字数据类型列的精度。
　　　. 减少列的长度时，该列应该不包含任何值，所有数据行都为NULL.
　　　. 改变数据类型时，该列的值必须是NULL.
　　　. 对于十进制数字，可以增加或减少但不能降低他的精度。

3、删除数据列

优化ORACLE数据库，唯一的方法是删除列，重新建立数据库。在ORACLE8i中有很多方法删除列，你可以删除未用数据列或者可以标示该列为未用数据列然后删除。

语法：ALTER TABLE [schema.] table_name DROP {COLUM column_names | (column_names)}[CASCADE CONSTRAINS]

要注意的是在删除列时关于该列的索引和完整性约束也同时删除。注意关键字CASCADE CONSTRAINS，如果删除的列是多列约束的一部分，那么这个约束条件相对于其他列也同时删除。

如果用户担心在大型数据库中删除列要花太多时间，可以先将他们标记为未用数据列，标记未用数据列的语法如下：

ALTER TABLE [schema.] table_name SET UNUSED {COLUM column_names | (column_names)}[CASCADE CONSTRAINS]

这个语句将一个或多个数据列标记为未用数据列，但并不删除数据列中的数据，也不释放占用的磁盘空间。但是，未用数据列在视图和数据字典中并不显示，并且该数据列的名称将被删除，新的数据列可以使用这个名称。基于该数据列的索引、约束，统计等都将被删除。

删除未用数据列的语句是：

ALTER TABLE [schema.] table_name DROP {UNUSED COLUM | COLUMN CONTINUE}

删除表和更改表名

删除表非常简单，但它是一个不可逆转的行为。

语法： DROP TABLE [schema.] table_name [CASCADE CONSTRAINTS]

删除表后，表上的索引、触发器、权限、完整性约束也同时删除。ORACLE不能删除视图，或其他程序单元，但oracle将标示他们无效。如果删除的表涉及引用主键或唯一关键字的完整性约束时，那么DROP TABLE语句就必须包含CASCADE CONSTRAINTS子串。

更改表名

RENAME命令用于给表和其他数据库对象改名。ORACLE系统自动将基于旧表的完整性约束、索引、权限转移到新表中。ORACLE同时使所有基于旧表的数据库对象，比如视图、程序、函数等，为不合法。

语法：RENAME old_name TO new_name;

例：

SQL> RENAME orders TO purchase_orders;

截短表

TRUNCATE命令与DROP命令相似， 但他不是删除整个数据表，所以索引、完整性约束、触发器、权限等都不会被删除。缺省情况下将释放部分表和视图空间，如果用户不希望释放表空间，TRUNCATE语句中要包含REUSE STORAGE子串。TRUNCATE命令语法如下：

TRUNCATE {TABLE|CLUSTER} [schema.] name {DROP|REUSE STORAGE}

例：

 SQL> TRUNCATE TABLE t1; 

管理视图

视图是一个或多个表中的数据的简化描述，用户可以将视图看成一个存储查询（stored query)或一个虚拟表(virtual table).查询仅仅存储在oracle数据字典中，实际的数据没有存放在任何其它地方，所以建立视图不用消耗其他的空间。视图也可以隐藏复杂查询，比如多表查询，但用户只能看见视图。视图可以有与他所基于表的列名不同的列名。用户可以建立限制其他用户访问的视图。

建立视图

CREATE VIEW命令创建视图，定义视图的查询可以建立在一个或多个表，或其他视图上。查询不能有FOR UPDATE子串，在早期的ORACLE8i版本中不支持ORDER BY子串，现在的版本中CREATE VIEW可以拥有ORDER BY子串。

例：

SQL> CREATE VIEW TOP_EMP AS 
  SELECT empno EMPLOYEE_ID,ename EMPLOYEE_NAME,salary 
  FROM emp
  WHERE salary > 2000 

用户可以在创建视图的同时更改列名，方法是在视图名后立即加上要命名的列名。重新定义视图需要包含OR REPLACE子串。

SQL> CREATE VIEW TOP_EMP(EMPLOYEE_ID，EMPLOYEE_NAME，SALARY) AS 
  SELECT empno ,ename ,salary FROM emp WHERE salary >2000 

如果在创建的视图包含错误在正常情况下，视图将不会被创建。但如果你需要创建一个带错误的视图必须在CREATE VIEW语句中带上FORCE选项。如：

CREATE FORCE VIEW ORDER_STATUS AS 
  SELECT * FROM PURCHASE_ORDERS
  WHERE STATUS="APPPOVE";

SQL>/
  warning :View create with compilation errors 

这样将创建了一个名为ORDER_STATUS的视图，但这样的视图的状态是不合法的，如果以后状态发生变化则可以重新编译，其状态也变成合法的。

从视图中获得数据

从视图中获得数据与从表中获得数据基本一样，用户可以在连接和子查询中使用视图，也可以使用SQL函数，以及所有SELECT语句的字串。

插入、更新、删除数据

用户在一定的限制条件下可以通过视图更新、插入、删除数据。如果视图连接多个表，那么在一个时间里只能更新一个表。所有的能被更新的列可以在数据字典USER_UPDATETABLE_COLUMNS中查到。

用户在CREATE VIEW中可以使用了WITH子串。WITH READ ONLY子串表示创建的视图是一个只读视图，不能进行更新、插入、删除操作。WITH CHECK OPTION表示可以进行插入和更新操作，但应该满足WHERE子串的条件。这个条件就是创建视图WHERE子句的条件，比如在上面的例子中用户创建了一个视图TOP_EMP,在这个视图中用户不能插入salary小于2000的数据行。

删除视图

删除视图使用DROP VIEW命令。同时将视图定义从数据字典中删除，基于视图的权限也同时被删除，其他涉及到该视图的函数、视图、程序等都将被视为非法。

例：

DROP VIEW TOP_EMP; 

过程和函数

过程和函数都以编译后的形式存放在数据库中，函数可以没有参数也可以有多个参数并有一个返回值。过程有零个或多个参数，没有返回值。函数和过程都可以通过参数列表接收或返回零个或多个值，函数和过程的主要区别不在于返回值，而在于他们的调用方式。过程是作为一个独立执行语句调用的：

 pay_involume(invoice_nbr,30,due_date);

函数以合法的表达式的方式调用：

order_volumn:=open_orders(SYSDATE,30);

创建过程的语法如下：

CREATE [ OR REPLACE] PROCEDURE [schema.]procedure_name
[parameter_lister]
{AS|IS}
declaration_section
BEGIN
executable_section
[EXCEPTION
exception_section]
END [procedure_name]  

每个参数的语法如下：

paramter_name mode datatype [(:=|DEFAULT) value]

mode有三种形式：IN、OUT、INOUT。

IN表示在调用过程的时候，实际参数的取值被传递给该过程，形式参数被认为是只读的，当过程结束时，控制会返回控制环境，实际参数的值不会改变。

OUT在调用过程时实际参数的取值都将被忽略，在过程内部形式参数只能是被赋值，而不能从中读取数据，在过程结束后形式参数的内容将被赋予实际参数。

INOUT这种模式是IN和OUT的组合；在过程内部实际参数的值会传递给形式参数，形势参数的值可读也可写，过程结束后，形势参数的值将赋予实际参数。

创建函数的语法和过程的语法基本相同，唯一的区别在于函数有RETUREN子句

CREATE [ OR REPLACE] FINCTION [schema.]function_name
[parameter_list]
RETURN returning_datatype
{AS|IS}
declaration_section
BEGIN
executable_section
[EXCEPTION]
exception_section
END [procedure_name]  

在执行部分函数必须有哟个或多个return语句。

在创建函数中可以调用单行函数和组函数，例如：

CREATE OR REPLACE FUNCTION my_sin(DegreesIn IN NUMBER)
  RETURN NUMBER
IS 
  pi NUMBER=ACOS(-1);
  RadiansPerDegree NUMBER;
BEGIN
  RadiansPerDegree=pi/180;
  RETURN(SIN(DegreesIn*RadiansPerDegree));
END; 

包

包是一种将过程、函数和数据结构捆绑在一起的容器；包由两个部分组成：外部可视包规范，包括函数头，过程头，和外部可视数据结构；另一部分是包主体(package body),包主体包含了所有被捆绑的过程和函数的声明、执行、异常处理部分。

打包的PL/SQL程序和没有打包的有很大的差异，包数据在用户的整个会话期间都一直存在，当用户获得包的执行授权时，就等于获得包规范中的所有程序和数据结构的权限。但不能只对包中的某一个函数或过程进行授权。包可以重载过程和函数，在包内可以用同一个名字声明多个程序，在运行时根据参数的数目和数据类型调用正确的程序。

创建包必须首先创建包规范，创建包规范的语法如下：

CREATE [OR REPLACE] PACKAGE package_name
{AS|IS}
public_variable_declarations |
public_type_declarations |
public_exception_declarations |
public_cursor_declarations |
function_declarations |
procedure_specifications
END [package_name]

创建包主体使用CREATE PACKAGE BODY语句：

CREATE [OR REPLACE] PACKAGE BODY package_name
{AS|IS}
private_variable_declarations |
private_type_declarations |
private_exception_declarations |
private_cursor_declarations |
function_declarations |
procedure_specifications
END [package_name]

私有数据结构是那些在包主体内部，对被调用程序而言是不可见的。

触发器(Triggers)

触发器是一种自动执行响应数据库变化的程序。可以设置为在触发器事件之前或之后触发或执行。能够触发触发器事件的事件包括下面几种：

DML事件
DDL事件
数据库事件

创建触发器的语法如下：

CREATE [OR REPLACE] TRIGGER trigger_name
{before|after|instead of} event
ON {table_or_view_name|DATABASE}
[FOR EACH ROW[WHEN condition>
trigger_body

只有DML触发器（INSERT、UPDATE、DELETE)语句可以使用INSTEAD OF触发器并且只有表的DML触发器可以是BEFORE或AFTER触发器。

象约束一样触发器可以被设置为禁用或启用来关闭或打开他们的执行体(EXECUTE),将触发器设置为禁用或启用使用ALTER TRIGGER语句：

ALTER TRIGGER trigger_name ENABLE;
ALTER TRIGGER trigger_name DISABLE;

要禁用或启用表的所有触发器，使用ALTER TABLE语句

ALTER TRIGGER table_name DISABLE ALL TRIGGER;
ALTER TRIGGER table_name ENABLE ALL TRIGGER;

删除触发器使用DROP TRIGGER

DROP TRIGGER trigger_name;

数据字典

Oracle数据字典包含了用户数据库的元数据。带下划线的表名称中带OBJ$、UET$、SOURCE$，这些表是在执行CREATE DATABASE语句期间由sql.bsq脚本创建的，一般情况下用户很少访问这些表。脚本catalog.sql（通常位于$oracle_home/rdbms/admin）在CREATE DATABASE语句之后立即运行，创建数据字典视图。

数据字典视图大致可以分为三类：

　　.前缀为USER_的数据字典视图，包含了用户拥有的对象的信息。
　　.前缀为ALL_的数据字典视图，包含了用户当前可以访问的全部对象和权限的信息。
　　.前缀为DBA_的数据字典视图，包含了数据库拥有的所有对象和权限的信息。

在绝大多数数据字典视图中都有象DBA_TABLES,ALL_TABLES和USER_TABLES这样的视图家族。Oracle中有超过100个视图家族，所以要全面介绍这些视图家族是单调乏味的而且没有多大的意义。在下表中列出了最重要和最常用的视图家族，需要注意的是每个视图家族都有一个DBA_,一个ALL_一个USER_视图。
其他的字典视图中主要的是V$视图，之所以这样叫是因为他们都是以V$或GV$开头的。V$视图是基于X$虚拟视图的。V$视图是SYS用户所拥有的，在缺省状况下，只有SYS用户和拥有DBA系统权限的用户可以看到所有的视图，没有DBA权限的用户可以看到USER_和ALL_视图，但不能看到DBA_视图。与DBA_,ALL,和USER_视图中面向数据库信息相反，这些视图可视的给出了面向实例的信息。

在大型系统上化几周时间手工输入每一条语句
手工输入带用户名变量的语句，然后再输入每一个用户名，这需要花好几个小时的时间
写一条SQL语句，生成需要的ALTER USER语句，然后执行他，这只需要几分钟时间

很明显我们将选择生成SQL的方法：

例：

SELECT "ALTER USER"||username||"TEMPORARY TABLESPACE temp;"
FROM DBA_USERS
WHERE username<>"SYS" 
  AND temporary_tablespace<>"TEMP"; 

这个查询的结果将被脱机处理到一个文件中，然后在执行：

ALTER USER SYSTEM TEMPORARY TABLESPACE temp;
ALTER USER OUTLN TEMPORARY TABLESPACE temp;
ALTER USER DBSNMP TEMPORARY TABLESPACE temp;
ALTER USER SCOTT TEMPORARY TABLESPACE temp;
ALTER USER DEMO TEMPORARY TABLESPACE temp;

前言

这篇文章主要介绍RMAN的常用方法，其中包含了作者一些自己的经验，里面的实验也基本全在WIN 2K和ORACLE 8.1.6环境下测试成功（因为这个环境比较容易实现）。

本文借鉴了网上一些高手的相关文章，希望大侠们不要见怪，此处一并谢过。

这篇文章主要是在北京出差期间写的，回到家后整理修改了一下，时间比较仓促，同时因为篇幅有限，一些技术细节不能一一覆盖了，只希望能够帮助新手入门的作用，想真正熟练掌握RMAN，必须经过较长时间的实践磨练才可以，尤其需要在工程中获得宝贵的故障解决经验。

1.什么是RMAN

RMAN可以用来备份和还原数据库文件、归档日志和控制文件。它也可以用来执行完全或不完全的数据库恢复。

注意：RMAN不能用于备份初始化参数文件和口令文件。

RMAN启动数据库上的Oracle服务器进程来进行备份或还原。备份、还原、恢复是由这些进程驱动的。

RMAN可以由OEM的Backup Manager GUI来控制，但在本文章里不作重点讨论。

2. Terminology专业词汇解释

2.1. Backup sets备份集合

备份集合有下面的特性：
　　包括一个或多个数据文件或归档日志
　　以oracle专有的格式保存
　　有一个完全的所有的备份片集合构成
　　构成一个完全备份或增量备份

2.2. Backup pieces备份片

一个备份集由若干个备份片组成。每个备份片是一个单独的输出文件。一个备份片的大小是有限制的；如果没有大小的限制， 备份集就只由一个备份片构成。备份片的大小不能大于使用的文件系统所支持的文件长度的最大值。

2.3. Image copies镜像备份

镜像备份是独立文件（数据文件、归档日志、控制文件）的备份。它很类似操作系统级的文件备份。它不是备份集或备份片，也没有被压缩。

2.4. Full backup sets全备份集合

全备份是一个或多个数据文件中使用过的数据块的的备份。没有使用过的数据块是不被备份的，也就是说，oracle 进行备份集合的压缩。

2.5. Incremental backup sets增量备份集合

增量备份是指备份一个或多个数据文件的自从上一次同一级别的或更低级别的备份以来被修改过的数据块。 与完全备份相同，增量备份也进行压缩。

2.6. File multiplexing

不同的多个数据文件的数据块可以混合备份在一个备份集中。

2.7. Recovery catalog resyncing 恢复目录同步

使用恢复管理器执行backup、copy、restore或者switch命令时，恢复目录自动进行更新，但是有关日志与归档日志信息没有自动记入恢复目录。需要进行目录同步。使用resync catalog命令进行同步。

RMAN>resync catalog;

RMAN-03022：正在编译命令：resync
RMAN-03023：正在执行命令：resync
RMAN-08002：正在启动全部恢复目录的 resync
RMAN-08004：完成全部 resync

3. 恢复目录

3.1.恢复目录的概念

恢复目录是由RMAN使用、维护的用来放置备份信息的仓库。RMAN利用恢复目录记载的信息去判断如何执行需要的备份恢复操作。

恢复目录可以存在于ORACLE数据库的计划中。

虽然恢复目录可以用来备份多个数据库，建议为恢复目录数据库创建一个单独的数据库。

恢复目录数据库不能使用恢复目录备份自身。

3.2.建立恢复目录

第一步，在目录数据库中创建恢复目录所用表空间：

SQL> create tablespace rman_ts datafile "d:\oracle\oradata\rman\rman_ts.dbf" size 20M;

表空间已创建。

第二步，在目录数据库中创建RMAN 用户并授权：

SQL> create user rman identified by rman default tablespace rman_ts temporary 
  tablespace temp quota unlimited on rman_ts;

用户已创建。

SQL> grant recovery_catalog_owner to rman;

授权成功。

SQL> grant connect, resource to rman;

授权成功。

第三步，在目录数据库中创建恢复目录

C:\>rman catalog rman/rman

恢复管理器：版本8.1.6.0.0 - Production

RMAN-06008：连接到恢复目录数据库
RMAN-06428：未安装恢复目录

RMAN>create catalog tablespace rman_ts;

RMAN-06431：恢复目录已创建

注意：虽然使用RMAN不一定必需恢复目录，但是推荐使用。因为恢复目录记载的信息大部分可以通过控制文件来记载，RMAN在恢复数据库时使用这些信息。不使用恢复目录将会对备份恢复操作有限制。

3.3.使用恢复目录的优势

可以存储脚本；

记载较长时间的备份恢复操作；

4. 启动RMAN

RMAN为交互式命令行处理界面，也可以从企业管理器中运行。

为了使用下面的实例，先检查环境符合：

　　the target database is called "his" and has the same TNS alias
　　user rman has been granted "recovery_catalog_owner "privileges
　　目标数据库的连接用户为internal帐号，或者以其他SYSDBA类型帐号连接　　
　　the recovery catalog database is called "rman" and has the same TNS alias
　　the schema containing the recovery catalog is "rman" (same password)

在使用RMAN前，设置NLS_DATE_FORMAT 和NLS_LANG环境变量，很多RMAN LIST命令的输出结果是与日期时间相关的，这点在用户希望执行以时间为基准的恢复工作也很重要。

下例是环境变量的示范：

NLS_LANG=SIMPLIFIED CHINESE_CHINA.ZHS16GBK
NLS_DATE_FORMAT=DD-MON-YYYY HH24:MI:SS

为了保证RMAN使用时能连接恢复目录，恢复目录数据库必须打开，目标数据库至少要STARTED（unmount），否则RMAN会返回一个错误，目标数据库必须置于归档模式下。

4.1.使用不带恢复目录的RMAN

设置目标数据库的 ORACLE_SID ，执行：

% rman nocatalog
RMAN> connect target
RMAN> connect target internal/<PASSWORD>@his

4.2.使用带恢复目录的RMAN

% rman rman_ts rman/rman@rman
RMAN> connect target

% rman rman_ts rman/rman@rman target internal/<PASSWORD>@his

4.3.使用RMAN

一旦连接到目标数据库，可以通过交互界面或者事先存储的脚本执行指定RMAN命令，下面是一个使用RMAN交互界面的实例：

RMAN> resync catalog;
RMAN-03022：正在编译命令：resync
RMAN-03023：正在执行命令：resync
RMAN-08002：正在启动全部恢复目录的 resync
RMAN-08004：完成全部 resync

使用脚本的实例：

RMAN> execute script alloc_1_disk;

创建或者替代存储的脚本：

RMAN> replace script alloc_1_disk { 
   2> allocate channel d1 type disk;
   3> }

5.注册或者注销目标数据库

5.1.注册目标数据库

数据库状态：

恢复目录状态：打开

目标数据库：加载或者打开

目标数据库在第一次使用RMAN之前必须在恢复目录中注册：

第一步，启动恢复管理器，并且连接目标数据库：

C:\>rman target internal/oracle@his catalog rman/rman@rman
恢复管理器：版本8.1.6.0.0 - Production
RMAN-06005：连接到目标数据库：HIS (DBID=3021445076)
RMAN-06008：连接到恢复目录数据库

第二步，注册数据库：

RMAN> register database;
RMAN-03022：正在编译命令：register
RMAN-03023：正在执行命令：register
RMAN-08006：注册在恢复目录中的数据库
RMAN-03023：正在执行命令：full resync
RMAN-08002：正在启动全部恢复目录的resync
RMAN-08004：完成全部resync

5.2.注销目标数据库

RMAN提供了一个注销工具，叫DBMS_RCVCAT工具包，请注意一旦注销了该目标数据库，就不可以使用恢复目录中含有的备份集来恢复数据库了。

为了能注销数据库，需要获得数据库的标识码（DB_ID）和数据库键值（DB_KEY）。其中连接目标数据库时将会获得DB_ID。

C:\>rman target internal/oracle@his catalog rman/rman@rman
恢复管理器：版本8.1.6.0.0 - Production
RMAN-06005：连接到目标数据库：HIS (DBID=3021445076)
RMAN-06008：连接到恢复目录数据库

SQL> select * from db;

  DB_KEY     DB_ID      CURR_DBINC_KEY
  ---------- ---------- --------------
  1          3021445076 2

获得DB_KEY＝1，这样，该目标数据库DB_KEY＝1，DBID=3021445076，利用两个值使用DBMS_RCVCAT工具包就可以注销数据库：

SQL> execute dbms_rcvcat.unregisterdatabase(1,3021445076);
PL/SQL 过程已成功完成。

至此，注销数据库操作完成。

6.操作已有的备份

6.1.加入目录数据库

数据库状态：

恢复目录：打开

目标数据库：加载或者打开

如果存在8.x版本以前创建的备份数据想注册到目标数据库，可以采用如下手工方式加入到恢复目录中

RMAN> catalog datafilecopy "/oracle/ .... /system01.dbf"; 

使用如下命令显示恢复目录中包含的文件

RMAN> list copy of database;

6.2.从目录数据库中删除

第一步：查看备份信息：

RMAN>list backup;
RMAN-03022：正在编译命令：list

备份集列表

关键字  Recid      标记       LV 集合标记   集合计数   完成时间
------- ---------- ---------- -- ---------- ---------- ----------------------
1104    2          501364455  0  501364446  2          06-8月 -03

备份段列表

关键字  Pc# Cp# 状态        完成时间               段名
------- --- --- ----------- ---------------------- ------------------------
1106    1   1   AVAILABLE   06-8月 -03             D:\ORACLE\ORA81\DATABASE\02EU4DMU_1_1

数据文件包括列表

文件 名称                                  LV 类型 检查点SCN  检查点时间
---- ------------------------------------- -- ---- ---------- -------------
   3 D:\ORACLE\ORADATA\HIS\USERS01.DBF      0 Full 160052     06-8月 -03

备份集的关键字为1104。

第二步：定义delete通道：

RMAN>allocate channel for delete type disk;
RMAN-03022：正在编译命令：allocate
RMAN-03023：正在执行命令：allocate
RMAN-08030：分配的通道：delete
RMAN-08500：通道 delete：sid=19 devtype=DISK

第三步：删除backupset备份集

RMAN>change backupset 1104 delete;
RMAN-03022：正在编译命令：change
RMAN-08073：已删除备份段
RMAN-08517：备份段 handle=D:\ORACLE\ORA81\DATABASE\02EU4DMU_1_1 recid=2 stamp=50 1364447
RMAN-03023：正在执行命令：partial resync
RMAN-08003：启动部分恢复目录的 resync
RMAN-08005：完成部分 resync

注意：部分执行删除备份集、备份片或者维护恢复目录的命令，需要先指定通道，如：

RMAN>allocate channel for delete type disk;

RMAN>allocate channel for maintenance type disk;

7.在非归档模式下备份

数据库状态：

恢复目录：打开

目标数据库：例程启动或者数据库加载

恢复目录数据库需要打开，目标数据库必须启动（或者加载）。因为目标数据库不在归档模式下，所以当进行备份恢复操作的时候数据库无法打开。不可以将表空间置于热备份模式上进行等同于文件系统级的拷贝，如果在非归档模式，数据库打开的状态下不能进行数据文件的备份。

7.1.数据库完全备份

RMAN> run {
   2> # backup the complete database to disk
   3> allocate channel dev1 type disk;
   4> backup
   5> full
   6> tag full_db_backup
   7> format "/oracle/backups/db_t%t_s%s_p%p"
   8> (database);
   9> release channel dev1;
  10> }

行#
2: 表明该行为注释行（＃是注释符）
3&9: See section 15 - Channels通道定义
5: Full backup (default if full or incremental not specified)完全备份模式（缺省模式）
6: Meaningful string (<=30 chars)（备份集标识，<＝30个字符）
7: Filename to use for backup pieces, including substitution variables. 备份片使用的文件名，可以包含代替变量。
8: Indicates all files including controlfiles are to be backed up表明备份所有数据文件包括控制文件

通过下面的命令显示恢复目录中记载的备份集信息：

RMAN> list backupset of database;

7.2.备份表空间

RMAN> run {
   2> allocate channel dev1 type disk;
   3> backup
   4> tag tbs_users_read_only
   5> format "/oracle/backups/tbs_users_t%t_s%s"
   6> (tablespace users)
   7> }

使用下列命令来显示恢复目录中该表的备份信息：

RMAN> list backupset of tablespace users;

假设USERS表空间在备份后被置为READ ONLY表空间，以后的全库备份就可以不用备份该表空间，为了达到这个目的，可以在以后的备份中指定"skip readonly"。

注意，目标数据库不需要一定打开，只要加载就可以，因为表空间的信息存储在控制文件中。

7.3.备份单独数据文件

RMAN> run {
   2> allocate channel dev1 type "SBT_TAPE";
   3> backup
   4> format "%d_%u"
   5> (datafile "/oracle/dbs/sysbigdb.dbf");
   6> release channel dev1;
   7> }

行#
2: 使用MML（media manager layer）分配磁带驱动器，必须指定类型为SBT_TAPE；

注意因为没有指定标识，所以标识为空；

使用下面的命令显示恢复目录中备份的表空间：

 RMAN> list backupset of datafile 1;

7.4.备份数据文件

RMAN> run {
   2> allocate channel dev1 type "SBT_TAPE";
   3> copy datafile "/oracle/dbs/temp.dbf" to "/oracle/backups/temp.dbf";
   4> release channel dev1;
   5> }

使用下面的命令显示恢复目录中的文件拷贝：

RMAN> list copy of datafile "/oracle/dbs/temp.dbf";

拷贝数据文件和备份数据文件是不一样的，数据文件拷贝是一个该文件的镜像。文件的备份产生一个备份集。

7.5.备份控制文件

RMAN> run { 
   2> allocate channel dev1 type "SBT_TAPE";
   3> backup
   4> format "cf_t%t_s%s_p%p"
   5> tag cf_monday_night
   6> (current controlfile);
   7> release channel dev1;
   8> }

注意：数据库完全备份将自动备份控制文件。

8.归档模式下的备份

数据库状态：

恢复目录：打开

目标数据库：例程启动，数据库加载或者打开

备份操作使用的命令与非归档模式下基本一样。

8.1. Backing up archived logs 备份归档日志

下面的脚本备份归档日志：

RMAN> run {
   2> allocate channel dev1 type disk;
   3> backup
   4> format "/oracle/backups/log_t%t_s%s_p%p"
   5> (archivelog all)
   6> release channel dev1;
   7> }

下面的脚本归档日志从# 90 to 100：

RMAN> run {
   2> allocate channel dev1 type disk;
   3> backup
   4> format "/oracle/backups/log_t%t_s%s_p%p"
   5> (archivelog from logseq=90 until logseq=100 thread 1);
   6> release channel dev1;
   7> }

下面的脚本备份在24小时内产生的归档日志，在备份完成后会自动删除归档日志。如果备份失败，归档日志不会被删除。

RMAN> run {
   2> allocate channel dev1 type disk;
   3> backup
   4> format "/oracle/backups/log_t%t_s%s_p%p"
   5> (archivelog from time "sysdate-1" all delete input);
   6> release channel dev1;
   7> }

使用下面的命令显示恢复目录中的归档日志：

RMAN> list backupset of archivelog all;

注意：RMAN找到归档日志后会备份指定日志，如果无法找到日志，它也不会返回错误信息。

8.2. Backing up the online logs 备份联机日志

联机日志不能用RMAN来备份，必须先将其归档。

为了实现这点，必须在RMAN中执行如下SQL语句：

RMAN> run {
   2> allocate channel dev1 type disk;
   3> sql "alter system archive log current";
   4> backup
   5> format "/oracle/backups/log_t%t_s%s_p%p"
   6> (archivelog from time "sysdate-1" all delete input);
   7> release channel dev1;
   8> }

上面的脚本可以在执行完一个完整的联机数据库备份后执行，确保所有的重做日志可以将数据库恢复到一个一致性的状态。

注意：不可以标识归档日志备份集。

9. 增量备份

N级别增量备份备份从最近的N级别或者更小级别以来的所有更改过的数据块内容。增量备份分为两种，一种是累积增量备份，一种是非累积增量备份。

累积增量备份包括自最后一次在更低级别进行备份以来所有改动过的数据块。

非累积增量备份包括自前一次在同级或者更低级别进行备份以来改动过的数据块。

9.1. Level 0--增量备份策略的基础

Level 0 是增量备份策略的基础--the basis of the incremental backup strategy

RMAN> run {
   2> allocate channel dev1 type disk;
   3> backup
   4> incremental level 0
   5> filesperset 4
   6> format "/oracle/backups/sunday_level0_%t"
   7> (database);
   8> release channel dev1;
   9> }

Line#
4: 0级备份
5: 定义每个backupset 的最大文件数

使用LIST语句查看，数据库备份集的列表显示中， "type" 将显示 "Incremental"，"LV"列将显示"0" 。

9.2. 使用增量备份的案例

一个典型的增量备份案例如下：
　　 星期天晚上 - level 0 backup performed
　　 星期一晚上 - level 2 backup performed
　　 星期二晚上 - level 2 backup performed
　　 星期三晚上 - level 1 backup performed
　　 星期四晚上 - level 2 backup performed
　　 星期五晚上 - level 2 backup performed
　　 星期六晚上 - level 2 backup performed
　　 星期天晚上 - level 0 backup performed

10. 恢复

恢复案例如下：

10.1. Database open，datafile deleted 数据库打开时，文件被删除

数据文件在数据库打开时被删除。有两种方法可以对打开的数据库进行恢复：还原数据文件或者表空间。下面两个实例显示了该方法：

(a) Datafile recovery 数据文件恢复

RMAN> run {
   2> allocate channel dev1 type disk;
   3> sql "alter tablespace users offline immediate";
   4> restore datafile 4;
   5> recover datafile 4;
   6> sql "alter tablespace users online";
   7> release channel dev1;
   8> }

(b) Tablespace recovery 表空间恢复

RMAN> run {
   2> allocate channel dev1 type disk;
   3> sql "alter tablespace users offline immediate";
   4> restore tablespace users;
   5> recover tablespace users;
   6> sql "alter tablespace users online";
   7> release channel dev1;
   8> }

注意：如果还原系统表空间文件，数据库必须关闭，因为系统表空间不可以脱机。

10.2. Complete restore (lost online redo) and rollforward - database closed 完全还原（丢失联机日志）并且前滚 - 数据库关闭

RMAN> run {
   2> allocate channel dev1 type disk;
   3> set until logseq=105 thread=1;
   4> restore controlfile to "/oracle/dbs/ctrltargdb.ctl";
   5> replicate controlfile from "/oracle/dbs/ctrltargdb.ctl";
   6> restore database;
   7> sql "alter database mount";
   8> recover database;
   9> sql "alter database open resetlogs";
  10> release channel dev1;
  11> }

Notes:
"set until" 命令指明恢复到指定的日志文件。这一点在数据文件恢复时很重要，否则RMAN将试图恢复最近的数据文件，该数据文件可能在指定的日志以前。
"replicate controlfile" 复制还原的控制文件到INIT.ORA指定的控制文件。

如果数据库使用WITH RESETLOGS打开，则需要使用RESET DATABASE命令注册改变后的数据库。在使用RESETLOGS命令打开数据库后强烈建议做一个完全的数据库备份。

10.3. 还原数据文件的子集，完全恢复

RMAN> run {
   2> allocate channel dev1 type disk;
   3> sql "alter database mount";
   4> restore datafile 2;
   5> restore datafile 3;
   6> restore archivelog all;
   7> recover database;
   8> sql "alter database open";
   9> release channel dev1;
  10> }

11. 脚本

创建或者取代脚本：

RMAN> create script alloc_disk {
   2> # Allocates one disk
   3> allocate channel dev1 type disk;
   4> setlimit channel dev1 kbytes 2097150 maxopenfiles 32 readrate 200;
   5> }

RMAN> replace script rel_disk {
   2> # releases disk
   3> release channel dev1;
   5> }

RMAN> replace script backup_db_full {
   2> # Performs a complete backup 
   3> execute script alloc_disk;
   4> backup
   5> .....
   6> execute script rel_disk;
   7> }

前两个脚本分别用来分配和回收通道。

alloc_disk 脚本还额外指定了备份片的最大兆字节数，备份时可以同时打开的输入文件的最大数目，以及每秒钟读每个输入文件的数据缓冲区的最大数目。

第三个脚本调用先前存储的两个脚本进行数据库备份。

运行存储脚本的示范：

RMAN> run {
   2> execute script backup_db_full;
   3> }

注意：存储的脚本必须在{ .... execute <script>; ....}命令中调用。

12. Corruption detection

RMAN可以备份包含损坏数据块的数据文件，查询视图V$BACK_CORRUPTION和V$COPY_CORRUPTION可以获得有关坏数据的信息。

通过设置 set maxcorrupt 可以跳过指定个数的坏块来避免备份失败。

RMAN> replace script backup_db_full {
   2> # Performs a complete backup
   3> execute script alloc_disk;
   4> set maxcorrupt for datafile 1 to 0;
   5> backup
   6> .....
   7> execute script rel_disk;
   8> }

上面的脚本maxcorrupt for datafile 1 to 0设置为0，所以如果有错误数据块在数据文件1中发现，上面的脚本执行就会失败。

13. 通道

一个通道是RMAN和目标数据库之间的一个连接，"allocate channel"命令在目标数据库启动一个服务器进程，同时必须定义服务器进程执行备份或者恢复操作使用的I/O类型

通道控制命令可以用来：
　　 控制RMAN使用的O/S资源
　　 影响并行度
　　 指定I/O带宽的限制值（设置limit read rate参数）
　　 定义备份片大小的限制（设置limit kbytes）
　　 指定当前打开文件的限制值（设置limit maxopenfiles）

14. Report & list commands

14.1. List

list命令查询恢复目录并且产生格式化的查询内容：

 RMAN> list backupset of datafile 1;

  

  Key File Type LV Completion_time Ckp SCN Ckp Time

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

  165 1 　Full Oct 03 11:24 32022 Oct 03 11:24

  208 1 　Full Oct 24 14:27 52059 Oct 24 14:26

  219 1　 Full Oct 24 14:31 52061 Oct 24 14:31

  << other entries here >>

  

  RMAN> list backupset of archivelog all;

  

  Key Thrd Seq Completion time

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

  179 1 94 Oct 03 11:26

  179 1 95 Oct 03 11:26

  << other entries here >>

14.2. Report

REPORT命令同样可以查询恢复目录，但是REPORT命令语法可以构建获得更为有用的信息的指令，REPORT命令输出可以保存到消息日志文件中，但是必须在连接恢复目录时指定MSGLOG或者LOG选项。

可以列出所有数据库中不能恢复的文件列表：

 RMAN> report unrecoverable database;

显示全部数据文件：

RMAN> report schema;
RMAN-03022：正在编译命令：report 数据库模式报表
文件    千字节     表空间    RB     segs 名称 
1       121472     SYSTEM    YES    D:\ORACLE\ORADATA\HIS\SYSTEM01.DBF 
2       327680     RBS       YES    D:\ORACLE\ORADATA\HIS\RBS01.DBF 
3       110592     USERS     NO     D:\ORACLE\ORADATA\HIS\USERS01.DBF 
4       73728      TEMP      NO     D:\ORACLE\ORADATA\HIS\TEMP01.DBF 
5       12288      TOOLS     NO     D:\ORACLE\ORADATA\HIS\TOOLS01.DBF 
6       59392      INDX      NO     D:\ORACLE\ORADATA\HIS\INDX01.DBF 

15. 小提示

经常同步恢复目录

确认删除不需要的归档日志

备份策略简单原则

文章来源：天极网

　　SQL语言共分为四大类：数据查询语言DQL，数据操纵语言DML，数据定义语言DDL，数据控制语言DCL。其中用于定义数据的结构，比如创建、修改或者删除数据库；DCL用于定义数据库用户的权限；在这篇文章中我将详细讲述这两种语言在Oracle中的使用方法。

　　DML语言

　　DML是SQL的一个子集，主要用于修改数据，下表列出了ORACLE支持的DML语句。

　　插入数据

　　INSERT语句常常用于向表中插入行，行中可以有特殊数据字段，或者可以用子查询从已存在的数据中建立新行。

　　列目录是可选的，缺省的列的目录是所有的列名，包括comlumn_id,comlumn_id可以在数据字典视图ALL_TAB_COLUMNS,USER_TAB_COLUMNS,或者DBA_TAB_COLUMNS中找到。

　　插入行的数据的数量和数据类型必须和列的数量和数据类型相匹配。不符合列定义的数据类型将对插入值实行隐式数据转换。NULL字符串将一个NULL值插入适当的列中。关键字NULL常常用于表示将某列定义为NULL值。

　　下面的两个例子是等价的。

        INSERT INTO customers(cust_id,state,post_code)
          VALUE("Ariel",NULL,"94501");  

　　或

        INSERT INTO customers(cust_id,state,post_code)
          VALUE("Ariel",,"94501"); 

　　更新数据

　　UPDATE命令用于修改表中的数据。

        UPDATE order_rollup
          SET(qty,price)=(SELECT SUM(qty),SUM(price) FROM order_lines WHERE customer_id="KOHL")
          WHERE cust_id="KOHL" AND order_period = TO_DATE("01-Oct-2000") 

　　删除数据

　　DELETE语句用来从表中删除一行或多行数据，该命令包含两个语句：
　　　1、关键字DELETE FROM后跟准备从中删除数据的表名。
　　　2、WHERE后跟删除条件

        DELETE FROM po_lines WHERE ship_to_state IN ("TX","NY","IL")

　　清空表

　　如果你想删除表中所有数据，清空表，可以考虑使用DDL语言的TRUNCATE语句。TRUNCATE就像没有WHERE子句的DELETE命令一样。TRUNCATE将删除表中所有行。TRUNCATE不是DML语句是DDL语句，他和DELETE右不同的特点。

        TRUNCATE TABLE (schema)table DROP(REUSE) STORAGE

　　STORAGE子串是可选的，缺省是DROP STORAGE。当使用DROP STORAGE时将缩短表和表索引，将表收缩到最小范围，并重新设置NEXT参数。REUSE STORAGE不会缩短表或者调整NEXT参数。

　　TRUNCATE和DELETE有以下几点区别：

　　1、TRUNCATE在各种表上无论是大的还是小的都非常快。如果有ROLLBACK命令DELETE将被撤销，而TRUNCATE则不会被撤销。

　　2、TRUNCATE是一个DDL语言，向其他所有的DDL语言一样，他将被隐式提交，不能对TRUNCATE使用ROLLBACK命令。

　　3、TRUNCATE将重新设置高水平线和所有的索引。在对整个表和索引进行完全浏览时，经过TRUNCATE操作后的表比DELETE操作后的表要快得多。

　　4、TRUNCATE不能触发任何DELETE触发器。

　　5、不能授予任何人清空他人的表的权限。

　　6、当表被清空后表和表的索引讲重新设置成初始大小，而delete则不能。

　　7、不能清空父表。

　　SELECT FOR UPDATE

　　select for update语句用于锁定行，阻止其他用户在该行上修改数据。当该行被锁定后其他用户可以用SELECT语句查询该行的数据，但不能修改或锁定该行。

　　锁定表

　　LOCK语句常常用于锁定整个表。当表被锁定后，大多数DML语言不能在该表上使用。LOCK语法如下：

        LOCK schema table IN lock_mode 

　　其中lock_mode有两个选项：

　　　share 共享方式
　　　exclusive 唯一方式

　　例：

        LOCK TABLE intentory IN EXCLUSIVE MODE 

　　死锁

　　当两个事务都被锁定，并且互相都在等待另一个被解锁，这种情况称为死锁。

　　当出现死锁时，ORACLE将检测死锁条件，并返回一个异常。

　　事务控制

　　事务控制包括协调对相同数据的多个同步的访问。当一个用户改变了另一个用户正在使用的数据时，oracle使用事务控制谁可以操作数据。

　　事务

　　事务表示工作的一个基本单元，是一系列作为一个单元被成功或不成功操作的SQL语句。在SQL和PL/SQL中有很多语句让程序员控制事务。程序员可以：

　　　1、显式开始一个事物，选择语句级一致性或事务级一致性
　　　2、设置撤销回滚点，并回滚到回滚点
　　　3、完成事务永远改变数据或者放弃修改。

　　事务控制语句

　　例：

BEGIN
  UPDATE checking SET balance=balance-5000 WHERE account="Kieesha";

  INSERT INTO checking_log(action_date,action,amount) 
    VALUES (SYSDATE,"Transfer to brokerage",-5000);

  UPDATE brokerage SET cash_balance=cash_balance+5000 WHERE account="Kiesha";

  INSERT INTO brokerage_log(action_date,action,amount)
    VALUES (SYSDATE,"Tracfer from checking",5000);

  COMMIT;

EXCEPTION
  WHEN OTHERS
    ROLLBACK;
END;

　　Savepoint 和 部分回滚(Partial Rollback)

　　在SQL和PL/SQL中Savepoint是在一事务范围内的中间标志。经常用于将一个长的事务划分为小的部分。保留点Savepoint可标志长事务中的任何点，允许可回滚该点之后的操作。在应用程序中经常使用Savepoint；例如一过程包含几个函数，在每个函数前可建立一个保留点，如果函数失败，很容易返回到每一个函数开始的情况。在回滚到一个Savepoint之后，该Savepoint之后所获得的数据封锁被释放。为了实现部分回滚可以用带TO Savepoint子句的ROLLBACK语句将事务回滚到指定的位置。

　　例

BEGIN 
  INSERT INTO ATM_LOG(who,when,what,where)
  VALUES ("Kiesha",SYSDATE,"Withdrawal of $100","ATM54");
  SAVEPOINT ATM_LOGGED;

  UPDATE checking
    SET balance=balance-100
    RETURN balance INTO new_balance;

  IF new_balance<0 THEN
    ROLLBACK TO ATM_LOGGED;
    COMMIT;
    RAISE insufficient_funda;
  END IF;
END;

　　关键字SAVEPOINT是可选的，所以下面两个语句是等价的：

ROLLBACK TO ATM_LOGGED;
ROLLBACK TO SAVEPOINT ATM_LOGGED; 

　　一致性和事务

　　一致性是事物控制的关键慨念。掌握了oracle 的一致性模型，能使您更好的，更恰当的使用事务控制。oracle通过一致性保证数据只有在事务全部完成后才能被用户看见和使用。这项技术对多用户数据库有巨大的作用。

　　oracle常常使用语句级（state-level)一致性，保证数据在语句的生命期之间是可见的但不能被改变。事务由多个语句组成，当使用事务时，事物级（transaction-level)一致性在整个事务生命期中保证数据对所有语句都是可见的。

　　oracle通过SCN(syatem change number)实施一致性。一个SCN是一个面向时间的数据库内部键。SCN只会增加不会减少，SCN表示了时间上的一个点，每个数据块都有一个SCN,通过比较这个点实施操作。

　　事务级一致性

　　SET TRANSACTION 的一个作用是确保事务级一致或语句级一致中有一个实施。ORACLE使用这些术语：

　　　ISOLATION LEVEL READ COMMIT 表示语句级一致
　　　ISOLATION LEVEL SERIALIZABLE 表示事务级一致。

　　例：

        SET TRANSACTION ISOLATION LEVEL READ COMMIT;

　　下面的语句也能确保事务级一致：

        SET TRANSCATION READ ONLY 

　　任何企图在只读（READ ONLY）事务中修改数据的操作都会抛出一个异常。但是，READ ONLY事务只能在下列语句中使用：

　　SELECT(没有FOR UPDATE子句）
　　LOCK TABLE
　　SET ROLE
　　ALTER SYSTEM
　　ALTER ALARM

　　即使没有改变任何数据，READ ONLY事务依然必须使用一个COMMIT或ROLLBACK以结束整个事务。

　　SET TRANSCTION的另外一个应用是在回滚时直接使用回滚段（ROLLBACK SEGMENT）。回滚段是ORACLE的一个特殊的数据对象，回滚段的头部包含正在使用该回滚段事务的信息。当用户回滚事务（ROLLBACK）时，ORACLE将会利用回滚段中的数据前影像来将修改的数据恢复到原来的值。oracle用round-robin给事务随机分配回滚段。一个大的事务可以分配任何回滚段，这也许会导致回滚段的大小变得很大。因此要避免让大的事务随机分配回滚段。

　　事务以SET TRANSACTION开始,象下面这样：

        SET TRANSACTION USE ROLLBACK SEGMENT rb_large; 

　　rb_large是一个大的回滚段的名称，现在就给一个大的事务分配了一个大的回滚段，其他的小的回滚段将不由动态空间管理，这样就更有效率。

　　下面我们看一个例子.我们有一个回滚段表空间大小是2G，在高峰时期需要10个回滚段以满足用户的需要，这些高峰在线用户只有小的事务。一周我们连续运行了4个大的事务，这些事务需要删除和加载数据，每一个撤销需要1G，回滚段的大小如下：

rb_large(initial 100M minextenta 2)
rb1 (initial 1M next minextents 5)
rb2 (initial 1M next minextents 5)
rb3 (initial 1M next minextents 5)
rb4 (initial 1M next minextents 5)
rb5 (initial 1M next minextents 5)
rb6 (initial 1M next minextents 5)
rb7 (initial 1M next minextents 5)
rb8 (initial 1M next minextents 5)
rb9 (initial 1M next minextents 5)
rb10 (initial 1M next minextents 5)

　　所有的都非常恰当的安排在2G的表空间中，如果我们缺省的round-robin给事务分配回滚段，4个大事务将有4个独立的回滚段，每个回滚段的大小将是1G,如果这样我们的2G表空间就不够，而数据库管理员就不得不在夜晚2点起来工作，每个事务都由以下面的语句开始：

        SET TRANSACTION USE ROLLBACK SEGMENT rb_large;

　　现在 4个事务重用相同的表空间，保正4个回滚段的表空间在2G以内。数据库管理员可以睡到天亮。

　　建立和修改用户

　　CREATE USER 语句将建立一个用户。当一个用户连接到ORACLE数据库时，它必须被验证。ORACLE中验证有三种类型：

　　　Database
　　　external
　　　Global

　　缺省是数据库验证，当用户连接到数据库时，oracle将检测用户是否是数据库的合法用户，并且要提供正确的password.external验证，oracle将只检测用户是否是合法用户，password已经被网络或系统验证了。global验证也是只检测是否是合法用户，password由oraclesecurity server验证。

　　Database验证用户账号

　　数据库验证账号是张好的缺省类型，也是最普通的类型。建立一个账号是piyush,口令是welcome的账号，只需执行下面的命令：

        CREATE USE piyush IDENTIFIED BY welcome 

　　piyush可以通过下面的语句将口令改变为saraswatt：

        ALTER USER piyush IDENTIFIED BY saraswati;

　　外部验证用户账号

　　用户账号进入数据库时可以不提供口令，这种情况下代替数据库识别口令的是客户端操作系统。外部验证账号有时也叫OPS$账号，当他们最初在oracle6开始介绍时，oracle账号都有关键字前缀OPS$,这也就是为什么init.ora 参数os_authent_prefix是OPS$--默认特征与oracle6保持一致。os_authent_prefix定义的字符串必须被预处理为用于Oracle外部识别账号的操作系统账号名。创建操作系统用户appl的语句是：

        CREATE USER ops$appl IDENTIFIED EATERNALLY;

　　但在通常情况下，os_authent_prefix将被设置为空，像下面这样：

        CREATE USER appl IDENTIFIED EATERNALLY;

　　这样效果是一样的,关键字IDENTIFIED EXTERNALLY告诉ORACLE这是一个外部识别账号。

　　GLOBAL用户账号

　　GLOBAL类型的用户账号数据库不检测口令，而是由X.509目录服务器检测口令。创建一个GLOBAL类型的用户账号的方法是：

        CREATE USER scott IDENTIFIED GLOBALLY AS "CN=scott,OU=divisional,O=sybex,C=US" 

　　关键字IDENTIFIED GLOBALLY AS表示建立的是一个GLOBAL类型的用户账号.

　　创建和更改用户账号

　　CREATE USER 用于建立用户账号和给用户账号的属性赋值。ALTER USER用于更改用户账号和属性。但CREATE USER语句必须包括用户名和口令。

　　有部分属性能用CREATER USER和ALTER USER语句设置，下面对是这些的属性具体描述：