iLeichun

[oracle@localhost oracle]$ top
10:50:49 up 19:17, 3 users, load average: 4.77, 5.85, 6.58
135 processes: 132 sleeping, 2 running, 0 zombie, 1 stopped
CPU states: cpu user nice system irq softirq iowait idle
total 0.7% 0.0% 1.1% 0.5% 0.0% 97.4% 0.0%
Mem: 510432k av, 503788k used, 6644k free, 0k shrd, 1432k buff
345208k actv, 64068k in_d, 6964k in_c
Swap: 1052248k av, 238344k used, 813904k free 338432k cached

PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
4665 oracle 15 0 52032 49M 49784 D 0.3 10.0 0:04 0 oracle
5 root 15 0 0 0 0 SW 0.1 0.0 1:41 0 kswapd
6 root 16 0 0 0 0 SW 0.1 0.0 1:15 0 kscand
2912 oracle 15 0 47344 44M 45256 D 0.1 8.9 5:18 0 oracle
4482 oracle 15 0 58752 56M 56504 S 0.1 11.3 0:19 0 oracle
4486 oracle 15 0 98.7M 96M 97760 D 0.1 19.4 0:21 0 oracle
4768 oracle 15 0 736 736 440 S 0.1 0.1 0:07 0 top
4991 testcent 15 0 708 708 420 S 0.1 0.1 0:00 0 top
5020 oracle 15 0 944 944 664 R 0.1 0.1 0:00 0 top
1 root 15 0 116 80 56 S 0.0 0.0 0:04 0 init
2 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 keventd
3 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 kapmd
4 root 34 19 0 0 0 SWN 0.0 0.0 0:00 0 ksoftirqd/0
7 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 bdflush
8 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 kupdated
9 root 25 0 0 0 0 SW 0.0 0.0 0:00 0 mdrecoveryd
13 root 15 0 0 0 0 SW 0.0 0.0 0:01 0 kjournald
78 root 25 0 0 0 0 SW 0.0 0.0 0:00 0 khubd

由于早上导了十几万的数据进去,一直怀疑是表索引失效,做了以下数据库调整,并删除了运行时间很短的jobs,果然速度快了不少...以下是我的调整步骤

几个简单的步骤大幅提高Oracle性能--我优化数据库的三板斧
　　
　　数据库优化的讨论可以说是一个永恒的主题。资深的Oracle优化人员通常会要求提出性能问题的人对数据库做一个statspack，贴出数据库配置等等。还有的人认为要抓出执行最慢的语句来进行优化。但实际情况是，提出疑问的人很可能根本不懂执行计划，更不要说statspack了。而我认为，数据库优化，应该首先从大的方面考虑：网络、服务器硬件配置、操作系统配置、Oracle服务器配置、数据结构组织、然后才是具体的调整。实际上网络、硬件等往往无法决定更换，应用程序一般也无法修改，因此应该着重从数据库配置、数据结构上来下手，首先让数据库有一个良好的配置，然后再考虑具体优化某些过慢的语句。我在给我的用户系统进行优化的过程中，总结了一些基本的，简单易行的办法来优化数据库，算是我的三板斧，呵呵。不过请注意，这些不一定普遍使用，甚至有的会有副作用，但是对OLTP系统、基于成本的数据库往往行之有效，不妨试试。（注：附件是Burleson写的用来报告数据库性能等信息的脚本，本文用到）
　　
　　一．设置合适的SGA
　　
　　常常有人抱怨服务器硬件很好，但是Oracle就是很慢。很可能是内存分配不合理造成的。
　　
　　(1)假设内存有512M，这通常是小型应用。建议Oracle的SGA大约240M，其中：共享池（SHARED_POOL_SIZE）可以设置60M到80M，根据实际的用户数、查询等来定。数据块缓冲区可以大致分配120M-150M，8i下需要设置DB_BLOCK_BUFFERS，DB_BLOCK_BUFFER*DB_BLOCK_SIZE等于数据块缓冲区大小。9i 下的数据缓冲区可以用db_cache_size来直接分配。
　　
　　(2)假设内存有1G，Oracle 的SGA可以考虑分配500M：共享池分配100M到150M，数据缓冲区分配300M到400M。
　　
　　(3)内存2G，SGA可以考虑分配1.2G，共享池300M到500M，剩下的给数据块缓冲区。
　　
　　(4)内存2G以上：共享池300M到500M就足够啦，再多也没有太大帮助；(Biti_rainy有专述)数据缓冲区是尽可能的大，但是一定要注意两个问题：一是要给操作系统和其他应用留够内存，二是对于32位的操作系统，Oracle的SGA有1.75G的限制。有的32位操作系统上可以突破这个限制，方法还请看Biti的大作吧。
　　
　　二．分析表和索引，更改优化模式
　　
　　Oracle默认优化模式是CHOOSE，在这种情况下，如果表没有经过分析，经常导致查询使用全表扫描，而不使用索引。这通常导致磁盘I/O太多，而导致查询很慢。如果没有使用执行计划稳定性，则应该把表和索引都分析一下，这样可能直接会使查询速度大幅提升。分析表命令可以用ANALYZE TABLE 分析索引可以用ANALYZE INDEX命令。对于少于100万的表，可以考虑分析整个表，对于很大的表，可以按百分比来分析，但是百分比不能过低，否则生成的统计信息可能不准确。可以通过DBA_TABLES的LAST_ANALYZED列来查看表是否经过分析或分析时间，索引可以通过DBA_INDEXES的LAST_ANALYZED列。
　　
　　下面通过例子来说明分析前后的速度对比。（表CASE_GA_AJZLZ大约有35万数据，有主键）首先在SQLPLUS中打开自动查询执行计划功能。(第一次要执行RDBMSADMINutlxplan.sql来创建PLAN_TABLE这个表)
　　
　　SQL> SET AUTOTRACE ON
　　SQL>SET TIMING ON
　　
　　通过SET AUTOTRACE ON 来查看语句的执行计划，通过SET TIMING ON 来查看语句运行时间。
　　
　　SQL> select count(*) from CASE_GA_AJZLZ;
　　COUNT(*)
　　----------
　　346639
　　
　　已用时间: 00: 00: 21.38
　　
　　Execution Plan
　　----------------------------------------------------------
　　0 SELECT STATEMENT Optimizer=CHOOSE
　　1 0 SORT (AGGREGATE)
　　2 1 TABLE ACCESS (FULL) OF ¹CASE_GA_AJZLZ¹
　　……………………
　　
　　请注意上面分析中的TABLE ACCESS(FULL)，这说明该语句执行了全表扫描。而且查询使用了21.38秒。这时表还没有经过分析。下面我们来对该表进行分析：
　　
　　SQL> analyze table CASE_GA_AJZLZ compute statistics;
　　
　　表已分析。
　　
　　已用时间: 00: 05: 357.63
　　
　　然后再来查询：
　　
　　SQL> select count(*) from CASE_GA_AJZLZ;
　　COUNT(*)
　　----------
　　346639
　　
　　已用时间: 00: 00: 00.71
　　
　　Execution Plan
　　----------------------------------------------------------
　　0 SELECT STATEMENT Optimizer=FIRST_ROWS (Cost=351 Card=1)
　　1 0 SORT (AGGREGATE)
　　2 1 INDEX (FAST FULL SCAN) OF ¹PK_AJZLZ¹ (UNIQUE) (Cost=351
　　Card=346351)
　　…………………………
　　
　　请注意，这次时间仅仅用了0.71秒！这要归功于INDEX(FAST FULL SCAN)。通过分析表，查询使用了PK_AJZLZ索引，磁盘I/O大幅减少，速度也大幅提升！下面的实用语句可以用来生成分析某个用户的所有表和索引，假设用户是GAXZUSR：
　　
　　SQL> set pagesize 0
　　SQL> spool d:analyze_tables.sql;
　　SQL> select ¹analyze table ¹||owner||¹.¹||table_name||¹ compute statistics;¹ from dba_tables where owner=¹GAXZUSR¹;
　　SQL> spool off
　　SQL> spool spool d:analyze_indexes.sql;
　　SQL> select ¹analyze index ¹||owner||¹.¹||index_name||¹ compute statistics;¹ from dba_indexes where owner=¹GAXZUSR¹;
　　SQL> spool off
　　SQL> @d:analyze_tables.sql
　　SQL> @d:analyze_indexes.sql
　　
　　解释：上面的语句生成了两个sql文件，分别分析全部的GAXZUSR的表和索引。如果需要按照百分比来分析表，可以修改一下脚本。通过上面的步骤，我们就完成了对表和索引的分析，可以测试一下速度的改进啦。建议定期运行上面的语句，尤其是数据经过大量更新。
　　
　　当然，也可以通过dbms_stats来分析表和索引，更方便一些。但是我仍然习惯上面的方法，因为成功与否会直接提示出来。
　　
　　另外，我们可以将优化模式进行修改。optimizer_mode值可以是RULE、CHOOSE、FIRST_ROWS和ALL_ROWS。对于OLTP系统，可以改成FIRST_ROWS，来要求查询尽快返回结果。这样即使不用分析，在一般情况下也可以提高查询性能。但是表和索引经过分析后有助于找到最合适的执行计划。
　　
　　三．设置cursor_sharing=FORCE 或SIMILAR
　　
　　这种方法是8i才开始有的，oracle805不支持。通过设置该参数，可以强制共享只有文字不同的语句解释计划。例如下面两条语句可以共享：
　　
　　SQL> SELECT * FROM MYTABLE WHERE NAME=¹tom¹
　　SQL> SELECT * FROM MYTABLE WHERE NAME=¹turner¹
　　
　　这个方法可以大幅降低缓冲区利用率低的问题，避免语句重新解释。通过这个功能，可以很大程度上解决硬解析带来的性能下降的问题。个人感觉可根据系统的实际情况，决定是否将该参数改成FORCE。该参数默认是exact。不过一定要注意，修改之前，必须先给ORACLE打补丁，否则改之后oracle会占用100%的CPU,无法使用。对于ORACLE9i，可以设置成SIMILAR，这个设置综合了FORCE和EXACT的优点。不过请慎用这个功能，这个参数也可能带来很大的负面影响！
　　
　　四．将常用的小表、索引钉在数据缓存KEEP池中
　　
　　内存上数据读取速度远远比硬盘中读取要快，据称，内存中数据读的速度是硬盘的14000倍！如果资源比较丰富，把常用的小的、而且经常进行全表扫描的表给钉内存中，当然是在好不过了。可以简单的通过ALTER TABLE tablename CACHE来实现，在ORACLE8i之后可以使用ALTER TABLE table STORAGE(BUFFER_POOL KEEP)。一般来说，可以考虑把200数据块之内的表放在keep池中，当然要根据内存大小等因素来定。关于如何查出那些表或索引符合条件，可以使用本文提供的access.sql和access_report.sql。这两个脚本是著名的Oracle专家 Burleson写的，你也可以在读懂了情况下根据实际情况调整一下脚本。对于索引，可以通过ALTER INDEX indexname STORAGE(BUFFER_POOL KEEP)来钉在KEEP池中。
　　
　　将表定在KEEP池中需要做一些准备工作。对于ORACLE9i 需要设置DB_KEEP_CACHE_SIZE，对于8i，需要设置buffer_pool_keep。在8i中，还要修改db_block_lru_latches，该参数默认是1，无法使用buffer_pool_keep。该参数应该比2*3*CPU数量少，但是要大于1，才能设置DB_KEEP_CACHE_BUFFER。buffer_pool_keep从db_block_buffers中分配，因此也要小于db_block_buffers。设置好这些参数后，就可以把常用对象永久钉在内存里。
　　
　　五．设置optimizer_max_permutations
　　
　　对于多表连接查询，如果采用基于成本优化(CBO)，ORACLE会计算出很多种运行方案，从中选择出最优方案。这个参数就是设置oracle究竟从多少种方案来选择最优。如果设置太大，那么计算最优方案过程也是时间比较长的。Oracle805和8i默认是80000，8建议改成2000。对于9i，已经默认是2000了。
　　
　　六．调整排序参数
　　
　　(1) SORT_AREA_SIZE:默认的用来排序的SORT_AREA_SIZE大小是32K，通常显得有点小，一般可以考虑设置成1M（1048576）。这个参数不能设置过大，因为每个连接都要分配同样的排序内存。
　　
　　(2) SORT_MULTIBLOCK_READ_COUNT:增大这个参数可以提高临时表空间排序性能，该参数默认是2，可以改成32来对比一下排序查询时间变化。注意，这个参数的最大值与平台有关系。
　　
　　七．调整其它几个关键的性能参数
　　
　　很多人认为使用oracle数据库，系统的默认参数就是最好的，其实不是这样

hongmo086 发表于:2006.12.12 12:29 ::分类: ( oracle管理 ) ::阅读:(20次) :: 评论 (0) :: 引用 (0)
2006 年 11 月 23日, 星期四一些知识
2 不借助第三方工具，怎样查看sql的执行计划
I) 使用Explain Plan,查询PLAN_TABLE;
EXPLAIN PLAN
SET STATEMENT_ID=¹QUERY1¹
FOR
SELECT *
FROM a
WHERE aa=1;
commit;
SELECT operation, options, object_name, object_type, ID, parent_id
FROM plan_table
WHERE STATEMENT_ID = ¹QUERY1¹
ORDER BY ID;

II)SQLPLUS中的SET TRACE 即可看到Execution Plan Statistics
SET AUTOTRACE ON;

3:如何使用CBO,CBO与RULE的区别
IF 初始化参数 OPTIMIZER_MODE = CHOOSE THEN --(8I DEFAULT)
IF 做过表分析
THEN 优化器 Optimizer=CBO(COST); /*高效*/
ELSE
优化器 Optimizer=RBO(RULE); /*高效*/
END IF;
END IF;

区别：
RBO根据规则选择最佳执行路径来运行查询。
CBO根据表统计找到最低成本的访问数据的方法确定执行计划。
使用CBO需要注意：
I) 需要经常对表进行ANALYZE命令进行分析统计;
II) 需要稳定执行计划;
III)需要使用提示(Hint);

hongmo086 发表于:2006.11.23 13:22 ::分类: ( oracle管理 ) ::阅读:(122次) :: 评论 (0) :: 引用 (0)
2006 年 11 月 16日, 星期四如何启动ARCHIVELOG模式
系统环境：
1、操作系统：Windows 2000 Server，机器内存128M
2、数据库：　Oracle 8i R2 (8.1.6) for NT 企业版
3、安装路径：C:ORACLE

实现步骤：

1、管理器
SVRMGR> connect internal
SVRMGR> shutdown
SVRMGR> startup mount [dbname]
SVRMGR> alter database [dbname] archivelog; --起用归档模式
SVRMGR> archive log start --启动自动归档模式，重起数据库后，按init.ora配置
SVRMGR> alter database [dbname] open; --打开数据库
SVRMGR> exit

2、修改数据库初始化参数文件，定义归档模式（自动）、归档日志文件保存路径、归档日志文件命名方法

3、重新启动数据库

具体实例：

C:>svrmgrl

Oracle Server Manager Release 3.1.6.0.0 - Production

版权所有 (c) 1997，1999，Oracle Corporation。保留所有权利。

Oracle8i Enterprise Edition Release 8.1.6.0.0 - Production
With the Partitioning option
JServer Release 8.1.6.0.0 - Production

SVRMGR> connect internal
连接成功。
SVRMGR> shutdown
已关闭数据库。
已卸下数据库。
已关闭 ORACLE 实例。
SVRMGR> startup mount
已启动 ORACLE 实例。
系统全局区域合计有 57124108个字节
Fixed Size 70924个字节
Variable Size 40198144个字节
Database Buffers 16777216个字节
Redo Buffers 77824个字节
已装入数据库。
SVRMGR> alter database archivelog;
语句已处理。
SVRMGR> archive log start
语句已处理。
SVRMGR> alter database open;
语句已处理。
SVRMGR> alter system switch logfile; --强制系统进行日志切换，可马上观察到归档日志的产生
语句已处理。
SVRMGR> exit
服务器管理程序结束。

修改数据库参数文件c:oracleadminoradbpfileinit.ora，
取消以下语句的#注释
log_archive_start = true
log_archive_dest_1 = "location=C:Oracleoradataoradbarchive"
log_archive_format = %%ORACLE_SID%%T%TS%S.ARC
关闭数据库，重新启动

查看C:Oracleoradataoradbarchive目录下，可以看到类似ORADBT001S01201.ARC的文件，说明归档成功

解释init.ora参数文件中关于归档重做日志参数项的含义

归档模式是自动还是手工，true为自动，false为手工
log_archive_start = true

归档日志文件所保存的路径
log_archive_dest_1 = "location=C:Oracleoradataoradbarchive"

归档日志文件的命名方法
log_archive_format = %%ORACLE_SID%%T%TS%S.ARC

归档命令：

启动自动归档模式，系统重起后，将按init.ora中的参数log_archive_start的值设置归档方式
SVRMGR> archive log start

启动手工归档模式
SVRMGR> archive log stop

查看归档信息：重做日志是否归档方式、是自动归档还是手工归档、归档路径、最旧的联机日志循序号...
SVRMGR> archive log list

归档一个已满，但没有归档的联机重做日志
SVRMGR> archive log next

归档所有已满，但没有归档的联机重做日志
SVRMGR> archive log all

注意：一个事务即使不被提交，也会被写入到重做日志中

实际上，对于特定的环境，总是存在不同的最优设置的，没有任何一种普遍使用的最优方案。对于设置这个参数，那仅仅是出于一个目的，避免过度的犯错误。事实上，在任何一个生产系统正式投入使用之前，我们不拥有任何系统运行信息让我们去调整，这样只有两种可能，一是根据文档推荐设置，另外一种就是根据经验设置。相对来说，根据经验根据的设置比根据文档的设置要可靠一些。尤其是那些7×24的系统，我们更要减少错误的发生。
在设置参数之前，先看下面几个问题

1.物理内存多大
2.操作系统估计需要使用多少内存
3.数据库是使用文件系统还是裸设备
4.估计系统会有多少并发数
 根据这几个问题的答案，我们可以粗略地为系统估计一下内存设置。那我们现在来逐个问题讨论。
 首先物理内存多大是最容易回答的一个问题。
 然后操作系统估计使用多少内存呢？从经验上来看，不会太多，通常应该在300M以内(不包含大量进程PCB).
 接下来我们要讨论一个重要的问题，那就是关于文件系统和裸设备的问题，这往往容易备我们所忽略。操作系统对于文件系统，使用了大量的buffer来缓存操作系统块。这样当数据库获取数据块的时候，虽然在SGA里没有命中，但却实际上可能是操作系统的文件缓存中获取的。而假如数据库和操作系统支持异步I/O，则实际上当数据库写进程DBWR写磁盘时，操作系统在文件缓存中标记该块为延迟写，等到真正地写入磁盘后，操作系统才通知DBWR写磁盘完成。对于这部分文件缓存，所需要的内存可能比较大，作为保守的估计，我们应该考虑在0.2－0.3倍内存大小。但是如果我们使用的是裸设备，则不考虑这部分缓存问题。这样的情况下SGA就有调大的机会。
 关于数据库有多少并发数，这实际上关系到PGA的大小(MTS下还有large_pool_size).相关的参数包括：
SQL> show parameter area_size
 
NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
bitmap_merge_area_size               integer     1048576
create_bitmap_area_size              integer     8388608
hash_area_size                       integer     16777216
sort_area_size                       integer     8388608
在这部分内存中我们最关注的通常是sort_area_size，这是当查询需要排序的时候，数据库会话将使用这部分内存进行排序，当内存大小不足的时候，使用临时表空间进行磁盘排序。由于磁盘排序效率和内存排序效率相差好几个数量级，所以这个参数的设置很重要。这四个参数都是针对会话进行设置的，是单个会话使用内存的大小，而不是整个数据库使用的。
根据上面这些参数，我们看一个公式：
OS使用内存+SGA+*并发进程数(sort_area_size+hash_area_size+2M)<07*总内存
(公式是死的，系统是活的，实际应用的调整不必框公式，不过是一个参考建议罢了)
SGA内参数设置

Log_buffer
对于日志缓冲区的大小设置，通常我觉得没有过多的建议，以为参考LGWR写的触发条件之后，我们会发现通常超过3M意义不是很大。作为一个正式系统，可能考虑先设置这部分为Log_buffer＝1－3M大小，然后针对具体的情况再做调整。
large_pool_size
对于大型缓冲池的设置，假如我们不使用MTS，建议在20－30M就够了。这部分主要是来保存并行查询时候的一些信息，还有就是RMAN在备份的时候可能会使用到。
java_pool_size
假如数据库没有使用java，我们通常认为保留10－20M大小就足够了。事实上可以更少，但具体根据安装数据库的时候的组件相关(比如 http server).
shared_pool_size
在一个充分使用绑定变量的比较大的系统中，shared_pool_size的开销通常应该维持在300M以内。除非系统使用了大量的存储过程、函数、包，比如oracle erp这样的应用，可以到达500M甚至更高。假定一个1G内存的系统，可考虑该参数设置为100M，2G的系统考虑设置为150M，8G的系统可以考虑设置为200－300M。当然，如果通过在操作系统监控，没有发现严重的cpu问题，而发现了共享池命中率不高可以适当的增加shared_pool_size。但是不主张这部分内存超过800M。

data_buffer
现在我们来谈数据缓冲区，在确定了SGA的大小并分配完了前面部分的内存后，其余的都分配给这部分内存。通常，在允许的情况下，我们都尝试使得这部分内存更大。这部分内存的作用主要是缓存在DB BLOCK，减少甚至避免从磁盘上获取数据。如果设置了buffer_pool_keep和buffer_pool_recycle，则应该加上后面这两部分内存的大小。
 

查询 
    SELECT语句用于从数据库中查询数据，当在PL/SQL中使用SELECT语句时，要与INTO子句一起使用，查询的返回值被赋予INTO子句中的变量，变量的声明是在DELCARE中。SELECT             INTO语法如下： 
     SELECT [DISTICT|ALL]{*|column[,column,...]} 
     INTO (variable[,variable,...] |record) 
     FROM {table|(sub-query)}[alias] 
     WHERE............ 
    PL/SQL中SELECT语句只返回一行数据。如果超过一行数据，那么就要使用显式游标（对游标的讨论我们将在后面进行），INTO子句中要有与SELECT子句中相同列数量的变量。INTO子句中也可以是记录变量。 

%TYPE属性 
     在PL/SQL中可以将变量和常量声明为内建或用户定义的数据类型，以引用一个列名，同时继承他的数据类型和大小。这种动态赋值方法是非常有用的，比如变量引用的列的数据类型和大小改变了，如果使用了%TYPE,那么用户就不必修改代码，否则就必须修改代码。 

例： 
  v_empno SCOTT.EMP.EMPNO%TYPE; 
  v_salary EMP.SALARY%TYPE; 
  　不但列名可以使用%TYPE,而且变量、游标、记录，或声明的常量都可以使用%TYPE。这对于定义相同数据类型的变量非常有用。 
    DELCARE 
    V_A NUMBER(5):=10; 
    V_B V_A%TYPE:=15; 
    V_C V_A%TYPE; 
    BEGIN 
      DBMS_OUTPUT.PUT_LINE 
      (¹V_A=¹||V_A||¹V_B=¹||V_B||¹V_C=¹||V_C); 
    END 
    
    SQL>;/ 
    V_A=10 V_B=15 V_C= 
     PL/SQL procedure successfully completed. 
     SQL>; 
     
其他DML语句 
    其它操作数据的DML语句是:INSERT、UPDATE、DELETE和LOCK TABLE,这些语句在PL/SQL中的语法与在SQL中的语法相同。我们在前面已经讨论过DML语句的使用这里就不再重复了。在DML语句中可以使用任何在DECLARE部分声明的变量，如果是嵌套块，那么要注意变量的作用范围。 

例： 
  CREATE OR REPLACE PROCEDURE FIRE_EMPLOYEE (pempno in number) 
  　AS 
    v_ename EMP.ENAME%TYPE; 
    BEGIN 
    　SELECT ename INTO v_ename 
      FROM emp 
      WHERE empno=p_empno; 
      INSERT INTO FORMER_EMP(EMPNO,ENAME) 
      VALUES (p_empno,v_ename); 
      DELETE FROM emp 
      WHERE empno=p_empno; 
      UPDATE former_emp 
      SET date_deleted=SYSDATE 
      WHERE empno=p_empno; 
      
    EXCEPTION 
       WHEN NO_DATA_FOUND THEN 
       DBMS_OUTPUT.PUT_LINE(¹Employee Number Not Found!¹); 
    END 

DML语句的结果 
    当执行一条DML语句后，DML语句的结果保存在四个游标属性中，这些属性用于控制程序流程或者了解程序的状态。当运行DML语句时，PL/SQL打开一个内建游标并处理结果，游标是维护查询结果的内存中的一个区域，游标在运行DML语句时打开，完成后关闭。隐式游标只使用SQL%FOUND,SQL%NOTFOUND,SQL%ROWCOUNT三个属性.SQL%FOUND,SQL%NOTFOUND是布尔值，SQL%ROWCOUNT是整数值。 

SQL%FOUND和SQL%NOTFOUND 
    在执行任何DML语句前SQL%FOUND和SQL%NOTFOUND的值都是NULL,在执行DML语句后，SQL%FOUND的属性值将是： 

. TRUE :INSERT 
. TRUE :DELETE和UPDATE，至少有一行被DELETE或UPDATE. 
. TRUE :SELECT INTO至少返回一行 
当SQL%FOUND为TRUE时,SQL%NOTFOUND为FALSE。 

SQL%ROWCOUNT 
   在执行任何DML语句之前，SQL%ROWCOUNT的值都是NULL,对于SELECT             INTO语句，如果执行成功，SQL%ROWCOUNT的值为1,如果没有成功，SQL%ROWCOUNT的值为0，同时产生一个异常NO_DATA_FOUND. 

SQL%ISOPEN 
  SQL%ISOPEN是一个布尔值，如果游标打开，则为TRUE, 如果游标关闭，则为FALSE.对于隐式游标而言SQL%ISOPEN总是FALSE，这是因为隐式游标在DML语句执行时打开，结束时就立即关闭。 

事务控制语句 
    事务是一个工作的逻辑单元可以包括一个或多个DML语句，事物控制帮助用户保证数据的一致性。如果事务控制逻辑单元中的任何一个DML语句失败，那么整个事务都将回滚，在PL/SQL中用户可以明确地使用COMMIT、ROLLBACK、SAVEPOINT以及SET TRANSACTION语句。 
     COMMIT语句终止事务，永久保存数据库的变化，同时释放所有LOCK,ROLLBACK终止现行事务释放所有LOCK，但不保存数据库的任何变化,SAVEPOINT用于设置中间点，当事务调用过多的数据库操作时，中间点是非常有用的，SET TRANSACTION用于设置事务属性，比如read-write和隔离级等。 

显式游标 
    当查询返回结果超过一行时，就需要一个显式游标，此时用户不能使用select into语句。PL/SQL管理隐式游标，当查询开始时隐式游标打开，查询结束时隐式游标自动关闭。显式游标在PL/SQL块的声明部分声明，在执行部分或异常处理部分打开，取数据,关闭。 

使用游标 
    这里要做一个声明，我们所说的游标通常是指显式游标，因此从现在起没有特别指明的情况，我们所说的游标都是指显式游标。要在程序中使用游标，必须首先声明游标。 

声明游标 
语法： 
    CURSOR cursor_name IS select_statement; 

在PL/SQL中游标名是一个未声明变量，不能给游标名赋值或用于表达式中。 

例： 
    DELCARE 
    CURSOR C_EMP IS SELECT empno,ename,salary 
    FROM emp 
    WHERE salary>;2000 
    ORDER BY ename; 
    ........ 
    BEGIN 
    在游标定义中SELECT语句中不一定非要表可以是视图，也可以从多个表或视图中选择的列，甚至可以使用*来选择所有的列 。 
    
打开游标 
使用游标中的值之前应该首先打开游标，打开游标初始化查询处理。打开游标的语法是： 
    OPEN cursor_name 
       cursor_name是在声明部分定义的游标名。 
    
例： 
     OPEN C_EMP; 
        
关闭游标 
语法： 
     CLOSE cursor_name 
    
例： 
     CLOSE C_EMP; 

从游标提取数据 
    从游标得到一行数据使用FETCH命令。每一次提取数据后，游标都指向结果集的下一行。语法如下： 
     FETCH cursor_name INTO variable[,variable,...] 
     对于SELECT定义的游标的每一列，FETCH变量列表都应该有一个变量与之相对应，变量的类型也要相同。 

例： 
   SET SERVERIUTPUT ON 
   DECLARE 
     v_ename EMP.ENAME%TYPE; 
     v_salary EMP.SALARY%TYPE; 
     CURSOR c_emp IS SELECT ename,salary FROM emp; 
     BEGIN 
       OPEN c_emp; 
          FETCH c_emp INTO v_ename,v_salary; 
            DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary); 
          FETCH c_emp INTO v_ename,v_salary; 
            DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary); 
          FETCH c_emp INTO v_ename,v_salary; 
            DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary); 
       CLOSE c_emp; 
     END 
     
    这段代码无疑是非常麻烦的，如果有多行返回结果，可以使用循环并用游标属性为结束循环的条件，以这种方式提取数据，程序的可读性和简洁性都大为提高，下面我们使用循环重新写上面的程序： 
SET SERVERIUTPUT ON 
DECLARE 
v_ename EMP.ENAME%TYPE; 
v_salary EMP.SALARY%TYPE; 
CURSOR c_emp IS SELECT ename,salary FROM emp; 
BEGIN 
  OPEN c_emp; 
    LOOP 
      FETCH c_emp INTO v_ename,v_salary; 
      EXIT WHEN c_emp%NOTFOUND; 
      DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary); 
END 

记录变量 
    定义一个记录变量使用TYPE命令和%ROWTYPE，关于%ROWsTYPE的更多信息请参阅相关资料。 
    记录变量用于从游标中提取数据行，当游标选择很多列的时候，那么使用记录比为每列声明一个变量要方便得多。 
    当在表上使用%ROWTYPE并将从游标中取出的值放入记录中时，如果要选择表中所有列，那么在SELECT子句中使用*比将所有列名列出来要安全得多。 

例： 
SET SERVERIUTPUT ON 
DECLARE 
R_emp EMP%ROWTYPE; 
CURSOR c_emp IS SELECT * FROM emp; 
BEGIN 
  OPEN c_emp; 
   LOOP 
     FETCH c_emp INTO r_emp; 
     EXIT WHEN c_emp%NOTFOUND; 
     DBMS_OUT.PUT.PUT_LINE(¹Salary of Employee¹||r_emp.ename||¹is¹|| r_emp.salary); 
   END LOOP; 
  CLOSE c_emp; 
END; 

%ROWTYPE也可以用游标名来定义，这样的话就必须要首先声明游标： 

SET SERVERIUTPUT ON 
DECLARE 
CURSOR c_emp IS SELECT ename,salary FROM emp; 
R_emp c_emp%ROWTYPE; 
BEGIN 
 OPEN c_emp; 
  LOOP 
    FETCH c_emp INTO r_emp; 
    EXIT WHEN c_emp%NOTFOUND; 
    DBMS_OUT.PUT.PUT_LINE(¹Salary of Employee¹||r_emp.ename||¹is¹|| r_emp.salary); 
  END LOOP; 
 CLOSE c_emp; 
END; 

带参数的游标 
    与存储过程和函数相似，可以将参数传递给游标并在查询中使用。这对于处理在某种条件下打开游标的情况非常有用。它的语法如下： 

CURSOR cursor_name[(parameter[,parameter],...)] IS select_statement; 

定义参数的语法如下： 
   Parameter_name [IN] data_type[{:=|DEFAULT} value] 

　 与存储过程不同的是，游标只能接受传递的值，而不能返回值。参数只定义数据类型，没有大小。 
   另外可以给参数设定一个缺省值，当没有参数值传递给游标时，就使用缺省值。游标中定义的参数只是一个占位符，在别处引用该参数不一定可靠。 

在打开游标时给参数赋值，语法如下： 

OPEN cursor_name[value[,value]....]; 
参数值可以是文字或变量。 

例： 
DECALRE 
CURSOR c_dept IS SELECT * FROM dept ORDER BY deptno; 
CURSOR c_emp (p_dept VARACHAR2) IS 
  SELECT ename,salary 
  FROM emp 
  WHERE deptno=p_dept 
  ORDER BY ename 
r_dept DEPT%ROWTYPE; 
v_ename EMP.ENAME%TYPE; 
v_salary EMP.SALARY%TYPE; 
v_tot_salary EMP.SALARY%TYPE; 
BEGIN 
  OPEN c_dept; 
     LOOP 
        FETCH c_dept INTO r_dept; 
        EXIT WHEN c_dept%NOTFOUND; 
        DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname); 
        v_tot_salary:=0; 
        OPEN c_emp(r_dept.deptno); 
            LOOP 
               FETCH c_emp INTO v_ename,v_salary; 
               EXIT WHEN c_emp%NOTFOUND; 
               DBMS_OUTPUT.PUT_LINE(¹Name:¹|| v_ename||¹ salary:¹||v_salary); 
               v_tot_salary:=v_tot_salary+v_salary; 
            END LOOP; 
        CLOSE c_emp; 
        DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary); 
     END LOOP; 
  CLOSE c_dept; 
END; 

游标FOR循环 
在大多数时候我们在设计程序的时候都遵循下面的步骤： 
1、打开游标 
2、开始循环 
3、从游标中取值 
4、检查那一行被返回 
5、处理 
6、关闭循环 
7、关闭游标 
    可以简单的把这一类代码称为游标用于循环。但还有一种循环与这种类型不相同，这就是FOR循环，用于FOR循环的游标按照正常的声明方式声明，它的优点在于不需要显式的打开、关闭、取数据，测试数据的存在、定义存放数据的变量等等。游标FOR循环的语法如下： 

FOR record_name IN 
 (corsor_name[(parameter[,parameter]...)] 
 | (query_difinition) 
LOOP 
  statements 
END LOOP; 

下面我们用for循环重写上面的例子： 
DECALRE 
CURSOR c_dept IS SELECT deptno,dname FROM dept ORDER BY deptno; 
CURSOR c_emp (p_dept VARACHAR2) IS 
 SELECT ename,salary 
 FROM emp 
 WHERE deptno=p_dept 
 ORDER BY ename 
v_tot_salary EMP.SALARY%TYPE; 
BEGIN 
   FOR r_dept IN c_dept LOOP 
     DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname); 
     v_tot_salary:=0; 
     FOR r_emp IN c_emp(r_dept.deptno) LOOP 
    DBMS_OUTPUT.PUT_LINE(¹Name:¹ || v_ename || ¹salary:¹ || v_salary);  
    v_tot_salary:=v_tot_salary+v_salary; 
     END LOOP; 
     DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary); 
  END LOOP; 
END; 

在游标FOR循环中使用查询 
    在游标FOR循环中可以定义查询，由于没有显式声明所以游标没有名字，记录名通过游标查询来定义。 
DECALRE 
 v_tot_salary EMP.SALARY%TYPE; 
BEGIN 
  FOR r_dept IN (SELECT deptno,dname FROM dept ORDER BY deptno) LOOP 
     DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname); 
     v_tot_salary:=0; 
     FOR r_emp IN (SELECT ename,salary 
            　　　FROM emp 
            　　　WHERE deptno=p_dept 
            　　　ORDER BY ename) LOOP 
       DBMS_OUTPUT.PUT_LINE(¹Name:¹|| v_ename||¹ salary:¹||v_salary); 
       v_tot_salary:=v_tot_salary+v_salary; 
     END LOOP; 
  DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary); 
  END LOOP; 
END; 

游标中的子查询 
    语法如下： 
    
CURSOR C1 IS SELECT * FROM emp 
  WHERE deptno NOT IN (SELECT deptno 
   FROM dept 
   WHERE dname!=¹ACCOUNTING¹); 
可以看出与SQL中的子查询没有什么区别。 

游标中的更新和删除 
    在PL/SQL中依然可以使用UPDATE和DELETE语句更新或删除数据行。显式游标只有在需要获得多行数据的情况下使用。PL/SQL提供了仅仅使用游标就可以执行删除或更新记录的方法。 
UPDATE或DELETE语句中的WHERE CURRENT OF子串专门处理要执行UPDATE或DELETE操作的表中取出的最近的数据。要使用这个方法，在声明游标时必须使用FOR UPDATE子串，当对话使用FOR UPDATE子串打开一个游标时，所有返回集中的数据行都将处于行级（ROW-LEVEL)独占式锁定，其他对象只能查询这些数据行，不能进行UPDATE、DELETE或SELECT...FOR            UPDATE操作。 

语法： 
    FOR UPDATE [OF [schema.]table.column[,[schema.]table.column].. 
    [nowait] 
    
    在多表查询中，使用OF子句来锁定特定的表,如果忽略了OF子句，那么所有表中选择的数据行都将被锁定。如果这些数据行已经被其他会话锁定，那么正常情况下ORACLE将等待，直到数据行解锁。 

在UPDATE和DELETE中使用WHERE CURRENT OF子串的语法如下： 

WHERE{CURRENT OF cursor_name|search_condition} 

例： 
DELCARE 
CURSOR c1 IS SELECT empno,salary 
 FROM emp 
 WHERE comm IS NULL 
 FOR UPDATE OF comm; 
v_comm NUMBER(10,2); 
BEGIN 
   FOR r1 IN c1 LOOP 
     IF r1.salary<500 THEN 
       v_comm:=r1.salary*0.25; 
     ELSEIF r1.salary<1000 THEN 
       v_comm:=r1.salary*0.20; 
     ELSEIF r1.salary<3000 THEN 
       v_comm:=r1.salary*0.15; 
     ELSE 
         v_comm:=r1.salary*0.12; 
     END IF; 
   UPDATE emp; 
   SET comm=v_comm 
   WHERE CURRENT OF c1l; 
   END LOOP; 
END

从游标提取数据
   从游标得到一行数据使用FETCH命令。每一次提取数据后，游标都指向结果集的下一行。语法如下：
   FETCH cursor_name INTO variable[,variable,...]
   对于SELECT定义的游标的每一列，FETCH变量列表都应该有一个变量与之相对应，变量的类型也要相同。

例：
   SET SERVERIUTPUT ON
   DECLARE
   v_ename EMP.ENAME%TYPE;
   v_salary EMP.SALARY%TYPE;
   CURSOR c_emp IS SELECT ename,salary FROM emp;
   BEGIN
     OPEN c_emp;
       FETCH c_emp INTO v_ename,v_salary;
         DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary);
       FETCH c_emp INTO v_ename,v_salary;
         DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary);
       FETCH c_emp INTO v_ename,v_salary;
         DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary);
     CLOSE c_emp;
   END
    
   这段代码无疑是非常麻烦的，如果有多行返回结果，可以使用循环并用游标属性为结束循环的条件，以这种方式提取数据，程序的可读性和简洁性都大为提高，下面我们使用循环重新写上面的程序：
 SET SERVERIUTPUT ON
 DECLARE
 v_ename EMP.ENAME%TYPE;
 v_salary EMP.SALARY%TYPE;
 CURSOR c_emp IS SELECT ename,salary FROM emp;
 BEGIN
 OPEN c_emp;
   LOOP
     FETCH c_emp INTO v_ename,v_salary;
     EXIT WHEN c_emp%NOTFOUND;
     DBMS_OUTPUT.PUT_LINE(¹Salary of Employee¹|| v_ename ||¹is¹|| v_salary);
 END

 记录变量
   定义一个记录变量使用TYPE命令和%ROWTYPE，关于%ROWsTYPE的更多信息请参阅相关资料。
   记录变量用于从游标中提取数据行，当游标选择很多列的时候，那么使用记录比为每列声明一个变量要方便得多。
   当在表上使用%ROWTYPE并将从游标中取出的值放入记录中时，如果要选择表中所有列，那么在SELECT子句中使用*比将所有列名列出来要得多。

例：
 SET SERVERIUTPUT ON
 DECLARE
 R_emp EMP%ROWTYPE;
 CURSOR c_emp IS SELECT * FROM emp;
 BEGIN
 OPEN c_emp;
   LOOP
   FETCH c_emp INTO r_emp;
   EXIT WHEN c_emp%NOTFOUND;
   DBMS_OUT.PUT.PUT_LINE(¹Salary of Employee¹||r_emp.ename||¹is¹|| r_emp.salary);
   END LOOP;
 CLOSE c_emp;
 END;

%ROWTYPE也可以用游标名来定义，这样的话就必须要首先声明游标：

SET SERVERIUTPUT ON
 DECLARE
 CURSOR c_emp IS SELECT ename,salary FROM emp;
 R_emp c_emp%ROWTYPE;
 BEGIN
 OPEN c_emp;
 LOOP
   FETCH c_emp INTO r_emp;
   EXIT WHEN c_emp%NOTFOUND;
   DBMS_OUT.PUT.PUT_LINE(¹Salary of Employee¹||r_emp.ename||¹is¹|| r_emp.salary);
 END LOOP;
 CLOSE c_emp;
 END;

 带参数的游标
   与存储过程和函数相似，可以将参数传递给游标并在查询中使用。这对于处理在某种条件下打开游标的情况非常有用。它的语法如下：

CURSOR cursor_name[(parameter[,parameter],...)] IS select_statement;

定义参数的语法如下：
   Parameter_name [IN] data_type[{:=|DEFAULT} value]

　　与存储过程不同的是，游标只能接受传递的值，而不能返回值。参数只定义数据类型，没有大小。
 　　另外可以给参数设定一个缺省值，当没有参数值传递给游标时，就使用缺省值。游标中定义的参数只是一个占位符，在别处引用该参数不一定可靠。

在打开游标时给参数赋值，语法如下：

OPEN cursor_name[value[,value]....];
 参数值可以是文字或变量。

例：
 DECALRE
 CURSOR c_dept IS SELECT * FROM dept ORDER BY deptno;
 CURSOR c_emp (p_dept VARACHAR2) IS
 SELECT ename,salary
 FROM emp
 WHERE deptno=p_dept
 ORDER BY ename
 r_dept DEPT%ROWTYPE;
 v_ename EMP.ENAME%TYPE;
 v_salary EMP.SALARY%TYPE;
 v_tot_salary EMP.SALARY%TYPE;
 BEGIN
 OPEN c_dept;
   LOOP
     FETCH c_dept INTO r_dept;
     EXIT WHEN c_dept%NOTFOUND;
     DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname);
     v_tot_salary:=0;
     OPEN c_emp(r_dept.deptno);
         LOOP
           FETCH c_emp INTO v_ename,v_salary;
           EXIT WHEN c_emp%NOTFOUND;
           DBMS_OUTPUT.PUT_LINE(¹Name:¹|| v_ename||¹ salary:¹||v_salary);
           v_tot_salary:=v_tot_salary+v_salary;
         END LOOP;
     CLOSE c_emp;
     DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary);
   END LOOP;
 CLOSE c_dept;
 END;

 游标FOR循环
 在大多数时候我们在设计程序的时候都遵循下面的步骤：
 1、打开游标
 2、开始循环
 3、从游标中取值
 那一行被返回
 5、处理
 6、关闭循环
 7、关闭游标
   可以简单的把这一类代码称为游标用于循环。但还有一种循环与这种类型不相同，这就是FOR循环，用于FOR循环的游标按照正常的声明方式声明，它的优点在于不需要显式的打开、关闭、取数据，测试数据的存在、定义存放数据的变量等等。游标FOR循环的语法如下：

FOR record_name IN
 (corsor_name[(parameter[,parameter]...)]
 | (query_difinition)
 LOOP
 statements
 END LOOP;

下面我们用for循环重写上面的例子：
 DECALRE
 CURSOR c_dept IS SELECT deptno,dname FROM dept ORDER BY deptno;
 CURSOR c_emp (p_dept VARACHAR2) IS
 SELECT ename,salary
 FROM emp
 WHERE deptno=p_dept
 ORDER BY ename
 v_tot_salary EMP.SALARY%TYPE;
 BEGIN
   FOR r_dept IN c_dept LOOP
   DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname);
   v_tot_salary:=0;
   FOR r_emp IN c_emp(r_dept.deptno) LOOP
   DBMS_OUTPUT.PUT_LINE(¹Name:¹ || v_ename || ¹salary:¹ || v_salary);  
   v_tot_salary:=v_tot_salary+v_salary;
   END LOOP;
   DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary);
 END LOOP;
 END;

在游标FOR循环中使用查询
  在游标FOR循环中可以定义查询，由于没有显式声明所以游标没有名字，记录名通过游标查询来定义。
 DECALRE
 v_tot_salary EMP.SALARY%TYPE;
 BEGIN
 FOR r_dept IN (SELECT deptno,dname FROM dept ORDER BY deptno) LOOP
   DBMS_OUTPUT.PUT_LINE(¹Department:¹|| r_dept.deptno||¹-¹||r_dept.dname);
   v_tot_salary:=0;
   FOR r_emp IN (SELECT ename,salary
         　　　FROM emp
         　　　WHERE deptno=p_dept
         　　　ORDER BY ename) LOOP
     DBMS_OUTPUT.PUT_LINE(¹Name:¹|| v_ename||¹ salary:¹||v_salary);
     v_tot_salary:=v_tot_salary+v_salary;
   END LOOP;
 DBMS_OUTPUT.PUT_LINE(¹Toltal Salary for dept:¹|| v_tot_salary);
 END LOOP;
 END;

游标中的子查询
   语法如下：
  
 CURSOR C1 IS SELECT * FROM emp
 WHERE deptno NOT IN (SELECT deptno
   FROM dept
   WHERE dname!=¹ACCOUNTING¹);
 可以看出与SQL中的子查询没有什么区别。

　　在学习Oracle中，我们使用SQL和ODBC链接进行数据插入，单独插入少量数据时，没有问题。但是在插入大量数据时，就会出现异常，内存溢出错误。

　　如何解决在进行大量数据插入时，java程序能够有效快速的进行数据处理。这就是数据库中性能优化的问题。

　　为什么要进行性能优化。

　　首先，在大量数据处理中 一般常规的方式会造成程序处理效率和时间低下。达不到产品上线要求。

　　其次，没有性能优化在产品维护时也会出现很多错误，带来麻烦。

　　如何进行性能优化。

　　一般软件都会进行大量数据测试，对性能做个整体评估，然后找出最好的方法来编写需要的代码。

　　同时再次进行测试达到最佳的性能点。

　　对于Oracle大量数据插入的性能优化我们采用如下方法进行

　　先采用常规方式编写代码，如在放入数据时就直接使用list接口方法进行。

　　插入数据中不进行批处理使用。

　　发现，在插入10万数据中 内存溢出，而且数据库使用时间非常长。

　　于是，我们先采用数据库批处理命令 采用每1000条数据再进行一次提交

　　使用addBAEACH 方法，和excutbeach 方法来处理

　　代码为

　　ps.addBatch();

　　if(i!=0&&i%10000==0) {

　　ps.executeBatch();

　　con.commit();

　　ps.clearBatch();

　　}

　　同时也使用预编译语句进行插入。

　　但是在仍然不能解决虚拟机内存溢出问题

　　于是我们使用

　　String[] fileList = new File(uploadDir).list();

　　ArrayList array = new ArrayList;

　　array.clear();

　　来解决读取文件后如何放入数据库中再使用SQL语句进行插入。

　　经过反复测试。最后找到最优点。在插入100万数据情况下 每次1万条数据提交。性能最优。

　　9月25日消息，为帮助企业以更低成本保护数据隐私，甲骨文公司在2010旧金山甲骨文全球大会上宣布，针对在具有Intel 高级加密标准新指令（Intel AES-NI）的Intel® Xeon® 5600系列处理器的服务器上运行的Oracle数据库11g 第二版，Oracle高级安全（Oracle Advanced Security）的透明数据加密速度取得了重大突破。

　基准测试结果显示，Oracle数据库11g 第二版透明数据加密（Oracle Database 11g Release 2 Transparent Data Encryption）的AES加密处理速度提高了10倍，在AES-NI的Intel® Xeon® X5680处理器上采用256节键的解密处理速度比在没有AES-NI的Intel® Xeon® X5560处理器上的速度提高了8倍。同样，128节键AES加密处理速度加快了10倍，解密处理速度加快了7倍(1)。

　　为敏感的Oracle应用数据提供易于部署的加密技术

　　采用透明数据加密技术的企业现在可利用Oracle数据库11g，对所有应用数据或具体领域包含的敏感信息如信用卡、社会安全号码或个人身份信息，以更低成本进行加密。

　　通过Oracle高级安全提供的透明数据加密，Oracle数据库11g在数据被写入或从磁盘读取时，可自动加密和解密数据。为此，闲时数据可获得有效保护，未经授权不能访问，而无需对数据库应用软件做任何改变。

　　通过Oracle企业管理器的网格控制界面，Oracle高级安全可快速、轻松的完成部署。透明数据加密密钥管理是内置的，主密钥可以选择存储在集中的高保证网络连接设备中。

　　作为Oracle 数据库安全解决方案完整产品组合的一部分，Oracle高级安全能帮助企业遵守保密和监督任务，如支付卡（PCI）数据安全标准（DSS）、健康保险流通与责任法案（HIPAA）和萨班斯法案，以及许多违反法律的通知。

　　甲骨文公司数据库安全副总裁Vipin Samar说：“我们一直致力于利用Oracle高级安全来实现数据加密透明化，帮助客户保护数据和满足法规需求，而无需昂贵地改变应用程序。在Intel® Xeon® 5600系列处理器硬件平台上运行透明数据加密的客户，现在他们的数据加密处理速度提高了10倍。”

　　英特尔架构集团副总裁和英特尔数据中心集团市场部总经理Boyd Davis说：“英特尔和甲骨文一直在为最终用户提供创新型的解决方案，以满足他们最重要的业务需求。新推出的内置于Intel® Xeon®处理器5600系列的Oracle高级安全和加速硬件的加密技术，将能帮助客户获得卓越的数据库加密性能。”   

create or replace
PROCEDURE proceudre_name AS
BEGIN
DECLARE
sPara VARCHAR(50);
sPara2 VARCHAR(50);
CURSOR c_cursor IS SELECT ID,Name FROM Temp_table;
BEGIN
OPEN c_cursor;
LOOP
FETCH c_cursor INTO sPara, sPara2;
EXIT WHEN c_cursor%NOTFOUND;
BEGIN
--just do what you want.
END;
END LOOP;
CLOSE c_cursor;
END;
END;

Oracle连接串方式，Oracle连接串方式如何实现？Oracle连接串方式怎样做？看看下面怎么做到的吧。

1.Connecting via TNS

"Data Source=NEWDB;User ID=SYSTEM;Password=admin";

2.Connecting Without TNSNames.ora

"Data Source = " +
      "(DESCRIPTION = " + 
    "  (ADDRESS_LIST = " + 
        "    (ADDRESS = (PROTOCOL = TCP)" + 
    "    (HOST = 127.0.0.1) " +
    "    (PORT = 1521) " +
    "  )" + 
    "  )" + 
    "  (CONNECT_DATA = " + 
    "  (SERVICE_NAME = NEWDB)" +
    "  )" + 
    ");" + 
    "User Id=SYSTEM;" + 
    "password=admin;"

3. Connecting via EZConnect

"Data Source=EDZEHOO-PC:1521/NEWDB;
    User ID=SYSTEM;Password=admin";

4. Connecting with Connection Pooling Activated

OracleConnection conn = new OracleConnection();
conn.ConnectionString = "Data Source=NEWDB;
  User ID=SYSTEM;
Password=admin;
  Min Pool Size=10;
  Max Pool Size=100;
  Connection Lifetime=120;
  Connection Timeout=60;
  Incr Pool Size=3;
  Decr Pool Size=1;"

5. Dynamically Building an ODP.NET Connection String

private string BuildConnectionString(string TNSName, string UserID, string
Password)
{
    OracleConnectionStringBuilder _conn = new OracleConnectionStringBuilder();
    {
        _conn.DataSource = TNSName;
        _conn.DecrPoolSize = 5;
        _conn.IncrPoolSize = 10;
        _conn.Pooling = true;
        _conn.MaxPoolSize = 100;
        _conn.MinPoolSize = 5;
  _conn.ConnectionLifeTime = 120
        _conn.ConnectionTimeout = 60
        _conn.UserID = UserID;
        _conn.Password = Password; 
    }
    return _conn.ConnectionString;
}