博客园_Ruthless-JAVA

ibatis注意要点

2012-06-01T01:29:00Z

一、ibatis的关键字like查询

select * from t_student where s_name '%张%';

这种like语句在ibatis中怎么写，他们现在的项目是用ibatis作为持久层的框架。

我的第一反应是这样写：
<select id="showOneStudentByName" parameterClass="String" resultMap="studentORM">
select * from t_student where s_name like #name#
</select>

但是在调用中需要在参数的前后加上%，比如这样：
return sqlMapper.queryForList("showOneStudentByName", "%"+name+"%");

虽然这样可行，但总显得有些不协调。仔细看了ibaitis的文档后发现最好的写法是这样
<select id="showOneStudentByName" parameterClass="String" resultMap="studentORM">
select * from t_student where s_name like '%'||#name#||'%'
</select>

在调用的时候就不用去前后加%了。

注意：sql语句不要写成select * from t_student where s_name like '%$name$%',这样极易受到注入攻击。
网上搜了一下ibatis的关于like的使用,撇开 '%$xxx$%' 不讲。网上的解决方法如下：

select *
from user
where username like '%'||#username#||'%'

其实上面的语句是针对Oracle 的，对于不同数据库字符串连接符不一样。现列举mysql

select *
from user
where username like concat('%', #username#, '%')

二、ibatis操作陷阱
在使用iBatis操作数据的时候，容易跌入陷阱。
1、保存insert方法
在保存数据方面，iBatis的insert方法返回的是新增记录的主键，类型为Object，但实为整型，有时候会让人误解为实体类型，也并非任何表的insert操作都会返回主键----这是一个陷阱。
要返回这个新增记录的主键，前提是表的主键是自增型的，或者是Sequence的。否则获取新增记录主键的值为0或者null。
对于oracle这样来写：
<selectKey resultClass="int" keyProperty="id">
<![CDATA[
select hibernate_seq.nextval as id from dual
]]>
</selectKey>
对比Hibernate返回的Serializable类型，实际上也是主键。
2、更新删除update/delete方法
返回影响的记录行数。
3、对DAO/Service设计时候的影响
1)、对于自增主键类型表，DAO的save方法可以返回主键、或者实体对象（该对象的标识符域会填充上主键值）。
2)、对于非自增主键类型表，DAO的save方法，在保存之前就指导整个实体对象的所有值（包括主键），因此返回什么都可以，也可以不返回值。
3)、对于Service的，不管表如何，一般都返回保存的实体对象。

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

ibatis 简介

2012-05-28T08:00:00Z

      相对Hibernate和Apache OJB等“一站式”ORM解决方案而言，ibatis是一种“半自动化”的ORM实现。
      所谓“半自动”，可能理解上有点生涩。纵观目前主流的ORM，无论Hibernate还是Apache OJB，都对数据库结构提供了较为完整的封装，提供了从POJO到数据库表的全套映射机制。程序员往往只需定义好了POJO到数据库表的映射关系，即可通过Hibernate或者OJB提供的方法完成持久层操作。程序员甚至不需要对SQL的熟练掌握，Hibernate/OJB会根据制定的存储逻辑，自动生成对应的SQL并调用JDBC接口加以执行。
      大多数情况下（特别是对新项目，新系统的开发而言），这样的机制无往不利，大有一统天下的势头。但是，在一些特定的环境下，这种一站式的解决方案却未必灵光。
      在笔者的系统咨询工作过程中，常常遇到以下情况：
1．系统的部分或全部数据来自现有数据库，处于安全考虑，只对开发团队提供几条Select SQL（或存储过程）以获取所需数据，具体的表结构不予公开。
2．开发规范中要求，所有牵涉到业务逻辑部分的数据库操作，必须在数据库层由存储过程实现（就笔者工作所面向的金融行业而言，工商银行、中国银行、交通银行，都在开发规范中严格指定）
3．系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。
      面对这样的需求，再次举起Hibernate大刀，却发现刀锋不再锐利，甚至无法使用，奈何？恍惚之际，只好再摸出JDBC准备拼死一搏……，说得未免有些凄凉，直接使用JDBC进行数据库操作实际上也是不错的选择，只是拖沓的数据库访问代码，乏味的字段读取操作令人厌烦。
      “半自动化”的ibatis，却刚好解决了这个问题。
      这里的“半自动化”，是相对Hibernate等提供了全面的数据库封装机制的“全自动化”ORM实现而言，“全自动”ORM实现了POJO和数据库表之间的映射，以及SQL的自动生成和执行。而ibatis的着力点，则在于POJO与SQL之间的映射关系。也就是说，ibatis并不会为程序员在运行期自动生成SQL执行。具体的SQL需要程序员编写，然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。
      使用ibatis提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象，这一层与通过Hibernate实现ORM而言基本一致，而对于具体的数据操作，Hibernate会自动生成SQL语句，而ibatis则要求开发者编写具体的SQL语句。相对Hibernate等“全自动”ORM机制而言，ibatis以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。作为“全自动”ORM 实现的一种有益补充，ibatis 的出现显得别具意义。

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

oracle物化视图日志结构

2012-05-23T06:53:00Z

物化视图的快速刷新要求基本必须建立物化视图日志，这篇文章简单描述一下物化视图日志中各个字段的含义和用途。

物化视图日志的名称为MLOG$_后面跟基表的名称，如果表名的长度超过20位，则只取前20位，当截短后出现名称重复时，Oracle会自动在物化视图日志名称后面加上数字作为序号。

物化视图日志在建立时有多种选项：可以指定为ROWID、PRIMARY KEY和OBJECT ID几种类型，同时还可以指定SEQUENCE或明确指定列名。上面这些情况产生的物化视图日志的结构都不相同。

任何物化视图都会包括的4列：
SNAPTIME$$：用于表示刷新时间。
DMLTYPE$$：用于表示DML操作类型，I表示INSERT，D表示DELETE，U表示UPDATE。
OLD_NEW$$：用于表示这个值是新值还是旧值。N（EW）表示新值，O（LD）表示旧值，U表示UPDATE操作。
CHANGE_VECTOR$$：表示修改矢量，用来表示被修改的是哪个或哪几个字段。
如果WITH后面跟了ROWID，则物化视图日志中会包含：M_ROW$$：用来存储发生变化的记录的ROWID。
如果WITH后面跟了PRIMARY KEY，则物化视图日志中会包含主键列。
如果WITH后面跟了OBJECT ID，则物化视图日志中会包含：SYS_NC_OID$：用来记录每个变化对象的对象ID。
如果WITH后面跟了SEQUENCE，则物化视图日子中会包含：SEQUENCE$$：给每个操作一个SEQUENCE号，从而保证刷新时按照顺序进行刷新。
如果WITH后面跟了一个或多个COLUMN名称，则物化视图日志中会包含这些列。

下面通过例子进行详细说明：

SQL> create table t_rowid (id number, name varchar2(30), num number);
表已创建。

SQL> create materialized view log on t_rowid with rowid, sequence (name, num) including new values;
实体化视图日志已创建。

SQL> create table t_pk (id number primary key, name varchar2(30), num number);
表已创建。

SQL> create materialized view log on t_pk with primary key;
实体化视图日志已创建。

SQL> create type t_object as object (id number, name varchar2(30), num number);
     /
类型已创建

SQL> create table t_oid of t_object;
表已创建。

SQL> desc t_oid;
名称                                      是否为空? 类型
----------------------------------------- -------- ---------------
ID                                                 NUMBER
NAME                                               VARCHAR2(30)
NUM                                                NUMBER

SQL> create materialized view log on t_oid with object id;
实体化视图日志已创建。

建立环境后来看看物化视图日志中包含的字段：
SQL> desc mlog$_t_rowid;
名称                                      是否为空? 类型
----------------------------------------- -------- -------------
NAME                                               VARCHAR2(30)
NUM                                                NUMBER
M_ROW$$                                            VARCHAR2(255)
SEQUENCE$$                                         NUMBER
SNAPTIME$$                                         DATE
DMLTYPE$$                                          VARCHAR2(1)
OLD_NEW$$                                          VARCHAR2(1)
CHANGE_VECTOR$$                                    RAW(255)
除了最基本的4列之外，由于指定了ROWID、SEQUENCE和NAME、NUM列，因此物化视图日志中包含了相对应的列。

SQL> desc mlog$_t_pk;
名称                                      是否为空? 类型
----------------------------------------- -------- ------------
ID                                                 NUMBER
SNAPTIME$$                                         DATE
DMLTYPE$$                                          VARCHAR2(1)
OLD_NEW$$                                          VARCHAR2(1)
CHANGE_VECTOR$$                                    RAW(255)

对象表的物化视图日志建立后包含系统对象标识列。
一、主键列、ROWID列、OBJECT ID列、SEQUENCE列和建立物化视图时指明的列。
主键、ROWID或OBJECT ID用来唯一表示物化视图日志中的记录。
SEQUENCE会根据操作发生的顺序对物化视图日志中的记录编号。

建立物化视图时指明的列会在物化视图日志中进行记录。

SQL> insert into t_pk values (1, 'a', 5);
已创建 1 行。

SQL> update t_pk set name = 'c' where id = 1;
已更新 1 行。

SQL> delete t_pk;
已删除 1 行。

SQL> select id, dmltype$$ from mlog$_t_pk;
        ID D
---------- -
         1 I
         1 U
         1 D

SQL> insert into t_oid values (1, 'a', 5);
已创建 1 行。

SQL> update t_oid set name = 'c' where id = 1;
已更新 1 行。

SQL> delete t_oid;
已删除 1 行。

SQL> select sys_nc_oid$, dmltype$$ from mlog$_t_oid;
SYS_NC_OID$ D
-------------------------------- -
18DCFDE5D65B4D5A88602D6C09E5CE20 I
18DCFDE5D65B4D5A88602D6C09E5CE20 U
18DCFDE5D65B4D5A88602D6C09E5CE20 D

SQL> rollback;

回退已完成。

二、时间列
当基本发生DML操作时，会记录到物化视图日志中，这时指定的时间4000年1月1日0时0分0秒。如果物化视图日志供多个物化视图使用，则一个物化视图刷新后会将它刷新的记录的时间更新为它刷新的时间。
下面建立快速刷新的两个物化视图来演示时间列的变化。（只有建立快速刷新的物化视图才能使用物化视图日志，如果只建立一个物化视图，则物化视图刷新完会将物化视图日志清除掉。

SQL> create materialized view mv_t_rowid refresh fast on commit as select name, count(*) from t_rowid group by name;
实体化视图已创建。

SQL> create materialized view mv_t_rowid1 refresh fast as select name, count(*) from t_rowid group by name;
实体化视图已创建。

SQL> insert into t_rowid values (1, 'a', 5);
已创建 1 行。

SQL> update t_rowid set name = 'c' where id = 1;
已更新 1 行。

SQL> delete t_rowid;
已删除 1 行。

SQL> select snaptime$$ from mlog$_t_rowid;
SNAPTIME$$
-------------------
4000-01-01 00:00:00
4000-01-01 00:00:00
4000-01-01 00:00:00
4000-01-01 00:00:00

SQL> commit;
提交完成。

SQL> select snaptime$$ from mlog$_t_rowid;
SNAPTIME$$
-------------------
2012/5/23 15:41:41
2012/5/23 15:41:41
2012/5/23 15:41:41
2012/5/23 15:41:41
COMMIT后，物化视图mv_t_rowid刷新，将SNAPTIME$$列更新成自己的刷新时间。

三、操作类型和新旧值
操作类型比较简单：只包括I(INSERT)、D(DELETE)和U(UPDATE)三种。
新旧值也包括三种：O表示旧值（一般对应的操作时DELETE）、N表示新值（一般对应的操作是INSERT），还有一种U（对应UPDATE操作）。

SQL> insert into t_pk values (1, 'a', 5);
已创建 1 行。

SQL> insert into t_pk values (2, 'b', 7);
已创建 1 行。

SQL> insert into t_pk values (3, 'c', 9);
已创建 1 行。

SQL> update t_pk set name = 'c' where id = 1;
已更新 1 行。

SQL> update t_pk set id = 4 where id = 2;
已更新 1 行。

SQL> delete t_pk where id = 3;
已删除 1 行。

SQL> select id, dmltype$$, old_new$$ from mlog$_t_pk;
        ID D O
---------- - -
         1 I N
         2 I N
         3 I N
         1 U U
         2 D O
         4 I N
         3 D O
已选择7行。

开始是插入三条记录，接着是UPDATE操作。需要注意，对于基于主键的物化视图日志，如果更新了主键，则UPDATE操作转化为一条DELETE操作，一条INSERT操作。最后是DELETE操作。

SQL> drop materialized view log on t_rowid;
实体化视图日志已删除。

SQL> create materialized view log on t_rowid with rowid, sequence (name, num) including new values;
实体化视图日志已创建。

SQL> insert into t_rowid values (1, 'a', 5);
已创建 1 行。

SQL> insert into t_rowid values (2, 'b', 7);
已创建 1 行。

SQL> insert into t_rowid values (3, 'c', 9);
已创建 1 行。

SQL> update t_rowid set name = 'c' where id = 1;
已更新 1 行。

SQL> update t_rowid set id = 4 where id = 2;
已更新 1 行。

SQL> delete t_rowid where id = 3;
已删除 1 行。

SQL> select name, num, m_row$$, dmltype$$, old_new$$ from mlog$_t_rowid;
NAME              NUM M_ROW$$            D   O
---------- ---------- ------------------ - -
a                   5 AAACIDAAFAAAAD4AAC I N
b                   7 AAACIDAAFAAAAD4AAA I N
c                   9 AAACIDAAFAAAAD4AAB I N
a                   5 AAACIDAAFAAAAD4AAC U U
c                   5 AAACIDAAFAAAAD4AAC U N
b                   7 AAACIDAAFAAAAD4AAA U U
b                   7 AAACIDAAFAAAAD4AAA U N
c                   9 AAACIDAAFAAAAD4AAB D O

已选择8行。

查询结果和上面类似，唯一的区别是每条UPDATE操作都对应物化视图日志中的两条记录。一条对应UPDATE操作的原记录DMLTYPE$$和OLD_NEW$$都为U，一条对应UPDATE操作后的新记录，DMLTYPE$$为U，OLD_NEW$$为N。当建立物化视图日志时指出了INCLUDING NEW VALUES语句时，就会出现这种情况。

四、修改矢量
      最后简单讨论一下CHANGE_VECTOR$$列。
      INSERT和DELETE操作都是记录集的，即INSERT和DELETE会影响整条记录。而UPDATE操作是字段集的，UPDATE操作可能会更新整条记录的所有字段，也可能只更新个别字段。
      无论从性能上考虑还是从数据的一致性上考虑，物化视图刷新时都应该是基于字段集。Oracle就是通过CHANGE_VECTOR$$列来记录每条记录发生变化的字段包括哪些。

基于主键、ROWID和OBJECT ID的物化视图日志在CHANGE_VECTOR$$上略有不同，但是总体设计的思路是一致的。

CHANGE_VECTOR$$列是RAW类型，其实Oracle采用的方式就是用每个BIT位去映射一个列。

      比如：第一列被更新设置为02，即00000010。第二列设置为04，即00000100，第三列设置为08，即00001000。当第一列和第二列同时被更新，则设置为06，00000110。如果三列都被更新，设置为0E，00001110。
      依此类推，第4列被更新时为10，第5列20，第6列40，第7列80，第8列0001。当第1000列被更新时，CHANGE_VECTOR$$的长度为1000/4+2为252。
      除了可以表示UPDATE的字段，还可以表示INSERT和DELETE。DELETE操作CHANGE_VECTOR$$列为全0，具体个数由基表的列数决定。INSERT操作的最低位为FE如果基表列数较多，而存在高位的话，所有的高位都为FF。如果INSERT操作是前面讨论过的由UPDATE操作更新了主键造成的，则这个INSERT操作对应的CHANGE_VECTOR$$列为全FF。

SQL> insert into t_rowid values (1, 'a', 5);
已创建 1 行。

SQL> insert into t_rowid values (2, 'b', 7);
已创建 1 行。

SQL> insert into t_rowid values (3, 'c', 9);
已创建 1 行。

SQL> update t_rowid set name = 'c' where id = 1;
已更新 1 行。

SQL> update t_rowid set id = 4 where id = 2;
已更新 1 行。

SQL> update t_rowid set name = 'd', num = 11 where id = 3;
已更新 1 行。

SQL> delete t_rowid where id = 3;
已删除 1 行。

SQL> select name, num, m_row$$, dmltype$$, old_new$$, change_vector$$ from mlog$_t_rowid;

可以看到，正如上面分析的，INSERT为FE，DELETE为00，对第一列的更新为02，第二列为04，第二列和第三列都更新为0C。需要注意，正常情况下，第一列会从02开始，但是如果对MLOG$表执行了TRUNCATE操作，或者重建了物化视图日志，则可能造成第一列开始位置发生偏移。

这个结果和ROWID类型基本一致，不同的是，如果更新了主键，会将UPDATE操作在物化视图日志中记录为一条DELETE和一条INSERT，不过这时INSERT对应的CHANGE_VECTOR$$的值是FF。

SQL> insert into t_oid values (1, 'a', 5);
已创建 1 行。

SQL> update t_oid set name = 'c' where id = 1;
已更新 1 行。

SQL> update t_oid set id = 5 where id = 1;
已更新 1 行。

SQL> delete t_oid;
已删除 1 行。

SQL> commit;
提交完成。

SQL> select * from mlog$_t_oid;

SQL> select name, segcollength from sys.col$ where obj# = (select object_id from user_objects where object_name ='T_OID');

NAME                           SEGCOLLENGTH
------------------------------ ------------
SYS_NC_OID$                        16
SYS_NC_ROWINFO$                1
ID                                          22
NAME                                     30
NUM                                      22

这个结果也和ROWID类型基本一致，需要注意的是，由于对象表包含两个隐含列，因此ID不再是第一个字段，而是第三个，因此对应的值是08。

SQL> create table t (
   col1 number,
   col2 number,
   col3 number,
   col4 number,
   col5 number,
   col6 number,
   col7 number,
   col8 number,
   col9 number,
   col10 number,
   col11 number,
   col12 number
);
表已创建。

SQL> create materialized view log on t with rowid;
实体化视图日志已创建。

SQL> insert into t values (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
已创建 1 行。

SQL> update t set col1 = 10;
已更新 1 行。

SQL> update t set col11 = 110;
已更新 1 行。

SQL> update t set col5 = 50, col12 = 120;
已更新 1 行。

SQL> delete t;
已删除 1 行。

SQL> commit;
提交完成。

SQL> select * from mlog$_t;

最后看一个包含列数较多的例子，唯一需要注意的是，低位在左，高位在右。

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

Oracle如何根据物化视图日志快速刷新物化视图

2012-05-22T08:51:00Z

Oracle物化视图的快速刷新机制是通过物化视图日志完成的。Oracle如何通过一个物化视图日志就可以支持多个物化视图的快速刷新呢，本文简单的描述一下刷新的原理。

首先，看一下物化视图的结构：
SQL> create table t(id number, name varchar2(30), num number);
表已创建。

SQL> create materialized view log on t with rowid, sequence(id, name) including new values;
实体化视图日志已创建。

SQL> desc mlog$_t

ID和NAME是建立物化视图日志时指定的基表中的列，它们记录每次DML操作对应的ID和NAME的值。
M_ROW$$保存基表的ROWID信息，根据M_ROW$$中的信息可以定位到发生DML操作的记录。
SEQUENCE$$根据DML操作发生的顺序记录序列的编号，当刷新时，根据SEQUENCE$$中的顺序就可以和基表中的执行顺序保持一致。
SNAPTIME$$列记录了刷新操作的时间。
DMLTYPE$$的记录值I、U和D，表示操作是INSERT、UPDATE还是DELETE。
OLD_NEW$$表示物化视图日志中保存的信息是DML操作之前的值（旧值）还是DML操作之后的值（新值）。除了O和N这两种类型外，对于UPDATE操作，还可能表示为U。
CHANGE_VECTOR$$记录DML操作发生在那个或那几个字段上。

有关物化视图日志结构的详细描述，可以参考文档：物化视图日志结构：http://blog.itpub.net/post/468/20498

根据上面的描述，可以发现，当刷新物化视图时，只需要根据SEQUENCE$$列给出的顺序，通过M_ROW$$定位到基表的记录，如果是UPDATE操作，通过CHANGE_VECTOR$$定位到字段，然后根据基表中的数据重复执行DML操作。

如果物化视图日志只针对一个物化视图，那么刷新过程就是这么简单，还需要做的不过是在刷新之后将物化视图日志清除掉。

但是，Oracle的物化视图日志是可以同时支持多个物化视图的快速刷新的，也就是说，物化视图在刷新时还必须判断哪些物化视图日志记录是当前物化视图刷新需要的，哪些是不需要的。而且，物化视图还必须确定，在刷新物化视图后，物化视图日志中哪些记录是需要清除的，哪些是不需要清除的。

回顾一下物化视图日志的结构，发现只剩下一个SHAPTIME$$列，那么Oracle如何仅通过这一列就完成了对多个物化视图的支持呢？下面建立一个小例子，通过例子来进行说明。

使用上文中建立的表和物化视图日志，下面对这个表建立三个快速刷新的物化视图。

SQL> create materialized view mv_t_id refresh fast as select id, count(*) from t group by id;
实体化视图已创建。

SQL> create materialized view mv_t_name refresh fast as select name, count(*) from t group by name;
实体化视图已创建。

SQL> create materialized view mv_t_id_name refresh fast as select id, name, count(*) from t group by id, name;
实体化视图已创建。

SQL> insert into t values (1, 'a', 2);
已创建 1 行。

SQL> insert into t values (1, 'b', 3);
已创建 1 行。

SQL> insert into t values (2, 'a', 5);
已创建 1 行。

SQL> insert into t values (3, 'b', 7);
已创建 1 行。

SQL> update t set name = 'c' where id = 3;
已更新 1 行。

SQL> delete t where id = 2;
已删除 1 行。

SQL> commit;
提交完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

当发生了DML操作后，物化视图日志中的SNAPTIME$$列保持的值是4000-01-01 00:00:00。这个值表示这条记录还没有被任何物化视图刷新过。第一个刷新这些记录的物化视图会将SNAPTIME$$的值更新为物化视图当前的刷新时间。

SQL> exec dbms_mview.refresh('MV_T_ID');
PL/SQL 过程已成功完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

Oracle根据数据字典中的信息可以知道表T上建立了三个物化视图，因此，MV_T_ID刷新完之后，不会删除物化视图记录。

Oracle的数据字典中还保存着每个物化视图上次刷新的时间和当前的刷新状态。

SQL> select name, last_refresh from user_mview_refresh_times;

SQL> select mview_name, last_refresh_date, staleness from user_mviews;

这些视图中记录了每个物化视图上次执行刷新操作的时间，并且给出每个物化视图中的数据是否是和基表同步的。由于MV_T_ID刚刚进行了刷新，因此状态是FRESH，而另外两个由于在刷新（建立）之后，基表又进行了DML操作，因此状态为NEEDS_COMPILE。如果这时对基表进行DML操作，则MV_T_ID的状态也会变为NEEDS_COMPILE。

SQL> insert into t values (4, 'd', 10);
已创建 1 行。

SQL> commit;
提交完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

SQL> select mview_name, last_refresh_date, staleness from user_mviews;

下面刷新物化视图MV_T_ID_NAME，刷新操作的判断依据是，只刷新SNAPTIME$$列大于当前物化视图的LAST_REFRESH_DATE的记录，由于物化视图日志中所有记录的SNAPTIME$$的值都比物化视图MV_T_ID_NAME上次刷新的时间点大，因此会刷新所有记录。对于SNAPTIME$$列的值是4000-01-01 00:00:00的记录，物化视图会把SNAPTIME$$列的值更新为当前刷新时间，对于那些已经被更新过的SNAPTIME$$列，则保持原值。

SQL> exec dbms_mview.refresh('MV_T_ID_NAME')
PL/SQL 过程已成功完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

SQL> select mview_name, last_refresh_date, staleness from user_mviews;

如果这时再次刷新物化视图MV_T_ID，则只有ID=4的这条记录的SNAPTIME$$的时间点大于MV_T_ID上次刷新的时间点，因此，只刷新这一条记录，且不会改变SNAPTIME$$的值。

SQL> exec dbms_mview.refresh('MV_T_ID')
PL/SQL 过程已成功完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

SQL> select mview_name, last_refresh_date, staleness from user_mviews;

到目前为止，还没有看到过物化视图日志的清除，其实每次进行完刷新，物化视图日志都会试图删除没有用的物化视图日志记录。物化视图日志记录的删除条件是删除那些SNAPTIME$$列小于等于基表所有物化视图的上次刷新时间。在上面的例子中，由于MV_T_NAME一直没有刷新，因此它的LAST_REFRESH_DATE比物化视图日志中所有记录的值都小，因此，一直没有发生物化视图日志记录清除的现象。

SQL> insert into t values (5, 'e', 2);
已创建 1 行。

SQL> commit;
提交完成。

SQL> exec dbms_mview.refresh('MV_T_NAME')
PL/SQL 过程已成功完成。

SQL> select id, name, m_row$$, snaptime$$, dmltype$$ from mlog$_t;

SQL> select mview_name, last_refresh_date, staleness from user_mviews;

物化视图MV_T_NAME刷新了物化视图中的每条记录，更新了ID=5的记录的SNAPTIME$$时间，并清除了其它所有物化视图日志记录。

SQL> drop materialized view log on t;
实体化视图日志已删除。

SQL> drop materialized view mv_t_id;
实体化视图已删除。

SQL> drop materialized view mv_t_name;
实体化视图已删除。

SQL> drop materialized view mv_t_id_name;
实体化视图已删除。

SQL> drop table t;
表已删除。

SQL>

最后，简单总结一下：
物化视图在刷新时，会刷新所有SNAPTIME$$大于物化视图上次刷新时间的记录，并将所有是4000-01-01 00:00:00的记录更新为当前刷新时间。对于其他大于上次刷新时间的记录，只刷新不更改。这样，当刷新执行完以后，数据字典中记录当前物化视图的上次刷新时间为当前时刻，这保证了物化视图日志中目前所有的记录都小于或等于刷新时间。因此，每个物化视图只要刷新大于上次刷新时间的记录，且保证每次刷新后，所有记录的时间都小于等于上次刷新时间，那么无论有多少个物化视图，就可以互不影响的使用同一个物化视图日志进行快速刷新了。当物化视图刷新完之后，会清除那些SNAPTIME$$列小于所有物化视图的上次刷新时间的记录，而这些记录已经被所有的物化视图都刷新过了，保存在物化视图日志中已经没有意义了。

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

Oracle物化视图语法

2012-05-21T07:29:00Z

一、Oracle物化视图语法

create materialized view [view_name]
refresh [fast|complete|force]
[
on [commit|demand] | start with (start_time) next (next_time)
]
as
{创建物化视图用的查询语句}

以上是Oracle创建物化视图（Materialized View, 以下简称MV）时常用的语法,各参数的含义如下:

1、refresh [fast|complete|force] 视图刷新的方式:
fast: 增量刷新.假设前一次刷新的时间为t1,那么使用fast模式刷新物化视图时,只向视图中添加t1到当前时间段内主表变化过的数据.为了记录这种变化，建立增量刷新物化视图还需要一个物化视图日志表。create materialized view log on 主表名。
complete: 全部刷新。相当于重新执行一次创建视图的查询语句。
force: 这是默认的数据刷新方式。当可以使用fast模式时，数据刷新将采用fast方式；否则使用complete方式。

2、MV数据刷新的时间：
on demand:在用户需要刷新的时候刷新，这里就要求用户自己动手去刷新数据了（也可以使用job定时刷新）
on commit:当主表中有数据提交的时候，立即刷新MV中的数据；
start ……：从指定的时间开始，每隔一段时间（由next指定）就刷新一次；

Oracle的物化视图提供了强大的功能，可以用于预先计算并保存表连接或聚集等耗时较多的操作的结果，这样，在执行查询时，就可以避免进行这些耗时的操作，而从快速的得到结果。物化视图有很多方面和索引很相似：使用物化视图的目的是为了提高查询性能；物化视图对应用透明，增加和删除物化视图不会影响应用程序中SQL语句的正确性和有效性；物化视图需要占用存储空间；当基表发生变化时，物化视图也应当刷新。

物化视图可以分为以下三种类型：包含聚集的物化视图；只包含连接的物化视图；嵌套物化视图。三种物化视图的快速刷新的限制条件有很大区别，而对于其他方面则区别不大。创建物化视图时可以指定多种选项，下面对几种主要的选择进行简单说明：

1、创建方式（Build Methods）：包括BUILD IMMEDIATE(立即)和BUILD DEFERRED(延迟)两种。BUILD IMMEDIATE是在创建物化视图的时候就生成数据，而BUILD DEFERRED则在创建时不生成数据，以后根据需要在生成数据。默认为BUILD IMMEDIATE。

2、查询重写（Query Rewrite）：包括ENABLE QUERY REWRITE和DISABLE QUERY REWRITE两种。分别指出创建的物化视图是否支持查询重写。查询重写是指当对物化视图的基表进行查询时，Oracle会自动判断能否通过查询物化视图来得到结果，如果可以，则避免了聚集或连接操作，而直接从已经计算好的物化视图中读取数据。默认为DISABLE QUERY REWRITE。

3、刷新（Refresh）：指当基表发生了DML操作后，物化视图何时采用哪种方式和基表进行同步。刷新的模式有两种：ON DEMAND和ON COMMIT。ON DEMAND指物化视图在用户需要的时候进行刷新，可以手工通过DBMS_MVIEW.REFRESH等方法来进行刷新，也可以通过JOB定时进行刷新。ON COMMIT指出物化视图在对基表的DML操作提交的同时进行刷新。刷新的方法有四种：FAST、COMPLETE、FORCE和NEVER。FAST刷新采用增量刷新，只刷新自上次刷新以后进行的修改。COMPLETE刷新对整个物化视图进行完全的刷新。如果选择FORCE方式，则Oracle在刷新时会去判断是否可以进行快速刷新，如果可以则采用FAST方式，否则采用COMPLETE的方式。NEVER指物化视图不进行任何刷新。默认值是FORCE ON DEMAND。

在建立物化视图的时候可以指定ORDER BY语句，使生成的数据按照一定的顺序进行保存。不过这个语句不会写入物化视图的定义中，而且对以后的刷新也无效。

4、物化视图日志：如果需要进行快速刷新，则需要建立物化视图日志。物化视图日志根据不同物化视图的快速刷新的需要，可以建立为ROWID或PRIMARY KEY类型的。还可以选择是否包括SEQUENCE、INCLUDING NEW VALUES以及指定列的列表。

可以指明ON PREBUILD TABLE语句将物化视图建立在一个已经存在的表上。这种情况下，物化视图和表必须同名。当删除物化视图时，不会删除同名的表。这种物化视图的查询重写要求参数QUERY_REWRITE_INTEGERITY必须设置为trusted或者stale_tolerated。

物化视图可以进行分区。而且基于分区的物化视图可以支持分区变化跟踪（PCT）。具有这种特性的物化视图，当基表进行了分区维护操作后，仍然可以进行快速刷新操作。对于聚集物化视图，可以在GROUP BY列表中使用CUBE或ROLLUP，来建立不同等级的聚集物化视图。

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

Java使用SOAP获取webservice实例解析

2012-05-07T13:19:00Z

1.webservice提供方：http://www.webxml.com.cn/zh_cn/index.aspx
2.下面我们以“获得腾讯QQ在线状态”为例。
参数截图如下图：

SOAP 1.1

以下是 SOAP 1.2 请求和响应示例。所显示的占位符需替换为实际值。

[http://www.webxml.com.cn/webservices/qqOnlineWebService.asmx?op=qqCheckOnline] 点击前面的网址，查看对应参数信息。

3.Java程序

package junit;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;

import org.junit.Test;

public class JxSendSmsTest {

/**
* 获得腾讯QQ在线状态
*
* 输入参数：QQ号码 String，默认QQ号码：8698053。返回数据：String，Y = 在线；N = 离线；E = QQ号码错误；A = 商业用户验证失败；V = 免费用户超过数量
* @throws Exception
*/
@Test
public void sendSms() throws Exception {
String qqCode = "416501600";//qq号码
String urlString = "http://www.webxml.com.cn/webservices/qqOnlineWebService.asmx";
String xml = JxSendSmsTest.class.getClassLoader().getResource("SendInstantSms.xml").getFile();
String xmlFile=replace(xml, "qqCodeTmp", qqCode).getPath();
String soapActionString = "http://WebXml.com.cn/qqCheckOnline";
URL url = new URL(urlString);
HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
File fileToSend = new File(xmlFile);
byte[] buf = new byte[(int) fileToSend.length()];
new FileInputStream(xmlFile).read(buf);
httpConn.setRequestProperty("Content-Length", String.valueOf(buf.length));
httpConn.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
httpConn.setRequestProperty("soapActionString", soapActionString);
httpConn.setRequestMethod("POST");
httpConn.setDoOutput(true);
httpConn.setDoInput(true);
OutputStream out = httpConn.getOutputStream();
out.write(buf);
out.close();

byte[] datas=readInputStream(httpConn.getInputStream());
String result=new String(datas);
//打印返回结果
System.out.println("result:" + result);
}

/**
* 文件内容替换
*
* @param inFileName 源文件
* @param from
* @param to
* @return 返回替换后文件
* @throws IOException
* @throws UnsupportedEncodingException
*/
public static File replace(String inFileName, String from, String to)
throws IOException, UnsupportedEncodingException {
File inFile = new File(inFileName);
BufferedReader in = new BufferedReader(new InputStreamReader(
new FileInputStream(inFile), "utf-8"));
File outFile = new File(inFile + ".tmp");
PrintWriter out = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(outFile), "utf-8")));
String reading;
while ((reading = in.readLine()) != null) {
out.println(reading.replaceAll(from, to));
}
out.close();
in.close();
//infile.delete(); //删除源文件
//outfile.renameTo(infile); //对临时文件重命名
return outFile;
}

/**
* 从输入流中读取数据
* @param inStream
* @return
* @throws Exception
*/
public static byte[] readInputStream(InputStream inStream) throws Exception{
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = 0;
while( (len = inStream.read(buffer)) !=-1 ){
outStream.write(buffer, 0, len);
}
byte[] data = outStream.toByteArray();//网页的二进制数据
outStream.close();
inStream.close();
return data;
}

}

4、SendInstantSms.xml文件如下，放在src目录下

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<qqCheckOnline xmlns="http://WebXml.com.cn/">
<qqCode>qqCodeTmp</qqCode>
</qqCheckOnline>
</soap:Body>
</soap:Envelope>

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

Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

常用的PL/SQL开发原则

2012-04-25T01:24:00Z

（1）广泛使用绑定变量，特别是批量绑定，因为这可以有效的避免sql的硬解析和PL/SQL引擎和SQL引擎的上下文切换！
（2）广泛使用UROWID来处理DML语句(UROWID是ROWID扩展，ORACLE推荐使用UROWID来替代ROWID)
（3）在你的存储过程中谨慎使用DDL语句(create、alter、drop、truncate等)，因为这可能会破坏你的transaction的连续性，更为严重的是可能会阻塞DML操作并可能会导致大量library cache latch争用并且有可能会导致某些sql执行计划的改变。
（4）不要在存储过程里不应该commit的地方commit，特别是当你的存储过程会被另外一个存储过程调用的时候，你考虑到了你这么做会破坏调用你的父存储过程的transaction的连续性了吗？
（5）注意你面对的数据量，小数据量的处理方法和海量数据的处理方法是不一样的！
（6）循环的时候要注意清空临时变量的值
（7）注意“select into 变量”的问题，使用子begin语句封装“select into 变量”以避免可能会出现的错误，这样就可以避免要在“select into 变量”之前先执行一下select count(*)
（8）不要让oracle执行你的PL/SQL代码时产生隐式转换
（9）在PL/SQL中定义varchar2变量的时候当你在不知道你所定义的变量的长度的时候可以将其定义为varchar2(4000)，这一点都不浪费！
（10）如果你写的一组存储过程有逻辑上的关联，那我建议你要把这些存储过程封装到一个package里面
（11）改正你的PL/SQL代码里的所有编译时编译器提示出的warning
（12）循环的时候一定要注意exit，否则就太可怕了！
（13）处理显式cursor的时候一定要注意fetch和exit，否则就太可怕了！如下是我处理的一个真实的案例，这个案例中暴露出的问题就很好的说明了处理cursor的时候一定要注意fetch和exit：

      今天下午1点多的时候接到同事的一封信，信里提到我们的一个10gR2的开发环境连不进去了，报这样的错“ORA-00257：archiver error.Connect internalonly,until freed.”。很明显是因为归档进行不下去而导致整个系统被hang住了。
      我上去一看，果然是存放归档日志的目录满了。上述开发环境的存放归档日志的目录大小为10个G，alert log显示从今天11点半开始到下午1点左右的这段时间系统整整产生了10个G的归档日志，而且还在源源不断的继续产生。在继续产生归档日志的时候因为空间满了，所以导致整个系统被hang住。原因知道了，处理过程就很清晰了。
      只保留一个归档日志，然后手工把所有其他的归档日志rm掉，注意这里不要一下子就把所有的归档日志给rm掉，否则可能导致文件系统的句柄无法释放，进而这些归档日志占用的空间也无法释放。然后run一个ADDM报告，看一下是什么导致了在这么短的时间内产生了这么多的归档日志。从ADDM报告中可以很清晰的看到产生这么多归档日志的根本原因是因为一个存储过程里的几条sql在短时间内执行了1400多万次的缘故。
     用alter system kill session配合kill -9杀掉这个存储过程所在的session，以阻止它源源不断的产生归档日志。
     接着我分析了一下上述存储过程，发现根本原因在于在这个存储过程里打开了一个cursor，fetch这个cursor中的一条记录到一个record里，然后开启一个循环，在循环里run上述的那几条sql语句。但致命的是在循环的末尾并没有再fetch这个cursor中的另外一条记录，这就导致了上述循环的条件永远为真，所以上述sql如果不被我中断的话就会永远执行下去。这也就解释了为什么会在短时间里产生了大量的归档日志，并且undo tablespace的空间也被消耗殆尽。后续处理过程这里省略……

（14）bulk collect into的时候不要一次collect太多的数据，建议一次collect的数据量在10000条以内，你可以用批量绑定自带的limit子句来限制或者使用rownum来限制
（15）如果你使用了批量绑定，那为什么要把时间浪费在写诸如insertinto tablename(column1,column2,……,column100) values(value1(i),value2(i),……,value100(i))这样的sql语句上面？如果有可能，就写一个你自己的存储过程代码生成器吧，让它来帮你生成这样的语句。你应该把精力集中在更有用的方面！
（16）你希望你的代码被并发执行吗？如果你不希望或者你的代码根本就不能够被并发执行，那就想一个办法控制并发吧！在应用层面控制就好，比如在update之前先尝试对该记录加for update nowait的锁，或者利用DML语句当前读的特性来避免并发都是不错的主意
（17）不要写诸如insert into tablename1 select* from tablename2这样的语句，你考虑到扩展性了吗？假如以后tablename1或者tablename2增加或减少字段了呢？
（18）谨慎使用hint，除非你很清楚你在做什么。比如说这里你强制oracle使用了某个索引，假如以后这个索引的名字被改了，由此带来的执行计划的变更你怎么办？你考虑到这种情况了吗？
（19）注意关联更新丢失数据的问题，update语句如果没有指定where条件那就是对所有的数据做update操作，这个就太恐怖了！
（20）用好临时表，有时候临时表很有用！特别是在根据一堆复杂条件去更新海量数据的时候
（21）尽量避免在存储过程里使用递规！不是说不能用递规（递规在某些特定的情况下很有用），而是说在用递规的时候一定要避免无限递规的情况！
（22）写好你的PL/SQL代码里的注释，这个很重要！不写注释并不代表你很厉害！

--------------------------------------------------------------------------
Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接

js字符串转化为日期及日期判断大小

2012-04-20T10:36:00Z

//将字符串转换为日期
var begin=new Date($("#begin").val().replace(/-/g,"/"));
var end=new Date($("#end").val().replace(/-/g,"/"));
//js判断日期
if(begin-end>0){
alert("开始日期要在截止日期之前!");
return false;
}

本文链接

webservices客户端调用

2012-04-18T03:48:00Z

1)、首先，你要先把你的WS服务启动起来，比如http://localhost:8080/Example/services/HelloWorldService?wsdl
2)、然后，在你的另一个项目中建一个Webservice Client 客户端，用来访问你的WS服务。
建立Webservice Client 方法如下，在Eclipses中建立一个java工程，然后在src上右键--NEW---Other---Web Service Client --Xfire--在WsdL url 中写上http://localhost:8080/Example/services/HelloWorldService?wsdl-----下一步结束。
在src里的会出现一些java文件，你找一个以Client结束的java文件，在里面的main方法中会有个service对象，现在你就可以直接用这个对象了，service.peerstatus(参数)这样写就行了。

1、用java调用webservice客户端
public static void main(String[] args) throws MalformedURLException {
    SimpleService simpleService=new SimpleService();
    SimpleServicePortType type=simpleService.getSimpleServiceHttpSoap11Endpoint();
    int price=type.getPrice().getReturn();
    String greet=type.getGreeting("ljq");
    System.out.println(price+" : "+greet);
}

本文链接

三、常见分析函数详解

2012-04-06T07:43:00Z

为了方便进行实践，特将演示表和数据罗列如下：

一、创建表

create table t(
bill_month varchar2(12) ,
area_code number,
net_type varchar(2),
local_fare number
);

二、插入数据

insert into t values('200405',5761,'G', 7393344.04);
insert into t values('200405',5761,'J', 5667089.85);
insert into t values('200405',5762,'G', 6315075.96);
insert into t values('200405',5762,'J', 6328716.15);
insert into t values('200405',5763,'G', 8861742.59);
insert into t values('200405',5763,'J', 7788036.32);
insert into t values('200405',5764,'G', 6028670.45);
insert into t values('200405',5764,'J', 6459121.49);
insert into t values('200405',5765,'G', 13156065.77);
insert into t values('200405',5765,'J', 11901671.70);
insert into t values('200406',5761,'G', 7614587.96);
insert into t values('200406',5761,'J', 5704343.05);
insert into t values('200406',5762,'G', 6556992.60);
insert into t values('200406',5762,'J', 6238068.05);
insert into t values('200406',5763,'G', 9130055.46);
insert into t values('200406',5763,'J', 7990460.25);
insert into t values('200406',5764,'G', 6387706.01);
insert into t values('200406',5764,'J', 6907481.66);
insert into t values('200406',5765,'G', 13562968.81);
insert into t values('200406',5765,'J', 12495492.50);
insert into t values('200407',5761,'G', 7987050.65);
insert into t values('200407',5761,'J', 5723215.28);
insert into t values('200407',5762,'G', 6833096.68);
insert into t values('200407',5762,'J', 6391201.44);
insert into t values('200407',5763,'G', 9410815.91);
insert into t values('200407',5763,'J', 8076677.41);
insert into t values('200407',5764,'G', 6456433.23);
insert into t values('200407',5764,'J', 6987660.53);
insert into t values('200407',5765,'G', 14000101.20);
insert into t values('200407',5765,'J', 12301780.20);
insert into t values('200408',5761,'G', 8085170.84);
insert into t values('200408',5761,'J', 6050611.37);
insert into t values('200408',5762,'G', 6854584.22);
insert into t values('200408',5762,'J', 6521884.50);
insert into t values('200408',5763,'G', 9468707.65);
insert into t values('200408',5763,'J', 8460049.43);
insert into t values('200408',5764,'G', 6587559.23);
insert into t values('200408',5764,'J', 7342135.86);
insert into t values('200408',5765,'G', 14450586.63);
insert into t values('200408',5765,'J', 12680052.38);
commit;

三、first_value()与last_value()：求最值对应的其他属性
问题、取出每月通话费最高和最低的两个地区。

SELECT BILL_MONTH,
AREA_CODE,
SUM(LOCAL_FARE) LOCAL_FARE,
FIRST_VALUE(AREA_CODE)
OVER(PARTITION BY BILL_MONTH
ORDER BY SUM(LOCAL_FARE) DESC
ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FIRSTVAL,
LAST_VALUE(AREA_CODE)
OVER(PARTITION BY BILL_MONTH
ORDER BY SUM(LOCAL_FARE) DESC
ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) LASTVAL
FROM T
GROUP BY BILL_MONTH, AREA_CODE
ORDER BY BILL_MONTH

运行结果：

四、rank(),dense_rank()与row_number()：求排序

rank，dense_rank，row_number函数为每条记录产生一个从1开始至n的自然数，n的值可能小于等于记录的总数。这3个函数的唯一区别在于当碰到相同数据时的排名策略。
①row_number：
row_number函数返回一个唯一的值，当碰到相同数据时，排名按照记录集中记录的顺序依次递增。
②dense_rank：
dense_rank函数返回一个唯一的值，当碰到相同数据时，此时所有相同数据的排名都是一样的。
③rank：
rank函数返回一个唯一的值，当碰到相同的数据时，此时所有相同数据的排名是一样的，同时会在最后一条相同记录和下一条不同记录的排名之间空出排名。

演示数据在Oracle自带的scott用户下：
1、rank()值相同时排名相同，其后排名跳跃不连续

SELECT *
FROM (SELECT DEPTNO,
RANK() OVER(PARTITION BY DEPTNO ORDER BY SAL DESC) RW,
ENAME,
SAL
FROM SCOTT.EMP)
WHERE RW <= 4;

运行结果：

2、dense_rank()值相同时排名相同，其后排名连续不跳跃

SELECT *
FROM (SELECT DEPTNO,
DENSE_RANK() OVER(PARTITION BY DEPTNO ORDER BY SAL DESC) RW,
ENAME,
SAL
FROM SCOTT.EMP)
WHERE RW <= 4;

运行结果：

3、row_number()值相同时排名不相等，其后排名连续不跳跃

SELECT *
FROM (SELECT DEPTNO,
ROW_NUMBER() OVER(PARTITION BY DEPTNO ORDER BY SAL DESC) RW,
ENAME,
SAL
FROM SCOTT.EMP)
WHERE RW <= 4;

运行结果：

五、lag()与lead()：求之前或之后的第N行
lag和lead函数可以在一次查询中取出同一字段的前n行的数据和后n行的值。这种操作可以使用对相同表的表连接来实现，不过使用lag和lead有更高的效率。
lag(arg1,arg2,arg3)
第一个参数是列名，
第二个参数是偏移的offset，
第三个参数是超出记录窗口时的默认值。

举例如下：
SQL> select * from kkk;

        ID NAME
---------- --------------------
         1 1name
         2 2name
         3 3name
         4 4name
         5 5name
SQL> select id,name,lag(name,1,0) over(order by id) from kkk;

        ID NAME                 LAG(NAME,1,0)OVER(ORDERBYID)
---------- -------------------- ----------------------------
         1 1name                0
         2 2name                1name
         3 3name                2name
         4 4name                3name
         5 5name                4name

SQL> select id,name,lead(name,1,0) over(order by id) from kkk;

        ID NAME                 LEAD(NAME,1,0)OVER(ORDERBYID)
---------- -------------------- -----------------------------
         1 1name                2name
         2 2name                3name
         3 3name                4name
         4 4name                5name
         5 5name                0

SQL> select id,name,lead(name,2,0) over(order by id) from kkk;
        ID NAME                 LEAD(NAME,2,0)OVER(ORDERBYID)
---------- -------------------- -----------------------------
         1 1name                3name
         2 2name                4name
         3 3name                5name
         4 4name                0
         5 5name                0
SQL> select id,name,lead(name,1,'linjiqin') over(order by id) from kkk;

        ID NAME                 LEAD(NAME,1,'ALSDFJLASDJFSAF')
---------- -------------------- ------------------------------
         1 1name                2name
         2 2name                3name
         3 3name                4name
         4 4name                5name
         5 5name                linjiqin

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

六、rollup()与cube()：排列组合分组
1)、group by rollup(a, b, c)：
首先会对(a、b、c)进行group by，
然后再对(a、b)进行group by，
其后再对(a)进行group by，
最后对全表进行汇总操作。

2)、group by cube(a, b, c)：
则首先会对(a、b、c)进行group by，
然后依次是(a、b)，(a、c)，(a)，(b、c)，(b)，(c)，
最后对全表进行汇总操作。

1、生成演示数据：
Connected to Oracle Database 10g Enterprise Edition Release 10.2.0.1.0
Connected as ds_trade

SQL> conn system/oracle as sysdba
Connected to Oracle Database 10g Enterprise Edition Release 10.2.0.3.0
Connected as SYS

SQL> create table scott.t as select * from dba_indexes;

Table created

SQL> connect scott/oracle
Connected to Oracle Database 10g Enterprise Edition Release 10.2.0.3.0
Connected as scott

SQL>

2、普通group by体验
sql> select owner, index_type, status, count(*) from t where owner like 'SY%' group by owner, index_type, status;

3、group by rollup(A,B,C)
GROUP BY ROLLUP(A, B, C)：
首先会对(A、B、C)进行GROUP BY，
然后再对(A、B)进行GROUP BY，
其后再对(A)进行GROUP BY，
最后对全表进行汇总操作。
sql> select owner, index_type, status, count(*) from t where owner like 'SY%' group by ROLLUP(owner, index_type, status);

4、group by cube(A,B,C)
GROUP BY CUBE(A, B, C)：
则首先会对(A、B、C)进行GROUP BY，
然后依次是(A、B)，(A、C)，(A)，(B、C)，(B)，(C)，
最后对全表进行汇总操作。

sql> select owner, index_type, status, count(*) from t where owner like 'SY%' group by cube(owner, index_type, status);

七、max(),min(),sun()与avg()：求移动的最值总和与平均值
问题：计算出各个地区连续3个月的通话费用的平均数(移动平均值)

SELECT AREA_CODE,
BILL_MONTH,
LOCAL_FARE,
SUM(LOCAL_FARE) OVER(PARTITION BY AREA_CODE
ORDER BY TO_NUMBER(BILL_MONTH)
RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) "3month_sum",
AVG(LOCAL_FARE) OVER(PARTITION BY AREA_CODE
ORDER BY TO_NUMBER(BILL_MONTH)
RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) "3month_avg",
MAX(LOCAL_FARE) OVER(PARTITION BY AREA_CODE
ORDER BY TO_NUMBER(BILL_MONTH)
RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) "3month_max",
MIN(LOCAL_FARE) OVER(PARTITION BY AREA_CODE
ORDER BY TO_NUMBER(BILL_MONTH)
RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) "3month_min"
FROM (SELECT T.AREA_CODE, T.BILL_MONTH, SUM(T.LOCAL_FARE) LOCAL_FARE
FROM T
GROUP BY T.AREA_CODE, T.BILL_MONTH)

运行结果：

问题：求各地区按月份累加的通话费

SELECT AREA_CODE,
BILL_MONTH,
LOCAL_FARE,
SUM(LOCAL_FARE) OVER(PARTITION BY AREA_CODE
ORDER BY BILL_MONTH ASC) "last_sum_value"
FROM (SELECT T.AREA_CODE, T.BILL_MONTH, SUM(T.LOCAL_FARE) LOCAL_FARE
FROM T
GROUP BY T.AREA_CODE, T.BILL_MONTH)
ORDER BY AREA_CODE, BILL_MONTH

运行结果：

--------------------------------------------------------------------------
Blog：http://www.cnblogs.com/linjiqin/
J2EE、Android、Linux、Oracle QQ交流群：142463980、158560018(满)

题外话：
本人来自铁观音的发源地——泉州安溪，正宗安溪铁观音，有需要的友友欢迎加我Q:416501600。
茶叶淘宝店：http://shop61968332.taobao.com/

本文链接