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%’;

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%’;

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

--低效
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’ ND REGION != ‘PERTH’ GROUP BY REGION

--低效
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’)

--为了提高效率改写为: (方法一: 高效)
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’);

--低效:
SELECT DISTINCT DEPT_NO,DEPT_NAME  FROM DEPT D,EMP E WHERE D.DEPT_NO = E.DEPT_NO
--高效:
SELECT DEPT_NO,DEPT_NAME  FROM DEPT D WHERE EXISTS ( SELECT ‘X’ FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);
--EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果.

--低效：
SELECT …FROM DEPT WHERE SAL * 12 > 25000;
--高效:
SELECT … FROM DEPT WHERE SAL  > 25000/12;

--如果DEPTNO上有一个索引
--高效：
SELECT *  FROM EMP  WHERE DEPTNO >=4
--低效：
SELECT *  FROM EMP   WHERE DEPTNO >3

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%’;

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%’;

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

--低效
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’ ND REGION != ‘PERTH’ GROUP BY REGION

--低效
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’)

--为了提高效率改写为: (方法一: 高效)
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’);

--低效:
SELECT DISTINCT DEPT_NO,DEPT_NAME  FROM DEPT D,EMP E WHERE D.DEPT_NO = E.DEPT_NO
--高效:
SELECT DEPT_NO,DEPT_NAME  FROM DEPT D WHERE EXISTS ( SELECT ‘X’ FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);
--EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果.

--低效：
SELECT …FROM DEPT WHERE SAL * 12 > 25000;
--高效:
SELECT … FROM DEPT WHERE SAL  > 25000/12;

--如果DEPTNO上有一个索引
--高效：
SELECT *  FROM EMP  WHERE DEPTNO >=4
--低效：
SELECT *  FROM EMP   WHERE DEPTNO >3

一、decode

在Oracle/PLSQL 中,  decode 具有和 IF-THEN-ELSE 一样的功能。

decode 函数语法如下：

decode( expression , search , result [, search , result]... [, default] )

expression 要比较的表达式.

search 要与expression 比较的字段。.

result 如果expression 与search 一样的话，返回该结果。.

default 此参数可选，如果没有与expression 匹配上的search . 就返回此结果，如果此参数没有设置，当没有与expression匹配上的search时，返回null。

search 和 result可成对出现多次，代表各种要匹配的情况。 
 

应用于

• Oracle 9i, Oracle 10g, Oracle 11g

例如：

You could use the decode function in an SQL statement as follows:

select supplier_name,decode(supplier_id,1000,'IBM',10001,'Microsoft','1002','Hewlett Packard','Gateway') result from suppliers;

上面的sql语句相当于下面的IF-THEN-ELSE :

IF supplier_id = 10000 THEN
     result := 'IBM';

ELSIF supplier_id = 10001 THEN
    result := 'Microsoft';

ELSIF supplier_id = 10002 THEN
    result := 'Hewlett Packard';

ELSE
    result := 'Gateway';

END IF;

 decode 函数会挨个匹配supplier_id 的值.

常见问题：

问题1:  现在一个阅读者想问，怎么使用decode函数来比较两个日期呢？（例如：date1 和 date2）, 如果date1 > date2, decode 函数返回date2. 否则decode函数返回 date1.

回答:  要实现上述要求，可使用decode函数如下：

decode((date1 - date2) - abs(date1 - date2), 0, date2, date1)

如果date1大于date2，下面表达是会等于0：

(date1 - date2) - abs(date1 - date2)

帮助性提示: 可用decode函数绑定SIGN 函数 像下面这样:

上面比较日期的语句可修改如下:

DECODE(SIGN(date1-date2), 1, date2, date1)

SIGN/DECODE 联合对于有关销售红利等数字方面的比较是非常有用的。

DECODE(SIGN(actual-target), -1, 'NO Bonus for you', 0,'Just made it', 1, 'Congrats, you are a winner')

问题2:  我想知道是否可以用decode函数来确定数字范围，例如 1-10 = 'category 1', 11-20 = 'category 2', 比一个一个比较应该会好一点吧.

回答: 不幸的告诉你，不可以用decode函数来确定数字的范围. 可是你可以试着创建一个表达式，这个表达式可以得一个数字指定的范围, 下一个数字对应下一个指定的范围, 以此类推.

例如：

select supplier_id,decode(trunc((supplier_id-1)/10),0,'category 1',1,'category 2',2,'category 3','unknown') result from suppliers;

这个例子基于这个公式：trunc ((supplier_id - 1) / 10

如果supplier_id在1和10之间，表达式计算值=0.

如果supplier_id在11和20之间，表达式计算值=1.

如果supplier_id在21和30之间，表达式计算值=3.

等等；

问题3:  我想写一个decode函数，要求如下:

如果 yrs_of_service < 1 返回 0.04
如 果 yrs_of_service >= 1 and < 5 返回0.04
如果 yrs_of_service > 5 返回 0.06

这种情况我该怎么做呢?

回答:  You will need to create a formula that will evaluate to a single number for each one of your ranges.

For example:

select emp_name,decode(trunc((yrs_of_service+3)/4),0,0.04,1,0.04,0.06) as perc_value from employees;

问题4:  decode函数的参数个数有限制吗？我得到一个错误 "ORA-00939: too many arguments for function".

回答:  是的，decode函数的最大参数个数为255个,包括expression, search, and result arguments.<!-- InstanceEndEditable -->

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

二、sign

在Oracle/PLSQL 中, sign 函数返回一个数字的正负标志.

语法如下：sign( number )

        number 要测试标志的数字.

If number < 0, then sign returns -1.
If number = 0, then sign returns 0.
If number > 0, then sign returns 1.

应用于:

• Oracle 8i, Oracle 9i, Oracle 10g, Oracle 11g
  

例如:

sign(-23)	would return -1
sign(0.001)	would return -1
sign(0)	would return 0
sign(0.001)	would return 1
sign(23)	would return 1
sig(23.601)	would return 1

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

三、trunc(number)

在Oracle/PLSQL中, trunc function returns a number truncated to a certain number of decimal places.

trunc function 语法如下:

trunc( number, [ decimal_places ] )

number 要截取的数字.

decimal_places 要保留的小数位. 这个参数必须是个整数. 如果此参数缺省，默认保留0位小数
 

应用于:

• Oracle 8i, Oracle 9i, Oracle 10g, Oracle 11g

例如For example:

trunc(125.815)	would return 125
trunc(125.815, 0)	would return 125
trunc(125.815, 1)	would return 125.8
trunc(125.815, 2)	would return 125.81
trunc(125.81, 3)	would return 125.81
trunc(-125.815, 2)	would return -125.81
trunc(125.815, -1)	would return 120
trunc(125.815, -2)	would return 100
trunc(125.81, -3)	would return 0

 

 如果decimal_places 大于number 本身的小数位数，返回原数字不会加0.

如：trunc(125.81,3) would return 125.81;

如果decimal_places 为负数，那么将指定的位数

对于rownum来说它是oracle系统顺序分配为从查询返回的行的编号，返回的第一行分配的是1，第二行是2，依此类推，这个伪字段可以用于限制查询返回的总行数，而且rownum不能以任何表的名称作为前缀。
举例说明：
例如表：student(学生)表，表结构为：
ID　　　 char(6)　　　　　      --学号
name　　VARCHAR2(10)　　　--姓名

/* Formatted on 2008/09/24 09:15 (Formatter Plus v4.8.7) */
CREATE TABLE student (ID CHAR(6), NAME VARCHAR2(100));

INSERT INTO student
     VALUES ('200001', '张一');
INSERT INTO student
     VALUES ('200002', '王二');
INSERT INTO student
     VALUES ('200003', '李三');
INSERT INTO student
     VALUES ('200004', '赵四');
COMMIT ;


(1) rownum 对于等于某值的查询条件
如果希望找到学生表中第一条学生的信息，可以使用rownum=1作为条件。但是想找到学生表中第二条学生的信息，使用rownum=2结果查不到数据。因为rownum都是从1开始，但是1以上的自然数在rownum做等于判断是时认为都是false条件，所以无法查到rownum = n（n>1的自然数）。
SQL> select rownum,id,name from student where rownum=1;（可以用在限制返回记录条数的地 方，保证不出错，如：隐式游标）
SQL> select rownum,id,name from student where rownum=1;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200001 张一
SQL> select rownum,id,name from student where rownum =2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------

（2）rownum对于大于某值的查询条件
   如果想找到从第二行记录以后的 记录，当使用rownum>2是查不出记录的， 原因是由于rownum是一个总是从1开始的伪列，Oracle 认为rownum> n(n>1的自然数)这种条件依旧不成立，所以查不到记录
SQL> select rownum,id,name from student where rownum >2;
ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
那如何才能找到第二行以后的记 录呀。可以使用以下的子查询方法来解决。注意子查询中的rownum必须要有别名，否则还是不会查出记录来，这是因为rownum不是某个表的列，如果不起别名的话，无法知道rownum是子查询的列还是主查询的列。
SQL>select * from(select rownum no ,id,name from student) where no>2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         4 200004 赵四
SQL> select * from(select rownum,id,name from student)where rownum>2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------

（3）rownum对于小于某值的查询条件
如果想找到第三条记录以前的记 录，当使用rownum<3是能得到两条记录 的。显然rownum对于rownum<n（(n>1的自然数）的条件认为是成立的，所以可以找到记录。
SQL> select rownum,id,name from student where rownum <3;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
        1 200001 张一
        2 200002 王二

综上几种情况，可能有时候需要 查询rownum在某区间的数据，那怎么办呀从上可以看出rownum对小于某值的查询条件是人为true的，rownum对于大于某值的查询条件直接认为是false的，但是可以间接的让它转为认为是true的。那就必须使用子查询。例如要查询rownum在第二行到第三行之间的数据，包括第二行和第三行数据，那么我们只能写以下语句，先让它返回小于等于 三的记录行，然后在主查询中判断新的rownum的别名 列大于等于二的记录行。但是这样的操作会在大数据集中影响速度。
SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         2 200002 王二
         3 200003 李三

（4）rownum和排序
Oracle中的rownum的是在取数据的时候产生的序号，所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出，rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号，rowid也是顺序分配的。为了解决这个问题，必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
这样就成了按name排序，并且用rownum标出正确序号（有小到大）。

笔者在工作中有一上百万条记录的表，在jsp页面中需对该表进行分页显示， 便考虑用rownum来作，下面是具体方法(每页
显示20条)：
“select * from tabname where rownum<20 order by name" 但却发现oracle却不能按自己的意愿来执行，而是先随便
取20条记录，然后再 order by，后经咨询oracle,说rownum确实就这样，想用的话，只能用子查询 来实现先排序，后
rownum，方法如下：
"select * from (select * from tabname order by name) where rownum<20",但这样一来，效率会较低很多。
后经笔者试验，只需在order by 的字段上加主键或索引即可让oracle先按 该字段排序，然后再rownum；方法不变：
   “select * from tabname where rownum<20 order by name"

补充：我们正常分页是如下（order by 主键，在最里面的那一层。非主键字段同样要 加索引）：
/* Formatted on 2008/09/24 12:14 (Formatter Plus v4.8.7) */
SELECT *
FROM (SELECT tmp.*, ROWNUM rn
          FROM (SELECT   *
                    FROM student
                   WHERE 1 = 1
                ORDER BY NAME DESC) tmp
         WHERE 1 = 1 AND ROWNUM <= 3)
WHERE 1 = 1 AND rn >= 2


(5) 取得某列中第N大的行

select column_name from
(select table_name.*,dense_rank() over (order by column desc) rank from table_name)
where rank = &N；

/* Formatted on 2008/09/24 12:30 (Formatter Plus v4.8.7) */
SELECT *
FROM (SELECT student.*, DENSE_RANK () OVER (ORDER BY ID DESC) RANK
          FROM student)
WHERE RANK = 2

(6)假如要返回前5条记录：

select * from tablename where rownum<6;(或是rownum <= 5 或是rownum != 6)
假如要返回第5-9条记录：
/* Formatted on 2008/09/24 12:34 (Formatter Plus v4.8.7) */
SELECT   *
    FROM student
   WHERE ROWNUM < 4
MINUS
SELECT   *
    FROM student
   WHERE ROWNUM < 2

order by name
选出结果后用name排序显示结果。(先选再排序)

注意：只能用以上符号(<、<=、!=)。

(7)select * from tablename where rownum != 10;返回的是前９条记录。
不能用：>,>=,=,Between...and。由于rownum是一个总是从1开始的伪列，Oracle 认为这种条件 不成立，查不到记录.

另 外，这个方法更快：

select * from (
select rownum r,a from yourtable
where rownum <= 20
order by name )
where r > 10
这样取出第11-20条记录!(先选再排序再选)

要先排序再选则须用select嵌套：内层排序外层选。
rownum是随着结果集生成的，一旦生成，就不会变化了；同时,生成的结果 是依次递加的，没有1就永远不会有2!
rownum 是在 查询集合产生的过程中产生的伪列，并且如果where条件中存在 rownum 条件的话，则:

1： 假如 判定条件是常量，则：
只能 rownum = 1, <= 大于1 的自然数， = 大于1 的数是没有结果的， 大于一个数也是没有结果的
即 当出现一个 rownum 不满足条件的时候则 查询结束 　　this is stop key!

2: 当判 定值不是常量的时候
若条件是 = var , 则只有当 var 为1 的时候才满足条件，这个时候不存在 stop key ,必须进行 full scan ,对每个满足其他where条件的数据进行判定
选出一行后才能去选rownum=2的行……

create table TEST_TREE
(
ID   NUMBER,
PID  NUMBER,
IND  NUMBER,
NAME VARCHAR2(32)
)

    ID是主键，PID是父节点ID，IND是排序字段，NAME是节点名称。初始化几条测试数据。

一、基本使用：

    在Oracle中，递归查询要用到start   with 。。。。connect   by   prior。。。

    具体格式是：

SELECT column
FROM table_name
START WITH column=value
CONNECT BY PRIOR 父主键=子外键

    对于本例来说，就是：

select   d.*   from  test_tree d
start   with   d.pid=0
connect   by   prior   d.id=d.pid 

   查询结果如下：

 我们从结果中可以看到，记录已经是按照树形结构进行排列了，但是现在有个新问题，如果我们有这样的需求，就是不但要求结果按照树形结构显示，还要根据ind字段在每一个分支内进行排序，这个问题怎么处理呢？我们可能很自然的想到如下语句：

select   d.*   from  test_tree d
start   with   d.pid=0
connect   by   prior   d.id=d.pid
order by d.ind

 结果如下：

这显然不是我们想要的结果，那下面的这个语句呢？

select   d.*   from  (select dd.* from test_tree dd order by dd.ind) d
start   with   d.pid=0
connect   by   prior   d.id=d.pid 

结果如下：

这个结果看似对了，但由于一级菜单3节点下有一个节点的ind=0，导致一级菜单2被拍到了3下面。如果想使用类似这样的语句做到各分支内排序，则需要找到一个能够准确描述菜单级别的字段，但是对于示例表来说，不存在这么一个字段。

那我们如何实现需求呢？其实Oracle9以后，提供了一种排序“order siblings by”就可以实现我们的需求，用法如下：

select   d.*   from  test_tree d
start   with   d.pid=0
connect   by   prior   d.id=d.pid
order   siblings   by   d.ind   asc

结果如下：

这样一来，查询结果就完全符合我们的要求了。

至于在Oracle8以前版本，或者其他数据库中如何实现类似的功能，希望大家来指教下，谢谢。

在java对oracle的操作中，日期字段是很头疼的事情，其实仔细研究一下也并不难掌握。

　　举个例子来说明：

　　表 book  中有name varchar2(20)//书籍名称,buydate Date //购买日期 两个字段。

　　已经创建了数据库连接Connection conn;

　　方法一、使用java.sql.Date实现比较简单的yyyy-mm-dd格式日期。

　　java.sql.Date不支持时间格式。切记不要使用new java.sql.Date(int year,int month,int date),因为还要处理时间差问题。

Java代码

1. PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");   
2.   
3. 　　java.sql.Date buydate=java.sql.Date.valueOf("2005-06-08");   
4. 　　pstmt.setString(1, "Java编程思想");   
5. 　　pstmt.setDate(2,buydate );   
6. 　　pstmt.execute();  

PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");
　　java.sql.Date buydate=java.sql.Date.valueOf("2005-06-08");
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setDate(2,buydate );
　　pstmt.execute();

　　方法二、使用java.sql.Timestamp,同上不使用new Timestamp(....)

Java代码

1. PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");   
2.   
3. 　　java.sql.Timestamp buydate=java.sql.Timestamp.valueOf("2004-06-08 05:33:99");   
4. 　　pstmt.setString(1, "Java编程思想");   
5. 　　pstmt.setTimestamp(2,buydate );   
6. 　　pstmt.execute();  

PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");
　　java.sql.Timestamp buydate=java.sql.Timestamp.valueOf("2004-06-08 05:33:99");
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setTimestamp(2,buydate );
　　pstmt.execute();

　　方法三、使用oracle 的to_date内置函数

Java代码

1. PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,to_date(?, 'yyyy-mm-dd hh24:mi:ss')");   
2.   
3. 　　String buydate="2004-06-08 05:33:99";   
4. 　　pstmt.setString(1, "Java编程思想");   
5. 　　pstmt.setString(2,buydate );   
6. 　　pstmt.execute();  

PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,to_date(?, 'yyyy-mm-dd hh24:mi:ss')");
　　String buydate="2004-06-08 05:33:99";
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setString(2,buydate );
　　pstmt.execute();

　　附:oracle日期格式参数 含义说明 
　　d: 一周中的星期几 
　　day: 天的名字，使用空格填充到9个字符 
　　dd: 月中的第几天 
　　ddd: 年中的第几天 
　　dy: 天的简写名 
　　iw: ISO标准的年中的第几周 
　　iyyy: ISO标准的四位年份 
　　yyyy: 四位年份 
　　yyy,yy,y: 年份的最后三位，两位，一位 
　　hh: 小时，按12小时计 
　　hh24: 小时，按24小时计 
　　mi: 分 
　　ss: 秒 
　　mm: 月 
　　mon: 月份的简写 
　　month: 月份的全名 
　　w: 该月的第几个星期 
　　ww: 年中的第几个星期

DECLARE @dtStartDate DATETIME,
    @dtEndDate DATETIME,
    @dtDate DATETIME,
    @i INTEGER

SET @dtEndDate = '5/5/1997'

SET @dtEndDate = DATEADD(DD, -1, CAST(CAST((MONTH(@dtEndDate) + 1) AS   
    VARCHAR(2)) + '/01/' + CAST(YEAR(@dtEndDate) AS VARCHAR(4)) + ' 23:59:59' AS DATETIME))
SET @dtStartDate = DATEADD(MM, -1 * 12, @dtEndDate)

-- Get all months into the first table
SET @i = 0
WHILE (@i < 12)
BEGIN
    SET @dtDate = DATEADD(mm, -1 * @i, @dtEndDate)
    INSERT INTO @tblMonths SELECT CAST(YEAR(@dtDate) AS VARCHAR(4)) + '-' +
                CASE
                WHEN MONTH(@dtDate) < 10
                    THEN '0' + CAST(MONTH(@dtDate) AS VARCHAR(2))
                ELSE CAST(MONTH(@dtDate) AS VARCHAR(2))
                END AS sMonth
    SET @i = @i + 1
END

-- Get all clients who had sales during that period into the "y" table
INSERT INTO @tblCustomers
    SELECT    DISTINCT
        c.CustomerID,
        c.CompanyName,
        c.ContactName
    FROM Customers c
        INNER JOIN Orders o ON c.CustomerID = o.CustomerID
    WHERE    o.OrderDate BETWEEN @dtStartDate AND @dtEndDate

INSERT INTO @tblFinal
SELECT    m.sMonth,
    c.CustomerID,
    c.CompanyName,
    c.ContactName,
    0
FROM @tblMonths m CROSS JOIN @tblCustomers c

UPDATE @tblFinal  SET
    mSales = mydata.mSales
FROM @tblFinal f INNER JOIN
    (
    SELECT    c.CustomerID,
        CAST(YEAR(o.OrderDate) AS VARCHAR(4)) + '-' +
        CASE WHEN MONTH(o.OrderDate) < 10
            THEN '0' + CAST(MONTH(o.OrderDate) AS VARCHAR(2))
            ELSE CAST(MONTH(o.OrderDate) AS VARCHAR(2))
        END AS sMonth,
        SUM(od.Quantity * od.UnitPrice) AS mSales
    FROM Customers c
        INNER JOIN Orders o ON c.CustomerID = o.CustomerID
        INNER JOIN [Order Details] od ON o.OrderID = od.OrderID
    WHERE    o.OrderDate BETWEEN @dtStartDate AND @dtEndDate
    GROUP BY
        c.CustomerID,
        CAST(YEAR(o.OrderDate) AS VARCHAR(4)) + '-' +
        CASE WHEN MONTH(o.OrderDate) < 10
            THEN '0' + CAST(MONTH(o.OrderDate) AS VARCHAR(2))
            ELSE CAST(MONTH(o.OrderDate) AS VARCHAR(2))
        END
    ) mydata on f.CustomerID = mydata.CustomerID AND f.sMonth =
       mydata.sMonth

SELECT    f.sMonth,
    f.CustomerID,
    f.CompanyName,
    f.ContactName,
    f.mSales
FROM @tblFinal f
ORDER BY
    f.CompanyName,
    f.sMonth


5, 拾遗补零 
这 里介绍其他一些可帮助提高 SQL 查询效率的常用技术。假设您将按区域对所有销售人员进行分组并将他们的销售额进行小计，但是您只想要那些数据库中标记为处于活动状态的销售人员。您可以按 区域对销售人员分组，并使用 HAVING 子句消除那些未处于活动状态的销售人员，也可以在 WHERE 子句中执行此操作。在 WHERE 子句中执行此操作会减少需要分组的行数，所以比在 HAVING 子句中执行此操作效率更高。HAVING 子句中基于行的条件的筛选会强制查询对那些在 WHERE 子句中会被去除的数据进行分组。

另 一个提高效率的技巧是使用 DISTINCT 关键字查找数据行的单独报表，来代替使用 GROUP BY 子句。在这种情况下，使用 DISTINCT 关键字的 SQL 效率更高。请在需要计算聚合函数（SUM、COUNT、MAX 等）的情况下再使用 GROUP BY。另外，如果您的查询总是自己返回一个唯一的行，则不要使用 DISTINCT 关键字。在这种情况下，DISTINCT 关键字只会增加系统开销。

1、 共享池又由两部分构成：共享SQL区和数据字典缓冲区。共享SQL区专门存放用户SQL命令，oracle使用最近最少使用等优先级算法来更新覆盖；数据字典缓冲区（library cache）存放数据库运行的动态信息。数据库运行一段时间后，DBA需要查看这些内存区域的命中率以从数据库角度对数据库性能调优。通过执行下述语句查看：
select (sum(pins - reloads)) / sum(pins) "Lib Cache"  from  v$librarycache;
--查看共享SQL区的重用率，最好在90％以上，否则需要增加共享池的大小。
select (sum(gets - getmisses - usage - fixED)) / sum(gets) "Row Cache"  from v$rowcache;
--查看数据字典缓冲区的命中率，最好在90％以上，否则需要增加共享池的大小。
2、  数据缓冲区：存放sql运行结果抓取到的data block；
 SELECT name, value   FROM v$sysstat   WHERE name IN ('db block gets', 'consistent gets','physical reads');
-- 查看数据库数据缓冲区的使用情况。查询出来的结果可以计算出来数据缓冲区的使用命中率＝1 - ( physical reads / (db block gets + consistent gets) )。命中率应该在90％以上，否则需要增加数据缓冲区的大小。
3、 日志缓冲区：存放数据库运行生成的日志。
select name,value from v$sysstat where name in ('redo entries','redo log space requests');
--查看日志缓冲区的使用情况。查询出的结果可以计算出日志缓冲区的申请失败率：申请失败率＝requests/entries，申请失败率应该接近于0，否则说明日志缓冲区开设太小，需要增加ORACLE数据库的日志缓冲区。
二．Sql语句的执行步骤：
　 了解sql的执行步骤有利于更好的优化它们，每条sql语句执行时都要经历以下几步：
1.  Create  cursor ；
2.  Parse, if it is not already in the shared pool.；
3.  Any query in the statement is processed.
4.  Bind Variables 
5.  Execute.
6.  If possible, the statement is parallelized.
7.  Rows to be returned are fetched.

其中，Parse—是最有优化潜力的阶段。
Cursor创建后，oracle将在share pool中寻找是否该sql语句已经存在，若已经存在且已经被parsed，则不需要再执行parse，直接到下一步。若未在share pool中找到，则parse步一般需要执行下面步骤：
1.  The statement is validated.
2.  The data is validated.
3.  Locks are allocated.
4.  Privileges are verified.
5.  The execution plan is determined.
6.  The statement is loaded into the shared SQL area.
--parse有这么多步骤，所以能利用sharepool中现成的parse结果很重要。

三. 如何提高share pool中Sql共享率？
要实现sql共享，跳过parse步骤，有如下基本要求条件：
1. sql文本完全相同：
--uppercase  and  lowercase
--white space (spaces, tabs, carriage returns)
--comments
2.参考对象相同:
  --Referenced schema’s objects must be the same objects
3. 绑定变量相同
--Bind variables must match the same name and data type.（所以对于格式相同、具体条件不同的sql，建议经常使用变量来代替常量，以尽量使用重复sql代码，避开parse阶段，提高执行速度）
--tip：
--尽量使用存储过程；尽量使用变量代替常量，可以提高share pool共享率，跳过parse阶段，提高效率。
四．什么是好的sql语句？
总结出以下特征：
• 尽量使用 PL/SQL提高性能： PL/SQL可以将sql语句块一次送给数据库服务器处理，不用PL/SQL只能一句一句送。
•  尽量使用stored procedure：降低oracle通过网络传输的数据量，并能提高共享sql区域的重用率。
• 尽量使用packages： Packages在第一次调用时能将整个包 load进内存，对提高性能有帮助。
•  尽量使用cached sequences 来生成primary key ：提高主键生成速度和使用性能。
•  很好地利用空间：如用VARCHAR2 数据类型代替 CHAR等
•  只在非常必要时才使用hint：仅在对sql的执行计划非常肯定地要使用hint时才使用。

五．Sql优化工具的介绍：
sqlexpert；toad；explain-table；PL/SQL；OEM等
掌握一种，熟练使用即可。
我的习惯：看执行计划用sqlplus 的autotrace，优化用sql expert。

--Autotrace使用方法：
1. DBA在db中创建plustrace 角色：运行@?/sqlplus/admin/plustrce.sql
2. DBA给用户赋予角色：grant plustrace to username;
3.  用户创建自己的plan_table：运行@?/rdbms/admin/utlxplan.sql。--以上是第一次使用时需要进行的必要操作。
4.  用户sqlplus连接数据库，对会话进行如下设置：
Set  autotrace  -----off/on/trace[only]------explain/statistics，
然后录入sql语句回车即可查看执行计划—推荐；
或者用如下命令行：
Explain plan set statement_id=’myplan1’   for   Your sql-statement;
然后查看用户自己的plan_table

--演示Sql-expert的使用，连接到指定数据库，输入sql，显示执行计划或者sql优化结果，图形界面如下：
 

--ps：但我在使用中发现sql-expert的执行计划有时候显示得并不准确，所以建议以sqlplus中的为准。其sql优化倒很值得参考，有多种结果，用户可以自己测试和选择。

六．SQL优化技巧
在这方面，长期搞数据库应用开发的人应该更有经验，我这里大概总结一下自己遇到过的和搜集到的一些sql优化经验，跟大家共同学习。
SQL语言是一种灵活的语言，相同的功能可以使用不同的语句来实现，但是语句的执行效率可能会很不相同的，生产系统里经常跑的sql语句更要注意执行效率，否则会占用大量系统资源，带慢整个系统。SQL优化的实质就是在结果正确的前提下，用优化器可以识别的语句，充份利用索引，执行过程中访问尽量少的数据块，减少表扫描的I/O次数，尽量避免全表扫描和其他额外开销。
Sql优化：
1、 先介绍一下oracle数据库常用的两种优化器：RBO（rule-based-optimizer）和CBO(cost-based-optimizer)。目前更多地采用CBO(cost-based-optimizer)基于开销的优化器。在CBO方式下，Oracle会根据表及索引的状态信息来选择计划；在RBO方式下，Oracle会根据自己内部设置的一些规则来决定选择计划，例如oracle会根据以下优先级来选择执行计划（越靠前，rank越低，越快）：

 RANK Access path
1 ROWID等于常量
2 唯一键值或主键的聚簇连接*
3 唯一键值或主键的哈希聚簇连接* 
4 整个复合索引等于常量
5 唯一索引列等于常量
6 完全聚簇键等于同一个聚簇上的另一个表对应的聚簇键*
7 哈希聚簇键等于常数*
8 完全聚簇键等于常数*
9 整个非唯一组合索引等于常量
10 非唯一索引连结
11 整个组合索引等于小范围的值
12 组合索引的大部分前面的列等于常量
13 索引列取值存在上限和下限或者索引列LIKE "ABC%"（范围限制）
14 非唯一索引列取值存在上限和下限或者索引列LIKE "ABC%"（范围限制）
15 唯一索引列或是常量（范围无限制）
16 非唯一索引列或是常（范围无限制）
17 非索引列的等值连接(sort/merge join)
18 单一索引列的最大或最小值
19 ORDER BY整个索引
20 全表扫描

2、 创建索引：创建索引一般有以下两个目的：维护被索引列的唯一性和提供快速访问表中数据的策略。
索引创建原则：
--在select操作占大部分的表上创建索引；
--在where子句中出现最频繁的列上创建索引；
--在选择性高的列上创建索引（补充索引选择性，最高是1，eg：primary key）
--复合索引的主列应该是最有选择性的和where限定条件最常用的列，并以此类推第二列……。
--小于5M的表，最好不要使用索引来查询，表越小，越适合用全表扫描。

索引使用原则：
--查询结果是所有数据行的5%以下时，使用index查询效果最好；
--where条件中经常用到表的多列时，使用复合索引效果会好于几个单列索引。因为当sql 语句所查询的列，全部都出现在复合索引中时，此时由于 Oracle 只需要查询索引块即可获得所有数据，当然比使用多个单列索引要快得多；
--索引利于select，但对经常insert，delte尤其update的表，会降低效率。

eg：试比较下面两条SQL语句(emp 表的deptno列上建有ununique index)：
语句A：SELECT dname, deptno FROM dept WHERE deptno NOT IN 
(SELECT deptno FROM emp);
语句B：SELECT dname, deptno FROM dept WHERE NOT EXISTS
(SELECT deptno  FROM emp WHERE dept.deptno = emp.deptno);
这两条查询语句实现的结果是相同的，但是执行语句A的时候，ORACLE会对整个emp表进行扫描，没有使用建立在emp表上的deptno索引，执行语句B的时候，由于在子查询中使用了联合查询，ORACLE只是对emp表进行的部分数据扫描，并利用了deptno列的索引，所以语句B的效率要比语句A的效率高。我的测试结果：(当emp表有37M时的测试)：
SQL> SELECT dname, deptno FROM dept WHERE deptno NOT IN
(SELECT deptno FROM emp);
DNAME              DEPTNO
-------------- ----------
OPERATIONS             40

Elapsed: 00:00:01.08
Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE
   1    0   FILTER
   2    1     TABLE ACCESS (FULL) OF 'DEPT'
   3    1     TABLE ACCESS (FULL) OF 'EMP'
Statistics
----------------------------------------------------------
          0  recursive calls
         31  db block gets
       4635  consistent gets
          1  physical reads
          0  redo size
        541  bytes sent via SQL*Net to client
        550  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
1 rows processed
SQL> SELECT dname, deptno FROM dept WHERE NOT EXISTS
(SELECT deptno  FROM emp WHERE dept.deptno = emp.deptno);
DNAME              DEPTNO
-------------- ----------
OPERATIONS             40

Elapsed: 00:00:00.30

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE
   1    0   FILTER
   2    1     TABLE ACCESS (FULL) OF 'DEPT'
   3    1     INDEX (RANGE SCAN) OF 'IND_EMP_DEPTNO' (NON-UNIQUE)

Statistics
----------------------------------------------------------
          0  recursive calls
         12  db block gets
         19  consistent gets
          0  physical reads
        144  redo size
        541  bytes sent via SQL*Net to client
        550  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed

3． 索引常用类型，按存储方式分为：B-tree ，bitmap，reverse key index
 B-ree：最常用的一种，又可以分为primary, unique,nonunique，composite,cluster等
 bitmap适用情况：
--该列重复值很高（eg：性别列、分数列ABC级等），最好该列有not null的限制；
--bitmap对大表效果好，且很节省索引空间；
--适合并发度低的表，因为其数据更新时会锁住整个bitmap block；
--使用bitmap索引时，需要加hint强制使用（应该是oracle一个bug）
 Reverse索引：适用于序列生成的数字列，会将index key列值倒序存放，尤其表的更改并发度又比较高时，更适合用reverse索引，这样可以将相似值的行分散到索引的多个叶子节点，降低冲突，提高性能。
根据应用需求在适当列建合适的索引。

4、　Oracle 要使用一个索引，有一些基本要求条件：
----where 子句中的这个字段，必须是复合索引的第一个字段；
eg：一个索引是按 f1, f2, f3的次序建立的，若where 子句是 f2 = : var2, 则因为 f2 不是索引的第1个字段，无法使用该索引。
---- where 子句中的这个字段，不应该参与任何形式的计算：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。
----应尽量熟悉各种操作符对 Oracle 是否使用索引的影响：以下这些操作会显式（explicitly）地阻止 Oracle 使用索引： is null ;  is not null ;  not in;  !=;  like ; numeric_col+0;date_col+0; char_col||’ ’;  to_char;  to_number，to_date 等。
Eg：
Select jobid from mytabs where isReq='0' and to_date (updatedate) >= to_Date ( '2001-7-18', 'YYYY-MM-DD')；--updatedate列的索引也不会生效。

5、索引不是越多越好。特别是大量从来或者几乎不用的索引，对系统只有损害。OLTP系统每表超过5个索引即会降低性能，  而且在一个sql 中， Oracle 从不能使用超过 5个索引。
索引对select有正面效果，但对insert，delete尤其是update有负面效果，会影响速度，索引越多，影响越大。所以oracle工具sqlldr倒入数据时，好的做法是先建好表结构，再倒入数据，最后才建索引，以提高数据倒入的速度，oracle工具import默认就是先倒入数据，然后才建索引。所以建索引时要充分考虑该表的主要应用。
Tips： 经常做insert，delete尤其是update的表最好定期exp/imp表数据，整理数据，降低碎片（缺点：要停应用，以保持数据一致性，不实 用）；有索引的最好定期rebuild索引（rebuild期间只允许表的select操作，可在数据库较空闲时间提交），以降低索引碎片，提高效率；

6、何时适合使用全表扫描？
  --小表，仅有几个data block的表（5M以下）；
--对数据行的选择率高于20%时可考虑用全表扫描（如有1000行记录，一次选出200行以上）
 
7．选择联合查询的联合次序。联合查询分为3种：merge join,nested loop,hash join，这里讲的是nested  loop的联合情况（后面实际案例1的优化就属于此类）；
考虑下面的例子：
SELECT stuff  FROM taba a, tabb b, tabc c
WHERE a.acol between :alow and :ahigh
AND b.bcol between :blow and :bhigh
AND c.ccol between :clow and :chigh
AND a.key1 = b.key1
AMD a.key2 = c.key2;
这 个SQL例子中，程序员首先需要选择要查询的主表，因为主表要进行整个表数据的扫描，所以主表应该数据量最小，所以例子中表A的acol列的范围应该比表 B和表C相应列的范围小。内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，乘积最小为最佳方案。

8、用UNION ALL代替UNION：
UNION是最常用的集操作，使多个记录集联结成为单个集，对返回的数据行有唯一性要求，所以oracle就需要进行SORT UNIQUE操作（与使用distinct时操作类似），如果结果集又比较大，则操作会比较慢；
UNION ALL操作不排除重复记录行，所以会快很多，如果数据本身重复行存在可能性较小时，用union all会比用union效率高很多！

9． 避免在SQL里使用PL/SQL功能调用：
PL/SQL块有利于提高重复使用代码，但是如果混合在SQL语句中，反而会降低效率。Eg：
US$()为一货币转换的PL/SQL
Sql:  select name,US$(amount,currency) from salary where US$(amount,currency)>1000;
该sql效率低下，因为混合PL/SQL和sql时，oracle使用的机制不同，执行时，oracle将调用分成两个组件：用带有赋值变量的SQL语句代替功能调用，和对功能调用的PL/SQL块：
即：
select name,:a1 from salary where :a2>1000;
和
begin
:a1:=US$(:amount,:currency);
end;
对salary表里的每一行执行PL/SQL两次，效率大大降低。

10 子查询中慎重使用IN或者NOT IN语句，使用where (NOT) exists的效果要好的多。IN、OR子句常会使索引失效，可以考虑把子句拆开，拆开的子句中尽量包含索引。
 
11慎重使用视图的联合查询，尤其是比较复杂的视图之间的联合查询。一般对视图的查询最好都分解为对数据表的直接查询效果要好一些。

12  ORACLE提 供的DBMS_SHARED_POOL程序可以帮助程序员将某些经常使用的存储过程“钉”在SQL区中而不被换出内存，程序员对于经常使用并且占用内存较 多的存储过程“钉”到内存中有利于提高最终用户的响应时间。一定要确认非常有必要时才采用这个方法，否则对系统只有坏的影响，会降低内存利用率。
(execute DBMS_SHARED_POOL.KEEP('APPOWNER.ADD_CLIENT','P');
（P代表PROCEDURES，C代表CURSORS）)

13. 从物理存储方面降低竞争，提高索引效率：将索引和数据分开不同的表空间存放，以减少I/O竞争（尽量将索引、数据表空间从物理底蹭分开是数据库建设前期物 理设计工作的重要部分）。举例：九七数据库里的TB表（长驻cache；仅几十行数据，并发度高，更新频繁，分多个block存放，降低block I/O竞争）

14．加hint强制使用索引
有时候oracle自动判断的CBO信息不能令人满意时，就需要我们手工加hint来强制sql语句得到我们想要的执行计划。
Hint的基本使用方法：
----紧跟DML（select，insert，delete，update）之后：/*+hint_content*/，/*和+之间不能有空格；或者用--+，此行后面均为hint内容；
----一句sql只能有一个hint，但里面可以有多层，eg：/*+hint1,hint2…*/；
----sql语句中若使用了别名(aliase)，则hint里面也必须使用别名。
--不要对view查询加hint，无效。
Tip：尽量少用hint，因为随着数据变化，可能加hint的执行计划逐渐变的不再是最优；加hint的维护成本较高；

15．使用session/transaction级别的临时表会大大提高中间处理的速度：
---临时表只对本session或者transaction可见，关闭session或者退出transaction时，临时表自动被清理drop；
---其他session/transaction可以建同名的temporary table，用户只对自己的temp table操作；
---临时表使用temp表空间，此类表的DML操作不产生redo log，只产生undo log
---可以在其上建index，index也一样是temporary的，生命阶段同temp table。
create global temporary table tab_name(….)；

结语：
Oracle 是否真正使用索引，使用索引是否真正有效，还是必须进行实地的测验。合理的做法是，对所写的复杂的 sql, 在将它写入应用程序之前，先在产品数据库上做一次explain，获得对该 sql 的解析，明确看到 Oracle 是如何执行该sql 的，并进行适当优化调整；
另外，即使是相同的sql语句，也会因为表的大小等原因造成执行计划的不同，所以一定要具体情况具体分析！ 如果经常做 explain, 就会发现，喜爱写复杂的 sql 并不是个好习惯，因为过分复杂的sql 其解析计划往往不尽如人意。事实上，将复杂的 sql 拆开，有时候会极大地提高效率，因为能获得很好的优化。

                                         赵春英             
 2004.5.26 定稿
实际案例:
1、 select 'x' from dh where dhso in (select ogso from og where ogid = 21097023 and ogzt='VALID') and dhcz = 18 and dhzt<>'OVER'；
执行情况：no rows selected   Elapsed: 00:07:05.98
Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE
   1    0   VIEW
   2    1     SORT (UNIQUE)
   3    2       NESTED LOOPS
   4    3         TABLE ACCESS (BY INDEX ROWID) OF 'DH'
   5    4           INDEX (RANGE SCAN) OF 'IND_DHCZ_DHZT' (NON-UNIQUE)
   6    3         TABLE ACCESS (BY INDEX ROWID) OF 'OG'
   7    6           INDEX (UNIQUE SCAN) OF 'PK_OGID_OGSO' (UNIQUE)
Statistics
----------------------------------------------------------
          0  recursive calls
          0  db block gets
     421027  consistent gets
      15181  physical reads
       1000  redo size
        181  bytes sent via SQL*Net to client
        278  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
0 rows processed
原语句用7分6秒完成，使用sqlexpert优化后选取的一个新语句如下，出结果仅用8秒！
select /*+ ALL_ROWS */ 'x' from dh
 where EXISTS (SELECT 'X' from og WHERE ogid = 21097023 and ogzt = 'VALID' AND ogso = dhso)    and dhcz = 18 and dhzt <> 'OVER'；
执行情况：  no rows selected   Elapsed: 00:00:08.23
Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=HINT: ALL_ROWS (Cost=119 Card=55
          Bytes=3410)
   1    0   TABLE ACCESS (BY INDEX ROWID) OF 'DH' (Cost=2 Card=1 Bytes
          =31)
   2    1     NESTED LOOPS (Cost=119 Card=55 Bytes=3410)
   3    2       SORT (UNIQUE)
   4    3         TABLE ACCESS (BY INDEX ROWID) OF 'OG' (Cost=6 Card=5
          5 Bytes=1705)
   5    4           INDEX (RANGE SCAN) OF 'PK_OGID_OGSO' (UNIQUE) (Cos
          t=2 Card=2191)

   6    2       INDEX (RANGE SCAN) OF 'IND_DHSO' (NON-UNIQUE) (Cost=1
          Card=2018)
Statistics
----------------------------------------------------------
         16  recursive calls
          0  db block gets
         10  consistent gets
          1  physical reads
          0  redo size
        181  bytes sent via SQL*Net to client
        278  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          0  rows processed

2、select  GGZT,GGXX,GGSJ,GGRQ,GGLR,GGGH,GGDH,GGBZ,GGID 
from GG  where GGRQ>='20040325'
and GGRQ<='20040325' and GGID>8673 and GGZT='VALID' and GGID in 
(select  GFGG from GF,GB where GFGG=GBGG
and ((GFGW=1 and GFQX>='003' and GBLX='001' and GBDW=104) 
or (GFGW=118 and GFQX>='000' and GBLX='002' and GBDW=102)))
order by GGID DESC;
--联合查询三个小表（GG 1M，  GB 2M，  GF 2M）, 用了索引反而慢，又费cpu，优化后改成全表扫描:

执行情况：
no rows selected
Elapsed: 00:00:18.57
Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE
   1    0   SORT (ORDER BY)
   2    1     VIEW
   3    2       SORT (UNIQUE)
   4    3         CONCATENATION
   5    4           NESTED LOOPS
   6    5             NESTED LOOPS
   7    6               TABLE ACCESS (BY INDEX ROWID) OF 'GB'
   8    7                 INDEX (RANGE SCAN) OF 'IND_GBLX_GBDW' (NON-U
          NIQUE)
   9    6               TABLE ACCESS (BY INDEX ROWID) OF 'GF'
  10    9                 INDEX (RANGE SCAN) OF 'IND_GFGW' (NON-UNIQUE
          )
11    5             TABLE ACCESS (BY INDEX ROWID) OF 'GG'
  12   11               INDEX (UNIQUE SCAN) OF 'PK_GGID' (UNIQUE)
  13    4           NESTED LOOPS
  14   13             NESTED LOOPS
  15   14               TABLE ACCESS (BY INDEX ROWID) OF 'GB'
  16   15                 INDEX (RANGE SCAN) OF 'IND_GBLX_GBDW' (NON-U
          NIQUE)
  17   14               TABLE ACCESS (BY INDEX ROWID) OF 'GF'
  18   17                 INDEX (RANGE SCAN) OF 'IND_GFGW' (NON-UNIQUE
          )
  19   13             TABLE ACCESS (BY INDEX ROWID) OF 'GG'
  20   19               INDEX (UNIQUE SCAN) OF 'PK_GGID' (UNIQUE)
Statistics
----------------------------------------------------------
        243  recursive calls
          0  db block gets
     346554  consistent gets
         20  physical reads
          0  redo size
        534  bytes sent via SQL*Net to client
        278  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          8  sorts (memory)
          0  sorts (disk)
          0  rows processed

select /*+ full(gg) */ GGZT,GGXX,GGSJ,GGRQ,GGLR,GGGH,GGDH,GGBZ,GGID 
from GG  where GGRQ>='20040325'
and GGRQ<='20040325' and GGID>8673 and GGZT='VALID' and GGID in 
(select /*+ full(gf) */ GFGG from GF,GB where GFGG=GBGG
and ((GFGW=1 and GFQX>='003' and GBLX='001' and GBDW=104) 
or (GFGW=118 and GFQX>='000' and GBLX='002' and GBDW=102)))
order by GGID DESC;
执行情况：
no rows selected

Elapsed: 00:00:07.96

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE (Cost=25 Card=1 Bytes=715)
   1    0   SORT (ORDER BY) (Cost=25 Card=1 Bytes=715)
   2    1     HASH JOIN (SEMI) (Cost=22 Card=1 Bytes=715)
   3    2       TABLE ACCESS (FULL) OF 'GG' (Cost=3 Card=1 Bytes=702)
   4    2       VIEW OF 'VW_NSO_1' (Cost=18 Card=1 Bytes=13)
   5    4         HASH JOIN (Cost=18 Card=1 Bytes=62)
   6    5           TABLE ACCESS (BY INDEX ROWID) OF 'GB' (Cost=4 Card
          =1041 Bytes=32271)
   7    6             BITMAP CONVERSION (TO ROWIDS)
   8    7               BITMAP OR
   9    8                 BITMAP CONVERSION (FROM ROWIDS)
  10    9                   INDEX (RANGE SCAN) OF 'IND_GBLX_GBDW' (NON
          -UNIQUE) (Cost=1)
  11    8                 BITMAP CONVERSION (FROM ROWIDS)
  12   11                   INDEX (RANGE SCAN) OF 'IND_GBLX_GBDW' (NON
          -UNIQUE) (Cost=1)
  13    5           TABLE ACCESS (FULL) OF 'GF' (Cost=13 Card=1213 Byt
          es=37603)
Statistics
----------------------------------------------------------
        390  recursive calls
          0  db block gets
         82  consistent gets
          4  physical reads
          0  redo size
        534  bytes sent via SQL*Net to client
        278  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          0  rows processed