2 基于数据仓库的决策支持系统(DSS)由三个部件组成：数据仓库技术(Data warehousing)，联机分析处理技术(OLAP，On—Line Analytical Pro—cessing)，数据挖掘技术(Data Mining)。

　　联机分析处理(OLAP，On—Analytical Pro—cessing)是使分析人员、管理人员或执行人员能够从多种角度对从原始数据中转化出来的、能够真正为用户所理解的、并真实反映企业给特性的信息进行快速、一致、交互地存取，从而获得对数据的更深入了解的一类软件技术。OLAP的目标是满足决策支持或多维环境特定的查询和报表需求。数据仓库侧重于存储和管理面向决策主题的数据；而OLAP侧重于数据仓库的数据分析，并将其转换成辅助决策信息。OLA P的一个主要特点是多维数据分析，这与数据仓库的多维数据组织正好形成相互结合、相互补充的关系。问此，利用OLAP技术与数据仓库的结合可以较好地解决传统决策支持系统既需要处理大量数据又需要进行大量数值计算的问题。
OLAP的多维数据分析主要通过对多维数据的维进行剖切、钻取和旋转来实现对数据库所提供的数据进行深入分析，为决策者提供决策支持。多维结构是决策支持的支柱，也是OLAP的核心。

　　数据挖掘(Data Mining)是从大量的、不完全的、有噪声的。模糊的、随机的数据中提取隐含在其中的、人们事先不知道的、但又是潜在有用的信息和知识的过程。数据挖掘可以看成是一种数据搜寻过程，它不必预先假设或提出问题，但是仍能找到那些非预期的却令人关注的信息，这些信息表示了数据元素的关系和模式。它能挖掘出数据键潜在的模式(pattern)，找出最有价值的信息和知识(knowledge)。指导商业行为或辅助科学研究。研究对象是大规模和超大规模的数据集合。

然后输入用户名密码：scott/tiger

SQL>set timing on 记录SQL的执行时间

SQL>SET LINESIZE 100

SQL>set autotrace on 启动自动跟踪功能
启动自动跟踪功能的方法，执行以下：
创建：
SQL>@%oracle_home%RDBMS\ADMIN\UTLXPLAN.SQL
步骤一：
SQL>conn / AS SYSDBA
步骤二：
SQL>@%Oracle_home%\SQLPLUS\admin\plustrce.sql
步骤三，授权给scott用户：
SQL>set echo off
SQL>grant plustrace to scott;
步骤四，进入SCOTT帐户，执行以下：
SQL>set autotrace on

只看方案和统计数据而不看执行的行的方法，执行以下：
SQL>set autotrace trace

=======================
课程开始
=======================
自然连接:
SQL>select * from employee natural join dept;

优化器提示：
select /*+ USE_HASH(表名1 表名2)*/ .... 散列连接(HASH JOIN)
select /*+ USE_NL(表名1 表名2)*/ .... 嵌套循环连接(NESTED LOOPS)
select /*+ USE_MERGE(表名1 表名2)*/ ....合并连接(MERGE JOIN)

强制使用散列连接，执行以下：
SQL>select  /*+ USE_HASH(emp dept) */ * from emp natural join dept;
USE_NL  嵌套循环连接
USE_MERGE 合并连接

查询各部门工资最高的人员编号、姓名、工资。
SELECT EMPNO,SAL,DEPTNO
FROM EMPLOYEE A
WHERE SAL=(SELECT MAX(SAL) FROM EMPLOYEE WHERE DEPTNO=A.DEPTNO);

  JOIN

    1) 连接的三种实现方法
    2）如何改变语句的连接方法
      （通过优化器提示 optimizer hints)
    3) 优化器有时候并没有选择最快的连接方式
    4）有时也没有选择正确的驱动表

  SUBQUERY

     1）子查询可能被优化器自动改变为连接去执行
     2) 连接比子查询快
     3) 查询时间与查询返回的列的数目成正比
     4）相关子查询比非相关子查询慢
     5) 相关子查询中，
        相关列的值的种类越多，速度越慢

试验：
查询高于所在部门平均工资
的职工编号、姓名、工资、以及高出多少钱。

SELECT A.EMPNO,A.ENAME,A.SAL-B.SAL
FROM EMPLOYEE A,(SELECT DEPTNO,AVG(SAL) SAL FROM EMPLOYEE GROUP BY DEPTNO) B
WHERE A.DEPTNO=B.DEPTNO
AND A.SAL > B.SAL;

SELECT /*+ USE_HASH(A B) */ A.EMPNO,A.ENAME,A.SAL-B.SAL
FROM EMPLOYEE A,(SELECT DEPTNO,AVG(SAL) SAL FROM EMPLOYEE GROUP BY DEPTNO) B
WHERE A.DEPTNO=B.DEPTNO
AND A.SAL > B.SAL;

以下因为在SELECT中存在相关子查询，所以其性能要低于以上的实现方式：
SELECT EMPNO,ENAME,SAL,(SELECT AVG(SAL) FROM EMPLOYEE WHERE DEPTNO=A.DEPTNO)
FROM EMPLOYEE A
WHERE SAL>(SELECT AVG(SAL) FROM EMPLOYEE WHERE DEPTNO=A.DEPTNO);
存在的相关子查询越多，速度越慢。

试验：
查询高于所在部门平均工资的职工编号、
姓名、工资，所在部门的平均工资，以及高出多少钱。

SELECT A.ENAME,A.SAL,B.SAL,A.SAL-B.SAL
FROM EMPLOYEE A,(SELECT DEPTNO,AVG(SAL) SAL FROM EMPLOYEE GROUP BY DEPTNO) B
WHERE A.DEPTNO=B.DEPTNO
AND A.SAL > B.SAL;

IN，EXISTS
NOT IN, NOT EXISTS
SELECT ...
FROM ...
WHERE EXIST(SUB QUERY)
当SUB QUERY有记录返回，则EXIST(SUB QUERY)返回真，否则返回假

试验：
分别用IN和EXISTS查询谁在NEW YORK工作
SELECT *
FROM EMPLOYEE A
WHERE EXISTS (SELECT 1 FROM DEPT WHERE LOC='NEW YORK' AND DEPTNO=A.DEPTNO);

SELECT *
FROM EMPLOYEE
WHERE DEPTNO IN (SELECT DEPTNO FROM DEPT WHERE LOC='NEW YORK');

分别用NOT IN和NOT EXISTS查询谁不在NEW YORK工作

SELECT *
FROM EMPLOYEE A
WHERE NOT EXISTS (SELECT 1 FROM DEPT WHERE LOC='NEW YORK' AND DEPTNO=A.DEPTNO);

SELECT *
FROM EMPLOYEE
WHERE DEPTNO NOT IN (SELECT DEPTNO FROM DEPT WHERE LOC='NEW YORK');

连接 > 非相关子查询 > 相关子查询
连接 > IN > EXISTS

当主查询或子查询的列中中有空值存在的话,
使用NOT IN会返回错误的结果，这时应该使用NOT EXISTS，
也就是说NOT EXISTS比NOT IN要安全。

=================================
WITH
=================================
练习：
查询各部门工资最高的职工的编号，姓名，工资，所在部门最低工资，所在部门的平均工资
效率低：
WITH
A AS (SELECT DEPTNO,AVG(SAL) ASAL FROM EMPLOYEE GROUP BY DEPTNO),
B AS (SELECT DEPTNO,MIN(SAL) BSAL FROM EMPLOYEE GROUP BY DEPTNO),
C AS (SELECT DEPTNO,MAX(SAL) CSAL FROM EMPLOYEE GROUP BY DEPTNO)
SELECT E.EMPNO,E.ENAME,E.SAL,A.ASAL,B.BSAL
FROM EMPLOYEE E,A,B,C
WHERE E.DEPTNO=A.DEPTNO
AND E.DEPTNO=B.DEPTNO
AND E.DEPTNO=C.DEPTNO
AND E.SAL=C.CSAL;

效率高：
WITH B AS (SELECT DEPTNO,MAX(SAL) MSAL,MIN(SAL) NSAL,AVG(SAL)ASAL FROM EMPLOYEE GROUP BY DEPTNO)
SELECT A.EMPNO,A.ENAME,A.SAL,B.NSAL,B.ASAL
FROM EMPLOYEE A,B
WHERE A.DEPTNO=B.DEPTNO
AND A.SAL=B.MSAL;

=================================
INDEX
=================================
试验：
在employee表的SAL列上创建一个索引，然后查询工资是1000的职工
SQL>CREATE INDEX IDX_SAL ON EMPLOYEE(SAL);
SQL>
观察执行方案是否使用了索引，记录查询的时间
SQL>SELECT /*+NO_INDEX(EMPLOYEE) */ * FROM EMPLOYEE WHERE SAL=1000;

当（查询结果行数/表中所有行数）< 10% 时，使用索引很可能会改善查询速度
当（查询结果行数/表中所有行数）> 10% 时，使用索引不会改善查询速度
如果查询的结果列是索引列的话，那么使用索引一定会提高查询速度。

 假设索引建立在(A,B,C)列上

 考虑以下语句能够利用此索引提高查询速度

  SELECT * FROM T1 WHERE A=? AND B=? AND C=?
  SELECT * FROM T1 WHERE A=? AND B=?
  SELECT * FROM T1 WHERE A=?
  SELECT * FROM T1 WHERE B=? AND C=? AND A=?
  SELECT * FROM T1 WHERE A=? AND C=?
  SELECT * FROM T1 WHERE B=? AND C=? 不能利用索引提高查询速度
  SELECT * FROM T1 WHERE A=? AND D=?
  SELECT * FROM T1 WHERE C=? 不能利用索引提高查询速度

  综上，只有当A类出现的时候才会利用索引提高查询速度。

试验：
在SAL列上创建索引IDX_SAL，
在SAL，DERGEE列上创建索引IND_SAL_DEGREE，
然后让以下语句分别使用上述两个索引，比较区别。
SELECT * FROM EMPLOYEE WHERE SAL=1000;
SELECT * FROM EMPLOYEE WHERE DERGEE=3;

强制使用索引：
SELECT /*+INDEX(表名 索引名) */ * FROM 表名 WHERE ......

试验：
在SAL，DEGREE，ID_NO列上创建一个索引，
执行以下查询，并强制使用这个索引
SELECT *
FROM EMPLOYEE
WHERE SAL=1000
AND DEGREE=1;

SELECT * FROM EMPLOYEE
WHERE SAL=1000
AND ID_NO>210101197200000000
 
SELECT * FROM EMPLOYEE
WHERE DEGREE=1
AND ID_NO>210101197200000000

可以利用索引进行排序已提高排序的速度，当然了这时因空间换效率的方法，
因为索引是需要占用空间的。
当使用ORDER BY进行排序，性能比较低的时候，可以使用将排序列建索引的方法来提高性能，
因为索引是排好序的。

# 索引必须跟标存放在不同的表空间上，是为了防止争用最大化读写硬盘的效率。
创建索引的方法：
CREATE INDEX 索引名 ON 表名(字段名1,字段名2,...);
TABLESPACE 表空间名

移动索引至新的表空间中的方法：
ALTER INDEX 索引名 REBUILD TABLESPACE 表空间名;

ALTER TABLE EMP ADD CONSTRANT PK_EMP PRIMARY KEY(EMPNO);

SQL>EXEC DBMS_STATS.GATHER_TABLE_STATS('SCOTT','EMPLOYEE',METHOD_OPT=>'FOR COLUMS SIZE 10 SAL');
DBMS_STAS是个包
GATHER_TABLE_STATS其参数为以下：

SQL>DESC DBMS_STATS;
PROCEDURE GATHER_TABLE_STATS
参数名称                       类型                    输入/输出默认值？
------------------------------ ----------------------- ------ --------
 OWNNAME                        VARCHAR2                IN
 TABNAME                        VARCHAR2                IN
 PARTNAME                       VARCHAR2                IN     DEFAULT
 ESTIMATE_PERCENT               NUMBER                  IN     DEFAULT
 BLOCK_SAMPLE                   BOOLEAN                 IN     DEFAULT
 METHOD_OPT                     VARCHAR2                IN     DEFAULT
 DEGREE                         NUMBER                  IN     DEFAULT
 GRANULARITY                    VARCHAR2                IN     DEFAULT
 CASCADE                        BOOLEAN                 IN     DEFAULT
 STATTAB                        VARCHAR2                IN     DEFAULT
 STATID                         VARCHAR2                IN     DEFAULT
 STATOWN                        VARCHAR2                IN     DEFAULT
 NO_INVALIDATE                  BOOLEAN                 IN     DEFAULT

搜集分析资料(改善优化器的数据来源)：
SQL>ANALYZE TABLE EMPLOYEE COMPUTE STATISTICS;

删除分析资料：
SQL>ANALYZE TABLE EMPLOYEE DELETE STATISTICS;

 索引 
   
   1)索引与全表扫描相比
     当查询返回的行的数量与表中行的总数相比
     比例较低时（至少低于10%），
     索引方式比全表扫描方式快

   2）有时优化器对索引的选择是错误的
      （全表扫描快时，优化器选择的是索引方式)

   3) 多列复合索引，
      如果从前向后按顺序使用索引中的列
      就有可能利用索引提高速度

    4）如果语句中，只出现和返回被索引列，
       则使用索引的速度一般是最快的

    5）索引和表应该存放在不同的表空间
       这样就有可能减少竞争，最大化两者的IO性能

    6) 主键约束上自动创建的唯一索引，
       应该放在和表不同的表空间上

=================================
大纲对象  OUTLINE
=================================
如何针对性地进行优化，而在以后再修改优化方案的时候不需要修改源代码？以下：
方案：大纲对象 OUTLINE

1.准备工作；
SQL>CONN / AS SYSDBA
创建用户：
SQL>CREATE USER USER_NAME IDENTIFIED BY PASSWD;
修改用户的默认表空间：
SQL>ALTER USER USER_NAME DEFAULT TABLESPACE TABLESPACE_NAME;
a.准备一个用来存放大纲数据的表空间
SQL>CONN / AS SYSDBA
SQL>SELECT NAME FROM V$DATAFILE;
SQL>CREATE TABLESPACE OL_TS DATAFILE 'D:\ORACLE\ORADATA\ORA\OL_TS01.DBF' SIZE 100M;
SQL>SELECT NAME FROM V$DATAFILE;
b.将OUTLN帐户的默认表空间设置为这个新建的表空间
SQL>ALTER USER OUTLN DEFAULT TABLESPACE OL_TS;
c.运行脚本dbmsol.sql
d.将OUTLN帐户解锁：
SQL>CONN / AS SYSDBA
SQL>ALTER USER OUTLN ACCOUNT UNLOCK;

2.如何创建大纲，来存储某个语句的当前执行方案
将创建大纲的权限授权给SCOTT：
SQL>GRANT CREATE ANY OUTLINE TO SCOTT

在SCOTT帐户下，为某个特定的语句创建大纲：
SQL>CREATE OUTLINE OL ON SELECT * FROM EMPLOYEE WHERE SAL=1000;

3.如何使用大纲中的存储的方案
全局启用：
SQL>ALTER SYSTEM SET USE_STORED_OUTLINES=TRUE；
当前会话启用：
SQL>ALTER SESSION SET USE_STORED_OUTLINES=TRUE;

4.如何篡改大纲中的存储方案
如果创建了两个大纲：
CREATE OUTLINE OL ON SELECT * FROM EMPLOYEE WHERE SAL=1000;
CREATE OUTLINE OL2 ON SELECT /*+INDEX(EMPLOYEE IND_EMPLOYEE_SAL) */ * FROM EMPLOYEE WHERE SAL=1000;

如何查看目前存在的大纲：
SQL>CONN OUTLN/OUTLN
SQL>SELECT OL_NAME,SQL_TEXT,TEXTLEN,SIGNATURE,HASH_VALUE,HASH_VALUE2,HINTCOUNT FROM OL$;

删除大纲的方法：
SQL>DROP OUTLINE 大纲名;

==========================
分组
==========================

练习：
使用ROLLUP对EMPLOYEE表的SAL,DEGREE列作多重分组
ROLLUP 结果中含有汇总行
SQL> SELECT SAL,DEGREE, COUNT(*) FROM EMPLOYEE GROUP BY ROLLUP (SAL,DEGREE);
       SAL     DEGREE   COUNT(*)
---------- ---------- ----------
      1000          1     157287
      1000          2      52429
      1000          3      52428
      1000                262144 汇总行
      2000          1     194715
      2000          2      52428
      2000                247143 汇总行
      3000          1     157287
      3000          2      52428
      3000          3      52429
      3000                262144 汇总行
      4000                262144 
      4000                262144 汇总行
      2001          1          1
      2001                     1 汇总行
      2002          1       5000
      2002                  5000 汇总行
      2003          1      10000
      2003                 10000 汇总行
                         1048576 汇总行

使用GRUPING(列名），可以表示出那行记录是自己加进来的，而不是原有记录
SQL> SELECT SAL,DEGREE, COUNT(*),GROUPING(DEGREE) FROM EMPLOYEE GROUP BY ROLLUP (SAL,DEGREE);

       SAL     DEGREE   COUNT(*) GROUPING(DEGREE)
---------- ---------- ---------- ----------------
      1000          1     157287                0
      1000          2      52429                0
      1000          3      52428                0
      1000                262144                1 是加进来的汇总记录
      2000          1     194715                0
      2000          2      52428                0
      2000                247143                1 是加进来的汇总记录
      3000          1     157287                0
      3000          2      52428                0
      3000          3      52429                0
      3000                262144                1 是加进来的汇总记录
      4000                262144                0
      4000                262144                1 是加进来的汇总记录
      2001          1          1                0
      2001                     1                1 是加进来的汇总记录
      2002          1       5000                0
      2002                  5000                1 是加进来的汇总记录
      2003          1      10000                0
      2003                 10000                1 是加进来的汇总记录
                         1048576                1 是加进来的汇总记录

===========
CUBE
===========
SELECT ... FROM T1 GROUP BY CUBE(A,B,C,D);
相当于：
 ...GROUP BY A,B,C,D
+...GROUP BY A,B,C
+...GROUP BY A,B
+...GROUP BY A
+...GROUP BY B,C,D
+...GROUP BY B,C
+...GROUP BY B
+...GROUP BY C,D
+...GROUP BY C
+...GROUP BY D
+...GROUP BY ()

练习：
使用CUBE对EMPLOYEE表的SAL,DEGREE列作多重分组
SQL> SELECT SAL,DEGREE,GROUPING(DEGREE),COUNT(*),SUM(SAL) FROM EMPLOYEE GROUP BY CUBE(SAL,DEGREE);

======
GROUPING SETS((...),(..),(...),...,())
======
练习：
使用GROUPING SETS在一个语句中同时查询出：
各种工资的职工工人数和工资总额
各种学位的职工人数和工资总额
每个部门每种学位的职工人数和工资总额
每个部门工资的职工人数和工资总额
全体人数和工资总额
SELECT DEPTNO,SAL,DEGREE,COUNT(*),SUM(SAL)
FROM EMPLOYEE
GROUP BY GROUPING SETS((SAL),(DEGREE),(DEPTNO,DEGREE),(DEPTNO,SAL),());

========================================
实体化视图 MATERALIZED VIEW
========================================
实体化视图与普通视图的区别：
普通视图是个虚表，相当一个子查询
实体化视图是将运算结果预先放到实体化视图表中了

CREATE OR REPLACE VIEW 视图名 AS 查询
SQL>CREATE OR REPLACE VIEW V_A AS SELECT SUM(SAL) SS FROM EMPLOYEE;

CREATE MATERIALIZED VIEW 实体化视图名 AS 查询
首先要给用户作CREATE MATERIALIZED VIEW的权限：
SQL>GRANT CREATE MATERIALIZED VIEW TO SCOTT
创建实体化视图：
SQL>CREATE MATERIALIZED VIEW MV_A SA SELECT SUM(SAL) FROM EMPLOYEE;

练习：
创建一个实体化视图，查询所有部门编号，人数和工资总额
然后比较从这个实体化视图上查询数据的速度和从表上查询数据的速度
SQL>CREATE MATERIALIZED VIEW MV_1 AS SELECT DEPTNO,COUNT(*),SUM(SAL) FROM EMPLOYEE GROUP BY DEPTNO;

因为实体化视图是将运算结果预先放到实体化视图表中，
所以实体化视图中的数据在不同的时刻可能会是旧数据
那么就需要对实体化视图进行刷新
a.手动刷新
SQL>EXEC DBMS_MVIEW.REFRESH('实体化视图名');
b.自动刷新
首先在表的列上，建立实体化视图日志对象，用来监视表中列值的变化
CREATE MATERIALIZED VIEW LOG ON 表名
WITH(列名列表),ROWID INCLUDING NEW VALUES;

CREATE MATERIALIZED VIEW LOG ON EMPLOYEE
WITH(SAL), ROWID INCLUDING NEW VALUES;
创建实体化视图，并且加入自动刷新选项
CREATE MATERIALIZED VIEW 实体化视图名
REFRESH FAST ON COMMIT
AS 查询;
#FAST方式不支持UPDATE。
或
CREATE MATERIALIZED VIEW 实体化视图名
REFRESH COMPLETE ON COMMIT
AS 查询;

删实体化视图的方法:
DROP MATERIALIZED VIEW 实体化视图名

===================
查询重写技术 QUERY REWRITE
===================
作用：
当实体化视图中的数据不准确时，Oracle会自动从表中进行查询
当实体化视图中的数据准确时，Oracle会自动从实体化视图中进行查询。
使用查询重写技术的步骤：
a.实体化视图需要支持查询重写
CREATE MATERIALIZED VIEW 实体化视图名
REFRESH COMPLETE ON COMMIT
ENABLE QUERY REWRITE
AS 查询;
b.启用查询重写功能
ALTER SYSTEM SET QUERY_REWRITE_ENABLED=TRUE;
或
ALTER SESSION SET QUERY_REWRITE_ENABLED=TRUE;

检查某查询语句查询重写是否启用，如果未启用是什么原因的方法：
a.在当前帐户内运行以下脚本：
SQL>@%ORACLE_HOME%\RDBMS\ADMIN\UTLXRW.SQL
b.执行过程：
SQL>EXEC DBMS_MVIEW.EXPLAIN_REWRITE('查询语句');
c.执行查询：
SQL>SELECT * FROM REWRITE_TABLE; 获得信息

=======================
分布式查询
=======================

数据库=控制文件，充作日志文件，数据文件三种文件逻辑集合

--------------------------
DB LINK
--------------------------
三种方式：
1、Connected user link
CREATE PUBLIC DATABASE LINK 名字
USING ‘网络服务名’;

SELECT * FROM EMP@db_link_name;

2、Fixed user link
CREATE PUBLIC DATABASE LINK 名字
CONNECT TO username IDENTIFIED BY password 
USING ‘网络服务名’;

SELECT * FROM EMP@db_link_name;

可以使用以下方式为EMP@DB_LINK_NAME创建别名
CREATE SYNONYM 别名 FRO EMP@DB_LINK_NAME
创建后可以按如下方式使用：
SELECT * FROM 别名;

使用DB-Link的方式如果被连接的数据库提交失败(如出现网络故障)，会导致本地数据库挂起:
ORA-01591：锁定以被有问题的分配事务1.37.1794挂起
解决的方式：
不能简单地使用[ROOLBACK]命令，而需要使用[rollback force '1.37.1794']命令。

如何找到会话信息，并杀掉该会话：
找：
SQL>DESC V$TRANSACTION
SQL>SELECT A.SID,A.SERIAL#,A.TERMINAL,A.USERNAME
FROM V$SESSION A, V$TRANSACTION B
WHERE A.SADDR=B.SES_ADDR

杀：
ALTER SYSTEM KILL SESSION 'SID,SERIAL#'
SQL> ALTER SYSTEM KILL SESSION '12,49'

=======================
并行执行的SQL
=======================

=======================
DDL&DML
=======================
使用外部表的步骤：
a.创建DIRECTORY对象，该对象指向磁盘上的一个目录
SQL> GRANT CREATE ANY DIRECTORY TO SCOTT
SQL> CREATE DIRECTORY test_dir AS '磁盘上的目录'；

b.将格式化的文本文件放在这个目录中

c.创建外部表，在数据库内部映射这个文件的数据
请参照PPT的P273

　　3. /*+CHOOSE*/
　　表明如果数据字典中有访问表的统计信息,将基于开销的优化方法,并获得最佳的吞吐量;
　　表明如果数据字典中没有访问表的统计信息,将基于规则开销的优化方法;
　　例如:
　　SELECT /*+CHOOSE*/ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO='SCOTT';

　　4. /*+RULE*/
　　表明对语句块选择基于规则的优化方法.
　　例如:
　　SELECT /*+ RULE */ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO='SCOTT';

　　5. /*+FULL(TABLE)*/
　　表明对表选择全局扫描的方法.
　　例如:
　　SELECT /*+FULL(A)*/ EMP_NO,EMP_NAM FROM BSEMPMS A WHERE EMP_NO='SCOTT';

　　6. /*+ROWID(TABLE)*/
　　提示明确表明对指定表根据ROWID进行访问.
　　例如:
　　SELECT /*+ROWID(BSEMPMS)*/ * FROM BSEMPMS WHERE ROWID>='AAAAAAAAAAAAAA'
　　AND EMP_NO='SCOTT';

　　7. /*+CLUSTER(TABLE)*/
　　提示明确表明对指定表选择簇扫描的访问方法,它只对簇对象有效.
　　例如:
　　SELECT /*+CLUSTER */ BSEMPMS.EMP_NO,DPT_NO FROM BSEMPMS,BSDPTMS
　　WHERE DPT_NO='TEC304' AND BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

　　8. /*+INDEX(TABLE INDEX_NAME)*/
　　表明对表选择索引的扫描方法.
　　例如:
　　SELECT /*+INDEX(BSEMPMS SEX_INDEX) USE SEX_INDEX BECAUSE THERE ARE FEWMALE BSEMPMS */ FROM BSEMPMS WHERE SEX='M';

　　9. /*+INDEX_ASC(TABLE INDEX_NAME)*/
　　表明对表选择索引升序的扫描方法.
　　例如:
　　SELECT /*+INDEX_ASC(BSEMPMS PK_BSEMPMS) */ FROM BSEMPMS WHERE DPT_NO='SCOTT';

　　10. /*+INDEX_COMBINE*/
　　为指定表选择位图访问路经,如果INDEX_COMBINE中没有提供作为参数的索引,将选择出位图索引的布尔组合方式.
　　例如:
　　SELECT /*+INDEX_COMBINE(BSEMPMS SAL_BMI HIREDATE_BMI)*/ * FROM BSEMPMS
　　WHERE SAL<5000000 AND HIREDATE

　　11. /*+INDEX_JOIN(TABLE INDEX_NAME)*/
　　提示明确命令优化器使用索引作为访问路径.
　　例如:
　　SELECT /*+INDEX_JOIN(BSEMPMS SAL_HMI HIREDATE_BMI)*/ SAL,HIREDATE
　　FROM BSEMPMS WHERE SAL<60000;

　　12. /*+INDEX_DESC(TABLE INDEX_NAME)*/
　　表明对表选择索引降序的扫描方法.
　　例如:
　　SELECT /*+INDEX_DESC(BSEMPMS PK_BSEMPMS) */ FROM BSEMPMS WHERE DPT_NO='SCOTT';

　　13. /*+INDEX_FFS(TABLE INDEX_NAME)*/
　　对指定的表执行快速全索引扫描,而不是全表扫描的办法.
　　例如:
　　SELECT /*+INDEX_FFS(BSEMPMS IN_EMPNAM)*/ * FROM BSEMPMS WHERE DPT_NO='TEC305';

　　14. /*+ADD_EQUAL TABLE INDEX_NAM1,INDEX_NAM2,...*/
　　提示明确进行执行规划的选择,将几个单列索引的扫描合起来.
　　例如:
　　SELECT /*+INDEX_FFS(BSEMPMS IN_DPTNO,IN_EMPNO,IN_SEX)*/ * FROM BSEMPMS WHERE EMP_NO='SCOTT' AND DPT_NO='TDC306';

　　15. /*+USE_CONCAT*/
　　对查询中的WHERE后面的OR条件进行转换为UNION ALL的组合查询.
　　例如:
　　SELECT /*+USE_CONCAT*/ * FROM BSEMPMS WHERE DPT_NO='TDC506' AND SEX='M';

　　16. /*+NO_EXPAND*/
　　对于WHERE后面的OR 或者IN-LIST的查询语句,NO_EXPAND将阻止其基于优化器对其进行扩展.
　　例如:
　　SELECT /*+NO_EXPAND*/ * FROM BSEMPMS WHERE DPT_NO='TDC506' AND SEX='M';

　　17. /*+NOWRITE*/
　　禁止对查询块的查询重写操作.

　　18. /*+REWRITE*/
　　可以将视图作为参数.

　　19. /*+MERGE(TABLE)*/
　　能够对视图的各个查询进行相应的合并.
　　例如:
　　SELECT /*+MERGE(V) */ A.EMP_NO,A.EMP_NAM,B.DPT_NO FROM BSEMPMS A (SELET DPT_NO
　　,AVG(SAL) AS AVG_SAL FROM BSEMPMS B GROUP BY DPT_NO) V WHERE A.DPT_NO=V.DPT_NO
　　AND A.SAL>V.AVG_SAL;

　　20. /*+NO_MERGE(TABLE)*/
　　对于有可合并的视图不再合并.
　　例如:
　　SELECT /*+NO_MERGE(V) */ A.EMP_NO,A.EMP_NAM,B.DPT_NO FROM BSEMPMS A (SELECT DPT_NO,AVG(SAL) AS AVG_SAL FROM BSEMPMS B GROUP BY DPT_NO) V WHERE A.DPT_NO=V.DPT_NO AND A.SAL>V.AVG_SAL;

　　21. /*+ORDERED*/
　　根据表出现在FROM中的顺序,ORDERED使ORACLE依此顺序对其连接.
　　例如:
　　SELECT /*+ORDERED*/ A.COL1,B.COL2,C.COL3 FROM TABLE1 A,TABLE2 B,TABLE3 C WHERE A.COL1=B.COL1 AND B.COL1=C.COL1;

　　22. /*+USE_NL(TABLE)*/
　　将指定表与嵌套的连接的行源进行连接,并把指定表作为内部表.
　　例如:
　　SELECT /*+ORDERED USE_NL(BSEMPMS)*/ BSDPTMS.DPT_NO,BSEMPMS.EMP_NO,BSEMPMS.EMP_NAM FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

　　23. /*+USE_MERGE(TABLE)*/
　　将指定的表与其他行源通过合并排序连接方式连接起来.
　　例如:
　　SELECT /*+USE_MERGE(BSEMPMS,BSDPTMS)*/ * FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

　　24. /*+USE_HASH(TABLE)*/
　　将指定的表与其他行源通过哈希连接方式连接起来.
　　例如:
　　SELECT /*+USE_HASH(BSEMPMS,BSDPTMS)*/ * FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

　　25. /*+DRIVING_SITE(TABLE)*/
　　强制与ORACLE所选择的位置不同的表进行查询执行.
　　例如:
　　SELECT /*+DRIVING_SITE(DEPT)*/ * FROM BSEMPMS,DEPT@BSDPTMS WHERE BSEMPMS.DPT_NO=DEPT.DPT_NO;

　　26. /*+LEADING(TABLE)*/
　　将指定的表作为连接次序中的首表.

　　27. /*+CACHE(TABLE)*/
　　当进行全表扫描时,CACHE提示能够将表的检索块放置在缓冲区缓存中最近最少列表LRU的最近使用端
　　例如:
　　SELECT /*+FULL(BSEMPMS) CAHE(BSEMPMS) */ EMP_NAM FROM BSEMPMS;

　　28. /*+NOCACHE(TABLE)*/
　　当进行全表扫描时,CACHE提示能够将表的检索块放置在缓冲区缓存中最近最少列表LRU的最近使用端
　　例如:
　　SELECT /*+FULL(BSEMPMS) NOCAHE(BSEMPMS) */ EMP_NAM FROM BSEMPMS;

　　29. /*+APPEND*/
　　直接插入到表的最后,可以提高速度.
　　insert /*+append*/ into test1 select * from test4 ;

　　30. /*+NOAPPEND*/
　　通过在插入语句生存期内停止并行模式来启动常规插入.
　　insert /*+noappend*/ into test1 select * from test4 ;

 几个统计语句

open c1;
LOOP fetch c1 into D_cfjg;
EXIT WHEN c1%NOTFOUND ;
i:=i+1;
v_cfjg.EXTEND;
-- DBMS_OUTPUT.PUT_LINE(TO_CHAR(D_cfjg.dm));
v_cfjg(v_cfjg.count):=D_cfjg.dm;
DBMS_OUTPUT.PUT_LINE(v_cfjg(v_cfjg.count));
-- 测试
-- FETCH C1 INTO D_cfjg;
-- EXIT WHEN c1%NOTFOUND ;
END LOOP;
end;
EXCEPTION
WHEN TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE('TOO_MANY_ROWS');
WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE(sqlerrm);
end test_array;

===========================

Java 调用PL/SQL Returning Object Array

上次写了oracle 存储过程返回数组的方法。这次实现在java调用返回值是数组的存储过程方法。

1. 数组：CYJ_ARRAY

CREATE OR REPLACE TYPE CYJ_ARRAY is VARRAY(20) OF integer

2. 存储过程：getTestArray()

CREATE OR REPLACE FUNCTION getTestArray RETURN CYJ_ARRAY
AS
  l_test CYJ_ARRAY :=CYJ_ARRAY();

   begin
    FOR i IN 1..10 LOOP
      l_test.extend;
      l_test(l_test.count) := i;
      dbms_output.put_line(l_test(l_test.count));
    END LOOP;
    RETURN  l_test;
  END;
3. 调用存储过程的java 类

public class TestOracleReturnArray  {
 

public static void main(String[] args) throws SQLException {
 Connection conn = null;
 CallableStatement cstmt = null;
 ResultSet rs = null;
 try {
  
  DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
  conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:ora","zzz","sss");
  
  conn.setAutoCommit(false);
  String procedure = "{? = call getTestArray() }";// 调用存储过程
  cstmt = conn.prepareCall(procedure);
  cstmt.registerOutParameter(1, OracleTypes.ARRAY,"CYJ_ARRAY"); //注：type name：区分大小，不是包中的type, 使用包中定义的type如何调用还不知道
  
  cstmt.execute();
  ARRAY array = (ARRAY)cstmt.getObject(1);
  Object[] items = (Object[])array.getArray();
  Object obj;
  
  for (int i = 0; i < items.length; i++) {
    obj = items[i];
   
   System.out.println(obj);
   
   } // for
 } catch (Exception e) {
  e.printStackTrace();
 } finally {
  //DbConnRestore.connRestore(rs, cstmt, null, conn);
 }
}

}

参考如下资料：

http://www.oracle.com/technology/global/cn/sample_code/tech/java/codesnippet/jdbc/varray/index.html

DBMS_SQL 与本地动态 SQL 比较

1、  动态 SQL 语句最长度限制在 32K 以内。比这个长的语句就只能用 DBMS_SQL 来处理 .

2、  还有很多。。省略

一个最简单的例子 :

SQL>  declare

  2      dyn_tab_name varchar2(20):='t_temp';

  3      dyn_string varchar2(150);

  4   begin

  5     dyn_string:='create table '||dyn_tab_name||' (colA number not null)';

  6     execute immediate dyn_string;

  7  end;

  8  /

使用 DBMS_SQL 的过程包括以下五个步骤

1、    以字符串的形式构造动态 SQL 语句

2、    专用明游标句柄并为该句柄打开游标

3、    解板动态构造的 SQL 语句，把该 SQL 语句与游标句柄关联。

4、    执行 SQL 语句

5、    关闭游标

如

SQL> declare

  2          dyn_tab_name varchar2(20):='t_temp';

  3          dyn_string varchar2(150);

  4          c   integer;

  5          ret_code integer;

  6      begin

  7        dyn_string:='create table '||dyn_tab_name||'( colA number not null)';

  8        c:=dbms_sql.open_cursor;

  9       dbms_sql.parse(c,dyn_string,dbms_sql.v7);

 10       ret_code:=dbms_sql.execute(c);

 11       dbms_sql.close_cursor(c);

 12     end;

 13  /

本地动态 SQL 语句

关于动态 DDL 、 DML 和会话控制的本地动态 SQL 语句如下所示

1、  Execute immediate <dyn_string>

2、  Execute immediate <dum_string> using < 参数 >

3、  Execute immediate <dyn_string>into <index-by 、 array 、嵌套表 >using< 参数 >

4、  Open cursor for <dyn_string>

5、  Open cursor form <dyn_string>  using < 参数 >

6、  Close <cursor>

7、  Execute immediate ‘begin…..end’ using < 参数 >

动态 DDL

动态 DDL 处理的是使用运行时为数据库对象提供的值的 DDL 语句。动态 DDL 一个典型的用法就是，创建仅在运行时表名和列名才可用的一个动态表。可以使用以下 DDL 语句 :

1 、 Execute immediate <dyn_string>

2 、 Execute immediate <dum_string> using < 参数 >

一个使用动态 DDL 创建表的存储过程

create or replace procedure dyn_ddl_demo(tablename varchar2,errnum  outnumber,errtext outvarchar2)
authidcurrent_user
is
  dyn_string varchar2( 1000 );
  dyn_tablename varchar2( 30 );
begin
  dyn_tablename:=tablename;
  dyn_string:= 'create table ' ||dyn_tablename||
  '(order_id number(10) primary key,
    order_date date not null,
    total_qty number,
    total_price number(15,2)
   )' ;
   dbms_output.put_line( 'dyn_string--->' ||dyn_string);
   executeimmediate dyn_string;
   errnum:= 0 ;
exception
   whenothersthen
      errnum:=sqlcode;
      errtext:= 'ERR: Create table ' ||dyn_tablename|| '---' ||sqlerrm;
end dyn_ddl_demo;

动态 SELECTS

查询可以返回一行记录或多行记录。多行记录的在《本地批绑定》里再介绍

单行 Selects

Execute immediate <dyn_string> into < 变量 > using < 参数 >

如 :

create or replace procedure dyn_selects(
vid number,
errnum outnumber,
errtext outvarchar2)
is
  sql_string varchar2( 500 );
  id number;
  uname varchar2( 200 );
  sex varchar2( 2 );
 
  upd_string varchar2( 500 );
  vname varchar2( 200 );
  vsex varchar2( 2 );
  vvid number;
begin
  sql_string := 'select * from t_user where id=:vid' ;
  executeimmediate sql_string into id,uname,sex using vid;
  dbms_output.put_line(id|| '----' ||uname|| '----' ||sex);
 
  upd_string:= 'update t_user set name=:vname,sex=:vsex where id=:vvid' ;
  vname:= ' 傻瓜 ' ;
  vsex:= 'xx' ;
  vvid:= 3 ;
 
  executeimmediate upd_string using vname,vsex,vvid;
  errnum:= 0 ;
exception
  whenothersthen
     errnum:=sqlcode;
     errtext:=sqlerrm;
end dyn_selects;

动态 INSERT 、 UPDATE 和 DELETE

除了 DDL 语句和 DML 的单 SELECT 语句以外，还能动态地构造 INSERT 、 UPDATE 和 DELETE 语句并在运行时执行它们。可以使用以下语句执行 insert,update,delete 语句

       Execute immediate <dyn_string>

    Execute immediate <dyn_string> into < 变量 > using < 参数 >

   像 DML 这样的数据库扣作都是在事务的上下文环境中执行的。事务是一个或多个 SQL 语句的序列，执行一定的工作逻辑单元。事务、定义的特定会话可以由 commit 和 rollback 操作进行控制。只要发生 commit 或 rollback 操作就会释放锁定资源的锁。

自治事务的定义和使用

自治事务是将单一的、完整的事务分割为多个子事务。控制从主事务（ MT ）转移到自治事务（ AT ）。一旦自治事务执行了，主事务就会恢复执行。自治事务独立于主事务， COMMIT 和 ROLLBACK 的范围仅仅限制在自治事务的上下文中。

自治事务的优点

1、  代码的模块人程度更高而且更简单。

2、  在触发器内执行 COMMIT

3、  从执行 DML 的 SQL 中调用用户自定义的函数。

将事务指定为自治事务

可以在代码的声明部分使用下面语句，以便在 PL/SQL 块中定义一个自治事务：

PRAGMA   AUTONOMOUS_TRANSACTION

其中 pragma 关键字的作用是通知 PL/SQL 编译器，将声明它的这个 PL/SQL 代码块分割为一个自治的或独立的事务。定义自治事务时，要遵守以下几条规则：

1 、如果 PL/SQL 块是匿名的，那么该匿名 PL/SQL 块必须是一个顶层块。

2 、如果 PL/SQL 块不是匿名的，那么它必须作为包或存储过程序单元一部分的一个过程或函数。当在包中定义自治事务时，只有包中具体的函数或过程才能被指定为自治的的。

3 、 PL/SQL 块也可以是存储对象类型的一个方法

4 、 PL/SQL 块也可以是一个数据库触发器

一个例子程序

create or replace procedure writelog(
  vid number,errtext varchar2    
)
is
pragmaautonomous_transaction;  -- 定义事务
begin
  insert into t_log values(vid,errtext);
  commit;
end;

create or replace procedure createuser(uid number ,vname varchar2,vsex varchar2)
is
begin
   insertinto t_user values (uid,vname,vsex);
   commit;
exception
  whenothersthen
    writelog(sqlcode,sqlerrm);
    rollback; 
end;

自治事务处理

主事务开始执行

主事务遇到一个对自治子程序的调用，这时主事务就暂停，将控制转移到自治例程中

自治事务开始执行

自治事务执行 commit 或 rollback 操作，这将结束当前自治事务。

主事务恢复

主事务结束

自治事务的一些关键问题

1、  带 ALTER SESSION 的自治事务

自治事务应该与主事务共享一个会话，因此通过 ALTER SESSION 语句，对该会话的任何修改，对自治事务和主事务应该都是可见的。但自治事务执行与主事务不同的上下文中。任何从自治块中引发的自治子程序调用都与自治事务共享相同的事务上下文。

2、  自治事务与死锁

必须以下面的这种方式定义自治事务：

  不创建主事务对资源和锁的死锁。死锁在自治事务试图访问一个被主事务占用的资源时发生，这时主事务会挂起，直到自治事务结束。自治事务死等主事务释放资源，结果可能导致死锁。

3、  定义自治事务的条件

只有顶层匿名块才能包括 PRAGMA  AUTONOMOUS_TRANSTRACTION

4、  COMMIT 或 ROLLBACK 行为与自治事务

自治事务是以 commit 或 rollback 语句结束的。因此，应该在自治事务程序的内部显式地包含一个 commit 或 rollback 语句。如果没有这样做，任何一个未确定的事务都会回滚。这是一个事务级的回滚，而不是一个语句级的回滚。

5、  异常与自治事务

当自治事务以一个异常的方式退出时，就发生一个事务级的回滚，自事事务中所有未确定的改变都会回滚 .

6、  多自治事务

一个自治事务的上下文中，初始化多个自治事务。可以在一个自治块内定义多个 commit 或 rollback 语句来完成这项任务，当包含一个 rollback 时，它就会属于当前事务，而不属于主事务。

7、  自治事务的并发问题

自治事务与主事务是并发运行的，初始化文件 init.ora 中的 transactions 参数决定着每个会话中并发事务的数量。 .

8、  通过自治事务和从 SQL 中调用用户自定义函数

通过自治事务，可以从 SQL 中调用用户自定义函数来执行 DML 操作。只需把用户自定义函数定义为自治事务，函数就变为可从 SQL 中调用的。

9、  自治事务和隔离等级

应该在自治事务中给出 commit 或 rollback 命令，一旦 commit 或 rollback 在自治事务内部执行，那些改变对主事务而言是可见。但是 oracle 也允许从主事务中通过设定主事务的隔离等级为 SERIALIZABLE ，而不是默认的 READ COMMITTED ，对主事务隐藏这些改变，这可以通过 Set TRANSCTION 语句完成，其语法如下：

Set transaction isolation level serializable;

关于隔离等级的问题，以下两点值得注意：

1 当自治事务以 commit 或 rollback 而结束时，由自治事务造成的改变对主事务以外的其它事务是可见的 .

2 设置隔离等级为 serializable ，对主事务隐藏自治事务的变化。直到主事务提交，主事务一旦提交，自治事务中的改变对自治事务也就可见。

10、              什么是隔离级别

隔离级别是一种处理修改数据库事务的方法，它影响到一个事务中的改变对另一个事务的可见性。 SQL92 中定义了 4 种隔离级别即：

 READ UNCOMMITTED

 REPEATABLE  READ

READ COMMOTTED

 SERIALIZABLE

些外 oracle 支持 READ COMMOTTED 和 SERIALIZABLE 两种隔离级别

Read committed ：这种设置是 oracle 默认的 , 它使 oracle 查询可以看到查询之前提将近的数据。换句话说，这种模式的事务是基于每句一致的事务集的。

Serializable ： 这种设置意味着一个事务中的所有语句，都在操作一个事务开始时的数据库映像中，这意味着没有 commit 之前，当前事务都不能看到其它事务所提交的数据。

游标变量就是一个PL/SQL变量，你可以在运行时针对不同的查询使用该变量同一游标变量能指行不同的工作区

游标变量的定义包括两个步骤：
1 定义CURSOR类型的指针
  在pl/SQL中，使用下面语法定义CURSOR类型的指针
  ref type
  如
  TYPE rc IS REF CURSOR
2 定义REF CURSOR 类型的变量
  v_rc rc
  完整的声明游标变量方法如下：
  type rc is ref cursor;
  v_rc rc;

这样定义的游标类型叫弱类ref curosr 类型 ，这是因为没指明游标的返回类型，因此它能指向任何一个具有任意多列的select 查询。
定义带有返回类型的强ref cursor 类型
type ref_type_name is ref cursor return return_type;
如
type rc is ref cursor return hrc_tab%rowtype;
v_rc rc;
游标变量的使用
 1) 分配内存
 2) 为查询打开游标变量
 3) 把结果取到pl/sql记录中
 4) 关闭游标变量

1 分配内存
   在pl/sql中声明游标变量后，pl/sql引擎会自动为期分配存储数据行的内存空间
2 打开游标
  open   游标变量名 fro select_query
3 把结果取到pl/sql记录或单独pl/sql变量中  fetch cursor_variable_name into var1,var2
或
 fetch   cursor_variable_name into table_name%rowtype;

4 关闭游标变量
  close  cursor_variable_name

一个例子
declare
 type rc is ref cursor ;
 v_rc rc;
 v_rc2 rc;
 hrc_rec hrc_tab%rowtype;
begin
  open v_rc for select * form hrc_tab;
  v_rc2:=vrc;
loop
  fetch v_rc into hrc_rec;
  exit when v_rc%nofound;
  dbms_output.put_line();
end loop; 
close v_rc; 
end;
注意：当关闭v_rc的同时也会关闭v_rc2,反之亦然。为一个游标变量简单的赋上一个已经打开的游标变量值，实际上是一个游标指向另一个工作区。不要把一个没打开的游标变量赋值给另一个游标变量，那样会出现invalid_cursor错误
游标变量也有4个属性curosr_variable_name%ISOPEN，curosr_variable_name%FOUND,curosr_variable_name%NOTFOUND,curosr_variable_name%ROWCOUNT
使用的办法和普通游标一样。

游标的高级功能

使用游标变量真正的好处是必须使用同一个游标变量打开多个查询，或根据运行时的条件需要动态的把不同的
查询赋给相同的游标变量时体现。

使用同一游标变理打开多个查询

 declare
 type rc is ref cursor ;
 v_rc rc;
 v_rc2 rc;
 hrc_rec hrc_tab%rowtype;
begin
  open v_rc for select * form hrc_tab;
  v_rc2:=vrc;
loop
  fetch v_rc into hrc_rec;
  exit when v_rc%nofound;
  dbms_output.put_line();
end loop; 
 open v_rc for select * from hrc_tab where class_id='55';
loop
  fetch v_rc into hrc_rec;
  exit when v_rc%nofound;
  dbms_output.put_line();
end loop; 
close v_rc; 
end;

两个地方值得注意：
 同一游标变量v_rc指向两个不同的查询
 第一个查询打开v_rc并取得值后，v_rc并没有立即关闭，它只是简单地为第二个查询重新打开一次，一个新
的结果值就确定下来

-===========================------
游标表达式
使用游标表达式的原因：使用游标表这式可以避免声明和使用多个游标这种复杂的使用方法，因此它能通过
SQL引擎产生更加优化的解决方案，之所以如此，是由于游标表达式相对于多个游标使用多个SQL语句来说，它只使用了一个SQL语句。还有oracle9i中解除了嵌入到pl/sql代码的的SQL中使用游标表达式的限制。，现在可以把游标表达式作为PL/SQL游标的一部分使用

      dbms_job.submit(jobid,v_sql,sysdate,'sysdate+1/1440');
      dbms_job.run(jobid);
      dbms_output.put_line('job'||to_char(jobid)||' is running');
   end createJob;
procedure selectAddr_alias(addrid in number,arecord out cur_talias ) as
   
begin
    open arecord for
    select al_id ,al_name from addr_alias where addr_id=addrid;
end selectAddr_alias;

procedure curtest as
cursor cur_sel_addrAlias is
  select al_id,al_name from addr_alias ;
  alias TAlias;
begin
     --open cur_sel_addrAlias ;
     /*
     fetch cur_sel_addrAlias into alias;
     loop
         exit when cur_sel_addrAlias%notfound;
         dbms_output.put_line(alias.id||'----'||alias.AL_NAME);
     end loop;
     */
     /*
     fetch cur_sel_addrAlias into alias;
     while cur_sel_addrAlias%found  loop
         dbms_output.put_line(alias.id||'----'||alias.AL_NAME);
         fetch cur_sel_addrAlias into alias;
     end loop;

     */
     /*
    
     for idx in cur_sel_addrAlias loop --使用这方式遍历游标不能先打开游标变量
         dbms_output.put_line(idx.al_id||'----'||idx.al_name);
     end loop;
     close cur_sel_addrAlias;
     */
     dbms_output.put_line('....避免显式身明游标....');
     for idx in (select * from addr_alias) loop
        dbms_output.put_line(idx.al_id||'---'||idx.al_name||'---'||idx.addr_id);
     end loop;
exception
  when  others then
    dbms_output.put_line(sqlerrm);
end curtest;
end peidw_test;
---------------------------------------------------------------------

无聊今天看了一下oracle 9i开发人同指南，好久没写pl/sql了，今天主要看游标这一章。
显式游标有4个属性
     %found  指明是否取到了指定的记录行
         用于判定是否取到一条记录，取到返回true，如果fetch没取到任何行，就返回false。
     %isopen 指明游标是打开的还是关闭的
         用于检查游标是否打开，游标打开了就返回true,未打开返回false。
     %notfound
           指示fetch是否失败或是否还有可取的记录行
     %rowcount 指明总共取得多少行记录


参数游标：
定义
  cursor cur_sel_addrAliasByid(vaddr_id number) is
         select al_id,al_name from addr_alias where addr_id=vaddr_id;
使用
     open cur_sel_addrAliasByid(1);
     fetch cur_sel_addrAliasByid into alias ;
     while cur_sel_addrAliasByid%found loop
         dbms_output.put_line(alias.id||'----'||alias.AL_NAME);
         fetch cur_sel_addrAliasByid into alias;
     end loop;
     close cur_sel_addrAliasByid;
Select for Update 游标
   用来更新游标所检索到的记录如：
declare
    cursor cur_1 is 
      select al_id,al_name form addr_alias for update of al_name;
     vname varchar2(50)
begin
   for idx in cur_1 loop
         vname:=upper(idx.al_name);
         upate  addr_alias set al_name=vname where current of cur_1;
  end loop;

commit;
end;   

/*构建一棵树*/
Function BuildTree(in_Level in Number) return varchar2
as
  result varchar2(4000);
begin
 if in_Level=1 then
   return null;
  end if;
 return '|'||incString('-',(in_Level-1)*4);  
end;


查询的构语句:

   select a.addr_id ,tools.BuildTree(2)||a.addr_name from addr_info a
   connect by a.addr_id =   prior a.parent_id
    start with a.addr_id='叶子结点id'
    order by level desc