t_xiaoxi  order by cid desc) where rownum<10000) where rn>9980) order by cid desc;
执行时间0.03秒
2.按分析函数来分
select * from (select t.*,row_number() over(order by cid desc) rk from t_xiaoxi t) where rk<10000 and rk>9980;
执行时间1.01秒
3.按ROWNUM来分
select * from(select t.*,rownum rn from(select * from t_xiaoxi order by cid desc) t where rownum<10000) where

rn>9980;执行时间0.1秒
其中t_xiaoxi为表名称，cid为表的关键字段，取按CID降序排序后的第9981-9999条记录，t_xiaoxi表有70000多条记录
个人感觉1的效率最好，3次之，2最差

PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”（翻译的还算好理解），对于定义成自治事务的Procedure，实际上相当于一段独立运行的程序段，这段程序不依赖于主程序，也不干涉主程序

自治事务的特点

第一,这段程序不依赖于原有Main程序，比如Main程序中有未提交的数据，那么在自治事务中是查找不到的。

第二,在自治事务中，commit或者rollback只会提交或回滚当前自治事务中的DML，不会影响到Main程序中的DML。

Autonomous Transaction Demo 1

Without Pragma Autonomous Transaction

With Pragma Autonomous Transaction

Autonomous Transaction Demo 2

CREATE OR REPLACE FUNCTION howmanyrows RETURN INTEGER IS
 i INTEGER;

 PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
  SELECT COUNT(*)
  INTO i
  FROM t;

  RETURN i;
END howmanyrows;
/

-- empty the test table
TRUNCATE TABLE t;

exec testproc;

pl/sql中设置:

tools->preferences->sql window->AutoSelect statement

然后光标放在一行，按F8就可以了, 注意: 每个语句结尾还要分号标注一下！

package com.abin.wto.dbs.oracle;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import oracle.sql.CLOB;

public class OperateOracle {
 public static void main(String[] args) {
  Connection conn=null;
  PreparedStatement ps=null;
  ResultSet rs=null;
  try {
   Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
   String url="jdbc:oracle:thin:@localhost:1521:XE";
   conn=DriverManager.getConnection(url,"abin","abin");
   String sql="insert into bignumber values(?,?)";
   ps=conn.prepareStatement(sql);
   ps.setInt(1, 8888);
   java.sql.Clob  clob=oracle.sql.CLOB.createTemporary(conn, false, oracle.sql.CLOB.DURATION_SESSION);
   clob.setString(1, "55555555555555");
   ps.setClob(2, clob);
   int result=ps.executeUpdate();
   System.out.println("result="+result);
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   if(ps!=null){
    try {
     ps.close();
    } catch (SQLException e) {
     e.printStackTrace();
    }
   }
   try {
    CLOB.freeTemporary(null);
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
 }

}

看到网上有个同学，举例说明，觉得不错，拿来用下：
假设有张表，叫table1，里面有5000万行数据，假设预计全表扫描1次需要1个小时，我们从过程来看：   
   
1、在1点钟，有个用户A发出了select * from table1;此时不管将来table1怎么变化，正确的结果应该是用户A会看到在1点钟这个时刻的内容。这个是没有疑问的。   
2、在1点30分，有个用户B执行了update命令，更新了table1表中的第4000万行的这条记录，这时，用户A的全表扫描还没有到达第4000万条。毫无疑问，这个时候，第4000万行的这条记录是被写到了回滚段里去了的，我假设是回滚段RBS1，如果用户A的全表扫描到达了第4000万行，是应该会正确的从回滚段RBS1中读取出1点钟时刻的内容的。   
3、这时，用户B将他刚才做的操作commit了，但是这时，系统仍然可以给用户A提供正确的数据，因为那第4000万行记录的内容仍然还在回滚段RBS1里，系统可以根据SCN来到回滚段里找到正确的数据，但是大家注意到，这时记录在RBS1里的第4000万行记录已经发生了一点重大的改变：就是这个第4000万行的在回滚段RBS1里的数据有可能随时被覆盖掉，因为这条记录已经被提交了！！！   
4、由于用户A的查询时间漫长，而业务在一直不断的进行，RBS1回滚段在被多个不同的tracnsaction使用着，这个回滚段里的extent循环到了第4000万行数据所在的extent，由于这条记录已经被标记提交了，所以这个extent是可以被其他transaction覆盖掉的！   
5、到了1点40分，用户A的查询终于到了第4000万行，而这时已经出现了第4条说的情况，需要到回滚段RBS1去找数据，但是已经被覆盖掉了，于是01555就出现了。   
   
这次出现的ORA-01555，引起的原因很特殊。   
报错是回滚段SYSSMU1有问题.   
所以断定的是，并不是因为大量的读写，造成的一致性读错误，而且因为回滚段的错误，使快照出现了问题。   
   
首先观察下回滚段：   
SQL> select segment_name,tablespace_name,status from dba_rollback_segs;   
发现表空间UNDOTBS1的回滚段_SYSSMU1$-10$都是online。   
发现表空间UNDOTBS2的回滚段SYSSMU1是竟然是needs recovery,其他都是offline。   
最有趣的是这个数据库指定的UNDO是UNDOTBS1，UNDOTBS2实际已经被弃用了。   
   
尝试把该回滚段offline后删除，但是提示非法。   
重启数据库后该回滚段状态变成了availabe。   
再次尝试offline后删除，还是提示正在使用。   

 
用直接更新数据字典的方法   
SQL>update undo$ set status$=2 where name='SYSSMU1';   
发现该回滚段状态变更为offline，drop掉即可。   
ORA-1555不再出现。   

本篇文章来源于 Linux公社网站(www.linuxidc.com)  原文链接：http://www.linuxidc.com/Linux/2012-10/73260.htm

SQL> show parameter processes

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
aq_tm_processes                      integer     1
db_writer_processes                  integer     1
job_queue_processes                  integer     10
log_archive_max_processes            integer     2
processes                            integer     150

SQL> show parameter sessions

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
java_max_sessionspace_size           integer     0
java_soft_sessionspace_limit         integer     0
license_max_sessions                 integer     0
license_sessions_warning             integer     0
logmnr_max_persistent_sessions       integer     1
mts_sessions                         integer     165
sessions                             integer     170
shared_server_sessions               integer     165
SQL>

2. 修改processes和sessions值

SQL> alter system set processes=300 scope=spfile;

系统已更改。

SQL> alter system set sessions=335 scope=spfile;

系统已更改。

3. 修改processes和sessions值必须重启oracle服务器才能生效

ORACLE的连接数(sessions)与其参数文件中的进程数(process)有关，它们的关系如下：

sessions=(1.1*process+5)

　查询数据库当前进程的连接数：

　select count(*) from v$process;

　　查看数据库当前会话的连接数：

　　select count(*) from v$session;

　　查看数据库的并发连接数：

　　select count(*) from v$session where status='ACTIVE';

　　查看当前数据库建立的会话情况：

　　select sid,serial#,username,program,machine,status from v$session;

　查询数据库允许的最大连接数：

　　select value from v$parameter where name = 'processes';

　　或者：show parameter processes;

　　修改数据库允许的最大连接数：

　　alter system set processes = 300 scope = spfile;

　　(需要重启数据库才能实现连接数的修改)

　　重启数据库：

　　shutdown immediate;

　　startup;

　　查看当前有哪些用户正在使用数据：

　　select osuser,a.username,cpu_time/executions/1000000||'s',sql_fulltext,machine

　　from v$session a,v$sqlarea b

　　where a.sql_address = b.address

　　order by cpu_time/executions desc;

　　备注：UNIX 1个用户session对应一个操作系统process，而Windows体现在线程。

　　启动oracle

　　su - oracle

　　sqlplus system/pwd as sysdba   //进入sql

　　startup                                      //启动数据库

　　lsnrctl start                               //启动监听

　　sqlplus "/as sysdba"

　　shutdown immediate;

　　startup mount;

　　alter database open;

package com.abin.lee.db.oracle.batch;

import java.sql.Connection;
import java.sql.DriverManager;

public class OracleConnection {
 private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
 private static final String URL="jdbc:oracle:thin:@localhost:1521:XE";
 private static final String USER="abin";
 private static final String PWD="abin";
 private static final String DRIVER="oracle.jdbc.driver.OracleDriver";
 
 public static Connection getConnection(){
  Connection conn=null;
  if(null==threadLocal.get()){
   try {
    Class.forName(DRIVER);
    conn=DriverManager.getConnection(URL, USER, PWD);
    threadLocal.set(conn);
   } catch (Exception e) {
    e.printStackTrace();
   }
  }else{
   conn=threadLocal.get();
  }
  return conn;
 }
 
 
}

package com.abin.lee.db.oracle.batch;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;

import junit.framework.TestCase;

public class OracleBatch extends TestCase {
 public void testinsert() throws SQLException {
  Connection conn = null;
  PreparedStatement ps = null;
  conn = OracleConnection.getConnection();
  String sql = "insert into abing(id,name) values (?,?)";
  ps = conn.prepareStatement(sql);
  System.out.println("start="
    + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")
      .format(new java.util.Date()));
  try {
   for (int i = 0; i <= 50000; i++) {
    ps.setObject(1, i);
    ps.setObject(2, "abin" + i);
    ps.addBatch();
    if (i % 10000 == 0) {
     // System.out.println("i="+i);
     ps.executeBatch();
     ps.clearBatch();
    }

   }

  } catch (SQLException e) {
   e.printStackTrace();
  }
  System.out.println("end="
    + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")
      .format(new java.util.Date()));

 }

}

create or replace function getFunction(myname varchar2)
return sys_refcursor
as

v_sql varchar2(4000);
mylist sys_refcursor;
begin
       v_sql:='select * from abin1 where name1=:1';
       open myList for v_sql using myname;
       return(myList);
end;

package com.abin.lee.db.oracle;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class OracleConnection {
 private static final String USER="abin";
 private static final String PWD="abin";
 private static final String URL="jdbc:oracle:thin:@localhost:1521:XE";
 private static final String DRIVER="oracle.jdbc.driver.OracleDriver";
 private static ThreadLocal<Connection> threadLocal=new ThreadLocal<Connection>(){
  protected Connection initialValue(){
   Connection conn=null;
   try {
    Class.forName(DRIVER);
    if(null==conn||conn.isClosed()){
     conn=DriverManager.getConnection(URL, USER, PWD);
    }
   } catch (Exception e) {
    e.printStackTrace();
   }
   return conn;
  }
  
 };
 
 
 public static Connection getConnection() throws ClassNotFoundException, SQLException{
  Connection conn=null;
  if(threadLocal.get()==null){
   Class.forName(DRIVER);
   conn=DriverManager.getConnection(URL, USER, PWD);
   threadLocal.set(conn);
  }else {
   return threadLocal.get();
  }
  return conn;
 }

}

package com.abin.lee.db.oracle;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;

import junit.framework.TestCase;
import oracle.jdbc.OracleTypes;

public class GetFunctionResultSet extends TestCase{
 public void test(){
  Connection conn=null;
  CallableStatement cs=null;
  ResultSet rs=null;
  try {
   conn=OracleConnection.getConnection();
 /*此处是关键，不要写错了。第一个问号代表返回值，getFunction（）括号里面是function的输入参数。*/  
   cs=conn.prepareCall("{?=call getFunction(?)}");
   cs.registerOutParameter(1, OracleTypes.CURSOR);
   cs.setString(2, "a1");
   cs.execute();
   rs=(ResultSet)cs.getObject(1);
   while(rs.next()&&rs!=null){
    System.out.println("ID="+rs.getInt("id1"));
    System.out.println("NAME="+rs.getString("name1"));
    System.out.println("NAME="+rs.getString("createtime1"));
   }
   
  } catch (Exception e) {
   e.printStackTrace();
  }
  /**
   * create or replace function getFunction(myname varchar2)
   return sys_refcursor
   as
   v_sql varchar2(4000);
   mylist sys_refcursor;
   begin
          v_sql:='select * from abin1 where name1=:1';
          open myList for v_sql using myname;
          return(myList);
   end;
   */
  
 }
}

参考资料：
http://lanselixiangxc.bokee.com/267623.html

package com.abin.lee.db.oracle;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class OracleConnection {
 private static final String USER="abin";
 private static final String PWD="abin";
 private static final String URL="jdbc:oracle:thin:@localhost:1521:XE";
 private static final String DRIVER="oracle.jdbc.driver.OracleDriver";
 private static ThreadLocal<Connection> threadLocal=new ThreadLocal<Connection>(){
  protected Connection initialValue(){
   Connection conn=null;
   try {
    Class.forName(DRIVER);
    if(null==conn||conn.isClosed()){
     conn=DriverManager.getConnection(URL, USER, PWD);
    }
   } catch (Exception e) {
    e.printStackTrace();
   }
   return conn;
  }
  
 };
 
 
 public static Connection getConnection() throws ClassNotFoundException, SQLException{
  Connection conn=null;
  if(threadLocal.get()==null){
   Class.forName(DRIVER);
   conn=DriverManager.getConnection(URL, USER, PWD);
   threadLocal.set(conn);
  }else {
   return threadLocal.get();
  }
  return conn;
 }

}

package com.abin.lee.db.oracle;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;

import junit.framework.TestCase;
import oracle.jdbc.OracleTypes;

public class GetProcedureResultSet extends TestCase{
 public void test(){
  Connection conn=null;
  CallableStatement cs=null;
  ResultSet rs=null;
  try {
   conn=OracleConnection.getConnection();
   cs=conn.prepareCall("{call getList(?,?)}");
   cs.setString(1, "a1");
   cs.registerOutParameter(2, OracleTypes.CURSOR);
   cs.execute();
   rs=(ResultSet)cs.getObject(2);
   while(rs.next()&&rs!=null){
    System.out.println("ID="+rs.getInt("id1"));
    System.out.println("NAME="+rs.getString("name1"));
    System.out.println("NAME="+rs.getString("createtime1"));
   }
   
  } catch (Exception e) {
   e.printStackTrace();
  }
  
  
 }
 /**
  * create or replace procedure getList(myname varchar2,mylist out sys_refcursor)
  is
  v_sql varchar2(4000);
  begin
        v_sql:='select * from abin1 where name1=:1';
         open myList for v_sql using myname;
  end;
  */
}

Oracle表分区和索引分区汇总

为了简化数据库大表的管理,例如在数据仓库中一般都是TB级的数量级.ORACLE8以后推出了分区选项.分区将表分离在若于不同的表空间上,用分而治之的方法来支撑元限膨胀的大表,组大表在物理一级的可管理性.将大表分割成较小的分区可以改善表的维护、备份、恢复、事务及查询性能。

分区的优点：

1、  增强可用性：如果表的一个分区由于系统故障而不能使用，表的其余好的分区仍可以使用；

2、  减少关闭时间：如果系统故障只影响表的一部份分区，那么只有这部份分区需要修复，矿能比整个大表修复花的时间更少；

3、  维护轻松：如果需要得建表，独产管理每个公区比管理单个大表要轻松得多；

4、  均衡I/O：可以把表的不同分区分配到不同的磁盘来平衡I/O改善性能；

5、  改善性能：对大表的查询、增加、修改等操作可以分解到表的不同分区来并行执行，可使运行速度更快，在数据仓库的TP查询特别有用。

6、  分区对用户透明，最终用户感觉不到分区的存在。

create tablespace dw1

datafile 'D:\oracle\oradata\ora9\dw11.ora' size 50M
 

create tablespace dw2

datafile 'D:\oracle\oradata\ora9\dw21.ora' size 50M

一、按范围分区：固名思义就是按一定range来分区，看下面的例子:

SQL> set linesize 1000

SQL> create table niegc_part

   (

    part_id integer primary key,

    part_date date,

    part_dec varchar2(100)

    )

    partition by range(part_date)

    (

    partition part_01 values less than(to_date('2006-01-01','yyyy-mm-dd')) tablespace dw1,

   partition part_02 values less than(to_date('2007-01-01','yyyy-mm-dd')) tablespace dw2,

   partition part_03 values less than(maxvalue) tablespace dw1

   );

表已创建。

SQL>

SQL> insert into niegc_part values(1,to_date('2005-12-30','yyyy-mm-dd'),'less 20

06-01-01');

已创建 1 行。

SQL> commit;

提交完成。

SQL> insert into niegc_part values(2,to_date('2006-01-01','yyyy-mm-dd'),'equal 2

007-01-01');

已创建 1 行。

SQL> commit;

提交完成。

SQL> insert into niegc_part values(3,sysdate,'sysdate');

已创建 1 行。

SQL> commit;

提交完成。

SQL>

SQL>

SQL> select * from niegc_part partition(part_01);

   PART_ID PART_DATE  PART_DEC

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

         1 30-12月-05 less 2006-01-01

SQL>

相信只要对oracle 有点熟,都能知道上面的range分区的意思了.

两个字段以上的range分区大同小异,请看下面的例子:

create table niegc_part
(
part_id integer primary key,
part_date date,
part_dec varchar2(100)
)
partition by range(part_id,part_date)
(
partition part_01 values less than(1,to_date('2006-01-01','yyyy-mm-dd')) tablespace dw,
partition part_02 values less than(10,to_date('2007-01-01','yyyy-mm-dd')) tablespace dw,
partition part_03 values less than(maxvalue,maxvalue) tablespace dw
);
 

二、Hash分区（散列分区）。 散列分区通过指定分区编号来均匀分布数据的一种分区类型，因为通过在I/O设备上进行散列分区，使行这些分区大小一致。如将part_id的数据根据自身的情况散列地存放在指定的三个表空间中：

create table niegc_part

(

part_id integer primary key,

part_date date,

part_dec varchar2(100)

)

partition by hash(part_id)

(

partition part_01  tablespace dw1,

partition part_02  tablespace dw2

);

系统将按part_id将记录散列地插入三个分区中，这里也就是二个不同的表空间中。

三、复合分区。根据范围分区后，每个分区内的数据再散列地分布在几个表空间中，这样我们就要使用复合分区。复合分区是先使用范围分区，然后在每个分区同再使用散列分区的一种分区方法，如将part_date的记录按时间分区，然后每个分区中的数据分三个子分区，将数据散列地存储在三个指定的表空间中：

create table niegc_part

(

part_id integer primary key,

part_date date,

part_dec varchar2(100)

)

partition by range(part_date) subpartition by hash(part_id)

subpartitions 2 store in(dw1,dw2)

(

partition part_01 values less than(to_date('2006-01-01','yyyy-mm-dd')) tablespace dw1,

partition part_02 values less than(to_date('2007-01-01','yyyy-mm-dd')) tablespace dw2,

partition part_03 values less than(maxvalue) tablespace dw1

);

先根据part_date进行范围分区，然后根据交易的ID将记录散列地存储在二个表空间中。

四、索引分区：

注意： 对某个字段已做了分区了，是不允许再建立索引分区的。这一点要非常注意。
全局索引建立时global子句允许指定索引的范围值，这个范围值为索引字段的范围值：

create index idx_part_id on niegc_part(part_dec)

global partition by range(part_dec)

(

partition idx_1 values less than('1000') tablespace dw,

partition idx_2 values less than(maxvalue) tablespace dw

)

局部索引分区的建立：（注意：表必须存在分区，此分区的个数必须和分区表的分区个数一样，不然是建立不起来的）

create index idx_part_id on niegc_part(part_dec)

local

(

partition idx_1 tablespace dw1,

partition idx_2 tablespace dw2

)

五、分区维护：(只对范围分区)

（1）、增加一个分区：分区范围只能往上增，不能增加一个少于原有的分区：

alter table niegc_part add partition part_03 values less than(maxvalue)

（2）、合并分区：（合并后的分区必须指下最后一个大value的分区）

alter table niegc_part merge partitions part_02,part_03 into  partition part_03

（3）、删除一个分区：

alter table niegc_part drop partition part_01

分区维护：(只对范围分区)

　　（1）、增加一个分区：分区范围只能往上增，不能增加一个少于原有的分区：

　　alter table tablename add partition new_partitionname values less than(maxvalue)

　　（2）、合并/拆分分区：（合并后的分区必须指下最后一个大value的分区）

　　alter table tablename merge partitions partitionname1,partitionname2 into partition partitionname2;

　　alter table tablename split partition partitionname1 at (xx) into (

　　partition newpartition1 ,partition newpartition2) ;

　　注意：xx为分割点

　　（3）、删除一个分区：

　　alter table niegc_part drop partition partitionname;

　　(4)将分区改名

　　alter table table_name rename Partition partition_name to partition_name

　　(5)将分区改表空间

　　alter table table_name move partition_name

　　tablespace tablespace_name nologging

　　(6)查询特定分区

　　select count(*) from table_name partition (partition_name);

　　(7)添加数据

　　insert into table_name select * from table_name partition (partition_name)

　　(8)分区表的导出

　　userid=USER/PWD

　　buffer=102400

　　tables=table_name:partition_name,

　　file=E:exp_paraxxx.dmp

　　log=E:exp_paraxxx.log

　　(9)技巧：删除表中一个字段

　　alter table table_name set unused column column_name;

　　(10)加一个字段

　　alter table table_name add column_name number(1);  




http://www.cnblogs.com/rootq/archive/2008/12/24/1361631.html

-- Create table
create table ORACLEEXCEPTION
(
  ID          VARCHAR2(36),
  CREATETIME  DATE,
  SQLCODE1    NVARCHAR2(300),
  SQLERRM1    NVARCHAR2(300),
  MYEXCEPTION NVARCHAR2(100)
)
tablespace USERS
  pctfree 10
  initrans 1
  maxtrans 255
  storage
  (
    initial 64K
    minextents 1
    maxextents unlimited
  );

编写oracle--function：

create or replace function getabin(abin in varchar2)
return varchar2
is
result varchar2(50);
sqlcode2 nvarchar2(500):='';
sqlerrm2 nvarchar2(500):='';
myexception nvarchar2(500):='';
exception1 exception;
begin
if(abin is not null) then
select count(1) into result from bing1 t where t.name1 like abin;
return(result);
elsif(abin is null) then
result:='there is a defined exception';
raise exception1;
end if;

exception
when exception1 then
sqlcode2:=sqlcode;
sqlerrm2:=sqlerrm;
begin
insert into oracleexception(id,createtime,sqlcode1,sqlerrm1,myexception) values (sys_guid(),sysdate,sqlcode2,sqlerrm2,'exception1');
commit;
end;
return(result);
when others then
result:='there is a other exception';
sqlcode2:=sqlcode;
sqlerrm2:=sqlerrm;
begin
insert into oracleexception(id,createtime,sqlcode1,sqlerrm1,myexception) values (sys_guid(),sysdate,sqlcode2,sqlerrm2,'others');
commit;
end;
return(result);
end;

测试oracle--function代码：

declare 
ename varchar2(50):='';
result varchar2(50);
begin
result:=getabin(ename);
dbms_output.put_line(result);
end;

ORACLE PL/SQL编程之八：

把触发器说透
http://www.cnblogs.com/huyong/archive/2011/04/27/2030466.html