亚洲一区二区三区高清不卡,亚洲线精品一区二区三区,亚洲欧洲日产国码无码久久99

風向逆轉 - ��p��爪哇 — Fri, 19 May 2006 14:46:00 GMT

原文地址�Q?a >http://java.ccidnet.com/art/297/20060326/489157_1.html

風向逆轉 - ��p��爪哇 2006-05-19 22:46 发表评论

風向逆轉 - ��p��爪哇 — Wed, 29 Mar 2006 20:01:00 GMT

下决心开始学oracle�?用mysql已经有不短的旉��?今天写下�q�些��是对自��q��一个mysql之旅的一个交代吧.以下仅仅是本人在使用mysql�q�程中的一点个人的体会,也许存在许多�U�漏和错�?�q�请指正!!

首先,��Z��使一个系�l�更�?最重要的部分就是基��设计,不过有些东西是现有情况下无法逾越�?比如说系�l�常见的瓉��.

我所能想到的:

1:��盘寻道能力,以高速硬�?7200�?�U?,理论上每�U�寻�?200��?�q�是没有办法改变�?优化的方法是----用多个硬�?或者把数据分散存储.

2:��盘的读写速度,�q�个速度非常的快(限于本�h的知识所�?只知道在每秒几十甚至上百MB).�q�个更容易解�?-可以从多个硬盘上�q�行��d��.

3:cpu.cpu处理内存中的数据,当有相对内存较小的表�?�q�是最常见的限制因�?

4:内存的限�?当cpu需要超出适合cpu�~�存的数据时,�~�存的带宽就成了内存的一个瓶�?--不过现在内存大的惊�h,一般不会出现这个问�?

�W�二�?

(本�h使用的是学校�|�站的linux�q�_��(Linux ADVX.Mandrakesoft.com 2.4.3-19mdk ))

1:调节服务器参�?

用shell>mysqld-help�q�个命��o声厂一张所有mysql选项和可配置变量的表.输出以下信息:

possible variables for option--set-variable(-o) are:

back_log current value:5 //要求mysql能有的连接数�?back_log指出在mysql暂停接受�q�接的时间内有多��个�q�接��h��可以被存在堆栈中

connect_timeout current value:5 //mysql服务器在用bad handshake(不好��译)应答前等待一个连接的旉��

delayed_insert_timeout current value:200 //一个insert delayed在终止前�{�待insert的时�?

delayed_insert_limit current value:50 //insert delayed处理器将��查是否有��M��select语句未执�?如果�?�l�箋前执行这些语�?

delayed_queue_size current value:1000 //为insert delayed分配多大的队

flush_time current value:0 //如果被设�|��ؓ�?,那么每个flush_time 旉��,所有表都被关闭

interactive_timeout current value:28800 //服务器在关上它之前在�z�交互连接上�{�待的时�?

join_buffer_size current value:131072 //用与全部�q�接的缓冲区大小

key_buffer_size current value:1048540 //用语索引块的�~�冲区的大小,增加它可以更好的处理索引

lower_case_table_names current value:0 //

long_query_time current value:10 //如果一个查询所用时间大于此旉��,slow_queried计数��增�?

max_allowed_packet current value:1048576 //一个包的大��?

max_connections current value:300 //允许同时�q�接的数�?

max_connect_errors current value:10 //如果有多于该数量的中断连�?��阻止进一步的�q�接,可以用flush hosts来解�?

max_delayed_threads current value:15 //可以启动的处理insert delayed的数�?

max_heap_table_size current value:16777216 //

max_join_size current value:4294967295 //允许��d��的连接的数量

max_sort_length current value:1024 //在排序blob或者text时��用的字节数量

max_tmp_tables current value:32 //一个连接同时打开的��时表的数�?

max_write_lock_count current value:4294967295 //指定一个�?通常很小)来启动mysqld,使得在一定数量的write锁定之后出现read锁定

net_buffer_length current value:16384 //通信�~�冲区的大小--在查询时被重�|��ؓ该大��?

query_buffer_size current value:0 //查询时缓冲区大小

record_buffer current value:131072 //每个��序扫描的连接�ؓ其扫描的每张表分配的�~�冲区的大小

sort_buffer current value:2097116 //每个�q�行排序的连接分配的�~�冲区的大小

table_cache current value:64 //为所有连接打开的表的数�?

thread_concurrency current value:10 //

tmp_table_size current value:1048576 //临时表的大小

thread_stack current value:131072 //每个�U�程的大��?

wait_timeout current value:28800 //服务器在关闭�?之前的一个连接上�{�待的时�?

�Ҏ(gu��)��自己的需要配�|�以上信息会对你帮助.

�W�三:

1:如果你在一个数据库中创建大量的�?那么执行打开,关闭�Q�创�?�?的操作就会很�?

2:mysql使用内存

a: 关键字缓存区(key_buffer_size)由所有线�E�共�?

b: 每个�q�接使用一些特定的�U�程�I�间.一个栈(默认�?4k,变量thread_stack),一个连接缓冲区(变量net_buffer_length)和一个结果缓冲区(net_buffer_length).特定情况�?�q�接�~�冲区和�l�果�~�冲��动态扩大到max_allowed_packet.

c:所有线�E�共享一个基存储�?

d:没有内存影射

e:每个做顺序扫描的��h��分配一个读�~�冲�?record_buffer)

f:所有联�l�均有一遍完成�ƈ且大多数联结甚至可以不用一个��时表完成.最临时的表是基于内存的(heap)�?

g:排序��h��分配一个排序缓冲区�?个��时表

h:所有语法分析和计算都在一个本地存储器完成

i:每个索引文�g只被打开一��?�q�且数据文�g为每个�ƈ发运行的�U�程打开一��?

j:�Ҏ(gu��)��个blob列的表，一个缓冲区动态的被扩大以便读入blob�?

k:所有正在��用的表的表处理器被保存在一个缓冲器中�ƈ且作��Z��个fifo��理.

l:一个mysqladmin flush-tables命��o关闭所有不在��用的表�ƈ且在当前执行的线�E�结束时标记所有在使用的表准备关闭

3:mysql锁定�?

mysql中所有锁定不会成为死�?

wirte锁定:

mysql的锁定原�?a:如果表没有锁�?那么锁定;b否则,把锁定请求放入写锁定队列�?

read锁定:

mysql的锁定原�?a:如果表没有锁�?那么锁定;b否则,把锁定请求放入读锁定队列�?

有时候会在一个表中进行很多的select,insert操作,可以在一个��时表中插入行�q�且偶尔用��时表的记录更新真正的�?

a:用low_priority属性给一个特定的insert,update或者delete较低的优先��

b:max_write_lock_count指定一个�?通常很小)来启动mysqld,使得在一定数量的write锁定之后出现read锁定

c:通过使用set sql_low_priority_updates=1可以从一个特定的�U�程指定所有的更改应该��p��低的优先�U�完�?

d:用high_priority指定一个select

e:如果使用insert....select....出现问题,使用myisam�?-----因�ؓ它支持因为它支持�q�发的select和insert

4:最基本的优化是使数据在��盘上占据的�I�间最��?如果索引做在最��的列上,那么索引也最��?实现�Ҏ(gu��)��:

a:使用��可能小的数据类�?

b:如果可能�Q�声明表列�ؓNOT NULL.

c:如果有可能��用变成的数据�c�d��,如varchar(但是速度会受一定的影响)

d:每个表应该有��可能短的主索引

e:创徏��实需要的索引

f:如果一个烦引在头几个字�W�上有唯一的前�~�,那么仅仅索引�q�个前缀----mysql支持在一个字�W�列的一部分上的索引

g:如果一个表�l�常被扫�?那么试图拆分它�ؓ更多的表

�W�四�?

1:索引的��?索引的重要性就不说�?功能也不说了,只说怎么�?

首先要明��所有的mysql索引(primary,unique,index)在b树中有存�?索引主要用语:

a:快速找到where指定条�g的记�?

b:执行联结�?从其他表��索行

c:对特定的索引列找出max()和min()�?

d�Q�如果排序或者分�l�在一个可用键的最前面加前�~��Q�排序或分组一个表

e�Q�一个查询可能被用来优化��索��|��而不用访问数据文�Ӟ��如果某些表的列是数字型�ƈ且正好是某个列的前缀�Q��ؓ了更快，值可以从索引树中取出

�Q�：存储或者更新数据的查询速度

　grant的执行会�E�稍的减低效率．

　mysql的函数应该被高度的优化．可以用benchmark�Q�loop_count,expression)来找出是否查询有问题

　select 的查询速度�Q�如果想要让一个select�Q�．�Q�where�Q�．�Q�更快，我能惛_��的只有徏立烦引．可以在一个表上运行myisamchk�Q�－analyze 来更好的优化查询�Q�可以用myisamchk�Q�－sort�Q�index�Q�－sort�Q�records�Q�１来设�|�用一个烦引排序一个烦引和数据�Q?

�Q�：mysql优化where子句

3.�Q�：删除不必要的括号�Q?

　�Q�（a AND b) AND c OR (((a AND b) AND (a AND d))))>(a AND b AND c) OR (a AND b AND c AND d)

3.2:使用常数

　�Q�a b>5 AND b=c AND a=5

3.3:删除常数条�g

�Q�b>=5 AND b=5) OR (b=6 AND 5=5) OR (b=100 AND 2=3) > b=5 OR b=6

3.4:索引使用的常数表辑ּ�仅计��一��?

3.5�Q�在一个表中，没有一个where的count(*)直接从表中检索信�?

3.6:所有常数的表在查询中在��M��其他表之前读�?

3.7:对外联结表最好联�l�组合是��试了所有可能性找到的

3.8�Q�如果有一个order　by字句和一个不同的group　by子句或者order　by或者group　by包含不是来自联结的第一个表的列�Q�那么创��Z��个��时表

3.9:如果使用了sql_small_result�Q�那么msyql使用在内存中的一个表

3.10:每个表的索引�l�查询�ƈ且��用跨��少于３�Q�％的行的烦引．

3.11在每个记录输出前�Q�蟩�q�不匚w��having子句的行

�Q�：优化left　join

在mysql中　a left join b按以下方式实�?

a�Q�表b依赖于表a　

b�Q�表a依赖于所有用在left　join条�g的表�Q�除了b�Q?

c�Q�所有left　join条�g被移到where子句�?

d�Q�进行所有的联结优化�Q�除了一个表��L��在所有他依赖的表后读取．如果有一个��@环依赖，那么��发生错�?

e�Q�进行所有的标准的where优化

f�Q�如果在a中有一行匹配where子句�Q�但是在b中没有�Q何匹配left　join条�g�Q�那么，在b中生成的所有设�|��ؓ�Q�Ｕ�Q�Ｌ的一�?

g�Q�如果��用left　join来找出某些表中不存在的行�q�且在where部分有column_name IS NULL��试(column_name为NOT NULL�?�Q�那么，mysql在它已经扑ֈ�了匹配left　join条�g的一行后�Q�将停止在更多的行后��L��

�Q�：优化limit

a�Q�如果用limit只选择一行，当mysql需要扫描整个表�Ӟ��它的作用相当于烦�?

b�Q�如果��用limit�Q�与order　by�Q�mysql如果扑ֈ�了第�Q�行�Q�将�l�束排序�Q�而不会排序正个表

c�Q�当�l�合limit�Q�和distinct�Ӟ��mysql如果扑ֈ�了第�Q�行�Q�将停止

d�Q�只要mysql已经发送了�W�一个＃行到客户�Q�mysql��放弃查�?

e�Q�limit 0一直会很快的返回一个空集合�Q?

f�Q��时表的大��用limit�Q�计��需要多��空间来解决查询

�Q�：优化insert

插入一条记录的是由以下构成�Q?

a:�q�接�Q�３�Q?

b:发送查询给服务器（�Q�）

c:分析查询�Q�２�Q?

d:插入记录�Q�１*记录大小�Q?

e�Q�插入烦引（�Q?索引�Q?

f�Q�关闭（�Q�）

以上数字可以看成和��L��间成比例

改善插入速度的一些方法：

6.1�Q�如果同时从一个连接插入许多行�Q��用多个值的insert�Q�这比用多个语句要快

6.2�Q�如果从不同�q�接插入很多行，使用insert　delayed语句速度更快

6.3: 用myisam�Q�如果在表中没有删除的行�Q�能在select�Q�s正在�q�行的同时插入行

6.4: 当从一个文本文件装载一个表�Ӟ��用load　data　infile�Q�这个通常比insert�?0

�?

6.5: 可以锁定表然后插入－�Q�主要的速度差别是在所有insert语句完成后，索引�~�冲��Z��被存入到��盘一�ơ．一般与有不同的insert语句那样多次存入要快�Q�如果能用一个单个语句插入所有的行，锁定��׃��需要．锁定也降低连接的整体旉��Q�但是对某些�U�程最大等待时间将上升�Q�例如：

thread 1 does 1000 inserts

thread 2,3 and 4 does 1 insert

thread 5 does 1000 inserts

如果不��用锁定，�Q�，�Q�，�Q�将在１和５之前完成�Q�如果��用锁定，�Q�，�Q�，�Q�，��可能在�Q�和�Q�之后完成．但是整体旉��应该快４�Q�％�Q�因为insert�Q?update�Q�delete操作在mysql中是很快的，通过为多于大�U�５�ơ连�l�不断的插入或更��C��行的东西加锁�Q�将获得更好的整体性能�Q�如果做很多一行的插入�Q�可以做一个lock　tables�Q�偶��随后做一个unlock　tables�Q�大�U�每�Q�０�Q�０行）以允许另外的�U�程存取表．�q�仍然将��D��获得好的性能�Q�load　data　infile对装载数据仍然是很快的．

��Z��对load　data　infile和insert得到一些更快的速度�Q�扩大关键字�~�冲区．

�Q�优化update的速度

它的速度依赖于被更新数据的大��和被更新烦引的数量

使update更快的另一个方法是推迟修改�Q�然后一行一行的做很多修改．如果锁定表，做一行一行的很多修改比一�ơ做一个快

�Q�优化delete速度

删除一个记录的旉��与烦引数量成正比�Q��ؓ了更快的删除记录�Q�可以增加烦引缓存的大小

从一个表删除所有行比删除这个表的大部分要快的多

�W�五�?

�Q�：选择一�U�表�c�d��

1.1静态myisam

�q�种格式是最��单且最安全的格式，它是��盘格式中最快的�Q�速度来自于数据能在磁盘上被找到的难易�E�度�Q�当锁定有一个烦引和静态格式的东西是，它很��单，只是行长度乘以数量．而且在扫描一张表�Ӟ��每次用磁盘读取来��d��常数个记录是很容易的�Q�安全性来源于如果当写入一个静态myisam文�g时导致计��机down 掉，myisamchk很容易指出每行在哪里开始和�l�束�Q�因此，它通常能收回所有记录，除了部分被写入的记录�Q�在mysql中所有烦引总能被重�?

1.2动态myisam

�q�种格式每一行必��L��一个头说明它有多长�Q�当一个记录在更改期间变长�Ӟ��它可以在多于一个位�|�上�l�束�Q�能使用optimize　tablename�?myisamchk整理一张表�Q�如果在同一个表中有像某些varchar或者blob列那样存取／改变的静态数据，��动态列�U�d��另外一个表以避免碎片．

1.2.1压羃myisam�Q�用可选的myisampack工具生成

1.2.2内存

�q�种格式对小型／中型表很有用�Q�对拯��Q�创��Z��个常用的查找表到�z�heap表有可能加快多个表联�l�，用同��h��据可能要快好几倍时��_��

select tablename.a,tablename2.a from tablename,tablanem2,tablename3 where

tablaneme.a=tablename2.a and tablename2.a=tablename3.a and tablename2.c!=0;

��Z��加速它�Q�可以用tablename2和tablename3的联�l�创��Z��个��时表�Q�因为用相同列（tablename1.a�Q�查找．

CREATE TEMPORARY TABLE test TYPE=HEAP

SELECT

tablename2.a as a2,tablename3.a as a3

FROM

tablenam2,tablename3

WHERE

tablename2.a=tablename3.a and c=0;

SELECT tablename.a,test.a3 from tablename,test where tablename.a=test.a1;

SELECT tablename.a,test,a3,from tablename,test where tablename.a=test.a1 and ....;

1.3静态表的特�?

1.3.1默认格式�Q�用在表不包含varchar�Q�blob�Q�text列的时�?

1.3.2所有的char�Q�numeric和decimal列填充到列宽�?

1.3.3非常�?

1.3.4�Ҏ(gu��)��~�冲

1.3.5�Ҏ(gu��)��在down后重建，因�ؓ记录位于固定的位�|?

1.3.6不必被重新组�l�（用myisamchk�Q�，除非是一个巨量的记录被删除�ƈ且优化存储大��?

1.3.7通常比动态表需要更多的存储�I�间

1.4动态表的特�?

1.4.1如果表包含�Q何varchar�Q�blob�Q�text列，使用该格�?

1.4.2所有字�W�串列是动态的

1.4.3每个记录前置一个位�Q?

1.4.4通常比定长表需要更多的��盘�I�间

1.4.5每个记录仅仅使用所需要的�I�间�Q�如果一个记录变的很大，它按需要被分成很多�D�，�q�导致了记录��片

1.4.6如果用超�q�行长度的信息更新行�Q�行被分�D�．

1.4.7在系�l�down掉以后不好重��Q�因��Z��个记录可以是多段

1.4.8对动态尺寸记录的期望行长度是�Q�＋�Q�number　of　columns�Q�７�Q�／�Q�＋(number

of char columns)+packed size of numeric columns+length of strings +(number of

NULL columns+7)/8

�Ҏ(gu��)��个连接有�Q�个字节的惩�|�．无论何时更改引�v记录的变大，都有一个动态记录被�q�接�Q�每个新�q�接臛_��有２�Q�个字节�Q�因此下一个变大将可能在同一个连接中�Q�如果不是，��有另外一个连接．可以用myisamchk　�Q�恶毒检查有多少�q�接�Q�所有连接可以用myisamchk -r删除�Q?

1.5压羃表的特点

1.5.1一张用myisampack实用�E�序制作的只读表�Q?

1.5.2解压�~�代码存在于所有mysql分发中，以便使没有myisampack的连接也能读取用myisampack压羃的表

1.5.3占据很小的磁盘空�?

1.5.4每个记录被单独压�~�．一个记录的头是一个定长的�Q�１～～�Q�个字节�Q�这取决于表的最大记录．每列以不同的方式被压�~�．一些常用的压羃�c�d��是：

　a:通常�Ҏ(gu��)��列有一张不同的哈夫��D��

　b:后缀�I�白压羃

　c:前缀�I�白压羃

d:用��|��的数字��用１位存�?

e:如果整数列的值有一个小范围�Q�列使用最��的可能�c�d��来存储．例如�Q�如果所有的值在�Q�到�Q�５�Q�之��_��一个bigint可以作�ؓ一个tinyint存储

　g:如果列仅有可能值的一个小集合�Q�列�c�d��被�{换到enum

　h:列可以��用上面的压羃�Ҏ(gu��)��的组�?

1.5.5能处理定长或动态长度的记录�Q�去不能处理blob或者text�?

1.5.6能用myisamchk解压�~?

mysql能支持不同的索引�c�d��Q�但一般的�c�d��是isam�Q�这是一个��树烦引�ƈ且能�_�略的�ؓ索引文�g计算大小�?key_length+4)*0.67�Q�在所有的键上的��d��Q?

字符串烦引是�I�白压羃的。如果第一个烦引是一个字�W�串�Q�它可将压羃前缀如果字符串列有很多尾部空白或是一个总部能甬道全长的varchar列，�I�白压羃使烦引文件更��．如果很多字符串有相同的前�~��Q?

1.6内存表的特点

mysql内部的heap表��用每偶溢出去的１�Q�０�Q�动态哈希�ƈ且没有与删除有关的问题．只能通过使用在堆表中的一个烦引来用等式存取东西（通常用＇�Q�＇操作�W�）

堆表的缺�Ҏ(gu��)��Q?

1.6.1惌��同时使用的所有堆表需要��够的额外内存

1.6.2不能在烦引的一个部分搜�?

1.6.3不能按顺序搜索下一个条目（卻I��使用�q�个索引做一个order　by�Q?

1.6.4mysql不能��出在２个��g��间大概有多少行．�q�被优化器��用是用来军_��使用哪个索引的，但是在另一个方面甚至不需要磁盘寻�?img src ="http://www.tkk7.com/iKingQu/aggbug/38162.html" width = "1" height = "1" />

風向逆轉 - ��p��爪哇 2006-03-30 04:01 发表评论

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:44:00 GMT

JDBC�p�d��教程�Q�六�Q?--可调用语�?

CallableStatement

本概�q�是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备�q�本书。这本书是一本教�E�，同时也是 JDBC 的重要参考手册，它将作�ؓ Java �p�d��的组成部份在 1997 �q�春季由 Addison-Wesley 出版公司出版。�?

7.1 概述
CallableStatement 对象为所有的 DBMS 提供了一�U�以标准形式调用已储存过�E�的�Ҏ(gu��)��。已储存�q�程储存在数据库中。对已储存过�E�的调用�?CallableStatement 对象所含的内容。这�U�调用是用一�U�换码语法来写的�Q�有两种形式�Q�一�U��Ş式带�l�果参数�Q�另一�U��Ş式不带结果参敎ͼ�有关换码语法的信息，参见�W?4 节“语句”）。结果参数是一�U�输�?(OUT) 参数�Q�是已储存过�E�的�q�回倹{��两�U��Ş式都可带有数量可变的输入�Q�IN 参数�Q�、输出（OUT 参数�Q�或输入和输出（INOUT 参数�Q�的参数。问号将用作参数的占位符�?

�?JDBC 中调用已储存�q�程的语法如下所�C�。注意，�Ҏ(gu��)��可��C�其间的内容是可选项�Q�方括号本��n�q�不是语法的�l�成部䆾�?

{call �q�程名[(?, ?, ...)]}

�q�回�l�果参数的过�E�的语法为：

{? = call �q�程名[(?, ?, ...)]}

不带参数的已储存�q�程的语法类��|��

{call �q�程名}

通常�Q�创�?CallableStatement 对象的�h应当知道所用的 DBMS 是支持已储存�q�程的，�q�且知道�q�些�q�程都是些什么。然而，如果需要检查，多种 DatabaseMetaData �Ҏ(gu��)��都可以提供这��L��信息。例如，如果 DBMS 支持已储存过�E�的调用�Q�则 supportsStoredProcedures �Ҏ(gu��)��返�?true�Q��?getProcedures �Ҏ(gu��)��返回对已储存过�E�的描述�?

CallableStatement �l�承 Statement 的方法（它们用于处理一般的 SQL 语句�Q�，�q��承了 PreparedStatement 的方法（它们用于处理 IN 参数�Q�。CallableStatement 中定义的所有方法都用于处理 OUT 参数�?INOUT 参数的输出部分：注册 OUT 参数�?JDBC �c�d��Q�一�?SQL �c�d��Q�、从�q�些参数中检索结果，或者检查所�q�回的值是否�ؓ JDBC NULL�?

7.1.1 创徏 CallableStatement 对象
CallableStatement 对象是用 Connection �Ҏ(gu��)�� prepareCall 创徏的。下例创�?CallableStatement 的实例，其中含有对已储存�q�程 getTestData 调用。该�q�程有两个变量，但不含结果参敎ͼ�

CallableStatement cstmt = con.prepareCall(
"{call getTestData(?, ?)}");

其中 ? 占位�W��ؓ IN�?OUT �q�是 INOUT 参数�Q�取决于已储存过�E?getTestData�?

7.1.2 IN �?OUT 参数
��?IN 参数传给 CallableStatement 对象是通过 setXXX �Ҏ(gu��)��完成的。该�Ҏ(gu��)��l�承�?PreparedStatement。所传入参数的类型决定了所用的 setXXX �Ҏ(gu��)��Q�例如，�?setFloat 来传�?float 值等�Q��?

如果已储存过�E�返�?OUT 参数�Q�则在执�?CallableStatement 对象以前必须先注册每�?OUT 参数�?JDBC �c�d��Q�这是必需的，因�ؓ某些 DBMS 要求 JDBC �c�d��Q�。注�?JDBC �c�d��是用 registerOutParameter �Ҏ(gu��)��来完成的。语句执行完后，CallableStatement �?getXXX �Ҏ(gu��)��取回参数倹{��正��的 getXXX �Ҏ(gu��)��是�ؓ各参数所注册�?JDBC �c�d��所对应�?Java �c�d��Q�从 JDBC �c�d��?Java �c�d��的标准映��见 8.6.1 节中的表�Q�。换�a�之， registerOutParameter 使用的是 JDBC �c�d��Q�因此它与数据库�q�回�?JDBC �c�d��匚w��Q�，�?getXXX ��之转换�?Java �c�d��?

作�ؓ�C�Z��Q�下�q�C��码先注册 OUT 参数�Q�执行由 cstmt 所调用的已储存�q�程�Q�然后检索在 OUT 参数中返回的倹{��方�?getByte 从第一�?OUT 参数中取��Z��?Java 字节�Q��?getBigDecimal 从第二个 OUT 参数中取��Z��?BigDecimal 对象�Q�小数点后面带三位数�Q�：

CallableStatement cstmt = con.prepareCall(
"{call getTestData(?, ?)}");
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.registerOutParameter(2, java.sql.Types.DECIMAL, 3);
cstmt.executeQuery();
byte x = cstmt.getByte(1);
java.math.BigDecimal n = cstmt.getBigDecimal(2, 3);

CallableStatement �?ResultSet 不同�Q�它不提供用增量方式��索大 OUT 值的�Ҏ(gu��)��机制�?

7.1.3 INOUT 参数
既支持输入又接受输出的参敎ͼ�INOUT 参数�Q�除了调�?registerOutParameter �Ҏ(gu��)��外，�q�要求调用适当�?setXXX �Ҏ(gu��)��Q�该�Ҏ(gu��)��是从 PreparedStatement �l�承来的�Q�。setXXX �Ҏ(gu��)��参数��D��|��ؓ输入参数�Q��?registerOutParameter �Ҏ(gu��)��它�?JDBC �c�d��注册��出参数。setXXX �Ҏ(gu��)��提供一�?Java ��|��而驱动程序先把这个��D�{换�ؓ JDBC ��|��然后��它送到数据库中�?

�q�种 IN 值的 JDBC �c�d��和提供给 registerOutParameter �Ҏ(gu��)��?JDBC �c�d��应该相同。然后，要检索输出��|��p��用对应的 getXXX �Ҏ(gu��)��。例如，Java �c�d��?byte 的参数应该��用方�?setByte 来赋输入倹{��应该给 registerOutParameter 提供�c�d��?TINYINT �?JDBC �c�d��Q�同时应使用 getByte 来检索输出�?�Q�第 8 节“JDBC �?Java �c�d��之间的映��”将�l�出详细信息和类型映��表�Q��?

下例假设有一个已储存�q�程 reviseTotal�Q�其唯一参数�?INOUT 参数。方�?setByte 把此参数设�ؓ 25�Q�驱动程序将把它作�ؓ JDBC TINYINT �c�d��送到数据库中。接着�Q�registerOutParameter ��该参数注册�?JDBC TINYINT。执行完该已储存�q�程后，��返回一个新�?JDBC TINYINT 倹{��方�?getByte ��把�q�个新��g��?Java byte �c�d��索�?

CallableStatement cstmt = con.prepareCall(
"{call reviseTotal(?)}");
cstmt.setByte(1, 25);
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.executeUpdate();
byte x = cstmt.getByte(1);

7.1.4 先检索结果，再检�?OUT 参数
�׃��某些 DBMS 的限�Ӟ��Z��实现最大的可移植性，��先检索由执行 CallableStatement 对象所产生的结果，然后再用 CallableStatement.getXXX �Ҏ(gu��)��来检�?OUT 参数�?

如果 CallableStatement 对象�q�回多个 ResultSet 对象�Q�通过调用 execute �Ҏ(gu��)��Q�，在检�?OUT 参数前应先检索所有的�l�果。这�U�情况下�Q��ؓ��保�Ҏ(gu��)��有的�l�果都进行了讉K��Q�必��d�� Statement �Ҏ(gu��)�� getResultSet、getUpdateCount �?getMoreResults �q�行调用�Q�直��C��再有�l�果为止�?

��索完所有的�l�果后，��可�?CallableStatement.getXXX �Ҏ(gu��)��来检�?OUT 参数中的倹{�?

7.1.5 ��索作�?OUT 参数�?NULL �?
�q�回�?OUT 参数中的值可能会�?JDBC NULL。当出现�q�种情�Ş�Ӟ��对 JDBC NULL ��D��行�{换以�?getXXX �Ҏ(gu��)��所�q�回的��gؓ null�? �?false�Q�这取决�?getXXX �Ҏ(gu��)��c�d��。对�?ResultSet 对象�Q�要知道 0 �?false 是否源于 JDBC NULL 的唯一�Ҏ(gu��)��Q�是用方�?wasNull �q�行��。如�?getXXX �Ҏ(gu��)��d��的最后一个值是 JDBC NULL�Q�则该方法返�?true�Q�否则返�?flase。第 5 节“ResultSet”将�l�出详细信息。 �?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630452

風向逆轉 - ��p��爪哇 2006-03-22 03:44 发表评论

[收藏]JDBC�p�d��教程�Q�五�Q?--准备语句

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:32:00 GMT

JDBC�p�d��教程�Q�五�Q?--准备语句

PreparedStatement

本概�q�是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备�q�本书。这是一本教�E�，同时也是 JDBC 的重要参考手册，它将作�ؓ Java �p�d��的组成部份在 1997 �q�春季由 Addison-Wesley 出版公司出版。�?

6.1 概述
�?PreparedStatement 接口�l�承 Statement�Q��ƈ与之在两斚w��有所不同�Q��?

PreparedStatement 实例包含已编译的 SQL 语句。这��是使语句“准备好”。�?
包含�?PreparedStatement 对象中的 SQL 语句可具有一个或多个 IN 参数。IN 参数的值在 SQL 语句创徏时未被指定。相反的�Q�该语句为每�?IN 参数保留一个问��P��“？”）作�ؓ占位�W�。每个问��L��值必��d��该语句执行之前，通过适当�?setXXX �Ҏ(gu��)��来提供。�?

�׃�� PreparedStatement 对象已预�~�译�q�，所以其执行速度要快�?Statement 对象。因此，多次执行�?SQL 语句�l�常创徏�?PreparedStatement 对象�Q�以提高效率�?

作�ؓ Statement 的子�c�，PreparedStatement �l�承�?Statement 的所有功能。另外它�q�添加了一整套�Ҏ(gu��)��Q�用于设�|�发送给数据库以取代 IN 参数占位�W�的倹{��同�Ӟ��三种�Ҏ(gu��)�� execute�?executeQuery �?executeUpdate 已被更改以��之不再需要参数。这些方法的 Statement 形式�Q�接�?SQL 语句参数的�Ş式）不应该用�?PreparedStatement 对象�?

6.1.1 创徏 PreparedStatement 对象
以下的代码段�Q�其�?con �?Connection 对象�Q�创建包含带两个 IN 参数占位�W�的 SQL 语句�?PreparedStatement 对象�Q��?

PreparedStatement pstmt = con.prepareStatement(
"UPDATE table4 SET m = ? WHERE x = ?");

pstmt 对象包含语句 "UPDATE table4 SET m = ? WHERE x = ?"�Q�它已发送给 DBMS�Q��ƈ为执行作好了准备�?

6.1.2 传�?IN 参数
在执�?PreparedStatement 对象之前�Q�必��设�|�每�?? 参数的倹{��这可通过调用 setXXX �Ҏ(gu��)��来完成，其中 XXX 是与该参数相应的�c�d��。例如，如果参数��h�� Java �c�d�� long�Q�则使用的方法就�?setLong。setXXX �Ҏ(gu��)��的第一个参数是要设�|�的参数的序��C��|�，�W�二个参数是讄��l�该参数的倹{��例如，以下代码��第一个参数设�?123456789�Q�第二个参数设�ؓ 100000000�Q��?

pstmt.setLong(1, 123456789);
pstmt.setLong(2, 100000000);

一旦设�|�了�l�定语句的参数��|��可用它多次执行该语句，直到调用 clearParameters �Ҏ(gu��)��清除它�ؓ止�?

在连接的�~�省模式下（启用自动提交�Q�，当语句完成时��自动提交或�q�原该语句�?

如果基本数据库和驱动�E�序在语句提交之后仍保持�q�些语句的打开状态，则同一�?PreparedStatement 可执行多�ơ。如果这一点不成立�Q�那么试��N��过使用 PreparedStatement 对象代替 Statement 对象来提高性能是没有意义的�?

利用 pstmt�Q�前面创建的 PreparedStatement 对象�Q�，以下代码例示了如何设�|�两个参数占位符的值�ƈ执行 pstmt 10 �ơ。如上所�q�ͼ�为做到这一点，数据库不能关�?pstmt。在该示例中�Q�第一个参数被讄��?"Hi"�q�保持�ؓ常数。在 for 循环中，每次都将�W�二个参数设�|��ؓ不同的��|��?0 开始，�?9 �l�束�?

pstmt.setString(1, "Hi");
for (int i = 0; i < 10; i++) {
pstmt.setInt(2, i);
int rowCount = pstmt.executeUpdate();
}

6.1.3 IN 参数中数据类型的一致�?
setXXX �Ҏ(gu��)��中的 XXX �?Java �c�d��。它是一�U�隐含的 JDBC �c�d��Q�一�?SQL �c�d��Q�，因�ؓ驱动�E�序��把 Java �c�d��映射为相应的 JDBC �c�d��Q�遵循该 JDBC Guide中�?.6.2 “映��?Java �?JDBC �c�d��”表中所指定的映��）�Q��ƈ��该 JDBC �c�d��发送给数据库。例如，以下代码�D�将 PreparedStatement 对象 pstmt 的第二个参数讄��?44�Q�Java �c�d��?short�Q��?

pstmt.setShort(2, 44);

驱动�E�序��?44 作�ؓ JDBC SMALLINT 发送给数据库，它是 Java short �c�d��的标准映��?

�E�序员的责�Q是确保将每个 IN 参数�?Java �c�d��映射��Z��数据库所需�?JDBC 数据�c�d��兼容�?JDBC �c�d��。不妨考虑数据库需�?JDBC SMALLINT 的情��c��如果��用方�?setByte �Q�则驱动�E�序��?JDBC TINYINT 发送给数据库。这是可行的�Q�因��多数据库可从一�U�相关的�c�d��转换为另一�U�类型，�q�且通常 TINYINT 可用�?SMALLINT 适用的�Q何地斏V��然而，对于要适用于尽可能多的数据库的应用�E�序�Q�最好��用与数据库所需的确切的 JDBC �c�d��相应�?Java �c�d��。如果所需�?JDBC �c�d��?SMALLINT�Q�则使用 setShort 代替 setByte ��应用�E�序的可�U�L��性更好�?

6.1.4 使用 setObject
�E�序员可使用 setObject �Ҏ(gu��)��昑ּ�地将输入参数转换为特定的 JDBC �c�d��。该�Ҏ(gu��)��可以接受�W�三个参敎ͼ�用来指定目标 JDBC �c�d��。将 Java Object 发送给数据库之前，驱动�E�序��把它�{换�ؓ指定�?JDBC �c�d��?

如果没有指定 JDBC �c�d��Q�驱动程序就会将 Java Object 映射到其�~�省�?JDBC �c�d��Q�参见第 8.6.4 节中的表��|��Q�然后将它发送到数据库。这与常规的 setXXX �Ҏ(gu��)��c�M��Q�在�q�两�U�情况下�Q�驱动程序在��值发送到数据库之前，会将该值的 Java �c�d��映射为适当�?JDBC �c�d��。二者的差别在于 setXXX �Ҏ(gu��)��使用�?Java �c�d��?JDBC �c�d��的标准映��（参见�W?8.6.2 节中的表��|��Q��?setObject �Ҏ(gu��)��使用�?Java Object �c�d��?JDBC �c�d��的映��（参见�W?8.6.4 节中的表��|��?

�Ҏ(gu��)�� setObject 允许接受所�?Java 对象的能力��应用�E�序更�ؓ通用�Q��ƈ可在�q�行时接受参数的输入。这�U�情况下�Q�应用程序在�~�译时�ƈ不清楚输入类型。通过使用 setObject�Q�应用程序可接受所�?Java 对象�c�d��作�ؓ输入�Q��ƈ��其转换为数据库所需�?JDBC �c�d��。第 8.6.5 节中的表格显�C�Z�� setObject 可执行的所有可能�{换�?

6.1.5 ��?JDBC NULL 作�ؓ IN 参数发�?
setNull �Ҏ(gu��)��允许�E�序员将 JDBC NULL ��g��?IN 参数发送给数据库。但要注意，仍然必须指定参数�?JDBC �c�d��?

当把 Java null ��g��递给 setXXX �Ҏ(gu��)��Ӟ��如果它接�?Java 对象作�ؓ参数�Q�，也将同样�?JDBC NULL 发送到数据库。但仅当指定 JDBC �c�d��Ӟ��Ҏ(gu��)�� setObject 才能接受 null 倹{�?

6.1.6 发送大�?IN 参数
setBytes �?setString �Ҏ(gu��)��能够发送无限量的数据。但是，有时�E�序员更喜欢用较?y��u)��的块传递大型的数据。这可通过��?IN 参数讄��?Java 输入��来完成。当语句执行�Ӟ��JDBC 驱动�E�序��重复调用该输入��，��d��其内容�ƈ��它们当作实际参数数据传输�?

JDBC 提供了三�U�将 IN 参数讄��入流的方法：setBinaryStream 用于含有未说明字节的��， setAsciiStream 用于含有 ASCII 字符的流�Q��?setUnicodeStream 用于含有 Unicode 字符的流。因为必��L��定流的总长度，所以这些方法所采用的参数比其它�?setXXX �Ҏ(gu��)��要多一个。这很有必要�Q�因��Z��些数据库在发送数据之前需要知道其�ȝ��传送大��?

以下代码例示了��用流作�ؓ IN 参数来发送文件内容：

java.io.File file = new java.io.File("/tmp/data");
int fileLength = file.length();
java.io.InputStream fin = new java.io.FileInputStream(file);
java.sql.PreparedStatement pstmt = con.prepareStatement(
"UPDATE Table5 SET stuff = ? WHERE index = 4");
pstmt.setBinaryStream (1, fin, fileLength);
pstmt.executeUpdate();

当语句执行时�Q�将反复调用输入��?fin 以传递其数据�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630450

風向逆轉 - ��p��爪哇 2006-03-22 03:32 发表评论

[收藏]JDBC�p�d��教程�Q�四�Q?--�l�果讄��

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:31:00 GMT

JDBC�p�d��教程�Q�四�Q?--�l�果讄��

ResultSet
本概�q�是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备�q�本书。这是一本教�E�，同时也是 JDBC 的重要参考手册，它将作�ؓ Java �p�d��的组成部份在 1997 �q�春季由 Addison-Wesley 出版公司出版。�?

5.1 概述
ResultSet 包含�W�合 SQL 语句中条件的所有行�Q��ƈ且它通过一�?get �Ҏ(gu��)��Q�这�?get �Ҏ(gu��)��可以讉K��当前行中的不同列�Q�提供了对这些行中数据的讉K��。ResultSet.next �Ҏ(gu��)��用于�U�d��?ResultSet 中的下一行，使下一行成为当前行�?

�l�果集一般是一个表�Q�其中有查询所�q�回的列标题及相应的倹{��例如，如果查询�?SELECT a, b, c FROM Table1�Q�则�l�果集将��h��如下形式�Q��?

a b c
-------- --------- --------
12345 Cupertino CA
83472 Redmond WA
83492 Boston MA

下面的代码段是执�?SQL 语句的示例。该 SQL 语句��返回行集合�Q�其中列 1 �?int�Q�列 2 �?String�Q�而列 3 则�ؓ字节数组�Q��?

java.sql.Statement stmt = conn.createStatement();
ResultSet r = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (r.next())
{
// 打印当前行的倹{�?
int i = r.getInt("a");
String s = r.getString("b");
float f = r.getFloat("c");
System.out.println("ROW = " + i + " " + s + " " + f);
}

5.1.1 行和光标
ResultSet �l�护指向其当前数据行的光标。每调用一��?next �Ҏ(gu��)��Q�光标向下移动一行。最初它位于�W�一行之前，因此�W�一�ơ调�?next ��把光标�|�于�W�一行上�Q��它成为当前行。随着每次调用 next ��D��光标向下�U�d��一行，按照从上至下的次序获�?ResultSet 行�?

�?ResultSet 对象或其父辈 Statement 对象关闭之前�Q�光标一直保持有效�?

�?SQL 中，�l�果表的光标是有名字的。如果数据库允许定位更新或定位删除，则需要将光标的名字作为参数提供给更新或删除命令。可通过调用�Ҏ(gu��)�� getCursorName 获得光标名�?

注意�Q�不是所有的 DBMS 都支持定位更新和删除。可使用 DatabaseMetaData.supportsPositionedDelete �?supportsPositionedUpdate �Ҏ(gu��)��来检查特定连接是否支持这些操作。当支持�q�些操作�Ӟ��DBMS/驱动�E�序必须��保适当锁定选定行，以��定位更新不会��D��更新异常或其它�ƈ发问题�?

5.1.2 �?
�Ҏ(gu��)�� getXXX 提供了获取当前行中某列值的途径。在每一行内�Q�可按�Q何次序获取列倹{��但��Z��保证可移植性，应该从左臛_��获取列��|��q�且一�ơ性地��d��列倹{�?

列名或列号可用于标识要从中获取数据的列。例如，如果 ResultSet 对象 rs 的第二列名�ؓ“title”，�q�将值存储�ؓ字符�Ԍ��则下列�Q一代码��获取存储在该列中的��|��

String s = rs.getString("title");
String s = rs.getString(2);

注意列是从左臛_��~�号的，�q�且从列 1 开始。同�Ӟ��用作 getXXX �Ҏ(gu��)��的输入的列名不区分大��写�?

提供使用列名�q�个选项的目的是��Z��让在查询中指定列名的用户可��用相同的名字作�ؓ getXXX �Ҏ(gu��)��的参数。另一斚w��Q�如�?select 语句未指定列名（例如在“select * from table1”中或列是导出的�Ӟ��Q�则应该使用列号。这些情况下�Q�用户将无法��切知道列名�?

有些情况下，SQL 查询�q�回的结果集中可能有多个列具有相同的名字。如果列名用�?getXXX �Ҏ(gu��)��的参敎ͼ��?getXXX ��返回第一个匹配列名的倹{��因而，如果多个列具有相同的名字�Q�则需要��用列索引来确保检索了正确的列倹{��这�Ӟ��使用列号效率要稍微高一些�?

关于 ResultSet 中列的信息，可通过调用�Ҏ(gu��)�� ResultSet.getMetaData 得到。返回的 ResultSetMetaData 对象��给出其 ResultSet 对象各列的编受��类型和属性�?

如果列名已知�Q�但不知其烦引，则可用方�?findColumn 得到其列受��?

5.1.3 数据�c�d��和�{�?
对于 getXXX �Ҏ(gu��)��Q�JDBC 驱动�E�序试图��基本数据�{换成指定 Java �c�d��Q�然后返回适合�?Java 倹{��例如，如果 getXXX �Ҏ(gu��)��?getString�Q�而基本数据库中数据类型�ؓ VARCHAR�Q�则 JDBC 驱动�E�序��把 VARCHAR 转换�?Java String。getString 的返回值将�?Java String 对象�?

下表昄��了允许用 getXXX 获取�?JDBC �c�d��及推荐用它获取的 JDBC �c�d��Q�通用 SQL �c�d��Q�。小写的 x 表示允许 getXXX �Ҏ(gu��)��获取该数据类型；大写�?X 表示对该数据�c�d��推荐使用 getXXX �Ҏ(gu��)��。例如，除了 getBytes �?getBinaryStream 之外的�Q�?getXXX �Ҏ(gu��)��都可用来获取 LONGVARCHAR ��|��但是推荐�Ҏ(gu��)��q�回的数据类型��?getAsciiStream �?getUnicodeStream �Ҏ(gu��)��。方�?getObject ��Q何数据类型返回�ؓ Java Object。当基本数据�c�d��是特定于数据库的抽象�c�d��或当通用应用�E�序需要接受�Q何数据类型时�Q�它是非常有用的�?

可��?ResultSet.getXXX �Ҏ(gu��)��获取常见�?JDBC 数据�c�d��?

“x”表�C�� getXXX �Ҏ(gu��)��可合法地用于获取�l�定 JDBC �c�d��?

“X”表�C�推荐��用该 getXXX �Ҏ(gu��)��来获取给�?JDBC �c�d��?

　 T
I
N
Y
I
N
T S
M
A
L
L
I
N
T I
N
T
E
G
E
R B
I
G

N
T R
E
A
L F
L
O
A
T D
O
U
B
L
E D
E
C
I
M
A
L N
U
M
E
R
I
C B
I
T C
H
A
R V
A
R
C
H
A
R
L
O
N
G
V
A
R
C
H
A
R B
I
N
A
R
Y V
A
R
B
I
N
A
R
Y L
O
N
G
V
A
R
B
I
N
A
R
Y D
A
T
E T
I
M
E T
I
M
E
S
T
A
M
P
getByte X x x x x x x x x x x x x 　　　　　　
getShort x X x x x x x x x x x x x 　　　　　　
getInt x x X x x x x x x x x x x 　　　　　　
getLong x x x X x x x x x x x x x 　　　　　　
getFloat x x x x X x x x x x x x x 　　　　　　
getDouble x x x x x X X x x x x x x 　　　　　　
getBigDecimal x x x x x x x X X x x x x 　　　　　　
getBoolean x x x x x x x x x X x x x 　　　　　　
getString x x x x x x x x x x X X x x x x x x x
getBytes 　　　　　　　　　　　　　 X X x 　　　
getDate 　　　　　　　　　　 x x x 　　　 X 　 x
getTime 　　　　　　　　　　 x x x 　　　　 X x
getTimestamp 　　　　　　　　　　 x x x 　　　 x 　 X
getAsciiStream 　　　　　　　　　　 x x X x x x 　　　
getUnicodeStream 　　　　　　　　　　 x x X x x x 　　　
getBinaryStream 　　　　　　　　　　　　　 x x X 　　　
getObject x x x x x x x x x x x x x x x x x x x

5.1.4 寚w��常大的行��g��用流
ResultSet 可以获取��L��大的 LONGVARBINARY �?LONGVARCHAR 数据。方�?getBytes �?getString ��数据返回�ؓ大的块（最大�ؓ Statement.getMaxFieldSize 的返回��|��。但是，以较?y��u)��的固定块获取非常大的数据可能会更方便，而这可通过�?ResultSet �c�返�?java.io.Input ��来完成。从该流中可分块��d��数据。注意：必须立即讉K��q�些��，因�ؓ在下一�ơ对 ResultSet 调用 getXXX 时它们将自动关闭�Q�这是由于基本实现对大块数据讉K��有限�Ӟ��。�?

JDBC API ��h��三个获取��的�Ҏ(gu��)��Q�分别具有不同的�q�回��|��

getBinaryStream �q�回只提供数据库原字节而不�q�行��M��转换的流�?

getAsciiStream �q�回提供单字�?ASCII 字符的流�?

getUnicodeStream �q�回提供双字�?Unicode 字符的流�?

注意�Q�它不同�?Java ��，后者返回无�c�d��字节�q�可�Q�例如）通用�?ASCII �?Unicode 字符�?

下列代码演示�?getAsciiStream 的用法：

java.sql.Statement stmt = con.createStatement();
ResultSet r = stmt.executeQuery("SELECT x FROM Table2");
// 现在�?4K 块大��获取列 1 �l�果�Q?
byte buff = new byte[4096];
while (r.next()) {
Java.io.InputStream fin = r.getAsciiStream(1);
for (;;) {
int size = fin.read(buff);
if (size == -1) { // 到达��末��?
break;
}
// ��新填充的缓冲区发送到 ASCII 输出��：
output.write(buff, 0, size);
}
}

5.1.5 NULL �l�果�?
要确定给定结果值是否是 JDBC NULL�Q�必��d��d��该列�Q�然后��?ResultSet.wasNull �Ҏ(gu��)��查该�ơ读取是否返�?JDBC NULL�?

当��?ResultSet.getXXX �Ҏ(gu��)��d�� JDBC NULL �Ӟ��Ҏ(gu��)�� wasNull ��返回下列��g��一�Q��?

Java null ��|��对于�q�回 Java 对象�?getXXX �Ҏ(gu��)��Q�例�?getString、getBigDecimal、getBytes、getDate、getTime、getTimestamp、getAsciiStream、getUnicodeStream、getBinaryStream、getObject �{�）�?

零��|��对于 getByte、getShort、getInt、getLong、getFloat �?getDouble�?

false ��|��对于 getBoolean�?

5.1.6 可选结果集或多�l�果�?
通常使用 executeQuery�Q�它�q�回单个 ResultSet�Q�或 executeUpdate�Q�它可用于�Q何数据库修改语句�Q��ƈ�q�回更新行数�Q�可执行 SQL 语句。但有些情况下，应用�E�序在执行语句之前不知道该语句是否返回结果集。此外，有些已存储过�E�可能返回几个不同的�l�果集和/或更新计数�?

��Z��适应�q�些情况�Q�JDBC 提供了一�U�机�Ӟ��允许应用�E�序执行语句�Q�然后处理由�l�果集和更新计数�l�成的�Q意集合。这�U�机制的原理是首先调用一个完全通用�?execute �Ҏ(gu��)��Q�然后调用另外三个方法，getResultSet、getUpdateCount �?getMoreResults。这些方法允许应用程序一�ơ一个地研究语句�l�果�Q��ƈ��定�l�定�l�果�?ResultSet �q�是更新计数�?

用户不必关闭 ResultSet�Q�当产生它的 Statement 关闭、重新执行或用于从多�l�果序列中获取下一个结果时�Q�该 ResultSet ��被 Statement 自动关闭。�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630447

風向逆轉 - ��p��爪哇 2006-03-22 03:31 发表评论

[收藏]JDBC�p�d��教程�Q�三�Q?--语句

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:30:00 GMT

JDBC�p�d��教程�Q�三�Q?--语句

Statement
本概�q�是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备�q�本书。这是一本教�E�，同时也是 JDBC 的重要参考手册，它将作�ؓ Java �p�d��的组成部份在 1997 �q�春季由 Addison-Wesley 出版公司出版。�?

4.1 概述
Statement 对象用于��?SQL 语句发送到数据库中。实际上有三�U?Statement 对象�Q�它们都作�ؓ在给定连接上执行 SQL 语句的包容器�Q�Statement、PreparedStatement�Q�它�?Statement �l�承而来�Q�和 CallableStatement�Q�它�?PreparedStatement �l�承而来�Q�。它们都专用于发送特定类型的 SQL 语句�Q?Statement 对象用于执行不带参数的简�?SQL 语句�Q�PreparedStatement 对象用于执行带或不带 IN 参数的预�~�译 SQL 语句�Q�CallableStatement 对象用于执行�Ҏ(gu��)��据库已存储过�E�的调用�?

Statement 接口提供了执行语句和获取�l�果的基本方法。PreparedStatement 接口��d��了处�?IN 参数的方法；�?CallableStatement ��d��了处�?OUT 参数的方法�?

4.1.1 创徏 Statement 对象
建立了到特定数据库的�q�接之后�Q�就可用该连接发�?SQL 语句。Statement 对象�?Connection 的方�?createStatement 创徏�Q�如下列代码�D�中所�C�：

Connection con = DriverManager.getConnection(url, "sunny", "");
Statement stmt = con.createStatement();

��Z��执行 Statement 对象�Q�被发送到数据库的 SQL 语句��被作�ؓ参数提供�l?Statement 的方法：

ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2");

4.1.2 使用 Statement 对象执行语句
Statement 接口提供了三�U�执�?SQL 语句的方法：executeQuery、executeUpdate �?execute。��用哪一个方法由 SQL 语句所产生的内容决定�?

�Ҏ(gu��)�� executeQuery 用于产生单个�l�果集的语句�Q�例�?SELECT 语句�?

�Ҏ(gu��)�� executeUpdate 用于执行 INSERT、UPDATE �?DELETE 语句以及 SQL DDL�Q�数据定义语�a��Q�语句，例如 CREATE TABLE �?DROP TABLE。INSERT、UPDATE �?DELETE 语句的效果是修改表中零行或多行中的一列或多列。executeUpdate 的返回值是一个整敎ͼ�指示受媄响的行数�Q�即更新计数�Q�。对�?CREATE TABLE �?DROP TABLE �{�不操作行的语句�Q�executeUpdate 的返回值��Mؓ零�?

�Ҏ(gu��)�� execute 用于执行�q�回多个�l�果集、多个更新计数或二者组合的语句。因为多数程序员不会需要该高��功能�Q�所以本概述后面��在单独一节中对其�q�行介绍�?

执行语句的所有方法都��关闭所调用�?Statement 对象的当前打开�l�果集（如果存在�Q�。这意味着在重新执�?Statement 对象之前�Q�需要完成对当前 ResultSet 对象的处理�?

应注意，�l�承�?Statement 接口中所有方法的 PreparedStatement 接口都有自己�?executeQuery、executeUpdate �?execute �Ҏ(gu��)��。Statement 对象本��n不包�?SQL 语句�Q�因而必��ȝ�� Statement.execute �Ҏ(gu��)��提供 SQL 语句作�ؓ参数。PreparedStatement 对象�q�不��?SQL 语句作�ؓ参数提供�l�这些方法，因�ؓ它们已经包含预编�?SQL 语句。CallableStatement 对象�l�承�q�些�Ҏ(gu��)��?PreparedStatement 形式。对于这些方法的 PreparedStatement �?CallableStatement 版本�Q��用查询参数将抛出 SQLException�?

4.1.3 语句完成
当连接处于自动提交模式时�Q�其中所执行的语句在完成时将自动提交或还原。语句在已执行且所有结果返回时�Q�即认�ؓ已完成。对于返回一个结果集�?executeQuery �Ҏ(gu��)��Q�在��索完 ResultSet 对象的所有行时该语句完成。对于方�?executeUpdate�Q�当它执行时语句卛_��成。但在少数调用方�?execute 的情况中�Q�在��索所有结果集或它生成的更新计��C��后语句才完成�?

有些 DBMS ��已存储�q�程中的每条语句视�ؓ独立的语句；而另外一些则��整个过�E�视��Z��个复合语句。在启用自动提交�Ӟ��q�种差别��变得非帔R��要，因�ؓ它媄响什么时候调�?commit �Ҏ(gu��)��。在前一�U�情况中�Q�每条语句单独提交；在后一�U�情况中�Q�所有语句同时提交�?

4.1.4 关闭 Statement 对象
Statement 对象��由 Java 垃圾攉��E�序自动关闭。而作��Z��U�好的编�E�风��|��应在不需�?Statement 对象时显式地关闭它们。这��立即释�?DBMS 资源�Q�有助于避免潜在的内存问题�?

4.1.5 Statement 对象中的 SQL 转义语法
Statement 可包含��?SQL 转义语法�?SQL 语句。�{义语法告诉驱动程序其中的代码应该以不同方式处理。驱动程序将扫描��M��转义语法�Q��ƈ��它转换成特定数据库可理解的代码。这使得转义语法�?DBMS 无关�Q��ƈ允许�E�序员��用在没有转义语法时不可用的功能�?

转义子句��p��括号和关键字界定�Q��?

{keyword . . . parameters . . . }

该关键字指示转义子句的类型，如下所�C��?

escape 表示 LIKE 转义字符

字符�?”和“_”类��g�� SQL LIKE 子句中的通配�W�（�?”匹配零个或多个字符�Q�而“_”则匚w��一个字�W�）。�ؓ了正��解释它们，应在其前面加上反斜杠�Q�“\”）�Q�它是字�W�串中的�Ҏ(gu��)��转义字符。在查询末尾包括如下语法卛_��指定用作转义字符的字�W�：

{escape 'escape-character'}

例如�Q�下列查询��用反斜杠字符作�ؓ转义字符�Q�查找以下划�U�开头的标识�W�名�Q��?

stmt.executeQuery("SELECT name FROM Identifiers
WHERE Id LIKE `\_%' {escape `\'};

fn 表示标量函数

几乎所�?DBMS 都具有标量值的数倹{��字�W�串、时间、日期、系�l�和转换函数。要使用�q�些函数�Q�可使用如下转义语法�Q�关键字 fn 后跟所需的函数名及其参数。例如，下列代码调用函数 concat ��两个参数连接在一��P��

{fn concat("Hot", "Java")};

可用下列语法获得当前数据库用户名�Q��?

{fn user()};

标量函数可能��p��法稍有不同的 DBMS 支持�Q�而它们可能不被所有驱动程序支持。各�U?DatabaseMetaData �Ҏ(gu��)��列出所支持的函数。例如，�Ҏ(gu��)�� getNumericFunctions �q�回用逗号分隔的数值函数列表，而方�?getStringFunctions ��返回字�W�串函数�Q�等�{��?

驱动�E�序��{义函数调用映��ؓ相应的语法，或直接实现该函数�?

d、t �?ts 表示日期和时间文�?

DBMS 用于日期、时间和旉��标记文字的语法各不相同。JDBC 使用转义子句支持�q�些文字的语法的 ISO 标准格式。驱动程序必��d��转义子句转换�?DBMS 表示�?

例如�Q�可用下列语法在 JDBC SQL 语句中指定日期：

{d `yyyy-mm-dd'}

在该语法中，yyyy 为年代，mm 为月份，�?dd 则�ؓ日期。驱动程序将用等��L��特定�?DBMS 的表�C�替换这个�{义子句。例如，如果 '28- FEB-99' �W�合基本数据库的格式�Q�则驱动�E�序��用它替�?{d 1999-02-28}�?

对于 TIME �?TIMESTAMP 也有�c�M��的�{义子句：

{t `hh:mm:ss'}
{ts `yyyy-mm-dd hh:mm:ss.f . . .'}

TIMESTAMP 中的��数点后的秒�Q?f . . .�Q�部分可忽略�?

call �?? = call 表示已存储过�E?

如果数据库支持已存储�q�程�Q�则可从 JDBC 中调用它们，语法为：

{call procedure_name[(?, ?, . . .)]}

或（其中�q�程�q�回�l�果参数�Q�：

{? = call procedure_name[(?, ?, . . .)]}

�Ҏ(gu��)��h��C�其中的内容是可选的。它们不是语法的必要部分�?

输入参数可以为文字或参数。有兌��l�信息，参见 JDBC 指南中第 7 节，“CallableStatement”�?

可通过调用�Ҏ(gu��)�� DatabaseMetaData.supportsStoredProcedures ��查数据库是否支持已存储过�E��?

oj 表示外部�q�接

外部�q�接的语法�ؓ

{oj outer-join}

其中 outer-join 形式为�?

table LEFT OUTER JOIN {table / outer-join} ON search-condition

外部�q�接属于高��功能。有兛_��们的解释可参�?SQL 语法。JDBC 提供了三�U?DatabaseMetaData �Ҏ(gu��)��用于��定驱动�E�序支持哪些外部�q�接�c�d��Q�supportsOuterJoins、supportsFullOuterJoins �?supportsLimitedOuterJoins�?

�Ҏ(gu��)�� Statement.setEscapeProcessing 可打开或关闭�{义处理；�~�省状态�ؓ打开。当性能极�ؓ重要�Ӟ��E�序员可能想关闭它以减少处理旉��。但通常它将��Z��打开状态。应注意�Q?setEscapeProcessing 不适用�?PreparedStatement 对象�Q�因为在调用该语句前它就可能已被发送到数据库。有关预�~�译的信息，参见 PreparedStatement�?

4.1.6 使用�Ҏ(gu��)�� execute
execute �Ҏ(gu��)��应该仅在语句能返回多�?ResultSet 对象、多个更新计数或 ResultSet 对象与更新计数的�l�合时��用。当执行某个已存储过�E�或动态执行未�?SQL 字符�Ԍ��卛_��用程序程序员在编译时未知�Q�时�Q�有可能出现多个�l�果的情况，��管�q�种情况很少见。例如，用户可能执行一个已存储�q�程�Q��?CallableStatement 对象 - 参见�W?135 ��늚� CallableStatement�Q�，�q�且该已存储�q�程可执行更斎ͼ�然后执行选择�Q�再�q�行更新�Q�再�q�行选择�Q�等�{�。通常使用已存储过�E�的人应知道它所�q�回的内宏V�?

因�ؓ�Ҏ(gu��)�� execute 处理非常规情况，所以获取其�l�果需要一些特�D�处理�ƈ不��为怪。例如，假定已知某个�q�程�q�回两个�l�果集，则在使用�Ҏ(gu��)�� execute 执行该过�E�后�Q�必��调用方�?getResultSet 获得�W�一个结果集�Q�然后调用适当�?getXXX �Ҏ(gu��)��获取其中的倹{��要获得�W�二个结果集�Q�需要先调用 getMoreResults �Ҏ(gu��)��Q�然后再调用 getResultSet �Ҏ(gu��)��。如果已知某个过�E�返回两个更新计敎ͼ�则首先调用方�?getUpdateCount�Q�然后调�?getMoreResults�Q��ƈ再次调用 getUpdateCount�?

对于不知道返回内容，则情冉|��为复杂。如果结果是 ResultSet 对象�Q�则�Ҏ(gu��)�� execute �q�回 true�Q�如果结果是 Java int�Q�则�q�回 false。如果返�?int�Q�则意味着�l�果是更新计数或执行的语句是 DDL 命��o。在调用�Ҏ(gu��)�� execute 之后要做的第一件事情是调用 getResultSet �?getUpdateCount。调用方�?getResultSet 可以获得两个或多�?ResultSet 对象中第一个对象；或调用方�?getUpdateCount 可以获得两个或多个更新计��C��W�一个更新计数的内容�?

�?SQL 语句的结果不是结果集�Ӟ��则方�?getResultSet ��返�?null。这可能意味着�l�果是一个更新计数或没有其它�l�果。在�q�种情况下，判断 null 真正含义的唯一�Ҏ(gu��)��是调用方�?getUpdateCount�Q�它?y��u)��返回一个整数。这个整��Cؓ调用语句所影响的行敎ͼ�如果�?-1 则表�C�结果是�l�果集或没有�l�果。如果方�?getResultSet 已返�?null�Q�表�C�结果不�?ResultSet 对象�Q�，则返回�?-1 表示没有其它�l�果。也��是��_��当下列条件�ؓ真时表示没有�l�果�Q�或没有其它�l�果�Q�：

((stmt.getResultSet() == null) && (stmt.getUpdateCount() == -1))

如果已经调用�Ҏ(gu��)�� getResultSet �q�处理了它返回的 ResultSet 对象�Q�则有必要调用方�?getMoreResults 以确定是否有其它�l�果集或更新计数。如�?getMoreResults �q�回 true�Q�则需要再�ơ调�?getResultSet 来检索下一个结果集。如上所�q�ͼ�如果 getResultSet �q�回 null�Q�则需要调�?getUpdateCount 来检�?null 是表�C�结果�ؓ更新计数�q�是表示没有其它�l�果�?

�?getMoreResults �q�回 false �Ӟ��它表�C�� SQL 语句�q�回一个更新计数或没有其它�l�果。因此需要调用方�?getUpdateCount 来检查它是哪一�U�情��c��在�q�种情况下，当下列条件�ؓ真时表示没有其它�l�果�Q��?

((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))

下面的代码演�C�Z��一�U�方法用来确认已讉K��调用�Ҏ(gu��)�� execute 所产生的全部结果集和更新计敎ͼ�

stmt.execute(queryStringWithUnknownResults);
while (true) {
int rowCount = stmt.getUpdateCount();
if (rowCount > 0) { // 它是更新计数
System.out.println("Rows changed = " + count);
stmt.getMoreResults();
continue;
}
if (rowCount == 0) { // DDL 命��o�?0 个更�?
System.out.println(" No rows changed or statement was DDL
command");
stmt.getMoreResults();
continue;
}

// 执行到这里，证明有一个结果集
// 或没有其它结�?

ResultSet rs = stmt.getResultSet;
if (rs != null) {
. . . // 使用元数据获得关于结果集列的信息
while (rs.next()) {
. . . // 处理�l�果
stmt.getMoreResults();
continue;
}
break; // 没有其它�l�果

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630445

風向逆轉 - ��p��爪哇 2006-03-22 03:30 发表评论

[收藏]JDBC�p�d��教程�Q�二�Q?--驱动讄��

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:28:00 GMT

JDBC�p�d��教程�Q�二�Q?--驱动讄��

DriverManager
本概�q�摘自《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference》，目前正由 JavaSoft �l�箋�~�写。这本书既是 JDBC 的教�E�，也是一本权威性参考手册，��作�?Java �p�d��的一部分�?1997 �q�春季由 Addison-Wesley 出版公司出版。�?

3.1 概述
DriverManager �c�L�� JDBC 的管理层�Q�作用于用户和驱动程序之间。它跟踪可用的驱动程序，�q�在数据库和相应驱动�E�序之间建立�q�接。另外，DriverManager �c�M��处理诸如驱动�E�序��d��旉��限制及登录和跟踪消息的显�C�等事务�?

对于��单的应用�E�序�Q�一般程序员需要在此类中直接��用的唯一�Ҏ(gu��)��?DriverManager.getConnection。正如名�U�所�C�，该方法将建立与数据库的连接。JDBC 允许用户调用 DriverManager 的方�?getDriver、getDrivers �?registerDriver �?Driver 的方�?connect。但多数情况下，�?DriverManager �cȝ��理徏立连接的�l�节��Z��{��?

3.1.1 跟踪可用驱动�E�序
DriverManager �c�d��含一�?Driver �c�，它们已通过调用�Ҏ(gu��)�� DriverManager.registerDriver 对自��p��行了注册。所�?Driver �c�都必须包含有一个静态部分。它创徏该类的实例，然后在加载该实例�?DriverManager �c�进行注册。这��P��用户正常情况下将不会直接调用 DriverManager.registerDriver�Q�而是在加载驱动程序时由驱动程序自动调用。加�?Driver �c�，然后自动�?DriverManager 中注册的方式有两�U�：

通过调用�Ҏ(gu��)�� Class.forName。这��显式地加蝲驱动�E�序�c�R��由于这与外部设�|�无养I��因此推荐使用�q�种加蝲驱动�E�序的方法。以下代码加载类 acme.db.Driver�Q��?
Class.forName("acme.db.Driver");

如果��?acme.db.Driver �~�写为加载时创徏实例�Q��ƈ调用以该实例为参数的 DriverManager.registerDriver�Q�本该如此）�Q�则它在 DriverManager 的驱动程序列表中�Q��ƈ可用于创��接�?

通过��驱动程序添加到 java.lang.System 的属�?jdbc.drivers 中。这是一个由 DriverManager �c�d��载的驱动�E�序�c�d��的列表，由冒号分隔：初始�?DriverManager �c�L��Q�它搜烦�pȝ��属�?jdbc.drivers�Q�如果用户已输入了一个或多个驱动�E�序�Q�则 DriverManager �c�d��试图加蝲它们。以下代码说明程序员如何�?~/.hotjava/properties 中输入三个驱动程序类�Q�启动时�Q�HotJava ��把它加载到�pȝ��属性列表中�Q�：
jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.test.ourDriver;

�?DriverManager �Ҏ(gu��)��的第一�ơ调用将自动加蝲�q�些驱动�E�序�c�R�?

注意�Q�加载驱动程序的�W�二�U�方法需要持久的预设环境。如果对�q�一点不能保证，则调用方�?Class.forName 昑ּ�地加载每个驱动程序就昑־�更�ؓ安全。这也是引入特定驱动�E�序的方法，因�ؓ一�?DriverManager �c�被初始化，它将不再��?jdbc.drivers 属性列表�?

在以上两�U�情况中�Q�新加蝲�?Driver �c�都要通过调用 DriverManager.registerDriver �c�进行自我注册。如上所�q�ͼ�加蝲�c�L��自动执行这一�q�程�?

�׃��安全斚w��的原因，JDBC ��理层将跟踪哪个�c�d��载器提供哪个驱动�E�序。这��P��?DriverManager �c�L��开�q�接�Ӟ��它仅使用本地文�g�pȝ��或与发出�q�接��h��的代码相同的�c�d��载器提供的驱动程序�?

3.1.2 建立�q�接
加蝲 Driver �c�dƈ�?DriverManager �c�M��注册后，它们卛_��用来与数据库建立�q�接。当调用 DriverManager.getConnection �Ҏ(gu��)��发出�q�接��h��Ӟ��DriverManager ��检查每个驱动程序，查看它是否可以徏立连接�?

有时可能有多�?JDBC 驱动�E�序可以与给定的 URL �q�接。例如，与给定远�E�数据库�q�接�Ӟ��可以使用 JDBC-ODBC 桥驱动程序、JDBC 到通用�|�络协议驱动�E�序或数据库厂商提供的驱动程序。在�q�种情况下，��试驱动�E�序的顺序至关重要，因�ؓ DriverManager ��用它所扑ֈ�的第一个可以成功连接到�l�定 URL 的驱动程序�?

首先 DriverManager 试图按注册的��序使用每个驱动�E�序�Q�jdbc.drivers 中列出的驱动�E�序��L��先注册）。它?y��u)��蟩�q�代码不可信�ȝ��驱动�E�序�Q�除非加载它们的源与试图打开�q�接的代码的源相同�?

它通过轮流在每个驱动程序上调用�Ҏ(gu��)�� Driver.connect�Q��ƈ向它们传递用户开始传递给�Ҏ(gu��)�� DriverManager.getConnection �?URL 来对驱动�E�序�q�行��试�Q�然后连接第一个认�� URL 的驱动程序�?

�q�种�Ҏ(gu��)��初看��h��效率不高�Q�但�׃��不可能同时加载数十个驱动�E�序�Q�因此每�ơ连接实际只需几个�q�程调用和字�W�串比较�?

以下代码是通常情况下用驱动�E�序�Q�例�?JDBC-ODBC 桥驱动程序）建立�q�接所需所有步骤的�C�Z��Q��?

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); //加蝲驱动�E�序
String url = "jdbc:odbc:fred";
DriverManager.getConnection(url, "userID", "passwd");

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630442

風向逆轉 - ��p��爪哇 2006-03-22 03:28 发表评论

[收藏]JDBC�p�d��教程�Q�一�Q?--�q�接

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:27:00 GMT

JDBC�p�d��教程�Q�一�Q?--�q�接

�q�接
本概�q�是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备�q�本书。这本书是一本教�E�，同时也是 JDBC 的重要参考手册，它将作�ؓ Java �p�d��的组成部份在 1997 �q�春季由 Addison-Wesley 出版公司出版。�?

2.1 概述
Connection 对象代表与数据库的连接。连接过�E�包括所执行�?SQL 语句和在该连接上所�q�回的结果。一个应用程序可与单个数据库有一个或多个�q�接�Q�或者可与许多数据库有连接�?

2.1.1 打开�q�接
与数据库建立�q�接的标准方法是调用 DriverManager.getConnection �Ҏ(gu��)��。该�Ҏ(gu��)��接受含有某个 URL 的字�W�串。DriverManager �c�（��x��谓的 JDBC ��理层）��尝试找到可与那�?URL 所代表的数据库�q�行�q�接的驱动程序。DriverManager �c�d��有已注册�?Driver �cȝ��清单。当调用�Ҏ(gu��)�� getConnection �Ӟ��它将��查清单中的每个驱动程序，直到扑ֈ�可与 URL 中指定的数据库进行连接的驱动�E�序为止。Driver 的方�?connect 使用�q�个 URL 来徏立实际的�q�接�?

用户可绕�q?JDBC ��理层直接调�?Driver �Ҏ(gu��)��。这在以下特�D�情况下��很有用�Q�当两个驱动器可同时�q�接到数据库中，而用户需要明��地选用其中特定的驱动器。但一般情况下�Q�让 DriverManager �c�d��理打开�q�接�q�种事将更�ؓ��单�?

下述代码昄��如何打开一个与位于 URL "jdbc:odbc:wombat" 的数据库的连接。所用的用户标识�W��ؓ "oboy" �Q�口令�ؓ "12Java"�Q��?

String url = "jdbc:odbc:wombat";
Connection con = DriverManager.getConnection(url, "oboy", "12Java");

2.1.2 一般用法的 URL
�׃�� URL 常引��h؜淆，我们��先对一�?URL 作简单说明，然后再讨�?JDBC URL�?

URL�Q�统一资源定位�W�）提供�?Internet 上定位资源所需的信息。可��它惌��Z��个地址�?

URL 的第一部䆾指定了访问信息所用的协议�Q�后面��L��跟着冒号。常用的协议�?"ftp"�Q�代表“文件传输协议”）�?"http" �Q�代表“超文本传输协议”）。如果协议是 "file"�Q�表�C��源是在某个本地文件系�l�上而非�?Internet 上（下例用于表示我们所描述的部分；它�ƈ�?URL 的组成部分）�?

ftp://javasoft.com/docs/JDK-1_apidocs.zip
http://java.sun.com/products/jdk/CurrentRelease
file:/home/haroldw/docs/books/tutorial/summary.html

URL 的其余部份（冒号后面的）�l�出了数据资源所处位�|�的有关信息。如果协议是 file�Q�则 URL 的其余部份是文�g的�\径。对�?ftp �?http 协议�Q�URL 的其余部份标识了��L��q�可选地�l�出某个更详��的地址路径。例如，以下�?JavaSoft 主页�?URL。该 URL 只标识了��L��Q��?

http://java.sun.com

从该主页开始浏览，��可以进到许多其它的�|�页中，其中之一��是 JDBC 主页。JDBC 主页�?URL 更�ؓ具体�Q�它看�v来类��|��

http://java.sun.com/products/jdbc

2.1.3 JDBC URL
JDBC URL 提供了一�U�标识数据库的方法，可以使相应的驱动�E�序能识别该数据库�ƈ与之建立�q�接。实际上�Q�驱动程序编�E�员��决定用什�?JDBC URL 来标识特定的驱动�E�序。用户不必关心如何来形成 JDBC URL�Q�他们只��M��用与所用的驱动�E�序一��h��供的 URL 卛_��。JDBC 的作用是提供某些�U�定�Q�驱动程序编�E�员在构造他们的 JDBC URL 时应该遵循这些约定�?

�׃�� JDBC URL 要与各种不同的驱动程序一起��用，因此�q�些�U�定应非常灵�z�R��首先，它们应允�怸�同的驱动�E�序使用不同的方案来命名数据库。例如， odbc 子协议允许（但�ƈ不是要求�Q?URL 含有属性倹{�?

�W�二�Q�JDBC URL 应允讔R��动程序编�E�员��一切所需的信息编入其中。这样就可以让要与给定数据库对话�?applet 打开数据库连接，而无��要求用户去做�Q何系�l�管理工作�?

�W�三�Q?JDBC URL 应允许某�U�程度的间接性。也��是��_��JDBC URL 可指向逻辑��L��或数据库名，而这�U�逻辑��L��或数据库名将��q��l�命名系�l�动态地转换为实际的名称。这可以使系�l�管理员不必��特定主机声明�ؓ JDBC 名称的一部䆾。网�l�命名服务（例如 DNS�?NIS �?DCE �Q�有多种,而对于��用哪�U�命名服务�ƈ无限制�?

JDBC URL 的标准语法如下所�C�。它�׃��部分�l�成�Q�各部分间用冒号分隔�Q��?

jdbc:< 子协�?>:< 子名�U?>

JDBC URL 的三个部分可分解如下�Q��?

jdbc ─ 协议。JDBC URL 中的协议��L�� jdbc�?

<子协�?gt; ─ 驱动�E�序名或数据库连接机�Ӟ��q�种机制可由一个或多个驱动�E�序支持�Q�的名称。子协议名的典型�C�Z��?"odbc"�Q�该名称是�ؓ用于指定 ODBC 风格的数据资源名�U�的 URL 专门保留的。例如，��Z��通过 JDBC-ODBC 桥来讉K��某个数据库，可以用如下所�C�的 URL�Q��?
jdbc:odbc:fred

本例中，子协议�ؓ "odbc"�Q�子名称 "fred" 是本�?
ODBC 数据资源�?

如果要用�|�络命名服务�Q�这�?JDBC URL 中的数据库名�U�C��必是实际名称�Q�，则命名服务可以作为子协议。例如，可用如下所�C�的 URL �Q��?

jdbc:dcenaming:accounts-payable

本例中，�?URL 指定了本�?DCE 命名服务应该��?
数据库名�U?"accounts-payable" 解析为更为具体的
可用于连接真实数据库的名�U��?

<子名�U?gt; ─ 一�U�标识数据库的方法。子名称可以依不同的子协议而变化。它�q�可以有子名�U�的子名�U�ͼ�含有驱动�E�序�~�程员所选的��M��内部语法�Q�。��用子名称的目的是为定位数据库提供��_��的信息。前例中�Q�因�?ODBC ��提供其余部份的信息�Q�因此用 "fred" ��已��_��。然而，位于�q�程服务器上的数据库需要更多的信息。例如，如果数据库是通过 Internet 来访问的�Q�则�?JDBC URL 中应��网�l�地址作�ؓ子名�U�的一部䆾包括�q�去�Q�且必须遵��@如下所�C�的标准 URL 命名�U�定�Q��?
//��L��?端口/子协�?

假设 "dbnet" 是个用于��某个主��接到 Internet 上的协议�Q�则 JDBC URL �c�M��Q?

jdbc:dbnet://wombat:356/fred

2.1.4 "odbc" 子协�?
子协�?odbc 是一�U�特�D�情��c��它是�ؓ用于指定 ODBC 风格的数据资源名�U�的 URL 而保留的�Q��ƈ��h��下列�Ҏ(gu��)��：允许在子名称�Q�数据资源名�U�ͼ�后面指定��L��多个属性倹{��odbc 子协议的完整语法为：

jdbc:odbc:< 数据资源名称 >[;< 属性名 >=< 属性�?>]*

因此�Q�以下都是合法的 jdbc:odbc 名称�Q��?

jdbc:odbc:qeor7
jdbc:odbc:wombat
jdbc:odbc:wombat;CacheSize=20;ExtensionCase=LOWER
jdbc:odbc:qeora;UID=kgh;PWD=fooey

2.1.5 注册子协�?
驱动�E�序�~�程员可保留某个名称以将之用�?JDBC URL 的子协议名。当 DriverManager �c�d��此名�U�加到已注册的驱动程序清单中�Ӟ��Z��保留该名�U�的驱动�E�序应能识别该名�U��ƈ与它所标识的数据库建立�q�接。例如，odbc 是�ؓ JDBC- ODBC 桥而保留的。示例之二，假设有个 Miracle 公司�Q�它可能会将 "miracle" 注册��接到�?Miracle DBMS 上的 JDBC 驱动�E�序的子协议�Q�从而��其他人都无法使用�q�个名称�?

JavaSoft 目前作�ؓ非正式代理负责注�?JDBC 子协议名�U�。要注册某个子协议名�U�ͼ�请发送电(sh��)子邮件到下述地址�Q��?

jdbc@wombat.eng.sun.com

2.1.6 发�?SQL 语句
�q�接一旦徏立，��可用来向它所涉及的数据库传�?SQL 语句。JDBC 对可被发送的 SQL 语句�c�d��不加��M��限制。这��提供了很大的灵�z�L��，卛_��怋�用特定的数据库语句或甚至于非 SQL 语句。然而，它要求用戯��p��责确保所涉及的数据库可以处理所发送的 SQL 语句�Q�否则将自食其果。例如，如果某个应用�E�序试图向不支持储存�E�序�?DBMS 发送储存程序调用，��׃��p�|�q�将抛出异常。JDBC 要求驱动�E�序应至��能提供 ANSI SQL-2 Entry Level 功能才可��是�W�合 JDBC 标准TM 的。这意味着用户臛_��可信赖这一标准�U�别的功能�?

JDBC 提供了三个类�Q�用于向数据库发�?SQL 语句。Connection 接口中的三个�Ҏ(gu��)��可用于创��些类的实例。下面列��些类及其创徏�Ҏ(gu��)��Q��?

Statement ─ 由方�?createStatement 所创徏。Statement 对象用于发送简单的 SQL 语句。�?
PreparedStatement ─ 由方�?prepareStatement 所创徏。PreparedStatement 对象用于发送带有一个或多个输入参数�Q?IN 参数�Q�的 SQL 语句。PreparedStatement 拥有一�l�方法，用于讄�� IN 参数的倹{��执行语句时�Q�这�?IN 参数��被送到数据库中。PreparedStatement 的实例扩展了 Statement �Q�因此它们都包括�?Statement 的方法。PreparedStatement 对象有可能比 Statement 对象的效率更高，因�ؓ它已被预�~�译�q��ƈ存放在那以供��来使用。�?
CallableStatement ─ 由方�?prepareCall 所创徏。CallableStatement 对象用于执行 SQL 储存�E�序 ─ 一�l�可通过名称来调用（��p��函数的调用那��P��?SQL 语句。CallableStatement 对象�?PreparedStatement 中��承了用于处理 IN 参数的方法，而且�q�增加了用于处理 OUT 参数�?INOUT 参数的方法。�?

以下所列提供的�Ҏ(gu��)��可以快速决定应用哪�?Connection �Ҏ(gu��)��来创��Z��同类型的 SQL 语句�Q��?

createStatement �Ҏ(gu��)��用于�Q?

��单的 SQL 语句�Q�不带参敎ͼ�

prepareStatement �Ҏ(gu��)��用于�Q��?

带一个或多个 IN 参数�?SQL 语句

�l�常被执行的��?SQL 语句

prepareCall �Ҏ(gu��)��用于�Q��?

调用已储存过�E?

2.1.7 事务
事务�׃��个或多个�q�样的语句组成：�q�些语句已被执行、完成�ƈ被提交或�q�原。当调用�Ҏ(gu��)�� commit �?rollback �Ӟ��当前事务卛_��q��束，另一个事务随卛_��始�?

�~�省情况下，新连接将处于自动提交模式。也��是��_��当执行完语句后，��自动对那个语句调用 commit �Ҏ(gu��)��。这�U�情况下�Q�由于每个语句都是被单独提交的，因此一个事务只�׃��个语句组成。如果禁用自动提交模式，事务��要�{�到 commit �?rollback �Ҏ(gu��)��被显式调用时才结束，因此它将包括上一�ơ调�?commit �?rollback �Ҏ(gu��)��以来所有执行过的语句。对于第二种情况�Q�事务中的所有语句将作�ؓ�l�来提交或还原�?

�Ҏ(gu��)�� commit �?SQL 语句�Ҏ(gu��)��据库所做的��M��更改成�ؓ�怹�性的�Q�它�q�将释放事务持有的全部锁。而方�?rollback ��弃去那些更攏V�?

有时用户在另一个更改生效前不想让此更改生效。这可通过��用自动提交�q�将两个更新�l�合在一个事务中来达到。如果两个更新都是成功的�Q�则调用 commit �Ҏ(gu��)��Q�从而��两个更新�l�果成�ؓ�怹�性的�Q�如果其中之一或两个更新都��p�|了，则调�?rollback �Ҏ(gu��)��Q�以��值恢复�ؓ�q�行更新之前的倹{�?

大多�?JDBC 驱动�E�序都支持事务。事实上�Q�符�?JDBC 的驱动程序必��L��持事务。DatabaseMetaData �l�出的信息描�q?DBMS 所提供的事务支持水�q��?

2.1.8 事务隔离�U�别
如果 DBMS 支持事务处理�Q�它必须有某�U�途径来管理两个事务同时对一个数据库�q�行操作时可能发生的冲突。用户可指定事务隔离�U�别�Q�以指明 DBMS 应该花多大精力来解决潜在冲突。例如，当事务更改了某个��D��第二个事务却在该更改被提交或还原前��d��该值时该怎么办？假设�W�一个事务被�q�原后，�W�二个事务所��d��的更改值将是无效的�Q�那么是否可允许�q�种冲突�Q?JDBC 用户可用以下代码来指�C?DBMS 允许在��D��提交前读取该��|��“dirty ��d��”）�Q�其�?con 是当前连接：

con.setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED);

事务隔离�U�别��高�Q��ؓ避免冲突所��q��_�֊�也就��多。Connection 接口定义了五�U�，其中最低��别指定了�Ҏ(gu��)��׃��支持事务�Q�而最高��别则指定当事务在�Ҏ(gu��)��个数据库�q�行操作�Ӟ��M��其它事务不得寚w��个事务正在读取的数据�q�行��M��更改。通常�Q�隔��ȝ�别越高，应用�E�序执行的速度也就��慢�Q�由于用于锁定的资源耗费增加了，而用户间的�ƈ发操作减��了�Q�。在军_��采用什么隔��ȝ�别时�Q�开发�h员必��d��性能需求和数据一致性需求之间进行权衡。当�Ӟ��实际所能支持的�U�别取决于所涉及�?DBMS 的功能�?

当创�?Connection 对象�Ӟ��其事务隔��ȝ�别取决于驱动�E�序�Q�但通常是所涉及的数据库的缺省倹{��用户可通过调用 setIsolationLevel �Ҏ(gu��)��来更改事务隔��ȝ�别。新的��别将在该�q�接�q�程的剩余时间内生效。要惛_��改变一个事务的事务隔离�U�别�Q�必��d��该事务开始前�q�行讄��Q��ƈ在该事务�l�束后进行复位。我们不提倡在事务的中途对事务隔离�U�别�q�行更改�Q�因��立卌��?commit �Ҏ(gu��)��的调用，使在此之前所作的��M��更改变成�怹�性的。�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=630439

風向逆轉 - ��p��爪哇 2006-03-22 03:27 发表评论

[收藏]Java�E�序员的存储�q�程

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:26:00 GMT

Java�E�序员的存储�q�程
--------------------------------------------------------------------------------

原文�Q?a >http://www.onjava.com/pub/a/onjava/2003/08/13/stored_procedures.html
by Nic Ferrier

本文阐述了怎么使用DBMS存储�q�程。我阐述了��用存储过�E�的基本的和高��Ҏ(gu��)��，比如�q�回ResultSet。本文假设你对DBMS和JDBC已经非常熟�?zh��n)��Q�也假设你能够毫无障��地阅读其它语言写成的代码（即不是Java的语�a��Q�，但是�Q��ƈ不要求你有�Q何存储过�E�的�~�程�l�历�?
存储�q�程是指保存在数据库�q�在数据库端执行的程序。你可以使用�Ҏ(gu��)��的语法在Java�c�M��调用存储�q�程。在调用�Ӟ��存储�q�程的名�U�及指定的参数通过JDBC�q�接发送给DBMS�Q�执行存储过�E��ƈ通过�q�接�Q�如果有�Q�返回结果�?
使用存储�q�程拥有和��用基于EJB或CORBA�q�样的应用服务器一��L��好处。区别是存储�q�程可以从很多流行的DBMS中免费��用，而应用服务器大都非常昂贵。这�q�不只是许可证费用的问题。��用应用服务器所需要花费的��理、编写代码的费用�Q�以及客��L��序所增加的复杂性，都可以通过DBMS中的存储�q�程所整个地替代�?
你可以��用Java�Q�Python�Q�Perl或C�~�写存储�q�程�Q�但是通常使用你的DBMS所指定的特定语�a�。Oracle使用PL/SQL�Q�PostgreSQL使用pl/pgsql�Q�DB2使用Procedural SQL。这些语�a�都非常相伹{��在它们之间�U�L��存储�q�程�q�不比在Sun的EJB规范不同实现版本之间�U�L��Session Bean困难。�ƈ且，存储�q�程是�ؓ嵌入SQL所设计�Q�这使得它们比Java或C�{�语�a�更加友好地方式表达数据库的机制�?
因�ؓ存储�q�程�q�行在DBMS自��n�Q�这可以帮助减少应用�E�序中的�{�待旉��。不是在Java代码中执�?个或5个SQL语句�Q�而只需要在服务器端执行1个存储过�E�。网�l�上的数据往�q�次数的减少可以戏剧性地优化性能�?

使用存储�q�程

��单的老的JDBC通过CallableStatement�c�L��持存储过�E�的调用。该�c�d��际上是PreparedStatement的一个子�c�R��假设我们有一个poets数据库。数据库中有一个设�|�诗人逝世�q�龄的存储过�E�。下面是对老酒鬼Dylan Thomas�Q�old soak Dylan Thomas�Q�不指定是否有关典故、文化，��h��评指正。译注）�q�行调用的详�l�代码：

try
{
    int age = 39;
    String poetName = "dylan thomas";
    CallableStatement proc =
        connection.prepareCall("{ call set_death_age(?, ?) }");
    proc.setString(1, poetName);
    proc.setInt(2, age);
    cs.execute();
}
catch (SQLException e)
{
    // ....
}

传给prepareCall�Ҏ(gu��)��的字串是存储�q�程调用的书写规范。它指定了存储过�E�的名称�Q�？代表了你需要指定的参数�?
和JDBC集成是存储过�E�的一个很大的便利�Q��ؓ了从应用中调用存储过�E�，不需要存根（stub�Q�类或者配�|�文�Ӟ��除了你的DBMS的JDBC驱动�E�序外什么也不需要�?
当这�D�代码执行时�Q�数据库的存储过�E�就被调用。我们没有去获取�l�果�Q�因��存储�q�程�q�不�q�回�l�果。执行成功或��p�|��通过例外得知。失败可能意味着调用存储�q�程时的��p�|�Q�比如提供的一个参数的�c�d��不正��）�Q�或者一个应用程序的��p�|�Q�比如抛��Z��个例外指�C�在poets数据库中�q�不存在“Dylan Thomas”）

�l�合SQL操作与存储过�E?

映射Java对象到SQL表中的行相当��单，但是通常需要执行几个SQL语句�Q�可能是一个SELECT查找ID�Q�然后一个INSERT插入指定ID的数据。在高度规格化（�W�合更高的范式，译注�Q�的数据库模式中�Q�可能需要多个表的更斎ͼ�因此需要更多的语句。Java代码会很快地膨胀�Q�每一个语句的�|�络开销也迅速增加�?
��这些SQL语句转移��C��个存储过�E�中��大大简化代码，仅涉及一�ơ网�l�调用。所有关联的SQL操作都可以在数据库内部发生。�ƈ且，存储�q�程语言�Q�例如PL/SQL�Q�允�怋�用SQL语法�Q�这比Java代码更加自然。下面是我们早期的存储过�E�，使用Oracle的PL/SQL语言�~�写�Q?

create procedure set_death_age(poet VARCHAR2, poet_age NUMBER)
    poet_id NUMBER;
begin
SELECT id INTO poet_id FROM poets WHERE name = poet;
INSERT INTO deaths (mort_id, age) VALUES (poet_id, poet_age);
end set_death_age;

很独特？不。我打赌你一定期待看��C��个poets表上的UPDATE。这也暗�C�Z��使用存储�q�程实现是多么容易的一件事情。set_death_age几乎可以肯定是一个很烂的实现。我们应该在poets表中��d��一列来存储逝世�q�龄。Java代码中�ƈ不关心数据库模式是怎么实现的，因�ؓ它仅调用存储�q�程。我们以后可以改变数据库模式以提高性能�Q�但是我们不必修�Ҏ(gu��)��们代码�?
下面是调用上面存储过�E�的Java代码�Q?

public static void setDeathAge(Poet dyingBard, int age)
    throws SQLException
{
   Connection con = null;
   CallableStatement proc = null;

   try
   {
      con = connectionPool.getConnection();
      proc = con.prepareCall("{ call set_death_age(?, ?) }");
      proc.setString(1, dyingBard.getName());
      proc.setInt(2, age);
      proc.execute();
   }
   finally
   {
      try
      {
         proc.close();
      }
      catch (SQLException e) {}
      con.close();
   }
}

��Z��保可维护性，��使用像这儿这��L��static�Ҏ(gu��)��。这也��得调用存储过�E�的代码集中在一个简单的模版代码中。如果你用到许多存储�q�程�Q�就会发��C��需要拷贝、粘贴就可以创徏新的�Ҏ(gu��)��。因��Z��码的模版化，甚至也可以通过脚本自动生��调用存储�q�程的代码�?

Functions

存储�q�程可以有返回��|��所以CallableStatement�c�L��c�M��getResultSet�q�样的方法来获取�q�回倹{��当存储�q�程�q�回一个值时�Q�你必须使用registerOutParameter�Ҏ(gu��)��告诉JDBC驱动器该值的SQL�c�d��是什么。你也必��调整存储过�E�调用来指示该过�E�返回一个倹{�?
下面接着上面的例子。这�ơ我们查询Dylan Thomas逝世时的�q�龄。这�ơ的存储�q�程使用PostgreSQL的pl/pgsql�Q?

create function snuffed_it_when (VARCHAR) returns integer '
declare
    poet_id NUMBER;
    poet_age NUMBER;
begin
    -- first get the id associated with the poet.
    SELECT id INTO poet_id FROM poets WHERE name = $1;
    -- get and return the age.
    SELECT age INTO poet_age FROM deaths WHERE mort_id = poet_id;
    return age;
end;
' language 'pl/pgsql';

另外�Q�注意pl/pgsql参数名通过Unix和DOS脚本�?n语法引用。同�Ӟ��也注意嵌入的注释�Q�这是和Java代码相比的另一个优��性。在Java中写�q�样的注释当然是可以的，但是看�v来很凌�ؕ�Q��ƈ且和SQL语句��p��Q�必��d��入到Java String中�?
下面是调用这个存储过�E�的Java代码�Q?

connection.setAutoCommit(false);
CallableStatement proc =
    connection.prepareCall("{ ? = call snuffed_it_when(?) }");
proc.registerOutParameter(1, Types.INTEGER);
proc.setString(2, poetName);
cs.execute();
int age = proc.getInt(2);

如果指定了错误的�q�回值类型会怎样�Q�那么，当调用存储过�E�时��抛��Z��个RuntimeException�Q�正如你在ResultSet操作中��用了一个错误的�c�d��所��到的一栗��?

复杂的返回�?

关于存储�q�程的知识，很多人好像就熟�?zh��n)�我们所讨论的这些。如果这是存储过�E�的全部功能�Q�那么存储过�E�就不是其它�q�程执行机制的替换方案了。存储过�E�的功能比这强大得多�?
当你执行一个SQL查询�Ӟ��DBMS创徏一个叫做cursor�Q�游标）的数据库对象�Q�用于在�q�回�l�果中�P代每一行。ResultSet是当前时间点的游标的一个表�C�。这��是��Z��么没有缓存或者特定数据库的支持，你只能在ResultSet中向前移动�?
某些DBMS允许从存储过�E�中�q�回游标的一个引用。JDBC�q�不支持�q�个功能�Q�但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针�Q�pointer�Q��?
设想列出所有没有活到退休年龄的诗�h�Q�下面是完成�q�个功能的存储过�E�，�q�回一个打开的游标，同样也��用PostgreSQL的pl/pgsql语言�Q?

create procedure list_early_deaths () return refcursor as '
declare
    toesup refcursor;
begin
    open toesup for
        SELECT poets.name, deaths.age
        FROM poets, deaths
        -- all entries in deaths are for poets.
        -- but the table might become generic.
        WHERE poets.id = deaths.mort_id
            AND deaths.age < 60;
    return toesup;
end;
' language 'plpgsql';

下面是调用该存储�q�程的Java�Ҏ(gu��)��Q�将�l�果输出到PrintWriter�Q?
PrintWriter:

static void sendEarlyDeaths(PrintWriter out)
{
    Connection con = null;
    CallableStatement toesUp = null;
    try
    {
        con = ConnectionPool.getConnection();

        // PostgreSQL needs a transaction to do this...
        con.setAutoCommit(false);

        // Setup the call.
        CallableStatement toesUp
            = connection.prepareCall("{ ? = call list_early_deaths () }");
        toesUp.registerOutParameter(1, Types.OTHER);
        getResults.execute();

        ResultSet rs = (ResultSet) getResults.getObject(1);
        while (rs.next())
        {
            String name = rs.getString(1);
            int age = rs.getInt(2);
            out.println(name + " was " + age + " years old.");
        }
        rs.close();
    }
    catch (SQLException e)
    {
        // We should protect these calls.
        toesUp.close();
        con.close();
    }
}

因�ؓJDBC�q�不直接支持从存储过�E�中�q�回游标�Q�我们��用Types.OTHER来指�C�存储过�E�的�q�回�c�d��Q�然后调用getObject()�Ҏ(gu��)��q�对�q�回��D��行强制类型�{换�?
�q�个调用存储�q�程的Java�Ҏ(gu��)��是mapping的一个好例子。Mapping是对一个集上的操作�q�行抽象的方法。不是在�q�个�q�程上返回一个集�Q�我们可以把操作传送进��L��行。本例中�Q�操作就是把ResultSet打印��C��个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过�E�的另外一个方法实玎ͼ�

public class ProcessPoetDeaths
{
    public abstract void sendDeath(String name, int age);
}

static void mapEarlyDeaths(ProcessPoetDeaths mapper)
{
    Connection con = null;
    CallableStatement toesUp = null;
    try
    {
        con = ConnectionPool.getConnection();
        con.setAutoCommit(false);

        CallableStatement toesUp
            = connection.prepareCall("{ ? = call list_early_deaths () }");
        toesUp.registerOutParameter(1, Types.OTHER);
        getResults.execute();

        ResultSet rs = (ResultSet) getResults.getObject(1);
        while (rs.next())
        {
            String name = rs.getString(1);
            int age = rs.getInt(2);
            mapper.sendDeath(name, age);
        }
        rs.close();
    }
    catch (SQLException e)
    {
        // We should protect these calls.
        toesUp.close();
        con.close();
    }
}

�q�允许在ResultSet数据上执行�Q意的处理�Q�而不需要改变或者复制获取ResultSet的方法：

static void sendEarlyDeaths(final PrintWriter out)
{
    ProcessPoetDeaths myMapper = new ProcessPoetDeaths()
    {
        public void sendDeath(String name, int age)
        {
            out.println(name + " was " + age + " years old.");
        }
    };
    mapEarlyDeaths(myMapper);
}

�q�个�Ҏ(gu��)��使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath�Ҏ(gu��)��的一个实玎ͼ�和我们上面的例子一��L��方式把结果写入到输出��。当�Ӟ��q�个技巧�ƈ不是存储�q�程�Ҏ(gu��)��的，但是和存储过�E�中�q�回的ResultSet�l�合使用�Q�是一个非常强大的工具�?

�l�论

存储�q�程可以帮助你在代码中分��逻辑�Q�这基本上��L��有益的。这个分��ȝ��好处有：
• 快速创建应用，使用和应用一��h��变和改善的数据库模式。�?
• 数据库模式可以在以后改变而不影响Java对象�Q�当我们完成应用后，可以重新设计更好的模式�?
• 存储�q�程通过更好的SQL嵌入使得复杂的SQL更容易理解�?
• �~�写存储�q�程比在Java中编写嵌入的SQL拥有更好的工��P��Q�大部分�~�辑器都提供语法高亮�Q?
• 存储�q�程可以在�Q何SQL命��o行中��试�Q�这使得调试更加�Ҏ(gu��)��?

�q�不是所有的数据库都支持存储�q�程�Q�但是存在许多很��的实现�Q�包括免�?开源的和非免费的，所以移植�ƈ不是一个问题。Oracle、PostgreSQL和DB2都有�c�M��的存储过�E�语�a��Q��ƈ且有在线的社区很好地支持�?
存储�q�程工具很多�Q�有像TOAD或TORA�q�样的编辑器、调试器和IDE�Q�提供了�~�写、维护PL/SQL或pl/pgsql的强大的环境�?
存储�q�程��实增加了你的代码的开销�Q�但是它们和大多数的应用服务器相比，开销��得多。如果你的代码复杂到需要��用DBMS�Q�我��整个采用存储�q�程的方式�?

资源

• JDBC specification
• PostgreSQL
• Oracle Corporation's Oracle database server
• IBM's DB2 database server

作者简介：Nic Ferrier 是Web应用斚w��的独立��Y仉��问。�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=629847

風向逆轉 - ��p��爪哇 2006-03-22 03:26 发表评论

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:24:00 GMT

谈谈JDBC接口技�?/span>
--------------------------------------------------------------------------------

   JDBC是一�U�可用于执行SQL语句的JavaAPI�Q�ApplicationProgrammingInterface应用�E�序设计接口�Q�。它�׃��些Java语言�~�写的类和界面组成。JDBC为数据库应用开发�h员、数据库前台工具开发�h员提供了一�U�标准的应用�E�序设计接口�Q��开发�h员可以用�U�Java语言�~�写完整的数据库应用�E�序。�?

    一、ODBC到JDBC的发展历�E��?

    说到JDBC�Q�很�Ҏ(gu��)��让�h联想到另一个十分熟�(zh��n)�的字眼“ODBC”。它们之间有没有联系呢？如果有，那么它们之间又是怎样的关�p�d��Q��?

    ODBC是OpenDatabaseConnectivity的英文简写。它是一�U�用来在相关或不相关的数据库��理�pȝ��Q�DBMS�Q�中存取数据的，用C语言实现的，标准应用�E�序数据接口。通过ODBCAPI�Q�应用程序可以存取保存在多种不同数据库管理系�l�（DBMS�Q�中的数据，而不论每个DBMS使用了何�U�数据存储格式和�~�程接口。�?

    1�Q�ODBC的结构模型�?
    ODBC的结构包括四个主要部分：应用�E�序接口、驱动器��理器、数据库驱动器和数据源。�?
    应用�E�序接口�Q�屏蔽不同的ODBC数据库驱动器之间函数调用的差别，为用��h��供统一的SQL�~�程接口。�?
    驱动器管理器�Q��ؓ应用�E�序装蝲数据库驱动器。�?
    数据库驱动器�Q�实现ODBC的函数调用，提供对特定数据源的SQL��h��。如果需要，数据库驱动器��修改应用程序的��h��Q��得请求符合相关的DBMS所支持的文法。�?
    数据源：��q��h��要存取的数据以及与它相关的操作系�l�、DBMS和用于访问DBMS的网�l��^台组成。�?

    虽然ODBC驱动器管理器的主要目的是加蝲数据库驱动器�Q�以便ODBC函数调用�Q�但是数据库驱动器本�w�也执行ODBC函数调用�Q��ƈ与数据库�怺�配合。因此当应用�pȝ��发出调用与数据源�q�行�q�接�Ӟ��数据库驱动器能管理通信协议。当建立起与数据源的�q�接�Ӟ��数据库驱动器便能处理应用�pȝ��向DBMS发出的请求，对分析或发自数据源的设计�q�行必要的翻译，�q�将�l�果�q�回�l�应用系�l�。�?

    2�Q�JDBC的诞生�?

    自从Java语言�?995�q?月正式公布以来，Java风靡全球。出现大量的用java语言�~�写的程序，其中也包括数据库应用�E�序。由于没有一个Java语言的API�Q�编�E��h员不得不在Java�E�序中加入C语言的ODBC函数调用。这��׃��很多Java的优�U��Ҏ(gu��)��无法充分发挥，比如�q�_��无关性、面向对象特性等。随着��来��多的编�E��h员对Java语言的日益喜爱，��来��多的公司在Java�E�序开发上投入的精力日益增加，对java语言接口的访问数据库的API的要求越来越强烈。也�׃��ODBC的有其不��之处，比如它�ƈ不容易��用，没有面向对象的特性等�{�，SUN公司军_��开发一Java语言为接口的数据库应用程序开发接口。在JDK1�Q�x版本中，JDBC只是一个可选部�Ӟ��C��JDK1�Q?公布�Ӟ��SQL�c�d��Q�也��是JDBCAPI�Q�就成�ؓJava语言的标准部件。�?

    二、JDBC技术概�q�W?

    JDBC是一�U�可用于执行SQL语句的JavaAPI�Q�ApplicationProgrammingInterface�Q�应用程序设计接口）。它�׃��些Java语言写的�c�R��界面组成。JDBC�l�数据库应用开发�h员、数据库前台工具开发�h员提供了一�U�标准的应用�E�序设计接口�Q��开发�h员可以用�U�Java语言�~�写完整的数据库应用�E�序。�?

    通过使用JDBC�Q�开发�h员可以很方便地将SQL语句传送给几乎��M��一�U�数据库。也��是��_��开发�h员可以不必写一个程序访问Sybase�Q�写另一个程序访问Oracle�Q�再写一个程序访问Microsoft的SQLServer。用JDBC写的�E�序能够自动地将SQL语句传送给相应的数据库��理�pȝ��Q�DBMS�Q�。不但如此，使用Java�~�写的应用程序可以在��M��支持Java的��^��C��q�行�Q�不必在不同的��^��C��~�写不同的应用。Java和JDBC的结合可以让开发�h员在开发数据库应用时真正实现“WriteOnce�Q�RunEverywhere�Q�”�?

    Java��h��健壮、安全、易用等�Ҏ(gu��)��，而且支持自动�|�上下蝲�Q�本质上是一�U�很好的数据库应用的�~�程语言。它所需要的是Java应用如何同各�U�各��L��数据库连接，JDBC正是实现�q�种�q�接的关键。�?

    JDBC扩展了Java的能力，如��用Java和JDBCAPI��可以公布一个Web��，��中带有能访问远端数据库的Ap?plet。或者企业可以通过JDBC让全部的职工�Q�他们可以��用不同的操作�pȝ��Q�如Windwos�Q�Machintosh和UNIX�Q�在In?tranet上连接到几个全球数据库上�Q�而这几个全球数据库可以是不相同的。随着��来��多的程序开发�h员��用Java语言�Q�对Java讉K��数据库易操作性的需求越来越强烈。�?

    MIS��理人员喜欢Java和JDBC�Q�因��样可以更�Ҏ(gu��)��l�济地公布信息。各�U�已�l�安装在数据库中的事务处理都��l�正常运行，甚至�q�些事务处理是存储在不同的数据库��理�pȝ��中；而对新的数据库应用来��_��开发时间将�~�短�Q�安装和版本升�񔞮�大大简化。程序员可以�~�写或改写一个程序，然后��它攑֜�服务器上�Q�而每个用户都可以讉K��服务器得到最新的版本。对于信息服务行业，Java和JDBC提供了一�U�很好的向外界用��h��C��息的�Ҏ(gu��)��。�?

    1�Q�JDBC的�Q务�?

    ��单地��_��JDBC能完成下列三件事�Q��?
    1�Q�同一个数据库建立�q�接�Q��?
    2�Q�向数据库发送SQL语句�Q��?
    3�Q�处理数据库�q�回的结果。�?

    2�Q�JDBC一�U�底层的API

    JDBC是一�U�底层API�Q�这意味着它将直接调用SQL命��o。JDBC完全胜�Q�q�个��d��Q�而且比其他数据库互联更加�Ҏ(gu��)��实现。同时它也是构造高层API和数据库开发工��L��基础。高层API和数据库开发工具应该是用户界面更加友好�Q��用更加方便，更易于理解的。但所有这��L��API��最�l�被��译��JDBC�q�样的底层API。目前两�U�基于JDBC的高层API正处在开发阶�D�c��?

    1�Q�SQL语言嵌入Java的预处理器。虽然DBMS已经实现了SQL查询�Q�但JDBC要求SQL语句被当作字�W�串参数传送给Java�E�序。而嵌入式SQL预处理器允许�E�序员将SQL语句��L��Q�Java变量可以在SQL语句中��用，来接收或提供数倹{��然后SQL的预处理器将把这�U�Java�Q�SQL��L��的程序翻译成带有JDBCAPI的Java�E�序。�?

    2�Q�实��C��关系数据库到Java�cȝ��直接映射。Javasoft和其他公司已�l�宣布要实现�q�一技术。在�q�种“对象／关系”映��中�Q�表的每一行都��变成这�cȝ��一个实例，每一列的值对应实例的一个属性。程序员可以直接操作Java的对象；而存取所需要的SQL调用��在内部直接产生。还可以实现更加复杂的映��，比如多张表的行在一个Java的类中实现。�?

    随着大家对JDBC兴趣的不断浓厚，��来��多的开发�h员已�l�开始利用JDBC为基��的工兯��行开发。这使开发工作变得容易。同�Ӟ��E�序员也正在开发对最�l�用��h��说访问数据库更加�Ҏ(gu��)��的应用程序。�?

    3�Q�JDBC和ODBC及其他API的比较�?

    到目前�ؓ止，微��Y的ODBC可能是用得最�q�泛的访问关�p�L��据库的API。它提供了连接几乎�Q何一�U��^台、�Q何一�U�数据库的能力。那么，��Z��么不直接从Java中直接��用ODBC呢？

    回答是可以从Java中��用ODBC�Q�但最好在JDBC的协助下�Q�用JDBC�Q�ODBC桥接器实现。那么，��Z��么需要JDBC呢？要回�{�这个问题，有这么几个方面：

    1�Q�ODBC�q�不适合在Java中直接��用。ODBC是一个C语言实现的API�Q�从Java�E�序调用本地的C�E�序会带来一�p�d��c�M��安全性、完整性、健壮性的�~�点。�?

    2�Q�其�ơ，完全�_��地实��C��C代码ODBC到JavaAPI写的ODBC的翻译也�q�不令�h满意。比如，Java没有指针�Q�而ODBC中大量地使用了指针，包括极易出错的空指针“void�Q�”。因此，对Java�E�序员来��_��把JDBC设想成将ODBC转换成面向对象的API是很自然的。�?

    3�Q�ODBC�q�不�Ҏ(gu��)��学习�Q�它?y��u)��简单特性和复杂�Ҏ(gu��)��؜杂在一��P��甚至寚w��常简单的查询都有复杂的选项。而JDBC刚好相反�Q�它保持了简单事物的��单性，但又允许复杂的特性。�?

    4�Q�JDBC�q�样的JavaAPI对于�U�Java�Ҏ(gu��)��来说是必��ȝ��。当使用ODBC�Ӟ��Z��必须在每一台客��h��上安装ODBC驱动器和驱动��理器。如果JDBC驱动器是完全用Java语言实现的话�Q�那么JDBC的代码就可以自动的下载和安装�Q��ƈ保证其安全性，而且�Q�这��适应��M��Java�q�_��Q�从�|�络计算机NC到大型主机Mainframe。�?

    总而言之，JDBCAPI是能体现SQL最基本抽象概念的、最直接的Java接口。它建构在ODBC的基��上，因此�Q�熟�(zh��n)�ODBC的程序员��发现学习JDBC非常�Ҏ(gu��)��。JDBC保持了ODBC的基本设计特征。实际上�Q�这两种接口都是��Z��X�Q�OPENSQL的调用��接口�Q�CLI�Q�。它们的最大的不同是JDBC是基于Java的风格和优点�Q��ƈ强化了Java的风格和优点。�?

    最�q�，微��Y又推��Z��除了ODBC以外的新的API�Q�如RDO�Q�ADO和OLEDB。这些API事实上在很多斚w��上同JDBC一��h��着相同的方向努力，也就是努力成��Z��个面向对象的�Q�基于ODBC的类接口。然而，�q�些接口目前�q�不能代替ODBC�Q�尤其在ODBC驱动器已�l�在市场完全形成的时候，更重要的是它们只是ODBC的“漂亮的包装”。�?

    4�Q�JDBC两层模型和三层模型�?

    JDBC支持两层模型�Q�也支持三层模型讉K��数据库�?两层模型中，一个java Appple或者一个JA�Q�va应用直接同数据库�q�接。这��需要能直接被访问的数据库进行连接的JDBC驱动器。用��L��SQL语句被传送给数据库，而这些语句执行的�l�果��被传回�l�用戗��数据库可以在同一机器上，也可以另一机器上通过�|�络�q�行�q�接。这被称为“Client/Server”结构，用户的计��机作�ؓClient,�q�行数据库的计算��Z��为Server。这个网�l�可是intranet�Q�比如连接全体雇员的企业内部�|�，当然也可以是internet。�?

    在三层模型中�Q�命令将被发送到服务的“中间层”，而“中间层”将SQL语句发送到数据库。数据库处理SQL语句�q�将�l�果�q�回“中间层”，然后“中间层”将它们 �q�回用户。MIS��理员将发现三层模型很有吸引力，因�ؓ“中间层”可以进行对讉K��的控制�ƈ协同数据库的更新�Q�另一个优势就是如果有一个“中间层”用户就可以使用一个易用的高层的API�Q�这个API可以由“中间层”进行�{换，转换成底层的调用。而且�Q�在许多情况下，三层模型可以提供更好的性能。�?

    到目前�ؓ止，“中间层”通常�q�是用C或C++实现�Q�以保证光��性能。但随着优化�~�译器的引入�Q�将java的字节码转换成高效的机器码，用java来实现“中间层”将��来��实际。而JDBC是允�总�一个java“中间层”访问数据库的关键�?

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=629840

風向逆轉 - ��p��爪哇 2006-03-22 03:24 发表评论

風向逆轉 - ��p��爪哇 — Tue, 21 Mar 2006 19:23:00 GMT

JDBC 4.0规范之目�?/span>
--------------------------------------------------------------------------------

　　历史

　　JDBC API是一�U�成熟的技术，最早发布是1997�q?月。在最初的版本中，JDBC API着重提供一个对SQL数据库的基本调用�U�接口。之后，JDBC 2.1规范�?.0可选包规范拓宽了API的范围。包括支持更高��应用和管理��用JDBC API来增强其应用的应用服务所需的各��特征�?/p>
　　JDBC 3.0规范以填补较?y��u)��范围内的功能缺�׃ؓ目标。对于JDBC 4.0�Q�我们的目标有两个：提高所有开发者在JAVA�q�_��使用SQL开发的易用性。第二，提供企业�U�特性的JDBC工具集和API来管理JDBC资源�?
　　目标概述

　　下面列出了一般的JDBC API和JDBC 4.0 API的目标和设计原理�Q?/p>
　　1.适合J2EE和J2SE�q�_��

　　JDBC API是JAVA�q�_��的重要技术。JDBC 4.0 API应遵循JAVA 2 企业版和JAVA 2 标准版��^台的��M��方向。另外，最�q�开发的JAVA 5.0�q�_��已经展示��Z��p�d��新的�Ҏ(gu��)��和语言的改�q�，�q�在本规范中�q�泛使用�?/p>
　　2.兼容SQL:2003

　　JDBC API提供用JAVA�~�程语言�~�写标准SQL来对应用�q�行�E�序�U�访问能力。JDBC 3.0致力于确保其可以支持可广泛支持工业的��h��SQL:99特征的子集。对于JDBC 4.0也一��P��支持SQL:2003是本规范的一个主要组成部分。我们期望在不久的将来可以实现�?/p>
　　3.巩固以前的规�?/p>
　　本文档把4个以前的JDBC规范�l�织成一个单一的JDBC API规范�?/p>
　　4.提供中立于开发商的一般访问特�?/p>
　　JDBC API致力于提供支持针对不同开发商应用的高带宽的一般访问特征。其目标是提供与原生应用可以辑ֈ�的同�U�别的访问特性。然而，本API必须��_��通用和灵�z�M��适应大范围的实施�?/p>
　　5.��x��于SQL

　　JDBC API一直关注于用JAVA�~�程语言讉K��相关数据。这个目标曾在JDBC 3.0 API规范中说明，在本规范中仍是一个主要原则。提供API和工��h��改进开发难度，�q��l�集中于在JAVA�q�_��开发基于SQL的��Y件的需要。与以前的规范相��|��本规范也不阻止与其它技术进行交互，如XML�Q�CORBA和非关系型数据�?/p>
　　6.提供基础数据和更高��别的API

　　JDBC API提供标准API访各�U�数据源或旧�pȝ��。实施的差异佉K��过JDBC API抽象透明化。这使其成�ؓ�Ҏ(gu��)��开发可�U�d��工具和应用的工具开发商来说�Q�一个有价值的目标�q�_��?/p>
　　�׃��它是一个用JAVA�~�程语言对SQL的“调用”��接口�Q�所以JDBC API也适用于更高��别应用的底层�Q�如EJB 3.0容器��理的持久性，SQLJ和JDBC的RowSet实现�?/p>
　　7.保持��?/p>
　　JDBC API意欲成�ؓ一�U��用简单、直接的接口。在之上可以构徏更多复杂的实体。这个目标通过定义大量紧凑、单一目的�Ҏ(gu��)��来代替少数带有控制标识参数的复杂、多目的的方法来实现�?/p>
　　8.增强可靠性、可用行和可��?/p>
　　可靠性、可用行和可��性是J2EE和J2SE�q�_��的主题，也是未来JAVA�q�_��的主题。JDBC 4.0 API严格按照以上目标�q�行。它扩展支持了一些领域，包括资源��理、对逻辑�q�接预备声明的复用和错误处理�?/p>
　　9.支持对已有应用和驱动的向后兼�?/p>
　　使用已有JDBC技术的驱动和应用必��能够在支持JDBC 4.0 API的JAVA虚拟��Z��l�箋工作。那些只使用更早版本中定义的JDBC API�Q�不包括在JDBC 2.0中已废除的）的应用，应该不需要修改就可以�l�箋�q�行。已有的应用应该可以直接�q�移到JDBC 4.0技术�?/p>
　　10.与JDBC RowSet工具紧密联系

　　J2SE 5.0包含一个标准JDBC RowSet工具�Q�在《JDBC RowSet工具集》中说明�Q�JSR-114�Q�）。本规范会提供一个工具集包括工具�cȝ�别和元数据语�a��U�别的工兗��它允许开发者轻易的把��用JDBC技术的应用�q�移到JDBC RowSet模型。该模型可以断开数据源访问连接，另外能够��理来自于XML�ȝ��点的关系数据存储�?/p>
　　11.允许对连接器的向前兼�?/p>
　　�q�接器构架定义了一个标准方法来对资源适配器进行打包和布��v。它允许一个J2EE容器整合它与外部资源的连接、处理和安全��理。JDBC 4.0 API提供JDBC驱动到连接器架构的迁�U��\径。对那些产品中��用JDBC技术的开发商来说�Q�应可以转向对连接器API的实现。希望这些实��C��重新包装已有数据源的实现。这样他们可以对�q�接器框架进行复用�?

　　12.清晰的列明需�?/p>
　　遵从JDBC要求的需求，要明��和易于识别。JDBC 4.0规范和API文档�Q�Javadoc�Q�会明晰什么特性是需要的�Q�什么特性是可选的�?/p>

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=629584

風向逆轉 - ��p��爪哇 2006-03-22 03:23 发表评论

[收藏]JDBC�q�接Oracle数据库常见问题及解决�Ҏ(gu��)��

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 16:27:00 GMT

Jbuilder正确�q�接 oracle 9i需要注意的几个问题
oracle8以上的应该都使用classes12.jar文�g作�ؓjdbc驱动�Q?
正确讄��windows的classpath和jbuilder中的enterprise setup 、configure libraries�Q�将casses12.jar路径正确��d��C��q�需要设�|�的地方�Q?strong>
�q�入database pilot�Q�在database pilot中，file---new 在driver列表中如果oracle的驱动是�U�色的，��p��明你的oralce在jb中加载失败；
若③没有错，则新��Z��个url�Q�jdbc:oracle:thin:@�Q�yourhostname�Q?1521:�Q�your sid�Q?strong>
�q�接数据库的Username/password
�?大部分站友的jbuilder�q�接oracle的问题都是由于没有正��配�|�classpath�{�引��L��?/p>

使用非XA方式�q�接ORACLE数据�?
在windows下配�|�Oracle_XA时要注意两点�Q?/p>
#ORACLE 10
Oracle_XA;xaosw;%ORACLE_HOME% dbms oraxa10.lib%ORACLE_HOME%precompibmsvcorasql10.lib
#oracle 9
Oracle_XA;xaosw;%ORACLE_HOME% dbms oraxa9.lib%ORACLE_HOME%precompibmsvcorasql9.lib
Unix�?br />Oracle_XA:xaosw:....
�W�一�Q�在windows �?ORACLE_XA 和xaosw后面的是分号";"�Q�不是冒�?:"
�W�二�Q�上面的�q�些LIB写在一行上�Q�中间用�I�格分开�Q�如果没有在�pȝ��的环境变量中讄��ORACLE_HOME�Q�就写绝对�\径�?/p>

JDBC操作ORACLE数据库时出现‘java.sql.SQLException:IO异常�Q�不在流模式下�?
用OracleStatment�Q�，不要用java.sql.Statment
如果对已有连接进行setAutoCommit��p�|�Q�则关闭该连接�ƈ重新建立一个连�?
到ORACLE站点下蝲一个最新的JDBC Driver�Q�如果操作LOB�c�d��Q�用ORACLE自带的接口和�c?

weblogic�q�接oracle问题�Q�The Network Adapter could not establish the connection
可能是服务器的监听停掉了�Q�是数据库的问题�Q�与应用无关�Q�应该先��查一下oracle是否正常�Q�用sql*plus�q�接一下数据库�Q�看能否正常�q�接�Q?/p>

Weblogic中��用Oracle�q�接池及Oracle备䆾的注意事��?
使用HP-UNIX�Q�Weblogic 8.1,Oracle 9.2.0.5
配置了一个普通的�q�接�?驱动�E�序采用oracle的Oracle’s Driver(Thin) version 9.0.1, 9.2.0
错误情况�Q?br />�l�果使用数据库连接池时报错，说没有连接池资源了。实际上数据库的�q�接池完全空�Ԍ��q�且��试也是对的�Q�Oracle也是正常可以�q�接、��用的�?/p>
问题�Ҏ(gu��)��Q?br />通过层层排错�Q�发现原来后台在使用Oracle的exp备䆾一个只有同义词的用��P��D��exp�q�程僉|��?br />杀死exp、重启Oracle�{�无法解决问题，最�l�重启UNIX�Q�禁止备份只有同义词的用��P��问题解决�?/p>
�ȝ��Q?br />应该是Oracle9的exp BUG��D��q�接池问题，不要使用exp倒出同义�?/p>

�q�接Oracle时抛出如下异常：java.sql.SQLException: Io exception:The Network Adapter could not establish connection一�U��生原�?
Oracle Database Connection (from oracle.com)
PROBLEM
You are attempting to connect to an Oracle instance using JDBC and you are receiving the following error.
   java.sql.SQLException: Io exception:
     The Network Adapter could not establish connection
   SQLException: SQLState (null) vendor code (17002)
Any or all of the following conditions may also apply:
1) You are able to establish a SQL*Plus connection from the same
   client to the same Oracle instance.
2) You are able to establish a JDBC OCI connection, but not a Thin
   connection from the same client to the same Oracle instance.
3) The same JDBC application is able to connect from a different
   client to the same Oracle instance.
4) The same behavior applies whether the initial JDBC connection
   string specifies a hostname or an IP address.
REDISCOVERY
To verify whether you are hitting this problem, verify whether the Oracle instance is configured for Multithreaded Server (MTS). If the Oracle instance is not configured for MTS, you are probably encountering a different problem. Otherwise, continue. Try forcing the JDBC connection to use a dedicated server instead of a shared server. This can be accomplished in several ways. For JDBC OCI or Thin, this can be done by reconfiguring the server for dedicated connections only. This approach, however, may not be feasible in many cases. In such cases, the following options apply: For JDBC OCI:
1) Add the (SERVER=DEDICATED) property to the TNS connect string
   stored in the tnsnames.ora file on the client.
2) Set the user_dedicated_server=ON in sqlnet.ora on the client.
For JDBC Thin:
You must specify a full name-value pair connect string (the same as it might appear in the tnsnames.ora file) instead of the short JDBC Thin syntax. For example, instead of
"jdbc:oracle:thin::port:sid"
you would need to use a string of the form
"jdbc:oracle:thin:@(DESCRIPTION="                    +
                       "(ADDRESS_LIST="              +
                           "(ADDRESS=(PROTOCOL=TCP)" +
                                    "(HOST=host)"    +                                      =
                                    "(PORT=port)"    +
                           ")"                       +
                       ")"                           +
                       "(CONNECT_DATA="              +
                           "(SERVICE_NAME=sid)"      +
                           "(SERVER=DEDICATED)"      +
                       ")"                           +
                     ")"
If the connection works fine after having made these changes, it is very likely that this is the problem you are encountering. In this case, one last test will help to verify this fact.
Log into the remote host on which the Oracle instance is running and execute the appropriate command to determine what the server 'thinks' its hostname is (i.e. the name that was configured when the server was installed and configured). For example, on a Unix host the 'hostname' command can be used for this purpose.
Using the name displayed (e.g. by the hostname command), exactly as it appeared (i.e. if the output from the hostname command had the domain name included, then include it), return to the client which was unable to connect and try pinging the server.
NOTE: It is critical that you attempt to ping the server using EXACTLY the same hostname you got from the server.
If you are unable to ping the server via this hostname, then you almost certainly hitting this problem. If not, this may be a new issue, but at least you will have found a workaround (i.e. use a dedicated connection).
EXPLANATION
To understand why this problem occurs, one must first understand the differences in how the listener handles connections to shared servers versus dedicated servers.
When connecting to a dedicated server, the client connects to the listener (via hostname or IP address). The listener then spawns a dedicated server process and hands off the socket used to accept the client connection to that server. The client and server then start communicating via the endpoints established by the initial connection. NOTE: There is only one connection in this case. When connecting to a shared server, the initial client connection to the listener is the same. However, with MTS, there is no need to spawn a new server process; a pool of shared processes already exists. Also, clients do not communicate directly with the server processes in MTS; rather, they communicate with a dispatcher.
For this reason, when setting up an MTS connection, the listener sends a redirect message back to the client asking the client to close the connection to the listener and connect to a dispatcher. The information in this message includes the hostname and a port number for the appropriate dispatcher. The redirect message will ALWAYS specify a hostname, even if the client initially provided an IP address.
If, for any reason, the hostname provided to the listener (e.g. by the 'hostname' or another command) doesn't agree with the hostname by which the server is known on the client, the connection fails.
On the other hand, if "(SERVER=DEDICATED)" already appears in the TNS connect string in tnsnames.ora or if "use_dedicated_server=ON" already appears in the sqlnet.ora file, you may find that SQL*Plus and/or JDBC OCI work fine, while JDBC Thin fails.
SOLUTION
Obviously, one solution is to use dedicated servers. However, this may not always be feasible.
The key is to make sure the hostname on both the client and server agree. This can be accomplished by reconfiguring either the client or the server, but there are things to be aware of in both cases.
If the server is configured to return a different hostname, then it is possible that other clients which used to work will now fail.
In some cases, it may not be feasible to reconfigure the client. For example, if the server version of the hostname does not include the domain, you would need to remove the domain portion of the hostname on the client; but, if the client needs to connect to more than one server with the same base name in different domains, this may not be possible, as the hostname may be ambiguous.
REFERENCES
bug:1269734 java.sql.SQLException: Io exception: The Network Adapter could not be found.

�q�接ORACLE数据库报错：javax.naming.NameNotFoundException: Unable to resolve oracThin. Resolved: '' Unresolved:'oracThin' ; remaining name ''
问题描述�Q�配�|�完JDBC后，打开��面的时候，报出如下错误信息�Q?br />javax.naming.NameNotFoundException: Unable to resolve oracThin. Resolved: '' Unresolved:'oracThin' ; remaining name ''
JDBC配置如下�Q?br />Connection Pools(�q�接�?
Name:OracThin
URL:jdbc:oracle:thin.0.0.1:LYSIMIS
Driver Classname:oracle.jdbc.driver.OracleDriver
Properties:
user=system
password=manager
dll=ocijdbc8
protocol=thin
数据源配�|�如下：
Name:OracThin
JNDI Name:OracThin
Pool Name:OracThin
当程序执行到�q�一步时出错�?br />ctx = new InitialContext();
ds = (javax.sql.DataSource)ctx.lookup ("OracThin");
问题解决后汉字是��q��
错误产生原因及解军_��法：
URL:jdbc:oracle:thin:.0.0.1:1521:LYSIMI�Q�thin后面�?,127.0.0.1后面加端口号
注意名字大小�?
target 到server�?
再看看pool是否��h��了，没�v来的�?重�vweblogic
��q��问题�Q�Java是基于Unicode�Q�：
在JSP 文�g中加�?lt;%@ page contentType="text/html; charset=GBK" %>
在weblogic.xml文�g�?lt;jsp-descriptor>部分加入

compilerSupportsEncoding
true

encoding
GBK

oracle XA的疑�?
问题描述�Q�Oracle_XA;xaosw;D:oracleora92 dbmsXAORAXA9.lib C:msvcoraSQL9.lib�?br />xaosw是什么意�?/p>
解答�Q�可以参考ORACLE的XA部分的文档�?/p>
http://www-rohan.sdsu.edu/doc/oracle/server803/A54642_01/ch_xa.htm

oracle与weblogic自动启动与停�?
问题描述�Q�每�ơ重新启动服务器时oracle数据库若没有关闭�Q�则必须先关闭后在重新启动redhat advance server�Q�oracle才能够正常运�?/p>
原因及解军_��法参见：
http://dev2dev.bea.com.cn/bbs/thread.jspa?forumID=81&threadID=8839&messageID=43184#43184

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=579829

風向逆轉 - ��p��爪哇 2006-03-21 00:27 发表评论

[收藏]JDBC数据库驱动下载网址大全 (好东西�{来分�?

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:57:00 GMT

链接:http://blog.csdn.net/baggio785/archive/2006/02/07/593802.aspx

風向逆轉 - ��p��爪哇 2006-03-20 23:57 发表评论

[收藏]Oracle内存分配与调�?

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:38:00 GMT
     摘要: l       前言对于 oracle 的内存的��理�Q�截止到 9iR2 �Q�都是相当重要的...  阅读全文

風向逆轉 - ��p��爪哇 2006-03-20 23:38 发表评论

[收藏]Oracle基本数据�c�d��存储格式��析�Q�一�Q�—（五）

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:37:00 GMT
Oracle基本数据�c�d��存储格式��析�Q�一�Q�——字�W�类�?br />发表�?yangtingkun | 发表旉��: 2004�q�十二月09�? 23:47
前一�늜�完文档，对oracle的基本数据类型的存储格式有了一些了解，最�q�有做了一些测试进行了验证�?br />打算整理�ȝ��一下，�q�一��主要说明字�W�类型的存储格式。主要包括char、varchar2和long�{�几�U�类型�?br />
SQL> create table test_char (char_col char(10), varchar_col varchar2(10), long_col long);
表已创徏�?br />SQL> insert into test_char values ('abc', '123', ',fd');
已创�?1 行�?br />SQL> commit;
提交完成�?br />SQL> select rowid from test_char;
ROWID
------------------
AAAB3LAAFAAAAAgAAA
�Ҏ(gu��)��rowid的定义规则，�W?�?位是表示的是数据文�g�Q�F表示5�Q��?0�?5位表�C�的是在�q�个数据文�g中的�W�几个BLOCK�Q�g表示32。（rowid�~�码相当�?4�q�制。用A~Z a~z 0~9 + /�?4个字�W�表�C�。A表示0�Q�B表示1�Q�……，a表示26�Q�……，0表示52�Q�……，+表示62�Q?表示63。）
我们�Ҏ(gu��)��计算的结果去dump�q�个block�?br />SQL> ALTER SYSTEM DUMP DATAFILE 5 BLOCK 32;
�pȝ��已更攏V�?br />打开产生的trace文�g�Q?br />data_block_dump,data header at 0x3421064
===============
tsiz: 0x1f98
hsiz: 0x14
pbl: 0x03421064
bdba: 0x01400020
     76543210
flag=--------
ntab=1
nrow=1
frre=-1
fsbo=0x14
fseo=0x1f82
avsp=0x1f6e
tosp=0x1f6e
0xe:pti[0] nrow=1 offs=0
0x12:pri[0] offs=0x1f82
block_row_dump:
tab 0, row 0, @0x1f82
tl: 22 fb: --H-FL-- lb: 0x1 cc: 3
col 0: [10] 61 62 63 20 20 20 20 20 20 20
col 1: [ 3] 31 32 33
col 2: [ 3] 2c 66 64
end_of_block_dump
End dump data blocks tsn: 5 file#: 5 minblk 32 maxblk 32
观察dump出来的结果，可以发现以下几点�Q?br />1.对于每个字段�Q�除了保存字�D늚��g��外，�q�会保存当前字段中数据的长度。而且�Q�oracle昄��没有把字�D늚�长度定义或类型定义保存在block中，�q�些信息保存在oracle的数据字兔R��面�?br />2. �Ҏ(gu��)��dump的结果，可以清楚的看刎ͼ�字符�c�d��在数据库中是以ascii格式存储的�?br />SQL> select chr(to_number('61', 'xx')) from dual;
CH
--
a
3.char�c�d��为定长格式，存储的时候会在字�W�串后面填补�I�格�Q�而varchar2和long�c�d��都是变长的�?br />SQL> SELECT DUMP(CHAR_COL, 16) D_CHAR FROM TEST_CHAR;
D_CHAR
-------------------------------------------------------------
Typ=96 Len=10: 61,62,63,20,20,20,20,20,20,20
SQL> SELECT DUMP(VARCHAR_COL, 16) D_VARCHAR2 FROM TEST_CHAR;
D_VARCHAR2
-------------------------------------------------------------
Typ=1 Len=3: 31,32,33
SQL> SELECT DUMP(LONG_COL, 16) D_VARCHAR2 FROM TEST_CHAR;
SELECT DUMP(LONG_COL, 16) D_VARCHAR2 FROM TEST_CHAR
            *
ERROR 位于�W?1 �?
ORA-00997: 非法使用 LONG 数据�c�d��
�׃��DUMP不支持LONG�c�d��Q�因此我们��用了alter system dump block的方式，通过比较两种方式得到的结果，发现DUMP()函数不但方便�Q�结果清晎ͼ�而且指出了进行DUMP的数据类型，在以后的例子中，除非必要的情况，否则都会采用DUMP()函数的方式进行说明�?br />下面看一下插入中文的情况�Q�首先看一下数据库的字�W�集
SQL> select name, value$ from sys.props$ where name like '%CHARACTERSET%';
NAME                           VALUE$
------------------------------ ------------------------------
NLS_CHARACTERSET               ZHS16GBK
NLS_NCHAR_CHARACTERSET         AL16UTF16
SQL> insert into test_char values ('定长', '变长', null);
已创�?1 行�?br />SQL> SELECT DUMP(CHAR_COL, 16) D_CHAR FROM TEST_CHAR;
D_CHAR
----------------------------------------------------------------
Typ=96 Len=10: 61,62,63,20,20,20,20,20,20,20
Typ=96 Len=10: b6,a8,b3,a4,20,20,20,20,20,20
SQL> SELECT DUMP(VARCHAR_COL, 16) D_VARCHAR2 FROM TEST_CHAR;
D_VARCHAR2
----------------------------------------------------------------
Typ=1 Len=3: 31,32,33
Typ=1 Len=4: b1,e4,b3,a4
�Ҏ(gu��)��dump�l�果�Q�可以清楚的看出�Q�普通英文字�W�和标点用一个字节表�C�，而中文字�W�或中文标点需要两个字节来表示�?br />下面�Q�对比一下nchar和nvarchar2与char、varchar2�c�d��有什么不同�?br />SQL> create table test_nchar (nchar_col nchar(10), nvarchar_col nvarchar2(10));
表已创徏�?br />SQL> insert into test_nchar values ('nchar定长', 'nvarchar变长');
已创�?1 行�?br />从这里已�l�可以看��Z��些不同了�Q�如果按照刚才中文的计算�Ҏ(gu��)��Q?nvarchar变长'的长度是8+2*2=12已经��过了数据类型定义的大小�Q�可是�ؓ什么插入成功了�Q?br />�q�是dump一下看看结果吧�?br />SQL> select dump(nchar_col, 16) from test_nchar;
DUMP(NCHAR_COL,16)
--------------------------------------------------------------
Typ=96 Len=20: 0,6e,0,63,0,68,0,61,0,72,5b,9a,95,7f,0,20,0,20,0,20
SQL> select dump(nvarchar_col, 16) from test_nchar;
DUMP(NVARCHAR_COL,16)
--------------------------------------------------------------
Typ=1 Len=20: 0,6e,0,76,0,61,0,72,0,63,0,68,0,61,0,72,53,d8,95,7f
�q�下��明白了�Q�虽然仍然是采用ascii码存储，但是nchar使用的AL16UTF16字符集，�~�码长度变�ؓ2个字节。这样中文��用两个字节，对于可以用一个字节就表示的英文字�W�，采用了高位补0的方式凑��?位，�q�样�Q�对于采用AL16UTF16字符集的nchar�c�d��Q�无��Z��文还是英文都�?位字�W�表�C�。因�?nvarchar变长'的长度是10�Q��ƈ没有��过数据�c�d��的限制�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�二�Q�——数字类�?br />发表�?yangtingkun | 发表旉��: 2004�q�十二月14�? 22:57
�q�篇文章主要描述NUMBER�c�d��的数据和如何在数据库中存储的�?br />Oracle的NUMBER�c�d��最多由三个部分构成�Q�这三个部分分别是最高位表示位、数据部分、符号位。其中负数包含符号位�Q�正��C��会包括符号位。另外，数�?比较�Ҏ(gu��)��Q�它只包含一个数值最高位表示�?0�Q�没有数据部分�?br />正数的最高位表示位大�?0�Q�负数的最高位表示位小�?0。其中一个正数的最高位是个位的话，则最高位表示位�ؓC1�Q�百位、万位依�ơ�ؓC2、C3�Q�百分位、万分�ؓ依次为C0、BF。一个负数的最高位��Z��位的话，最高位表示位�ؓ3E�Q�百位、万位依�ơ�ؓ3D�?C�Q�百分位、万分位依次�?F�?0�?br />数据部分每一位都表示2位数。这个两位数可能是从0�?9�Q�如果是数据本��n是正敎ͼ�则分别用二进制的1�?4表示�Q�如果数据本�w�是负数�Q�则使用二进�?5�?表示�?br />�W�号位用66表示�?br />上面的这些是我通过DUMP�l�果�ȝ��出来的，对于上面提到的这些关�p�d��敎ͼ�Oracle之所以这样选择是有道理的，我们后面�Ҏ(gu��)��例子也可以推导出来，而且会进一步说明�ؓ什么会采用�q�种方式表示。这里列出的意思是使大家先对NUMBER�c�d��数据有一个大概的了解�?br />下面我们通过一个例子详�l�说明：

SQL> CREATE TABLE TEST_NUMBER (NUMBER_COL NUMBER);
表已创徏�?br />SQL> INSERT INTO TEST_NUMBER VALUES (0);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (1);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (2);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (25);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (123);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (4100);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (132004078);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (2.01);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (0.3);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (0.00000125);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (115.200003);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (-1);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (-5);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (-20032);
已创�?1 行�?br />SQL> INSERT INTO TEST_NUMBER VALUES (-234.432);
已创�?1 行�?br />SQL> COMMIT;
提交完成�?br />SQL> COL D_NUMBER FORMAT A50
SQL> SELECT NUMBER_COL, DUMP(NUMBER_COL, 16) D_NUMBER FROM TEST_NUMBER;
NUMBER_COL D_NUMBER
---------- --------------------------------------------------
         0 Typ=2 Len=1: 80
         1 Typ=2 Len=2: c1,2
         2 Typ=2 Len=2: c1,3
        25 Typ=2 Len=2: c1,1a
       123 Typ=2 Len=3: c2,2,18
      4100 Typ=2 Len=2: c2,2a
132004078 Typ=2 Len=6: c5,2,21,1,29,4f
      2.01 Typ=2 Len=3: c1,3,2
        .3 Typ=2 Len=2: c0,1f
.00000125 Typ=2 Len=3: be,2,1a
115.200003 Typ=2 Len=6: c2,2,10,15,1,4
        -1 Typ=2 Len=3: 3e,64,66
        -5 Typ=2 Len=3: 3e,60,66
    -20032 Typ=2 Len=5: 3c,63,65,45,66
-234.432 Typ=2 Len=6: 3d,63,43,3a,51,66
已选择15行�?br />
    下面�Ҏ(gu��)��例子得到的结果，�Ҏ(gu��)��行进行说明。首先说明两点基本的。DUMP函数�q�回的TYPE�Q?表示DUMP的数据类型是NUMBER�Q�LENGTH�Q�N表示数值在数据库中存储的长度是N�?br />1.DUMP(0)的结果是0x80�Q�在前面已经提到�Q?只有高位表示位，没有数据位。由�?的特�D�，既不属于正数�Q�也不属于负敎ͼ�因此使用高位表示位用80表示��p��够了�Q�不会和其它数据冲突�Q�Oracle��Z��节省�I�间的考虑��后面数据部分省掉了。但是�ؓ什么Oracle选择0x80表示0呢？我们知道正数和负��C��为相反数�Q�每个正数都有一个对应的负数。因此如果我们要使用�~�码表示数��|��则表�C�正数和负数的编码应该各占一半，�q�样才能保证使Oracle表示数据范围是合理的。�?x80的二�q�制�~�码�?000 0000�Q�正好是一个字节编码最大值的一半，因此�Q�Oracle选择0x80来表�C?�Q�是十分有道理的�?br />2.DUMP(1)的结果是0xc102�Q?xc1表示了最高位个位�Q?x2表示数值是1。首先，Oracle��Z��么用C1表示个位呢？其实�Q�道理和刚才的差不多。采用科学计数法�Q��Q何一个实数S都可以描�q�CؓA.B×10n�Q�A表示整数部分�Q�B表示��数部分�Q�而N表示10的指数部分。当S大于1�Ӟ��N大于�{�于0�Q�S��于1�Ӟ��N��于0。也��是��_��采用指数的方式表�C�，N大于0和N��于0的情况各占一半左��x��Q�Oracle所表示的范围最�qѝ��因此，Oracle选择了C1表示个位是最高位的情��c�?br />SQL> SELECT TO_CHAR(ROUND(TO_NUMBER('81', 'XXX') + (TO_NUMBER('FF', 'XXX') - TO_NUMBER('81', 'XXX') + 1)/2), 'XX') FROM DUAL;
TO_
---
C1

��Z��么ORACLE使用0x2表示1�Q�而不直接使用0x1表示1呢？Oracle每个字节表示2位数�Q�因此对于这�?位数�Q�出现的可能�?�?9�?00�U�可能，问题出在0�q�里。Oracle底层是用C语言实现的，我们知道二进�?在C语言中用作字�W�串�l�结�W�，Oracle��Z��避免�q�个问题�Q�因此��用了0x1表示0�Q��ƈ依次�c�L��Q��?x64表示99�?br />3.DUMP(2)的结果是0xc103�?br />4.DUMP(25)的结果是0xc11a。前面提刎ͼ�数据部分是以2位�ؓ最��单位保存的。因此对�?5来说�Q�最高位表示位仍然是个位�Q�个位上的值是25�Q�根据上面推出的规则�Q?5在存储�ؓ0xc11a�?br />SQL> SELECT TO_CHAR(25 + 1, 'xx') FROM DUAL;
TO_
---
1a

5.DUMP(123)的结果是0xc20218。由�?23最高�ؓ是百位，所以最高位表示位�ؓ0xc2�Q�百位上�?�Q�用0x02表示�Q�个位上�?3�Q�用0x18表示�?br />6.DUMP(4100)的结果是0xc22a�?br />注意一点，如果数字最后数位上如果�?�Q�Oracle��Z��节省�I�间的考虑不会存储。比如：4100只保存百位上�?1�Q?2000000只保存百位位上的12�Q?12000只保存万位上�?1和百位上�?0�?br />7.DUMP(132004078)的结果是0xc5022101294f。最高位是亿位，因此�?xC5表示�Q�亿位上�?�?x02表示�Q�百位位上是32�?x21表示�Q�万位上�?�?x01表示�Q�百位上�?0�?x29表示�Q�个位上78�?x4F表示�?br />注意�Q�中间数位上�?不能省略�?br />8.DUMP(2.01)的结果是0xc10302。最高位是个位用0xC1表示�Q�个位上�?�?x03表示�Q�百分位上是1�?x02表示�?br />注意�Q�个位下面一位是癑ֈ�位不是十分位�?br />9.DUMP(0.3)的结果是0xc01f。最高位是百分位�Q��?xC0表示�Q�百分位上是30�?x1F表示�?br />10.DUMP(0.00000125)的结果是0xbe021a。最高位是百万分位，�?xBE表示�Q�最高位上的1�?x02表示�Q?5�?x1a表示�?br />11.DUMP(115.200003)的结果是0xc20210150104�?br />12.DUMP(-1)的结果是0x3e6466。最高位个位�Q�用0x3E表示�Q?4表示个位上是1�Q?6是符号位�Q�表�C��个数是负数�?br />负数和正��C��为相反数�Q�负数的最高位表示位和它对应的相反数的最高位相加的值是FF�?的最高位表示位是C1�Q?1的最高位表示位是3E。负��C��1�?4表示。负��C��的数值和它相反数的数据相加是0x66�Q�也��是�W�号位。正�?�?x02表示�Q�负�?�?x64表示�Q�二者相加是0x66。负数多个一个标识位�Q�用0x66表示。由于正数的表示范围�?x01�?x64�Q�负数的表示范围�?x65�?x02。因此，不会在表�C�数字时出现�?x66表示�?br />13.DUMP(-5)的结果是0x3e6066�?x3e表示最高位是个位，0x60表示个位上是5�Q?x66是符��h��识位�?x3E�?xC1�?xFF�?x60�?x06的结果是0x66�?br />14.DUMP(-20032)的结果是0x3c63654566。最高位是万位，正数的万位是0xC3�Q�因此负数的万位�?x3C。万位上�?�Q�正数用0x03表示�Q�负��Cؓ0x63�Q�百位上�?�Q�正数用0x01表示�Q�负��C��?x65表示�Q�个位上�?2�Q�正数用0x21表示�Q�负��C��?x45表示�?x66是负数表�C�Z��?br />15.DUMP(-234.432)的结果是0x3d63433a5166�?br />
�Ҏ(gu��)��Oracle的存储特性，�q�可以推出Oracle的number�c�d��的取��D��围�?br />Oracle的concept上是�q�样描述的：
The following numbers can be stored in a NUMBER column:
Positive numbers in the range 1 x 10-130 to 9.99...9 x 10125 with up to 38 significant digits.
Negative numbers from -1 x 10-130 to 9.99...99 x 10125 with up to 38 significant digits.
Zero.
下面来推导出取��D��围�?br />来看�W�号位，0xC1表示个位�?br />SQL> select to_number('ff', 'xxx') - to_number('c1', 'xxx') from dual;
TO_NUMBER('FF','XXX')-TO_NUMBER('C1','XXX')
-------------------------------------------
                                         62
�׃��Oracle是两位、两位存储的�Q�因此最高位相当�?2×2=124�Q�而且最高位上最大值是99�Q�因此正数的最大��gؓ9.999……�?0125�?br />SQL> select to_number('c1', 'xxx') - to_number('80', 'xxx') from dual;
TO_NUMBER('C1','XXX')-TO_NUMBER('80','XXX')
-------------------------------------------
                                         65
最高位相当�?5×2=130�Q�因此正数的最��gؓ1×10-130�?br />负数和正数在各��用了一半的�~�码�Q�因此具有相同的极��D��围�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�三�Q�——日期类型（一�Q?br />发表�?yangtingkun | 发表旉��: 2004�q�十二月15�? 14:00
�q�篇文章描述DATE�c�d��的数据在Oracle中是以何�U�格式存攄��?
下面通过一个例子进行说明�?

SQL> create table test_date (date_col date);
表已创徏�?br />SQL> insert into test_date values (to_date('2000-1-1 0:0:0', 'yyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (to_date('1-1-1 0:0:0', 'yyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (to_date('-1-1-1 0:0:0', 'syyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (to_date('-101-1-1 0:0:0', 'syyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (to_date('-4712-1-1 0:0:0', 'syyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (to_date('9999-12-31 23:59:59', 'syyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> insert into test_date values (sysdate);
已创�?1 行�?br />SQL> insert into test_date values (to_date('-4713-1-1 0:0:0', 'syyyy-mm-dd hh24:mi:ss'));
insert into test_date values (to_date('-4713-1-1 0:0:0', 'syyyy-mm-dd hh24:mi:ss'))
                                      *
ERROR 位于�W?1 �?
ORA-01841: �Q�全�Q�年度值必��M��?-4713 �?+9999 之间�Q�且不�ؓ 0
SQL> insert into test_date values (to_date('0000-1-1 0:0:0', 'yyyy-mm-dd hh24:mi:ss'));
insert into test_date values (to_date('0000-1-1 0:0:0', 'yyyy-mm-dd hh24:mi:ss'))
                                      *
ERROR 位于�W?1 �?
ORA-01841: �Q�全�Q�年度值必��M��?-4713 �?+9999 之间�Q�且不�ؓ 0
SQL> col dump_date format a80
SQL> select to_char(date_col, 'syyyy-mm-dd hh24:mi:ss'), dump(date_col) dump_date from test_date;
TO_CHAR(DATE_COL,'SY DUMP_DATE
-------------------- ---------------------------------------
2000-01-01 00:00:00 Typ=12 Len=7: 120,100,1,1,1,1,1
0001-01-01 00:00:00 Typ=12 Len=7: 100,101,1,1,1,1,1
-0001-01-01 00:00:00 Typ=12 Len=7: 100,99,1,1,1,1,1
-0101-01-01 00:00:00 Typ=12 Len=7: 99,99,1,1,1,1,1
-4712-01-01 00:00:00 Typ=12 Len=7: 53,88,1,1,1,1,1
9999-12-31 23:59:59 Typ=12 Len=7: 199,199,12,31,24,60,60
2004-12-15 13:56:19 Typ=12 Len=7: 120,104,12,15,14,57,20
已选择7行�?br />
通过最后两条语句已�l�可以看出Oracle的DATE�c�d��的取��D��围是公元�?712�q?�?日至公元9999�q?2�?1日。而且�Ҏ(gu��)��日期的特定，要不然是公元1�q�_��要不然是公元�?�q�_��不会出现0�q�的情况�?br />日期�c�d��长度�?�Q?个字节分别表�C�Z��U�、年、月、日、时、分和秒�?br />�׃��不会出现0的情况，月和日都是按照原值存储的�Q�月的范围是1�?2�Q�日的范围是1�?1�?br />�׃��时、分、秒都会出现0的情况，因此存储旉��用原值加1的方式�?时保存�ؓ1�Q?3时保存�ؓ14�Q?3时保存�ؓ24。分和秒的情况与��时�c�M��。小时的范围�?�?3�Q�在数据库中�?�?4保存。分和秒的范围都�?�?9�Q�在数据库中�?�?0保存�?br />�q�和世纪的情�늛��Ҏ(gu��)��较复杂，可分为公元前和公元后两种情况。由于最��的世纪的值是-47�Q�公元前4712�q�_��Q�最大值是99�Q�公�?999�q�_��。�ؓ了避免负数的产生�Q�oracle把世�U�加100保存在数据库中。公�?000�q�_��世纪保存�?20�Q�公�?999�q�_��世纪保存�?99�Q�公元前101�q�_��世纪保存�?9�Q?00+(-1)�Q�，公元�?712�q�_��世纪保存�?3�Q?00+(-47)�Q��?br />注意�Q�对于公元前1�q�_��虽然已经是公元前了，但是表示世纪的前两位的��g��然是0�Q�因此，�q�时的保存的世纪的��g��然是100。世�U�的范围�?47�?9�Q�保存的值是53�?99�?br />�q�的保存与世�U�的保存方式�c�M��Q�也把年的值加�?00�q�行保存。对于公�?000�q�_��q�保持�ؓ100�Q�公�?�q�保存�ؓ101�Q�公�?004�q�保存�ؓ104�Q�公�?999�q�保存�ؓ199�Q�公元前1�q�_��保存�?9�Q?00+(-1)�Q�，公元�?01�q�_��保存�?9�Q?00+(-1)�Q�，公元�?712�q�保存�ؓ88�Q?00+(-12)�Q�。对于公元前的年�Q�保存的值��L��于�{�于100�Q�对于公元后的年�Q�保存的值��L��大于�{�于100。年的范围是0�?9�Q�保存的值是1�?99�?br />注意�Q�一般的世纪�Q�都包含�?00�q�_��而对�?世纪�Q�由于包含公元前和公元后两部分且不包�?�q�_��因此包含�?98�q��?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�三�Q�——日期类型（二）
发表�?yangtingkun | 发表旉��: 2004�q�十二月16�? 18:03
�q�篇文章描述TIMESTAMP�c�d��的数据在Oracle中是以何�U�格式存攄��?br />下面通过一个例子进行说明�?br />
SQL> create table test_time (col_time timestamp);
表已创徏�?br />SQL> insert into test_time values (to_timestamp('0001-1-1 0:0:0.0', 'syyyy-mm-dd hh24:mi:ss.ff'));
已创�?1 行�?br />SQL> insert into test_time values (to_timestamp('2000-1-1 0:0:0.0', 'syyyy-mm-dd hh24:mi:ss.ff'));
已创�?1 行�?br />SQL> insert into test_time values (to_timestamp('9999-12-31 23:59:59.999999', 'syyyy-mm-dd hh24:mi:ss.ff'));
已创�?1 行�?br />SQL> insert into test_time values (to_timestamp('-0001-1-1 0:0:0.0', 'syyyy-mm-dd hh24:mi:ss.ff'));
已创�?1 行�?br />SQL> insert into test_time values (to_timestamp('-0100-3-4 13:2:3.234015', 'syyyy-mm-dd hh24:mi:ss.ff'));
已创�?1 行�?br />SQL> insert into test_time values (systimestamp);
已创�?1 行�?br />SQL> insert into test_time values (to_timestamp('2000-1-1 0:0:0.123456789', 'syyyy-mm-dd hh24:mi:ss.ff9'));
已创�?1 行�?br />SQL> commit;
提交完成�?br />SQL> select to_char(col_time, 'syyyy-mm-dd hh24:mi:ss.ff9') time, dump(col_time) dump_time
2 from test_time;
TIME                           DUMP_TIME
------------------------------ ----------------------------------------------------
0001-01-01 00:00:00.000000000 Typ=180 Len=7: 100,101,1,1,1,1,1
2000-01-01 00:00:00.000000000 Typ=180 Len=7: 120,100,1,1,1,1,1
9999-12-31 23:59:59.999999000 Typ=180 Len=11: 199,199,12,31,24,60,60,59,154,198,24
-0001-01-01 00:00:00.000000000 Typ=180 Len=7: 100,99,1,1,1,1,1
-0100-03-04 13:02:03.234015000 Typ=180 Len=11: 99,100,3,4,14,3,4,13,242,201,24
2004-12-15 16:14:52.738000000 Typ=180 Len=11: 120,104,12,15,17,15,53,43,252,252,128
2000-01-01 00:00:00.123457000 Typ=180 Len=11: 120,100,1,1,1,1,1,7,91,205,232
已选择7行�?br />与DATE�c�d��Ҏ(gu��)��可以发现�Q�对于TIMESTAMP�c�d��Q�如果不包含微秒信息或者微�U��gؓ0�Q�那么存储结果和DATE完全相同。当微秒��gؓ0�Ӟ��Oracle��Z��节省�I�间�Q�不会保存微�U�信息�?br />如果毫秒��g��?�Q�Oracle把微�U�值当作一�?位数的数字来保存�?br />比如999999000�Q�保存�ؓ59,154,198,24�?34015000保存�?3,242,201,24�?br />SQL> select to_char(999999000, 'xxxxxxxxxx') from dual;
TO_CHAR(999
-----------
   3b9ac618
SQL> select to_number('3b', 'xxx') one, to_number('9a', 'xxx') two,
2 to_number('c6', 'xxx') three, to_number('18', 'xxx') four from dual;
       ONE        TWO      THREE       FOUR
---------- ---------- ---------- ----------
        59        154        198         24
SQL> select to_char(234015000, 'xxxxxxxx') from dual;
TO_CHAR(2
---------
df2c918
SQL> select to_number('d', 'xxx') one, to_number('f2', 'xxx') two,
2 to_number('c9', 'xxx') three, to_number('18', 'xxx') four from dual;
       ONE        TWO      THREE       FOUR
---------- ---------- ---------- ----------
        13        242        201         24

另外�Q�注意一点，不指定精度的情况下，TIMESTAMP默认�?位。长度超�q?位，会四舍五入到6位。如果希望保�?位的TIMESTAMP�Q�必��L��指定精度�?br />SQL> alter table test_time modify (col_time timestamp(9));
表已更改�?br />SQL> insert into test_time values (to_timestamp('2000-1-1 0:0:0.123456789', 'syyyy-mm-dd hh24:mi:ss.ff9'));
已创�?1 行�?br />SQL> select to_char(col_time, 'syyyy-mm-dd hh24:mi:ss.ff9') time, dump(col_time) dump_time
2 from test_time;
TIME                           DUMP_TIME
------------------------------ ---------------------------------------------------
0001-01-01 00:00:00.000000000 Typ=180 Len=7: 100,101,1,1,1,1,1
2000-01-01 00:00:00.000000000 Typ=180 Len=7: 120,100,1,1,1,1,1
9999-12-31 23:59:59.999999000 Typ=180 Len=11: 199,199,12,31,24,60,60,59,154,198,24
-0001-01-01 00:00:00.000000000 Typ=180 Len=7: 100,99,1,1,1,1,1
-0100-03-04 13:02:03.234015000 Typ=180 Len=11: 99,100,3,4,14,3,4,13,242,201,24
2004-12-15 16:14:52.738000000 Typ=180 Len=11: 120,104,12,15,17,15,53,43,252,252,128
2000-01-01 00:00:00.123457000 Typ=180 Len=11: 120,100,1,1,1,1,1,7,91,205,232
2000-01-01 00:00:00.123456789 Typ=180 Len=11: 120,100,1,1,1,1,1,7,91,205,21
已选择8行�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�三�Q�——日期类型（三）
发表�?yangtingkun | 发表旉��: 2004�q�十二月17�? 17:00
如果直接在SQL语句中对SYSDATE或由TO_DATE函数生成日期�q�行DUMP操作�Q�会发现得到的结果与DUMP数据库中保存的日期的�l�果不一栗��?br />
SQL> truncate table test_date;
表已截掉�?br />SQL> insert into test_date values (to_date('2004-12-17 16:42:42', 'syyyy-mm-dd hh24:mi:ss'));
已创�?1 行�?br />SQL> col dump_date format a65
SQL> select to_char(date_col, 'syyyy-mm-dd hh24:mi:ss') dat, dump(date_col) dump_date from test_date;
DAT                  DUMP_DATE
-------------------- ---------------------------------------------------------
2004-12-17 16:42:42 Typ=12 Len=7: 120,104,12,17,17,43,43
SQL> select to_char(to_date('2004-12-17 16:42:42', 'syyyy-mm-dd hh24:mi:ss'), 'syyyy-mm-dd hh24:mi:ss') dat,
2 dump(to_date('2004-12-17 16:42:42', 'syyyy-mm-dd hh24:mi:ss')) dump_date from dual;
DAT                  DUMP_DATE
-------------------- ---------------------------------------------------------
2004-12-17 16:42:42 Typ=13 Len=8: 212,7,12,17,16,42,42,0
存储在数据库中的DATE�c�d��?2�Q�而直接在SQL中��用的DATE�c�d��?3。而且二者的长度以及表示方式都不相同。这两种�c�d��的不同指��Z��要体现在两点�Q�一�Q�时、分、秒的表�C�Z��同；二、世�U�和�q�的表示不同�?br />SQL中��用DATE的时分秒没有采用�?存储方式�Q�而且原值存储�?br />SQL中��用DATE没有采用世纪、年的方式保持，而是采用了按数��g��存的方式。第一位表�C�Z��位，�W�二位表�C�高位。低位表�C�最大的值是255。如上面的例子中�Q?12+7×256=2004�?br />SQL> select to_char(to_date('-2004-12-17 16:42:42', 'syyyy-mm-dd hh24:mi:ss'), 'syyyy-mm-dd hh24:mi:ss') dat,
2 dump(to_date('-2004-12-17 16:42:42', 'syyyy-mm-dd hh24:mi:ss')) dump_date from dual;
DAT                  DUMP_DATE
-------------------- ---------------------------------------------------
-2004-12-17 16:42:42 Typ=13 Len=8: 44,248,12,17,16,42,42,0
SQL> select dump(to_date('-1-1-1', 'syyyy-mm-dd')) from dual;
DUMP(TO_DATE('-1-1-1','SYYYY-MM-D
---------------------------------
Typ=13 Len=8: 255,255,1,1,0,0,0,0

对于公元前的日期�Q�Oracle�?55�Q?55开始保存。公元前的年的保存的值和对应的公元后的年的值相加的和是256�Q?55。如上例中的公元2004�q�和公元�?004�q�的值相加：212+44=256�Q?+248=255�?br />SQL中DATE�c�d��最后还包括一�?�Q�似乎目前没有��用�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�三�Q�——日期类型（四）
发表�?yangtingkun | 发表旉��: 2005�q�一�?2�? 02:26
本文对TIMESTAMP WITH LOCAL TIME ZONE和TIMESTAMP WITH TIME ZONE�c�d��的存储格式进行简单的说明�?br />
SQL> CREATE TABLE TEST_TIMESTAMP(TIME1 TIMESTAMP(9), TIME2 TIMESTAMP(6) WITH LOCAL TIME ZONE,
2 TIME3 TIMESTAMP(4) WITH TIME ZONE);
表已创徏�?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
SQL> SELECT * FROM TEST_TIMESTAMP;
TIME1
----------------------------------------------------
TIME2
----------------------------------------------------
TIME3
----------------------------------------------------
11-1�?-05 11.08.15.027000000 下午
11-1�?-05 11.08.15.027000 下午
11-1�?-05 11.08.15.0270 下午 +08:00
SQL> SELECT DUMP(TIME1, 16), DUMP(TIME2, 16), DUMP(TIME3, 16) FROM TEST_TIMESTAMP;
DUMP(TIME1,16)
-------------------------------------------------------------
DUMP(TIME2,16)
-------------------------------------------------------------
DUMP(TIME3,16)
-------------------------------------------------------------
Typ=180 Len=11: 78,69,1,b,18,9,10,1,9b,fc,c0
Typ=231 Len=11: 78,69,1,b,18,9,10,1,9b,fc,c0
Typ=181 Len=13: 78,69,1,b,10,9,10,1,9b,fc,c0,1c,3c
可以发现�Q�如果客��L��和数据库中的时区是一致的�Q�那么TIMESTAMP和TIMESTAMP WITH LOCAL TIME ZONE存储的数据是完全一��L��?
TIMESTAMP WITH TIME ZONE则略有不同，它保存的�?时区的时��_��和所处的时区信息�?
修改客户端主机的时区�Q�由�?区（+8区）改�ؓ0时区�?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
修改客户端主机的时区�Q�改��5区（-5时区�Q��?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
修改客户端主机的时区�Q�改��12区（-12时区�Q��?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
修改客户端主机的时区�Q�改��Z��13区（+13时区�Q��?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
修改客户端主机的时区�Q�改��3.5区（-3.5时区�Q��?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
修改客户端主机的时区�Q�改��Z��9.5区（+9.5时区�Q��?
SQL> INSERT INTO TEST_TIMESTAMP VALUES (SYSTIMESTAMP, SYSTIMESTAMP, SYSTIMESTAMP);
已创�?1 行�?
SQL> COMMIT;
提交完成�?
修改客户端主机的时区�Q�改回东8区（+8时区�Q��?
SQL> SELECT * FROM TEST_TIMESTAMP;
TIME1
-----------------------------------------------
TIME2
-----------------------------------------------
TIME3
-----------------------------------------------
11-1�?-05 11.08.15.027000000 下午
11-1�?-05 11.08.15.027000 下午
11-1�?-05 11.08.15.0270 下午 +08:00
11-1�?-05 03.11.43.746000000 下午
11-1�?-05 11.11.43.746000 下午
11-1�?-05 03.11.43.7460 下午 +00:00
11-1�?-05 10.14.08.987000000 上午
11-1�?-05 11.14.08.987000 下午
11-1�?-05 10.14.08.9870 上午 -05:00
11-1�?-05 03.15.01.732000000 上午
11-1�?-05 11.15.01.732000 下午
11-1�?-05 03.15.01.7320 上午 -12:00
12-1�?-05 04.20.21.522000000 上午
11-1�?-05 11.20.21.522000 下午
12-1�?-05 04.20.21.5220 上午 +13:00
11-1�?-05 02.15.16.567000000 下午
12-1�?-05 01.45.16.567000 上午
11-1�?-05 02.15.16.5670 下午 -03:30
12-1�?-05 03.16.54.992000000 上午
12-1�?-05 01.46.54.992000 上午
12-1�?-05 03.16.54.9920 上午 +09:30
已选择7行�?
SQL> SELECT DUMP(TIME1, 16), DUMP(TIME2, 16), DUMP(TIME3, 16) FROM TEST_TIMESTAMP;
DUMP(TIME1,16)
-------------------------------------------------------------
DUMP(TIME2,16)
-------------------------------------------------------------
DUMP(TIME3,16)
-------------------------------------------------------------
Typ=180 Len=11: 78,69,1,b,18,9,10,1,9b,fc,c0
Typ=231 Len=11: 78,69,1,b,18,9,10,1,9b,fc,c0
Typ=181 Len=13: 78,69,1,b,10,9,10,1,9b,fc,c0,1c,3c
Typ=180 Len=11: 78,69,1,b,10,c,2c,2c,77,e,80
Typ=231 Len=11: 78,69,1,b,18,c,2c,2c,77,e,80
Typ=181 Len=13: 78,69,1,b,10,c,2c,2c,77,e,80,14,3c
Typ=180 Len=11: 78,69,1,b,b,f,9,3a,d4,6c,c0
Typ=231 Len=11: 78,69,1,b,18,f,9,3a,d4,6c,c0
Typ=181 Len=13: 78,69,1,b,10,f,9,3a,d4,6c,c0,f,3c
Typ=180 Len=11: 78,69,1,b,4,10,2,2b,a1,6f,0
Typ=231 Len=11: 78,69,1,b,18,10,2,2b,a1,6f,0
Typ=181 Len=13: 78,69,1,b,10,10,2,2b,a1,6f,0,8,3c
Typ=180 Len=11: 78,69,1,c,5,15,16,1f,1d,16,80
Typ=231 Len=11: 78,69,1,b,18,15,16,1f,1d,16,80
Typ=181 Len=13: 78,69,1,b,10,15,16,1f,1d,16,80,21,3c
Typ=180 Len=11: 78,69,1,b,f,10,11,21,cb,bb,c0
Typ=231 Len=11: 78,69,1,c,2,2e,11,21,cb,bb,c0
Typ=181 Len=13: 78,69,1,b,12,2e,11,21,cb,bb,c0,11,1e
Typ=180 Len=11: 78,69,1,c,4,11,37,3b,20,b8,0
Typ=231 Len=11: 78,69,1,c,2,2f,37,3b,20,b8,0
Typ=181 Len=13: 78,69,1,b,12,2f,37,3b,20,b8,0,1d,5a

SQL> SELECT TO_NUMBER('1C', 'XXX'), TO_NUMBER('3C', 'XXX') FROM DUAL;
TO_NUMBER('1C','XXX') TO_NUMBER('3C','XXX')
--------------------- ---------------------
                   28                    60
SQL> SELECT TO_NUMBER('14', 'XXX'), TO_NUMBER('3C', 'XXX'), TO_NUMBER('143C', 'XXXXXXX') FROM DUAL;
TO_NUMBER('14','XXX') TO_NUMBER('3C','XXX')
--------------------- ---------------------
                   20                    60
SQL> SELECT TO_NUMBER('3C', 'XXX') , TO_NUMBER('1E', 'XXX'), TO_NUMBER('5A', 'XXX') FROM DUAL;
TO_NUMBER('3C','XXX') TO_NUMBER('1E','XXX') TO_NUMBER('5A','XXX')
--------------------- --------------------- -------------------
                   60                    30                  90
可以看出�Q�修�Ҏ(gu��)��Z��D��pȝ��TIMESTAMP旉��发生变化�Q�但是对于TIMESTAMP WITH LOCAL TIME ZONE�c�d��Q��L��系�l�的旉��转化到数据库服务器上时区的时间进行存储�?
TIMESTAMP WITH TIME ZONE保存的是当前旉��转化�?时区的对应的旉��Q��ƈ通过最后两位来保存时区信息�?
�W�一位表�C�时区的��时部分�?时区�?x14表示。东n区在�q�个基础上加n�Q�西n区在�q�个基础上减n。我们所处的�?��C�Zؓ0x1C。西5��C�Zؓ0xF�?
�W�二位表�C�时区的分钟部分。标准是0x3C�Q�即60分钟。对于东时区的半区，在这个基��上加�?0分钟�Q�如果是西时区，则减�?0分钟�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�四�Q�——ROWID�c�d��Q�一�Q?br />发表�?yangtingkun | 发表旉��: 2004�q�十二月21�? 19:14
Oracle的ROWID用来唯一标识表中的一条记录，是这条数据在数据库中存放的物理地址�?br />Oracle的ROWID分�ؓ两种�Q�物理ROWID和逻辑ROWID。烦引组�l�表使用逻辑ROWID�Q�其他类型的表��用物理ROWID。其中物理ROWID在Oracle�?版本中进行了扩展�Q�Oracle7及以下版本��用约束ROWID�Q�Oracle8及以上版本��用扩展ROWID。本文描�q�物理扩展ROWID�Q�由于约束ROWID仅仅是�ؓ了兼�Ҏ(gu��)��期版本，因此不做讨论�?br />SQL> create table test_rowid (id number, row_id rowid);
表已创徏�?br />SQL> insert into test_rowid values (1, null);
已创�?1 行�?br />SQL> update test_rowid set row_id = rowid where id = 1;
已更�?1 行�?br />SQL> commit;
提交完成�?br />SQL> select rowid, row_id from test_rowid;
ROWID              ROW_ID
------------------ ------------------
AAABnRAAGAAAACWAAA AAABnRAAGAAAACWAAA
Oracle的物理扩展ROWID�?8位，每位采用64位编码，分别用A~Z、a~z�?~9�?�?�?4个字�W�表�C�。A表示0�Q�B表示1�Q�……Z表示25�Q�a表示26�Q�……z表示51�Q?表示52�Q�……，9表示61�Q?表示62�Q?表示63�?br />ROWID具体划分可以分�ؓ4部分�?br />1.OOOOOO�Q�前6位表�C�DATA OBJECT NUMBER�Q�将赯��{化位数字后匹配DBA_OBJECTS中的DATA_OBJECT_ID�Q�可以确定表信息�?br />如上面例子中的DATA OBJECT NUMBER是AAABnR�Q��{化位数字�?×64×64 �Q?9×64 �Q?17�?br />SQL> select owner, object_name from dba_objects
2 where data_object_id = 1*64*64 + 39*64 + 17;
OWNER                          OBJECT_NAME
------------------------------ -----------------------------
YANGTK                         TEST_ROWID
2.FFF�Q�第7�?位表�C�相对表�I�间的数据文件号�?br />上面的例子中是AAG�Q�表�C�数据文�?�?br />SQL> select file_name, tablespace_name from dba_data_files where relative_fno = 6;
FILE_NAME                                     TABLESPACE_NAME
--------------------------------------------- ---------------
E:ORACLEORADATATESTYANGTK01.DBF           YANGTK
3.BBBBBB�Q�第10�?5位表�C��条记录在数据文�g中的�W�几个BLOCK中�?br />上面的例子是AAAACW�Q��{化位数字�?×64�Q?2�Q�表�C��条记录在数据文�g中的�W?50个BLOCK�?br />4.RRR�Q�最�?位表�C��条记录是BLOCK中的�W�几条记录�?br />上面的例子是AAA�Q�表�C�第0条记录（��L��?开始计敎ͼ��?br />SQL> alter system dump datafile 6 block 150;
�pȝ��已更攏V�?br />SQL> select row_id, dump(row_id, 16) dump_rowid from test_rowid;
ROW_ID             DUMP_ROWID
------------------ -------------------------------------------------
AAABnRAAGAAAACWAAA Typ=69 Len=10: 0,0,19,d1,1,80,0,96,0,0

扑ֈ�对应的dump文�g�Q�可以发现类型的信息
*** 2004-12-21 17:58:26.000
*** SESSION ID:(13.91) 2004-12-21 17:58:26.000
Start dump data blocks tsn: 6 file#: 6 minblk 150 maxblk 150
buffer tsn: 6 rdba: 0x01800096 (6/150)
scn: 0x0000.2e389c16 seq: 0x01 flg: 0x06 tail: 0x9c160601
frmt: 0x02 chkval: 0xc97d type: 0x06=trans data
Block header dump: 0x01800096
Object id on Block? Y
seg/obj: 0x19d1 csc: 0x00.2e389c0f itc: 2 flg: O typ: 1 - DATA
     fsl: 0 fnx: 0x0 ver: 0x01

Itl           Xid                  Uba         Flag Lck        Scn/Fsc
0x01   0x0003.009.00000057 0x0080004b.0042.56 --U-    1 fsc 0x0000.2e389c16
0x02   0x0000.000.00000000 0x00000000.0000.00 ----    0 fsc 0x0000.00000000

data_block_dump,data header at 0x651105c
===============
tsiz: 0x3fa0
hsiz: 0x14
pbl: 0x0651105c
bdba: 0x01800096
     76543210
flag=--------
ntab=1
nrow=1
frre=-1
fsbo=0x14
fseo=0x3f89
avsp=0x3f7b
tosp=0x3f7b
0xe:pti[0] nrow=1 offs=0
0x12:pri[0] offs=0x3f89
block_row_dump:
tab 0, row 0, @0x3f89
tl: 17 fb: --H-FL-- lb: 0x1 cc: 2
col 0: [ 2] c1 02
col 1: [10] 00 00 19 d1 01 80 00 96 00 00
end_of_block_dump
End dump data blocks tsn: 6 file#: 6 minblk 150 maxblk 150

有时需要查看表的DUMP信息�Q�但是很隑և��定位表中数据开始于哪个BLOCK�Q�根据ROWID中包含的信息��可以方便的扑ֈ�起始BLOCK�?br />下面��单描�q�C��下ROWID�c�d��是如何存储的�?br />SQL> select row_id, dump(row_id, 16) dump_rowid from test_rowid;
ROW_ID             DUMP_ROWID
------------------ -------------------------------------------------
AAABnRAAGAAAACWAAA Typ=69 Len=10: 0,0,19,d1,1,80,0,96,0,0
�?位表�C�ROWID的前6位，也就是DATA_OBJECT_ID信息。数据以数值的格式保存�?br />SQL> select to_number('19d1', 'xxxxxx') from dual;
TO_NUMBER('19D1','XXXXXX')
--------------------------
                      6609
SQL> select 1*64*64 + 39*64 + 17 from dual;
1*64*64+39*64+17
----------------
            6609
�q�里存在一个问题，�Ҏ(gu��)��ROWID的取��D��_��OBJECT_DATA_ID最大的值是64�?�ơ方�Q�而根据DUMP�Q�oracle只用�?位保存，因此取��D��围是256�?�ơ方�?br />SQL> set numwid 12
SQL> select power(64, 6), power(256, 4), power(64, 6)/power(256, 4) from dual;
POWER(64,6) POWER(256,4) POWER(64,6)/POWER(256,4)
------------ ------------ ------------------------
68719476736   4294967296                       16
可见�Q�OBJECT_DATA_ID的最大值是4294967296�Q�当��过�q�个值时会出现重复的情况。（当然�Q�现实中不大可能�Q��?br />后面4位比较特�D�，是数据文件号和BLOCK数的“和”值构成�?br />数据文�g的数��g��64后保存在5�?位上�?br />SQL> select to_number('0180', 'xxxx') from dual;
TO_NUMBER('0180','XXXX')
------------------------
                     384
SQL> select 6*64 from dual;
        6*64
------------
         384
同时�Q?位BLOCK的��|��也保存在�q?位上�Q��ƈ与数据文件�{存结果相加。仍然是以数字格式存放�?br />SQL> select to_number('96', 'xxx') from dual;
TO_NUMBER('96','XXX')
---------------------
                  150
SQL> select 2*64 + 22 from dual;
   2*64+22
----------
       150
�׃��采用两位保存数据文�g的��|��且最��单位是64�Q�因此，ROWID中可以保存的数据文�g数是1024�Q�超�q?024会造成ROWID的重复�?br />SQL> select 256*256/64 from dual;
256*256/64
----------
      1024
�׃��BLOCK的值和数据文�g��q��q?位，因此BLOCK的第3位最大值应��于64�Q�这��h��能保证ROWID的不重复。因此BLOCK值的最大值应该是4194304�?br />SQL> select 64*256*256 from dual;
64*256*256
----------
   4194304
最后两位保存BLOCK中记录的倹{��这个值的最大值是65536�?br />SQL> select 256*256 from dual;
   256*256
----------
     65536

下面看一个例子，Oracle是如何将相对文�g号和BLOCK号“共享”第5�?字节的�?br />SQL> select blocks from user_segments where segment_name = 'TEST1';
    BLOCKS
----------
     86016
SQL> select max(rowid), dump(max(rowid)) dump_rowid from test1;
MAX(ROWID)         DUMP_ROWID
------------------ -------------------------------------------
AAABy+AAJAAAU5EAAM Typ=69 Len=10: 0,0,28,190,2,65,78,68,0,12
SQL> select dbms_rowid.rowid_relative_fno('AAABy+AAJAAAU5EAAM') fno,
2 dbms_rowid.rowid_block_number('AAABy+AAJAAAU5EAAM') block_num from dual;
       FNO BLOCK_NUM
---------- ----------
         9      85572
SQL> select 9*64, 2*256+65 from dual;
      9*64   2*256+65
---------- ----------
       576        577
SQL> select 1*256*256 + 78*256 + 68 from dual;
1*256*256+78*256+68
-------------------
              85572
可以看到�Q?�?为的值除�?4得到的商是相�Ҏ(gu��)��件号�Q�余数是BLOCK��L��高位�Q�乘�?5536后加上低两位才是BLOCK受��?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�四�Q�——ROWID�c�d��Q�二�Q?br />发表�?yangtingkun | 发表旉��: 2004�q�十二月22�? 23:52
Oracle的文档上没有介绍逻辑ROWID的编码规则，而且通过DUMP的结果也很难反推出编码规则。因此，本文只简单讨��Z��下逻辑ROWID的存储�?br />下面来看例子�?br />SQL> create table test_index (id number primary key, name varchar2(20)) organization index;
表已创徏�?
SQL> insert into test_index values (1, 'a');
已创�?1 行�?
SQL> commit;
提交完成�?
SQL> col dump_rowid format a60
SQL> select rowid, dump(rowid) dump_rowid from test_index;
ROWID                       DUMP_ROWID
--------------------------- ----------------------------------------
*BAFAB4wCwQL+               Typ=208 Len=10: 2,4,1,64,7,140,2,193,2,254
逻辑ROWID的DUMP�l�果前两位都�?�?�Q�最后一位都�?54�Q�（我还没有发现其他的情况）�Q�由于逻辑ROWID和主键的值有养I��所以长度是不定的，因此应该是用来表�C�开始和�l�束的�?
�W?�?位和物理ROWID一��P��表示的是相对表空间的数据文�g号乘�?4的倹{�?
�W?�?位表�C��条记录在数据文�g的第几个BLOCK中�?
从第7位开始到DUMP�l�果的倒数�W�二位，表示主键的倹{��首先是主键中第一个字�D늚�长度�Q�这里是2�Q�然后是主键的��|��׃��是NUMBER�c�d��Q�因�?93�Q?表示数�?。如果是多个字段�l�成的主键，�W�一个字�D�之后是�W�二个字�D늚�长度�Q�然后是�W�二个字�D늚�值……�?
SQL> select (1*256 + 64)/64 from dual;
(1*256+64)/64
-------------
            5
SQL> select 7*256 + 140 from dual;
7*256+140
----------
      1932
SQL> alter system dump datafile 5 block 1932;
�pȝ��已更攏V�?
扑ֈ�相应的dump文�g�Q�可以发现刚才插入的记录�?
Dump file f:oracleadmintest4udumptest4_ora_3828.trc
Thu Dec 23 00:17:53 2004
ORACLE V9.2.0.4.0 - Production vsnsta=0
vsnsql=12 vsnxtr=3
Windows 2000 Version 5.1 Service Pack 1, CPU type 586
Oracle9i Enterprise Edition Release 9.2.0.4.0 - Production
With the Partitioning, Oracle Label Security, OLAP and Oracle Data Mining options
JServer Release 9.2.0.4.0 - Production
Windows 2000 Version 5.1 Service Pack 1, CPU type 586
Instance name: test4
Redo thread mounted by this instance: 1
Oracle process number: 9
Windows thread id: 3828, image: ORACLE.EXE
*** 2004-12-23 00:17:53.361
*** SESSION ID:(8.82) 2004-12-23 00:17:53.301
Start dump data blocks tsn: 5 file#: 5 minblk 1932 maxblk 1932
buffer tsn: 5 rdba: 0x0140078c (5/1932)
scn: 0x0000.00e9f122 seq: 0x01 flg: 0x02 tail: 0xf1220601
frmt: 0x02 chkval: 0x0000 type: 0x06=trans data
Block header dump: 0x0140078c
Object id on Block? Y
seg/obj: 0x1e48 csc: 0x00.e9f113 itc: 2 flg: E typ: 2 - INDEX
     brn: 0 bdba: 0x1400789 ver: 0x01
     inc: 0 exflg: 0

Itl           Xid                  Uba         Flag Lck        Scn/Fsc
0x01   0x0000.000.00000000 0x00000000.0000.00 ----    0 fsc 0x0000.00000000
0x02   0x0005.008.000000e7 0x00800226.005c.24 --U-    1 fsc 0x0000.00e9f122

Leaf block dump
===============
header address 71963236=0x44a1264
kdxcolev 0
KDXCOLEV Flags = - - -
kdxcolok 0
kdxcoopc 0x90: opcode=0: iot flags=I-- is converted=Y
kdxconco 1
kdxcosdc 0
kdxconro 1
kdxcofbo 38=0x26
kdxcofeo 8026=0x1f5a
kdxcoavs 7988
kdxlespl 0
kdxlende 0
kdxlenxt 0=0x0
kdxleprv 0=0x0
kdxledsz 0
kdxlebksz 8036
row#0[8026] flag: K----, lock: 2
col 0; len 2; (2): c1 02
tl: 5 fb: --H-FL-- lb: 0x0 cc: 1
col 0: [ 1]
Dump of memory from 0x044A31C7 to 0x044A31C8
44A31C0          61010100                        [...a]
----- end of leaf block dump -----
End dump data blocks tsn: 5 file#: 5 minblk 1932 maxblk 1932
可以看到�Q�根据DUMP�l�果�?�?�?�?位可以定位记录的物理位置�?
需要注意的是，索引�l�织表以主键的顺序存储数据，因此插入、更新和删除数据都可能造成一条记录的物理位置发生变化�Q�这旉��过ROWID中的DATAFILE和BLOCK的信息可能就无法正确定位到记录的物理位置。当�Ҏ(gu��)��逻辑ROWID讉K��索引�l�织表时�Q�首先会�Ҏ(gu��)��DATAFILE和BLOCK信息��L��到相应的BLOCK�Q�检查数据是否在�q�个BLOCK中，如果不在�Q�就通过逻辑ROWID中的主键信息去通过索引扫描�Q�找到这条记录。这��是Oracle文档在提到的physical guess�?
下面看一个由字符串和日期�l�成联合主键的例子�?
SQL> create table test_index2 (id char(4), time date,
2 constraint pk_test_index2 primary key (id, time)) organization index;
表已创徏�?
SQL> insert into test_index2 values ('1', sysdate);
已创�?1 行�?
SQL> col dump_rowid format a75
SQL> select rowid, dump(rowid) dump_rowid from test_index2;
ROWID                        DUMP_ROWID
---------------------------- ------------------------------------------------------------------
*BAFAB5QEMSAgIAd4aAwXASMT/g Typ=208 Len=20: 2,4,1,64,7,148,4,49,32,32,32,7,120,104,12,23,1,35,19,254
可以看出�Q�第7位是字段id的长�?�Q�然后是字符�?和三个空格的ASCII码，�q�是字符串的存储格式�Q�后面跟着�?是字�D�time长度�Q�后面七位是日期的存储格式。在逻辑ROWID中，数倹{��字�W�和日期�c�d��的存储格式都和它们本�w�的存储格式一��_��q�里不在赘述�?
一般情况下�Q��用一位来表示长度�Q�但是如果长度超�q�了127�Q?6�q�制DUMP的结果是7F�Q�，则长度开始用两位表示。第一位以8开��_��q�个8只是标识位，表明长度字段现在�׃��位来表示。例如长�?28表示�?080�Q�而支持的最大�?800表示�?ED8�?br />==============================================================
Oracle基本数据�c�d��存储格式��析�Q�五�Q�——RAW�c�d��
发表�?yangtingkun | 发表旉��: 2004�q�十二月23�? 15:20
和其他数据类型相比，RAW�c�d��的存储显得直观多了，它和SELECT时数据展�C�的值完全一栗��（SELECT时是按照16�q�制展示的）

SQL> create table test_raw (id number, raw_date raw(10));
表已创徏�?br />SQL> insert into test_raw values (1, hextoraw('ff'));
已创�?1 行�?br />SQL> drop table test_raw;
表已丢弃�?br />SQL> create table test_raw (raw_col raw(10));
表已创徏�?br />SQL> insert into test_raw values (hextoraw('ff'));
已创�?1 行�?br />SQL> insert into test_raw values (hextoraw('0'));
已创�?1 行�?br />SQL> insert into test_raw values (hextoraw('23fc'));
已创�?1 行�?br />SQL> insert into test_raw values (hextoraw('fffffffffff'));
已创�?1 行�?br />SQL> insert into test_raw values (hextoraw('ffffffffffffffffffff'));
已创�?1 行�?br />SQL> insert into test_raw values (utl_raw.cast_to_raw('051'));
已创�?1 行�?br />SQL> select raw_col, dump(raw_col, 16) dump_raw from test_raw;
RAW_COL              DUMP_RAW
-------------------- -----------------------------------------------
FF                   Typ=23 Len=1: ff
00                   Typ=23 Len=1: 0
23FC                 Typ=23 Len=2: 23,fc
0FFFFFFFFFFF         Typ=23 Len=6: f,ff,ff,ff,ff,ff
FFFFFFFFFFFFFFFFFFFF Typ=23 Len=10: ff,ff,ff,ff,ff,ff,ff,ff,ff,ff
303531               Typ=23 Len=3: 30,35,31
已选择6行�?br />RAW�c�d��的存储很��单，�Ҏ(gu��)��字段的查询结果和DUMP的结果就一目了然了�?br />需要注意的是，两种转化为RAW的函��C��间的差别。当使用HEXTORAW�Ӟ��会把字符串中数据当作16�q�制数。而��用UTL_RAW.CAST_TO_RAW�Ӟ��直接把字�W�串中每个字�W�的ASCII码存攑ֈ�RAW�c�d��的字�D�中�?br />SQL> insert into test_raw values ('gg');
insert into test_raw values ('gg')
                             *
ERROR 位于�W?1 �?
ORA-01465: 无效的十六进制数�?br />SQL> insert into test_raw values (hextoraw('gg'));
insert into test_raw values (hextoraw('gg'))
                                      *
ERROR 位于�W?1 �?
ORA-01465: 无效的十六进制数�?br />SQL> insert into test_raw values (utl_raw.cast_to_raw('gg'));
已创�?1 行�?br />SQL> select raw_col, dump(raw_col, 16) dump_raw from test_raw;
RAW_COL              DUMP_RAW
-------------------- ----------------------------------------------
FF                   Typ=23 Len=1: ff
00                   Typ=23 Len=1: 0
23FC                 Typ=23 Len=2: 23,fc
6767                 Typ=23 Len=2: 67,67
0FFFFFFFFFFF         Typ=23 Len=6: f,ff,ff,ff,ff,ff
FFFFFFFFFFFFFFFFFFFF Typ=23 Len=10: ff,ff,ff,ff,ff,ff,ff,ff,ff,ff
303531               Typ=23 Len=3: 30,35,31
已选择7行�?br />

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=607570

風向逆轉 - ��p��爪哇 2006-03-20 23:37 发表评论

[收藏]Windows环境下的Oracle服务

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:35:00 GMT
注：SID - 数据库标�?br /> HOME_NAME - Oracle Home名称�Q�如OraHome92、OraHome81
�Q?�Q�OracleServiceSID
数据库服务，�q�个服务会自动地启动和停止数据库。如果安装了一个数据库�Q�它的缺省启动类型�ؓ自动。服务进�E��ؓORACLE.EXE�Q�参数文件initSID.ora�Q�日志文件SIDALRT.log�Q�控制台SVRMGRL.EXE、SQLPLUS.EXE�?br />
�Q?�Q�OracleHOME_NAMETNSListener
监听器服务，服务只有在数据库需要远�E�访问时才需要（无论是通过另外一��C��是在本地通过 SQL*Net �|�络协议都属于远�E�访问）�Q�不用这个服务就可以讉K��本地数据库，它的�~�省启动�c�d��动。服务进�E��ؓTNSLSNR.EXE�Q�参数文件Listener.ora�Q�日志文件listener.log�Q�控制台LSNRCTL.EXE�Q�默认端�?521�?526�?br />
�Q?�Q�OracleHOME_NAMEAgent
OEM代理服务�Q�接收和响应来自OEM控制台的��d��和事件请求，只有使用OEM��理数据库时才需要，它的�~�省启动�c�d��动。服务进�E��ؓDBSNMP.EXE�Q�参数文件snmp_rw.ora�Q�日志文件nmi.log�Q�控制台LSNRCTL.EXE�Q�默认端�?748�?br />
�Q?�Q�OracleHOME_NAMEClientCache
名字�~�存服务�Q�服务缓存用于连接远�E�数据库的Oracle Names 数据。它的缺省启动类型是手动。然而，除非有一台Oracle Names 服务器，否则没有必要�q�行�q�个服务。服务进�E��ؓONRSD.EXE�Q�参数文件NAMES.ORA�Q�日志文件ONRSD.LOG�Q�控制台NAMESCTL.EXE�?br />
�Q?�Q�OracleHOME_NAMECMAdmin
�q�接��理服务�Q�是构徏Connection Manager服务器所用，只有服务器作为Connection Manager才需要，它的�~�省启动�c�d��是手动。服务进�E��ؓCMADMIN.EXE�Q�参数文件CMAN.ORA�Q�日志文件CMADM_PID.TRC�Q�控制台CMCTL.EXE�Q�默认端�?830�?br />
�Q?�Q�OracleHOME_NAMECMan
�q�接�|�关服务�Q�是构徏Connection Manager服务器所用，只有服务器作为Connection Manager才需要，它的�~�省启动�c�d��是手动。服务进�E��ؓCMGW.EXE�Q�参数文件CMAN.ORA�Q�日志文件CMAN_PID.TRC�Q�控制台CMCTL.EXE�Q�默认端�?630�?br />
�Q?�Q�OracleHOME_NAMEDataGatherer
性能包数据采集服务，除非使用Oracle Capacity Planner �?Oracle Performance Manager�Q�否则不需要启动，它的�~�省启动�c�d��是手动。服务进�E��ؓVPPDC.EXE�Q�日志文件alert_dg.log�Q�控制台vppcntl.exe�?br />
�Q?�Q�OracleHOME_NAMEHTTPServer
Oracle提供的WEB服务器，一般情况下我们只用它来讉K��Oracle Apache 目录下的Web ��面�Q�比如说JSP 或者modplsql ��面。除非你使用它作��Z��的HTTP服务�Q�否则不需要启动（若启动它会接��IIS的服务）�Q�它的缺省启动类型是手动。服务进�E��ؓAPACHE.EXE�Q�参数文件httpd.conf�Q�默认端�?0�?br />
�Q?�Q�OracleHOME_NAMEPagingServer
通过一个��用调制解调器的数字传呼机或者电(sh��)子邮件发��告（没试�q�）�Q�它的缺省启动类型是手动。服务进�E�PAGNTSRV.EXE�Q�日志文件paging.log�?br />
�Q?0�Q�OracleHOME_NAMENames
Oracle Names服务�Q�只有服务器作�ؓNames Server才需要，它的�~�省启动�c�d��是手动。服务进�E�NAMES.EXE�Q�参数文件NAMES.ORA�Q�日志文件NAMES.LOG�Q�控制台NAMESCTL.EXE�Q�默认端�?575�?br />
�Q?1�Q�OracleSNMPPeerMasterAgent
SNMP服务代理�Q�用于支持SNMP的网��Y件对服务器的��理�Q�除非你使用�|�管工具监控数据库的情况�Q�否则不需要启动，它的�~�省启动�c�d��是手动。服务进�E��ؓAGNTSVC.EXE�Q�参数文件MASTER.CFG�Q�默认端�?61�?br />
�Q?2�Q�OracleSNMPPeerEncapsulater
SNMP协议��装服务�Q�用于SNMP协议转换�Q�除非你使用一个不兼容的SNMP代理服务�Q�否则不需要启动，它的�~�省启动�c�d��是手动。服务进�E��ؓENCSVC.EXE�Q�参数文件ENCAPS.CFG�Q�默认端�?161�?br />
�Q?3�Q�OracleHOME_NAMEManagementServer
OEM��理服务�Q��用OEM旉��要，它的�~�省启动�c�d��是手动。服务进�E��ؓOMSNTSVR.EXE�Q�日志文件oms.nohup�?br />

作者Blog�Q?/strong> http://blog.csdn.net/lm20224/

風向逆轉 - ��p��爪哇 2006-03-20 23:35 发表评论

[收藏]数据库连接池Java实现��结

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:24:00 GMT
  因�ؓ工作需要要使用到连接池�Q�所以拜��M��互联�|�上众多前辈的文章，学了不少�l�验�Q�这里想做一个小�l�，加上自己的想法和在一��P��希望能给大家一些帮助�?
目的�Q?/h3>
消除数据库频�J�连接带来的开销和瓶颈�?/li>
解决�Ҏ(gu��)��Q?/h3>
不过多的限制用户的��用，既不能太多的要求用户按规定的�Ҏ(gu��)��得到和��用数据库�q?/li>
��量保持用户的习�?/li>
目前的很多方法都是要求用户只能按规定�Ҏ(gu��)��使用�q�接�Q�不能��用直接关闭数据连接的�Ҏ(gu��)��。解军_��法就是��用代理类�Q�来中间解决。可以参�?a >http://www-900.ibm.com/developerWorks/cn/java/l-connpoolproxy/index.shtml
能维护连接的正常状�?/li>
因�ؓ针对数据库连接创建的资源�Q�如果不能及时的释放�Q�就会媄响下一�ơ数据连接的使用。例如在sql 2k中，一个连接不同创建多条Statement否则操作时会有数据连接占�U�的异常�Q�所以必��d��归还�q�接以后释放�q�些资源�?/p>
   //�?/font>断是使用了createStatement语句    if (CREATESTATE.equals(method.getName()))    {     obj = method.invoke(conn, args);     statRef = (Statement)obj;//记录语句     return obj;    }
   //�?/font>断是否调用了close的方法，如果调用close�Ҏ(gu��)��则把�q�接�|��ؓ无用状�?br />   if(CLOSE.equals(method.getName()))    {     //�?/font>�|�不使用标志     setIsFree(false);     //��查是否有后箋工作�Q�清除该�q�接无用资源     if (statRef != null)      statRef.close();     if (prestatRef != null)      prestatRef.close();     return null;    }
正确保护�c�M��被违例��?/li>
一个考虑��是不能让用户随便��用代理类�Q�而只能自�׃��用，一个就是用内部�U�有�c�，一个就是��用只有指定类才能调用的标志。我的实现就是采用后者�?/p>
/** * 创徏�q�接的工厂，只能让工厂调�?br /> * @param factory 要调用工厂，�q�且一定被正确初始�?br /> * @param param �q�接参数 * @return �q�接 */ static public _Connection getConnection(ConnectionFactory factory, ConnectionParam param) {   if (factory.isCreate())//判断是否正确初始化的工厂   {    _Connection _conn = new _Connection(param);    return _conn;   }   else    return null; }
提供良好的用��h��口，��单实�?/li>
使用静态方法创建工厂，然后来得到连接，使用完全和普通的Connection�Ҏ(gu��)��一��P��没有限制。同时�ؓ了方便，讄��了连接参数类和工厂参数类�?/p>
ConnectionParam param = new ConnectionParam(driver,url,user,password);   ConnectionFactory cf = null;//new ConnectionFactory(param, new FactoryParam());   try{    cf = new ConnectionFactory(param,new FactoryParam());    Connection conn1 = cf.getFreeConnection();    Connection conn2 = cf.getFreeConnection();    Connection conn3 = cf.getFreeConnection();    Statement stmt = conn1.createStatement();    ResultSet rs = stmt.executeQuery("select * from requests");    if (rs.next())    {     System.out.println("conn1 y");      }    else    {     System.out.println("conn1 n");      }    stmt.close();    conn1.close();
��Z��实现�q�接池的正常�q�作�Q��用了单态模
/** * 使用指定的参数创��Z��个连接池 */ public ConnectionFactory(ConnectionParam param, FactoryParam fparam)   throws SQLException {   //�?/font>允许参数为空   if ((param == null)||(fparam == null))    throw new SQLException("ConnectionParam和FactoryParam不能为空");   if (m_instance == null)   {    synchronized(ConnectionFactory.class){     if (m_instance == null)     {      //new instance      //�?/font>数定�?br />     m_instance = new ConnectionFactory();      m_instance.connparam = param;      m_instance.MaxConnectionCount = fparam.getMaxConn();      m_instance.MinConnectionCount = fparam.getMinConn();      m_instance.ManageType = fparam.getType();      m_instance.isflag = true;      //�?/font>始化�Q�创建MinConnectionCount个连�?br />     System.out.println("connection factory 创徏�Q?);      try{       for (int i=0; i < m_instance.MinConnectionCount; i++)       {        _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);        if (_conn == null) continue;        System.out.println("connection创徏");        m_instance.FreeConnectionPool.add(_conn);//加入�I�闲�q�接�?br />       m_instance.current_conn_count ++;        //�?/font>志是否支持事�?br />       m_instance.supportTransaction = _conn.isSupportTransaction();           }      }      catch(Exception e)      {       e.printStackTrace();      }      //�?/font>据策略判断是否需要查�?br />     if (m_instance.ManageType != 0)      {       Thread t = new Thread(new FactoryMangeThread(m_instance));       t.start();      }     }    }   } }
�q�接池的��理
对于�q�接池的��理�Q�我是设想��用静态管理和动态管理两�U�策略，讄��了最大限�Ӟ��和恒定的�q�接数。��用了2个池�Q�一个空闲池�Q�一个��用池。静态就是��用的时候发现空闲连接不够再��L��查。动态就是��用了一个线�E�定时检查�?/p>
//�Ҏ(gu��)��{�略判断是否需要查�?br />     if (m_instance.ManageType != 0)      {       Thread t = new Thread(new FactoryMangeThread(m_instance));       t.start();      }
//�q�接池调度线�E?br />public class FactoryMangeThread implements Runnable { ConnectionFactory cf = null; long delay = 1000; public FactoryMangeThread(ConnectionFactory obj) {   cf = obj; } /* (non-Javadoc) * @see java.lang.Runnable#run() */ public void run() {   while(true){    try{     Thread.sleep(delay);    }    catch(InterruptedException e){}    System.out.println("eeeee");    //�?/font>断是否已�l�关闭了工厂�Q�那��退出监�?br />   if (cf.isCreate())     cf.schedule();    else     System.exit(1);   } } }
最后给出完整的源代码：
_Connectio.java
package scut.ailab.connectionpool;
import java.lang.reflect.*;
import java.sql.*;
/**
* @author youyongming
* 定义数据库连接的代理�c?br /> */
public class _Connection implements InvocationHandler {
//�?/font>义连�?br /> private Connection conn = null;
//�?/font>义监控连接创建的语句
private Statement statRef = null;
private PreparedStatement prestatRef = null;
//�?/font>否支持事务标�?br /> private boolean supportTransaction = false;
//�?/font>据库的忙状�?br /> private boolean isFree = false;
//最后一�ơ访问时�?br /> long lastAccessTime = 0;
//�?/font>义要接管的函数的名字
String CREATESTATE = "createStatement";
String CLOSE = "close";
String PREPARESTATEMENT = "prepareStatement";
String COMMIT = "commit";
String ROLLBACK = "rollback";
/**
* 构造函敎ͼ�采用�U�有�Q�防止被直接创徏
* @param param �q�接参数
*/
private _Connection(ConnectionParam param) {
  //�?/font>录日�?br />
  try{
   //�?/font>��?br />   Class.forName(param.getDriver()).newInstance();
   conn = DriverManager.getConnection(param.getUrl(),param.getUser(), param.getPassword());
   DatabaseMetaData dm = null;
   dm = conn.getMetaData();
   //�?/font>断是否支持事�?br />   supportTransaction = dm.supportsTransactions();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}

/* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
   Object obj = null;
   //�?/font>断是否调用了close的方法，如果调用close�Ҏ(gu��)��则把�q�接�|��ؓ无用状�?br />   if(CLOSE.equals(method.getName()))
   {
    //�?/font>�|�不使用标志
    setIsFree(false);
    //��查是否有后箋工作�Q�清除该�q�接无用资源
    if (statRef != null)
     statRef.close();
    if (prestatRef != null)
     prestatRef.close();
    return null;
   }
   //�?/font>断是使用了createStatement语句
   if (CREATESTATE.equals(method.getName()))
   {
    obj = method.invoke(conn, args);
    statRef = (Statement)obj;//记录语句
    return obj;
   }
   //�?/font>断是使用了prepareStatement语句
   if (PREPARESTATEMENT.equals(method.getName()))
   {
    obj = method.invoke(conn, args);
    prestatRef = (PreparedStatement)obj;
    return obj;
   }
   //�?/font>果不支持事务�Q�就不执行该事物的代�?br />   if ((COMMIT.equals(method.getName())||ROLLBACK.equals(method.getName())) && (!isSupportTransaction()))
    return null;
   obj = method.invoke(conn, args);
   //�?/font>�|�最后一�ơ访问时��_��以便及时清除��时的连�?br />   lastAccessTime = System.currentTimeMillis();
   return obj;
}
/**
* 创徏�q�接的工厂，只能让工厂调�?br /> * @param factory 要调用工厂，�q�且一定被正确初始�?br /> * @param param �q�接参数
* @return �q�接
*/
static public _Connection getConnection(ConnectionFactory factory, ConnectionParam param)
{
  if (factory.isCreate())//判断是否正确初始化的工厂
  {
   _Connection _conn = new _Connection(param);
   return _conn;
  }
  else
   return null;
}

public Connection getFreeConnection() {
  //�q?/font>回数据库�q�接conn的接��类�Q�以便截住close�Ҏ(gu��)��
  Connection conn2 = (Connection)Proxy.newProxyInstance(
   conn.getClass().getClassLoader(),
   conn.getClass().getInterfaces(),this);
  return conn2;
}
/**
* 该方法真正的关闭了数据库的连�?br /> * @throws SQLException
*/
void close() throws SQLException{
  //�?/font>于类属性conn是没有被接管的连接，因此一旦调用close�Ҏ(gu��)��后就直接关闭�q�接
  conn.close();
}

public void setIsFree(boolean value)
{
  isFree = value;
}

public boolean isFree() {
  return isFree;
}
/**
* 判断是否支持事务
* @return boolean
*/
public boolean isSupportTransaction() {
  return supportTransaction;
}
}
ConnectionFactory.java
package scut.ailab.connectionpool;
/**
* @author youyongming
*
*/
import java.util.LinkedHashSet;
import java.sql.*;
import java.util.Iterator;
public class ConnectionFactory {
private static ConnectionFactory m_instance = null;
//�?/font>使用的连接池
private LinkedHashSet ConnectionPool = null;
//�I?/font>闲连接池
private LinkedHashSet FreeConnectionPool = null;
//最大连接数
private int MaxConnectionCount = 4;
//最��连接数
private int MinConnectionCount = 2;
//�?/font>前连接数
private int current_conn_count = 0;
//�q?/font>接参�?br /> private ConnectionParam connparam = null;
//�?/font>否创建工厂的标志
private boolean isflag = false;
//�?/font>否支持事�?br /> private boolean supportTransaction = false;
//�?/font>义管理策�?br /> private int ManageType = 0;
private ConnectionFactory() {
  ConnectionPool = new LinkedHashSet();
  FreeConnectionPool = new LinkedHashSet();
}

/**
* 使用指定的参数创��Z��个连接池
*/
public ConnectionFactory(ConnectionParam param, FactoryParam fparam)
  throws SQLException
{
  //�?/font>允许参数为空
  if ((param == null)||(fparam == null))
   throw new SQLException("ConnectionParam和FactoryParam不能为空");
  if (m_instance == null)
  {
   synchronized(ConnectionFactory.class){
    if (m_instance == null)
    {
     //new instance
     //�?/font>数定�?br />     m_instance = new ConnectionFactory();
     m_instance.connparam = param;
     m_instance.MaxConnectionCount = fparam.getMaxConn();
     m_instance.MinConnectionCount = fparam.getMinConn();
     m_instance.ManageType = fparam.getType();
     m_instance.isflag = true;
     //�?/font>始化�Q�创建MinConnectionCount个连�?br />     System.out.println("connection factory 创徏�Q?);
     try{
      for (int i=0; i < m_instance.MinConnectionCount; i++)
      {
       _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);
       if (_conn == null) continue;
       System.out.println("connection创徏");
       m_instance.FreeConnectionPool.add(_conn);//加入�I�闲�q�接�?br />       m_instance.current_conn_count ++;
       //�?/font>志是否支持事�?br />       m_instance.supportTransaction = _conn.isSupportTransaction();
      }
     }
     catch(Exception e)
     {
      e.printStackTrace();
     }
     //�?/font>据策略判断是否需要查�?br />     if (m_instance.ManageType != 0)
     {
      Thread t = new Thread(new FactoryMangeThread(m_instance));
      t.start();
     }
    }
   }
  }
}

/**
* 标志工厂是否已经创徏
* @return boolean
*/
public boolean isCreate()
{
  return m_instance.isflag;
}

/**
* 从连接池中取一个空闲的�q�接
* @return Connection
* @throws SQLException
*/
public synchronized Connection getFreeConnection()
  throws SQLException
{
  Connection conn = null;
  //�?/font>取空闲连�?br />  Iterator iter = m_instance.FreeConnectionPool.iterator();
  while(iter.hasNext()){
   _Connection _conn = (_Connection)iter.next();
   //�?/font>到未用连�?br />   if(!_conn.isFree()){
    conn = _conn.getFreeConnection();
    _conn.setIsFree(true);
    //�U?/font>出空闲区
    m_instance.FreeConnectionPool.remove(_conn);
    //�?/font>入连接池
    m_instance.ConnectionPool.add(_conn);
    break;
   }
  }
  //��查空闲池是否为空
  if (m_instance.FreeConnectionPool.isEmpty())
  {
   //�?/font>��查是否能够分�?br />   if (m_instance.current_conn_count < m_instance.MaxConnectionCount)
   {
   //�?/font>��接到�I�闲�q�接�?br />    int newcount = 0 ;
    //�?/font>得要建立的数�?br />    if (m_instance.MaxConnectionCount - m_instance.current_conn_count >=m_instance.MinConnectionCount)
    {
     newcount = m_instance.MinConnectionCount;
    }
    else
    {
     newcount = m_instance.MaxConnectionCount - m_instance.current_conn_count;
    }
    //�?/font>��?br />    for (int i=0;i     {
     _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);
     m_instance.FreeConnectionPool.add(_conn);
     m_instance.current_conn_count ++;
    }
   }
   else
   {//如果不能新徏�Q�检查是否有已经归还的连�?br />    iter = m_instance.ConnectionPool.iterator();
    while(iter.hasNext()){
     _Connection _conn = (_Connection)iter.next();
     if(!_conn.isFree()){
      conn = _conn.getFreeConnection();
      _conn.setIsFree(false);
      m_instance.ConnectionPool.remove(_conn);
      m_instance.FreeConnectionPool.add(_conn);
      break;
     }
    }
   }
  }//if (FreeConnectionPool.isEmpty())
//�?/font>�ơ检查是否能分配�q�接
  if(conn == null){
   iter = m_instance.FreeConnectionPool.iterator();
   while(iter.hasNext()){
    _Connection _conn = (_Connection)iter.next();
    if(!_conn.isFree()){
     conn = _conn.getFreeConnection();
     _conn.setIsFree(true);
     m_instance.FreeConnectionPool.remove(_conn);
     m_instance.ConnectionPool.add(_conn);
     break;
    }
   }
   if(conn == null)//如果不能则说明无�q�接可用
    throw new SQLException("没有可用的数据库�q�接");
  }
  System.out.println("get connection");
  return conn;
}

/**
* 关闭该连接池中的所有数据库�q�接
* @throws SQLException
*/
public synchronized void close() throws SQLException
{
  this.isflag = false;
  SQLException excp = null;
  //�?/font>闭空闲池
  Iterator iter = m_instance.FreeConnectionPool.iterator();
  while(iter.hasNext()){
   try{
    ((_Connection)iter.next()).close();
    System.out.println("close connection:free");
    m_instance.current_conn_count --;
   }catch(Exception e){
    if(e instanceof SQLException)
     excp = (SQLException)e;
   }
  }
  //�?/font>闭在使用的连接池
  iter = m_instance.ConnectionPool.iterator();
  while(iter.hasNext()){
   try{
    ((_Connection)iter.next()).close();
    System.out.println("close connection:inused");
    m_instance.current_conn_count --;
   }catch(Exception e){
    if(e instanceof SQLException)
     excp = (SQLException)e;
   }
  }
  if(excp != null)
   throw excp;
}

/**
* �q�回是否支持事务
* @return boolean
*/
public boolean isSupportTransaction() {
  return m_instance.supportTransaction;
}
/**
* �q�接池调度管�?br /> *
*/
public void schedule()
{
  Connection conn = null;
  //�?/font>��查是否能够分�?br />  Iterator iter = null;
  //��查是否有已经归还的连�?br />  {
   iter = m_instance.ConnectionPool.iterator();
   while(iter.hasNext()){
    _Connection _conn = (_Connection)iter.next();
    if(!_conn.isFree()){
     conn = _conn.getFreeConnection();
     _conn.setIsFree(false);
     m_instance.ConnectionPool.remove(_conn);
     m_instance.FreeConnectionPool.add(_conn);
     break;
    }
   }
  }
  if (m_instance.current_conn_count < m_instance.MaxConnectionCount)
  {
   //�?/font>��接到�I�闲�q�接�?br />   int newcount = 0 ;
   //�?/font>得要建立的数�?br />   if (m_instance.MaxConnectionCount - m_instance.current_conn_count >=m_instance.MinConnectionCount)
   {
    newcount = m_instance.MinConnectionCount;
   }
   else
   {
    newcount = m_instance.MaxConnectionCount - m_instance.current_conn_count;
   }
   //�?/font>��?br />   for (int i=0;i    {
    _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);
    m_instance.FreeConnectionPool.add(_conn);
    m_instance.current_conn_count ++;
   }
  }
}
}
ConnectionParam.java
package scut.ailab.connectionpool;
import java.io.Serializable;
/**
* @author youyongming
* 实现数据库连接的参数�c?br /> */
public class ConnectionParam implements Serializable {
private String driver;    //�?/font>据库驱动�E�序
private String url;   //�?/font>据连接的URL
private String user;    //�?/font>据库用户�?br /> private String password;   //�?/font>据库密码

/**
* 唯一的构造函敎ͼ�需要指定连接的四个必要参数
* @param driver 数据驱动
* @param url  数据库连接url
* @param user  用户�?br /> * @param password 密码
*/
public ConnectionParam(String driver,String url,String user,String password)
{
  this.driver = driver;
  this.url = url;
  this.user = user;
  this.password = password;
}
public String getDriver() {
  return driver;
}
public String getPassword() {
  return password;
}
public String getUrl() {
  return url;
}
public String getUser() {
  return user;
}
public void setDriver(String driver) {
  this.driver = driver;
}
public void setPassword(String password) {
  this.password = password;
}
public void setUrl(String url) {
  this.url = url;
}
public void setUser(String user) {
  this.user = user;
}
/**
* @see java.lang.Object#clone()
*/
public Object clone(){
  ConnectionParam param = new ConnectionParam(driver,url,user,password);
  return param;
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
  if(obj instanceof ConnectionParam){
   ConnectionParam param = (ConnectionParam)obj;
   return ((driver.compareToIgnoreCase(param.getDriver()) == 0)&&
   (url.compareToIgnoreCase(param.getUrl()) == 0)&&
   (user.compareToIgnoreCase(param.getUser()) == 0)&&
   (password.compareToIgnoreCase(param.getPassword()) == 0));
  }
  return false;
}
}
FactoryMangeThread.java
/*
* Created on 2003-5-13
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package scut.ailab.connectionpool;
/**
* @author youyongming
*
*/
//�q?/font>接池调度�U�程
public class FactoryMangeThread implements Runnable {
ConnectionFactory cf = null;
long delay = 1000;
public FactoryMangeThread(ConnectionFactory obj)
{
  cf = obj;
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
public void run() {
  while(true){
   try{
    Thread.sleep(delay);
   }
   catch(InterruptedException e){}
   System.out.println("eeeee");
   //�?/font>断是否已�l�关闭了工厂�Q�那��退出监�?br />   if (cf.isCreate())
    cf.schedule();
   else
    System.exit(1);
  }
}
}
FactoryParam.java
/*
* Created on 2003-5-13
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package scut.ailab.connectionpool;
/**
* @author youyongming
*
*/
//�q?/font>接池工厂参数
public class FactoryParam {
//最大连接数
private int MaxConnectionCount = 4;
//最��连接数
private int MinConnectionCount = 2;
//�?/font>收策�?br /> private int ManageType = 0;

public FactoryParam() {
}

/**
* 构造连接池工厂参数的对�?br /> * @param max 最大连接数
* @param min 最��连接数
* @param type ��理�{�略
*/
public FactoryParam(int max, int min, int type)
{
  this.ManageType = type;
  this.MaxConnectionCount = max;
  this.MinConnectionCount = min;
}

/**
* 讄��最大的�q�接�?br /> * @param value
*/
public void setMaxConn(int value)
{
  this.MaxConnectionCount = value;
}
/**
* 获取最大连接数
* @return
*/
public int getMaxConn()
{
  return this.MaxConnectionCount;
}
/**
* 讄��最��连接数
* @param value
*/
public void setMinConn(int value)
{
  this.MinConnectionCount = value;
}
/**
* 获取最��连接数
* @return
*/
public int getMinConn()
{
  return this.MinConnectionCount;
}
public int getType()
{
  return this.ManageType;
}
}
testmypool.java
/*
* Created on 2003-5-13
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package scut.ailab.connectionpool;
/**
* @author youyongming
*
*/
import java.sql.*;
public class testmypool {
public void test1()
{
  String user = "DevTeam";
  String password = "DevTeam";
  String driver = "sun.jdbc.odbc.JdbcOdbcDriver";
  String url = "jdbc:odbc:gfqh2";
  ConnectionParam param = new ConnectionParam(driver,url,user,password);
  ConnectionFactory cf = null;//new ConnectionFactory(param, new FactoryParam());
  try{
   cf = new ConnectionFactory(param,new FactoryParam());
   Connection conn1 = cf.getFreeConnection();
   Connection conn2 = cf.getFreeConnection();
   Connection conn3 = cf.getFreeConnection();
   Statement stmt = conn1.createStatement();
   ResultSet rs = stmt.executeQuery("select * from requests");
   if (rs.next())
   {
    System.out.println("conn1 y");
   }
   else
   {
    System.out.println("conn1 n");
   }
   stmt.close();
   conn1.close();
   Connection conn4 = cf.getFreeConnection();
   Connection conn5 = cf.getFreeConnection();
   stmt = conn5.createStatement();
   rs = stmt.executeQuery("select * from requests");
   if (rs.next())
   {
    System.out.println("conn5 y");
   }
   else
   {
    System.out.println("conn5 n");
   }
   conn2.close();
   conn3.close();
   conn4.close();
   conn5.close();
   }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  finally{
   try{
    cf.close();
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
  }
}
public static void main(String[] args) {
  String user = "DevTeam";
  String password = "DevTeam";
  String driver = "sun.jdbc.odbc.JdbcOdbcDriver";
  String url = "jdbc:odbc:gfqh2";
  ConnectionParam param = new ConnectionParam(driver,url,user,password);
  ConnectionFactory cf = null;//new ConnectionFactory(param,new FactoryParam());
  try{
   cf = new ConnectionFactory(param,new FactoryParam());
   ConnectionFactory cf1= new ConnectionFactory(param,new FactoryParam());
   Connection conn1 = null;
   long time = System.currentTimeMillis();
   for (int i=0; i <10;i++)
   {
    conn1 = cf.getFreeConnection();
    Statement stmt = conn1.createStatement();
    ResultSet rs = stmt.executeQuery("select * from requests");
    if (rs.next())
    {
     System.out.println("conn1 y");
    }
    else
    {
     System.out.println("conn1 n");
    }
    conn1.close();
   }
   System.out.println("pool:" + (System.currentTimeMillis()-time));
   time = System.currentTimeMillis();
   Class.forName(param.getDriver()).newInstance();
   for (int i=0; i <10;i++)
   {
    conn1 = DriverManager.getConnection(param.getUrl(),param.getUser(), param.getPassword());
    Statement stmt = conn1.createStatement();
    ResultSet rs = stmt.executeQuery("select * from requests");
    if (rs.next())
    {
     System.out.println("conn1 y");
    }
    else
    {
     System.out.println("conn1 n");
    }
    conn1.close();
   }
   System.out.println("no pool:" + (System.currentTimeMillis()-time));
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  finally{
   try{
    cf.close();
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
  }
}
}

原文链接:http://www.jaron.cn/chs_db/16/2003-09/20030916110224-101181.html

風向逆轉 - ��p��爪哇 2006-03-20 23:24 发表评论

[收藏]Tomcat5配置Mysql JDBC数据库连接池

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:14:00 GMT

如果只是对MySql感兴��可以照抄这��短文，如果想配�|�其他数据库�c�d��的连接池�Q�也可以做简单修改参数即可��用。�?br />

1、安装Tomcat

参考Tomcat for window 的安装向��|��基本直接安装卛_��Q�注意：安装时会提示输入��理用户名和密码�Q�这是以后会用到的用户名和密码，切记�?br />

2、安装MySql

默认安装卛_��?br />

3、 ��用Tomcat的Web��理应用配置数据�?br />
启动Tomcat服务器，打开��览器，输入http://localhost:8080/admin/�Q�其中localhost可能是一台机器的IP或是服务器名�U�ͼ��Q�进入管理界面的登陆��面�Q�这时候请输入原来安装时要求输入的用户名和密码�Q�登陆到��理界面�Q?br />

选择Resources�Q�Data sources�q�入配置数据源界面，选择Data Source Actions �Q?gt;选择Create New Data Source,�q�入配置详细信息界面�Q�内容如下：

JNDI Name: jdbc/mysql
Data Source URL: jdbc:mysql://192.168.0.16/SUBRDB
JDBC Driver Class: org.gjt.mm.mysql.Driver
User Name: root
Password: ********
Max. Active Connections: 4
Max. Idle Connections: 2
Max. Wait for Connection: 500
Validation Query:

要求输入的JNDI Name�{�信息，其中除了JDBC DriverClass之外�Q�其他的可以�Ҏ(gu��)��你的需要填写。比如Data Source URL的内容可能是�Q�jdbc:mysql:// IP或是名称/DataBaseName�Q�其中DataBaseName是你的数据库名称�Q�IP是你的数据库的所在的服务器的IP或是名称。最后点击Save�Q?gt;Commit Change.�q�样你的数据源的基本资料配置一半了�?br />

4、 web.xml�?TOMCAT_HOME%\conf\Catalina\localhost下对应你的引用的配置文�g修改

通过文�g夹导航到%TOMCAT_HOME%\conf�Q�打开web.xml,�?lt;/web-app>的前面添加以下内容：

DB Connection

jdbc/mysql

javax.sql.DataSource

Container

注意res-ref-name填写的内容要与在上文提到的JNDI Name名称一致。�?br />
通过文�g夹导航到%TOMCAT_HOME%\conf\Catalina\localhost下，扑ֈ�你的web应用对应�?xml文�g�Q�如 ROOT.xml�Q��ƈ在此文�g的下��d��代码�Q?br />

到这里，配置工作��基本完成了�?br />

5、其他注意事��?br />
别忘了JDBC驱动�E�序mysql-connector-java-3.0.9-stable-bin.jar一定要攄��到Tomcat的对应目�?你的JDBC驱动可能版比�W�者高�Q�不�q�只要能与所使用的MySql对应��可以了�Q�因为我发现版本太低的JDBC驱动不能支持4.0.*版本的MySQL数据库，��攄��?TOMCAT_HOME%\common\lib和应用的WEB-INF\lib下。两者有什么不同呢�Q�其实一看就明白了，common\li是所有的应用都可以��用的库文件位�|��?br />
重启你的Tomcat服务�?br />

6、编写测试代�?br />
在应用的目录下徏立一个Test.jsp文�g�Q�代码如下：

"http://www.w3.org/TR/REC-html40/strict.dtd">

<%@ page import="java.sql.*"%>

<%@ page import="javax.sql.*"%>

<%@ page import="javax.naming.*"%>

<%@ page session="false" %>

<%

out.print("我的��试开�?);

DataSource ds = null;

try{

InitialContext ctx=new InitialContext();

ds=(DataSource)ctx.lookup("java:comp/env/jdbc/mysql");

Connection conn = ds.getConnection();

Statement stmt = conn.createStatement();

//提示�Q�users必须是数据库已有的表�Q?br />
//�q�里的数据库前文提及的Data Source URL配置里包含的数据库�?br />
String strSql = " select * from users";

ResultSet rs = stmt.executeQuery(strSql);

while(rs.next()){

out.print(rs.getString(1));

}

out.print("我的��试�l�束");

}

catch(Exception ex){

out.print(“出��C��外，信息�?�?ex.getMessage());

ex.printStackTrace();

}

%>

�q�行�l�果�Q?br />
我的��试开�?2345678我的��试�l�束�Q�因为我的rs.getString(1) 在数据库��是存放12345678

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=613371

風向逆轉 - ��p��爪哇 2006-03-20 23:14 发表评论

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 15:03:00 GMT

大家都在讨论关于数据库优化方面的东东�Q�刚好参与开发了一个数据仓库方面的��目�Q�以下的一点东西算是数据库优化斚w��的学�?实战的一些心得体会了�Q�拿出来大家�׃�n。欢�q�批评指正阿�Q��?br />
SQL语句�Q��?br />是对数据�?数据)�q�行操作的惟一途径�Q��?br />消耗了70%~90%的数据库资源�Q�独立于�E�序设计逻辑�Q�相对于对程序源代码的优化，对SQL语句的优化在旉��成本和风险上的代价都很低�Q��?br />可以有不同的写法�Q�易学，隄��通。�?br />
SQL优化�Q��?br />固定的SQL书写习惯�Q�相同的查询��量保持相同�Q�存储过�E�的效率较高。�?br />应该�~�写与其格式一致的语句�Q�包括字母的大小写、标点符受��换行的位置�{�都要一臾b?br />
ORACLE优化器：
在�Q何可能的时候都会对表达式进行评伎ͼ��q�且把特定的语法�l�构转换成等��L��l�构�Q�这么做的原因是
要么�l�果表达式能够比源表辑ּ��h��更快的速度
要么源表辑ּ�只是�l�果表达式的一个等仯��义结构�?br />不同的SQL�l�构有时��h��同样的操作（例如�Q? ANY (subquery) and IN (subquery)�Q�，ORACLE会把他们映射��C��个单一的语义结构。�?br />
1 帔R��优化�Q��?br />帔R��的计��是在语句被优化时一�ơ性完成，而不是在每次执行时。下面是��索月薪大�?000的的表达式：
sal > 24000/12
sal > 2000
sal*12 > 24000
如果SQL语句包括�W�一�U�情况，优化器会��单地把它转变成第二种。�?br />优化器不会简化跨��比较符的表辑ּ��Q�例如第三条语句�Q�鉴于此�Q�应��量写用帔R��跟字�D�|��较检索的表达式，而不要将字段�|�于表达式当中。否则没有办法优化，比如如果sal上有索引�Q�第一和第二就可以使用�Q�第三就难以使用。�?br />
2 操作�W�优化：
优化器把使用LIKE操作�W�和一个没有通配�W�的表达式组成的��索表辑ּ�转换��Z��个�?”操作符表达式。�?br />例如�Q�优化器会把表达式ename LIKE 'SMITH'转换为ename = 'SMITH'
优化器只能�{换涉及到可变长数据类型的表达式，前一个例子中�Q�如果ENAME字段的类型是CHAR(10)�Q� 那么优化器��不做�Q何�{换。�?br />一般来讲LIKE比较难以优化。�?br />
其中�Q��?br />~~ IN 操作�W�优化：
优化器把使用IN比较�W�的��索表辑ּ�替换为等��L��使用�?”和“OR”操作符的检索表辑ּ�。�?br />例如�Q�优化器会把表达式ename IN ('SMITH','KING','JONES')替换为�?br />ename = 'SMITH' OR ename = 'KING' OR ename = 'JONES‘�?br />
~~ ANY和SOME 操作�W�优�?
优化器将跟随值列表的ANY和SOME��索条件用�{��h(hu��n)的同�{�操作符和“OR”组成的表达式替换。�?br />例如�Q�优化器��如下所�C�的�W�一条语句用�W�二条语句替换：
sal > ANY (:first_sal, :second_sal)
sal > :first_sal OR sal > :second_sal
优化器将跟随子查询的ANY和SOME��索条件�{换成由“EXISTS”和一个相应的子查询组成的��索表辑ּ�。�?br />例如�Q�优化器��如下所�C�的�W�一条语句用�W�二条语句替换：
x > ANY (SELECT sal FROM emp WHERE job = 'ANALYST')
EXISTS (SELECT sal FROM emp WHERE job = 'ANALYST' AND x > sal)

~~ ALL操作�W�优�?
优化器将跟随值列表的ALL操作�W�用�{��h(hu��n)的�?”和“AND”组成的表达式替换。例如：
sal > ALL (:first_sal, :second_sal)表达式会被替换�ؓ�Q��?br />sal > :first_sal AND sal > :second_sal
对于跟随子查询的ALL表达式，优化器用ANY和另外一个合适的比较�W�组成的表达式替换。例如�?br />x > ALL (SELECT sal FROM emp WHERE deptno = 10) 替换为：
NOT (x <= ANY (SELECT sal FROM emp WHERE deptno = 10))
接下来优化器会把�W�二个表辑ּ�适用ANY表达式的转换规则转换��Z��面的表达式：
NOT EXISTS (SELECT sal FROM emp WHERE deptno = 10 AND x <= sal)

~~ BETWEEN 操作�W�优�?
优化器��L��用�?gt;=”和�?lt;=”比较符来等��L��代替BETWEEN操作�W�。�?br />例如�Q�优化器会把表达式sal BETWEEN 2000 AND 3000用sal >= 2000 AND sal <= 3000来代�ѝ��?br />
~~ NOT 操作�W�优�?
优化器��L��试图��化检索条件以消除“NOT”逻辑操作�W�的影响�Q�这��涉及到“NOT”操作符的消除以及代以相应的比较�q�算�W�。�?br />例如�Q�优化器��下面的�W�一条语句用�W�二条语句代替：
NOT deptno = (SELECT deptno FROM emp WHERE ename = 'TAYLOR')
deptno <> (SELECT deptno FROM emp WHERE ename = 'TAYLOR')
通常情况下一个含有NOT操作�W�的语句有很多不同的写法�Q�优化器的�{换原则是低쀜NOT”操作符后边的子句尽可能的简单，即��可能会�ɾl�果表达式包含了更多的“NOT”操作符。�?br />例如�Q�优化器��如下所�C�的�W�一条语句用�W�二条语句代替：
NOT (sal < 1000 OR comm IS NULL)
NOT sal < 1000 AND comm IS NOT NULL sal >= 1000 AND comm IS NOT NULL

如何�~�写高效的SQL:
当然要考虑sql帔R��的优化和操作�W�的优化啦，另外�Q�还需要：

1 合理的烦引设计：
例：表record�?20000行，试看在不同的索引下，下面几个SQL的运行情况：
语句A
SELECT count(*) FROM record
WHERE date >'19991201' and date < '19991214‘ and amount >2000

语句B
SELECT count(*) FROM record
WHERE date >'19990901' and place IN ('BJ','SH')

语句C
SELECT date,sum(amount) FROM record
group by date
1 在date上徏有一个非聚集索引
A�Q?25�U?
B�Q?27�U?
C�Q?55�U?
分析�Q��?br />date上有大量的重复��|��在非聚集索引下，数据在物理上随机存放在数据页上，在范围查找时�Q�必��L��行一�ơ表扫描才能扑ֈ��q�一范围内的全部行。�?br />2 在date上的一个聚集烦引�?br />A�Q�（14�U�）
B�Q�（14�U�）
C�Q�（28�U�）
分析�Q��?br />在聚集烦引下�Q�数据在物理上按��序在数据页上，重复��g��排列在一��P��因而在范围查找�Ӟ��可以先找到这个范围的��h��点，且只在这个范围内扫描数据��，避免了大范围扫描�Q�提高了查询速度。�?br />3 在place�Q�date�Q�amount上的�l�合索引
A�Q�（26�U�）
C�Q�（27�U�）
B�Q�（< 1�U�）
分析�Q��?br />�q�是一个不很合理的�l�合索引�Q�因为它的前导列是place�Q�第一和第二条SQL没有引用place�Q�因此也没有利用上烦引；�W�三个SQL使用了place�Q�且引用的所有列都包含在�l�合索引中，形成了烦引覆盖，所以它的速度是非常快的。�?br />4 在date�Q�place�Q�amount上的�l�合索引
A�Q��?< 1�U?
B�Q�（< 1�U�）
C�Q�（11�U�）
分析�Q��?br />�q�是一个合理的�l�合索引。它?y��u)��date作�ؓ前导列，使每个SQL都可以利用烦引，�q�且在第一和第三个SQL中�Ş成了索引覆盖�Q�因而性能辑ֈ�了最优。�?br />
�ȝ��1
�~�省情况下徏立的索引是非聚集索引�Q�但有时它�ƈ不是最佳的�Q�合理的索引设计要徏立在对各�U�查询的分析和预��上。一般来��_��
有大量重复倹{��且�l�常有范围查询（between, >,< �Q?gt;=,< =�Q�和order by、group by发生的列�Q�考虑建立聚集索引�Q��?br />�l� 常同时存取多列�Q�且每列都含有重复值可考虑建立�l�合索引�Q�在条�g表达式中�l�常用到的不同��D��多的列上建立��索，在不同值少的列上不要徏立烦引。比如在雇员表的“性别”列上只有“男”与“女”两个不同��|��因此��无必要建立索引。如果徏立烦引不但不会提高查询效率，反而会严重降低更新速度。�?br />�l�合索引要尽量��关键查询形成索引覆盖�Q�其前导列一定是使用最频繁的列。�?br />
2 避免使用不兼容的数据�c�d��Q��?br />例如float和INt、char和varchar、bINary和varbINary是不兼容的。数据类型的不兼容可能��优化器无法执行一些本来可以进行的优化操作。例�?
SELECT name FROM employee WHERE salary �Q��?0000
在这条语句中,如salary字段是money型的,则优化器很难对其�q�行优化,因�ؓ60000是个整型数。我们应当在�~�程时将整型转化成�ؓ钱币�?而不要等到运行时转化。�?br />
3 IS NULL 与IS NOT NULL�Q��?br />不能用null作烦引，��M��包含null值的列都��不会被包含在烦引中。即使烦引有多列�q�样的情况下�Q�只要这些列中有一列含有null�Q�该列就会从索引中排除。也��是说如果某列存在空��|��即��对该列徏索引也不会提高性能。�Q何在WHERE子句中��用is null或is not null的语句优化器是不允许使用索引的。�?br />
4 IN和EXISTS�Q��?br />EXISTS要远比IN的效率高。里面关�p�d��full table scan和range scan。几乎将所有的IN操作�W�子查询改写��Z��用EXISTS的子查询。�?br />例子�Q��?br />语句1
SELECT dname, deptno FROM dept
WHERE deptno NOT IN
(SELECT deptno FROM emp);
语句2
SELECT dname, deptno FROM dept
WHERE NOT EXISTS
(SELECT deptno FROM emp
WHERE dept.deptno = emp.deptno);
明显的，2要比1的执行性能好很多�?br />因�ؓ1中对emp�q�行了full table scan,�q�是很浪�Ҏ(gu��)��间的操作。而且1中没有用到emp的INdex�Q��?br />因�ؓ没有WHERE子句。�?中的语句对emp�q�行的是range scan。�?br />
5 IN、OR子句�怼�使用工作表，使烦引失效：
如果不��生大量重复��|��可以考虑把子句拆开。拆开的子句中应该包含索引。�?br />
6 避免或简化排序：
应当��化或避免对大型表�q�行重复的排序。当能够利用索引自动以适当的次序��生输出时�Q�优化器��避免了排序的步骤。以下是一些媄响因素：
索引中不包括一个或几个待排序的列；
group by或order by子句中列的次序与索引的次序不一��P��
排序的列来自不同的表。�?br />��Z��避免不必要的排序�Q�就要正��地增徏索引�Q�合理地合�ƈ数据库表�Q�尽��有时可能媄响表的规范化�Q�但相对于效率的提高是值得的）。如果排序不可避免，那么应当试图��化它�Q�如�~�小排序的列的范围等。�?br />
7 消除对大型表行数据的��序存取�Q��?br />在嵌套查询中�Q�对表的��序存取�Ҏ(gu��)��询效率可能��生致命的影响。比如采用顺序存取策略，一个嵌�?层的查询�Q�如果每层都查询1000行，那么�q�个查询��p��查询 10亿行数据。避免这�U�情�늚�主要�Ҏ(gu��)��是对连接的列进行烦引。例如，两个表：学生表（学号、姓名、年�??�Q�和选课表（学号、课�E�号、成�l�）。如果两个表要做�q�接�Q�就要在“学号”这个连接字�D�上建立索引。�?br />�q�可以��用�ƈ集来避免��序存取。尽��在所有的��查列上都有烦引，但某些�Ş式的WHERE子句��优化器��用顺序存取。下面的查询��强�q�对orders表执行顺序操作：
SELECT �Q� FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008
虽然在customer_num和order_num上徏有烦引，但是在上面的语句中优化器�q�是使用��序存取路径扫描整个表。因��个语句要��索的是分��ȝ��行的集合�Q�所以应该改为如下语句：
SELECT �Q� FROM orders WHERE customer_num=104 AND order_num>1001
UNION
SELECT �Q� FROM orders WHERE order_num=1008
�q�样��p��利用索引路径处理查询。�?br />
8 避免相关子查询：
一个列的标�{�֐�时在��L��询和WHERE子句中的查询中出玎ͼ�那么很可能当��L��询中的列值改变之后，子查询必��重新查询一�ơ。查询嵌套层�ơ越多，效率��低�Q�因此应当尽量避免子查询。如果子查询不可避免�Q�那么要在子查询中过滤掉��可能多的行。�?br />
9 避免困难的正规表辑ּ��Q��?br />MATCHES和LIKE关键字支持通配�W�匹配，技术上叫正规表辑ּ�。但�q�种匚w��特别耗费旉��。例如：SELECT �Q� FROM customer WHERE zipcode LIKE �?8_ _ _”�?br />即��在zipcode字段上徏立了索引�Q�在�q�种情况下也�q�是采用��序扫描的方式。如果把语句改�ؓSELECT �Q� FROM customer WHERE zipcode >�?8000”，在执行查询时��׃��利用索引来查询，昄��会大大提高速度。�?br />另外�Q�还要避免非开始的子串。例如语句：SELECT �Q� FROM customer WHERE zipcode[2�Q?] >�?0”，在WHERE子句中采用了非开始子�Ԍ��因而这个语句也不会使用索引。�?br />
10 不充份的�q�接条�g�Q��?br />例：表card�?896行，在card_no上有一个非聚集索引�Q�表account�?91122行，在account_no上有一个非聚集索引�Q�试看在不同的表�q�接条�g下，两个SQL的执行情况：
SELECT sum(a.amount) FROM account a,card b WHERE a.card_no = b.card_no
�Q?0�U�）
��SQL改�ؓ�Q��?br />SELECT sum(a.amount) FROM account a,card b WHERE a.card_no = b.card_no and a.account_no=b.account_no
�Q?lt; 1�U�）
分析�Q��?br />在第一个连接条件下�Q�最��x��询方案是��account作外层表�Q�card作内层表�Q�利用card上的索引�Q�其I/O�ơ数可由以下公式估算为：
外层表account上的22541��?�Q�外层表account�?91122�?内层表card上对应外层表�W�一行所要查扄��3��）=595907�ơI/O
在第二个�q�接条�g下，最��x��询方案是��card作外层表�Q�account作内层表�Q�利用account上的索引�Q�其I/O�ơ数可由以下公式估算为：
外层表card上的1944��?�Q�外层表card�?896�?内层表account上对应外层表每一行所要查扄��4��）= 33528�ơI/O
可见�Q�只有充份的�q�接条�g�Q�真正的最��x��案才会被执行。�?br />多表操作在被实际执行前，查询优化器会�Ҏ(gu��)��q�接条�g�Q�列出几�l�可能的�q�接�Ҏ(gu��)��q�从中找出系�l�开销最��的最��x��案。连接条件要充䆾考虑带有索引的表、行数多的表�Q�内外表的选择可由公式�Q�外层表中的匚w��行数*内层表中每一�ơ查扄��ơ数��定�Q�乘�U�最��ؓ最��x��案。�?br />不可优化的WHERE子句
�?
下列SQL条�g语句中的列都建有恰当的烦引，但执行速度却非常慢�Q��?br />SELECT * FROM record WHERE substrINg(card_no,1,4)='5378'
(13�U?
SELECT * FROM record WHERE amount/30< 1000
�Q?1�U�）
SELECT * FROM record WHERE convert(char(10),date,112)='19991201'
�Q?0�U�）
分析�Q��?br />WHERE子句中对列的��M��操作�l�果都是在SQL�q�行旉��列计算得到的，因此它不得不�q�行表搜索，而没有��用该列上面的索引�Q�如果这些结果在查询�~�译时就能得刎ͼ�那么��可以被SQL优化器优化，使用索引�Q�避免表搜烦�Q�因此将SQL重写成下面这��P��
SELECT * FROM record WHERE card_no like '5378%'
�Q?lt; 1�U�）
SELECT * FROM record WHERE amount< 1000*30
�Q?lt; 1�U�）
SELECT * FROM record WHERE date= '1999/12/01'
�Q?lt; 1�U�）

11 存储�q�程中，采用临时表优化查询：
例�?br />1�Q�从parven表中按vendor_num的次序读数据�Q��?br />SELECT part_num�Q�vendor_num�Q�price FROM parven ORDER BY vendor_num
INTO temp pv_by_vn
�q�个语句��序读parven�Q?0��）�Q�写一个��时表�Q?0��）�Q��ƈ排序。假定排序的开销�?00��，��d��?00��c��?br />2�Q�把临时表和vendor表连接，把结果输出到一个��时表�Q��ƈ按part_num排序�Q��?br />SELECT pv_by_vn�Q�＊ vendor.vendor_num FROM pv_by_vn�Q�vendor
WHERE pv_by_vn.vendor_num=vendor.vendor_num
ORDER BY pv_by_vn.part_num
INTO TMP pvvn_by_pn
DROP TABLE pv_by_vn
�q� 个查询��d��pv_by_vn(50��?�Q�它通过索引存取vendor�?.5万次�Q�但�׃��按vendor_num�ơ序排列�Q�实际上只是通过索引��序地读 vendor表（40�Q?=42��）�Q�输出的表每��늺�95行，�?60��c��写�q�存取这些页引发5�Q?60=800�ơ的��d��Q�烦引共��d��892��c��?br />3�Q�把输出和part�q�接得到最后的�l�果�Q��?br />SELECT pvvn_by_pn.�Q�，part.part_desc FROM pvvn_by_pn�Q�part
WHERE pvvn_by_pn.part_num=part.part_num
DROP TABLE pvvn_by_pn
�q�样�Q�查询顺序地读pvvn_by_pn(160��?�Q�通过索引读part�?.5万次�Q�由于徏有烦引，所以实际上�q�行1772�ơ磁盘读写，优化比例�?0�?。�?br />
好了�Q�搞定。�?br />其实sql的优化，各种数据库之间都是互通的�?br />
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=629369

風向逆轉 - ��p��爪哇 2006-03-20 23:03 发表评论

[收藏]Transact SQL 常用语句以及函数

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 14:53:00 GMT
     摘要: Transact SQL   语句功能 ======================================================================== 　　 -- 数据操作 ...  阅读全文

風向逆轉 - ��p��爪哇 2006-03-20 22:53 发表评论

[收藏]SQL优化

風向逆轉 - ��p��爪哇 — Mon, 20 Mar 2006 12:53:00 GMT
最�q�做��目发现很多SQL没有优化: 现在�ȝ��几种优化方式.
首先先了解一个SQL语句的执行过�E�分3�? 语法分析(parase)与编�?执行,取数�?
1�Q?在语法分析与�~�译�?oracle 使用哈希函数为SQL语句在库�~�存中分配一个SQL�?
首先��查语句是否存�?若在,则查询数据库字典、检查必��ȝ��权限�?br />若无�Q�需要语法分析与�~�译。所以SQL语句存在与内存中�Q�将减少分析�Q�编译时间�?br />SQL语句的分析与�~�译占整个语句运行过�E�的60%的时��_��SQL优化的目标就是减��分析与�~�译的时��_��׃�n代码�?
查询SQL语句分析与编译的旉��Q?br />select * from v$sysstat
where name in ('parse time cpu','parse time elapsed','parse count (hard)')
一个SQL语句的响应时�?elapsed time )应该是服务时�?�{�待旉��.
服务旉��= CPU执行旉��.
�{�待旉�� 可以从v$system_event
select total_waits, total_timeouts, time_waited, average_wait ,event
from v$system_event
where event='latch free'
所以解析一个SQL语句的��^均等待时间是"�{�待旉��/parse count" �q�个值接�q?
通过数据字典v$sqlare,可以查询到频�J�被分析与编译的SQL语句.应该减少SQL语句的分析与�~�译的次�?
2: ��常用的实体�ȝ��内存.
��Z��减少分析与编译时�?可以��常用的的实体如: 存储�q�程,包等,��可能驻留在内存区域.
1)预留内存�I�间. sql> show parameter shared_pool_reserved_size
       2)��频�J��用的实体�ȝ��在内存中. 在��用DBMS_SHARED_POOL�E�序包前,必须首先�q�行�pȝ��提供的程序包: dbmspool.sql 和prvtpool.plb
在加载这两个�E�序包后,自动生成所需的包.
      加蝲: sql> @/u01/app/oracle/product/8.17/rdbms/admin/dbmspool.sql
           sql> @/u01/app/oracle/product/8.17/rdbms/admin/prvtpool.sql
      包DBMS_SHARED_POOL包含以下存储�q�程.
      dbms_shared_pool.keep 用于��实体保存内�? dbms_shared_pool.keep(object in varchar2,[type in char default p]);
                             object 表示参数�? type 表示被驻留内存的实体�c�d��;P 表示存储�q�程,C表示光标,R表示触发�?默认P

      dbms_shared_pool.unkeep 用于取消被设�|�进入内存的实体. dbms_shared_pool.unkeep(object in varchar2,[type in char default p]);
                             object 表示参数�? type 表示被驻留内存的实体�c�d��;P 表示存储�q�程,C表示光标,R表示触发�?默认P

      dbms_shared_pool.size(minsize in number)
      select name ,type ,source_size+code_size+parsed_size+error_size "total bytes"
      from dba_object_size
      where owner='SCOTT'
3: 创徏索引.
   select index_name,table_owner, table_name, tablespace_name from all_indexes

   select user_indexes.TABLE_NAME, user_indexes.INDEX_NAME,uniqueness, column_name
   from user_ind_columns ,user_indexes
   where user_ind_columns.INDEX_NAME=user_indexes.INDEX_NAME
   and user_ind_columns.TABLE_NAME=user_indexes.TABLE_NAME
   order by user_indexes.TABLE_TYPE,user_indexes.TABLE_NAME,user_indexes.INDEX_NAME,user_ind_columns.COLUMN_POSITION
4: 创徏聚簇(cluster): 是一�l�存储在一��L��有共同列或经�怸�起��用的�?被聚��的两个表只有一个数据段.聚簇表在存储�?在物理层��子表合�q�到父表�?�q�样��少了表的连接时�?
5: 创徏哈希索引.

6: SQL优化�? ��Z��成本的优化器CBO(cose_based)和基于规则RBO(rule_based)
   sql> show parameter OPTIMIZER_MODE
   可以修改参数文�g: initSID.ora,增加: optimizer_Mode={CHOOSE| RULE| FIRST_ROWS|ALL_ROWS}
all_rows , first_rows(n)��Z��成本; rule ��Z��规则,choose��Z��规则、成本�?br /> /*+ ordered*/
/*+ rule */
/*+ first_rows(50) */
/*+ordered star*/
写发�Q��?
alter system flush shared_pool;
select /*+ rule */ aa from visit

原文链接:http://www.tkk7.com/yanmin/archive/2006/03/20/36332.html

風向逆轉 - ��p��爪哇 2006-03-20 20:53 发表评论

[收藏]Tomcat5配置Mysql/Oracle JDBC数据库连接池

風向逆轉 - ��p��爪哇 — Tue, 14 Mar 2006 18:32:00 GMT
     摘要: Tomcat5配置Mysql/Oracle JDBC数据库连接池 1�?nbsp; 安装Tomcat 在安装了jdk后，参考Tomcat for window 的安装向��|��基本直接安装卛_��Q�注意：安装时会提示输入��理用户名和密码�Q�这是以后会用到的用户名和密码，切记�? 2�?nbsp; 安装MySql/Oracl...  阅读全文

風向逆轉 - ��p��爪哇 2006-03-15 02:32 发表评论

[收藏]HSQLDB介绍

風向逆轉 - ��p��爪哇 — Mon, 13 Mar 2006 18:51:00 GMT
by jini

目前�E�_��版本 1.7.1
下蝲�?http://hsqldb.sourceforge.net/

(1)��?
hsqldb 是由 Tomas Muller �?Hypersonic SQL 後箋开发出来的专案, hsql 已经停止研发�? hypersonic db 是纯 java 所开发的资料�? 可以透过 jdbc driver 来存�? 支援 ANSI-92 标准�?SQL 语法, 而且他占的空间很��? 大约只有 160K, 拥有快速的资料库引�? 也提供了一些工�? 例如 web-server, 记忆体查�? 及一些管理工�?
他是属於 BSD �?license, 可以自由下蝲, �q�且可以安装使用在商业��品之�?

(2)安装
当你下蝲了hsqldb_1_7_1.zip, ��他解压�~�到一个目�? 我将�U�C��?%HSQLDB_HOME% , 你可以看�?hsqldb 下面有这些目�?
- bin
- build
- data
- demo
- doc
- lib　　- hsqldb.jar
　　　　 - servlet.jar
- src

最重要的就�?hsqldb.jar, ��他攑ֈ�工作目录下的 lib �?

(3)使用
在命令列模式到工作目�?
cmd>java -cp lib/hsqldb.jar org.hsqldb.util.DatabaseManager
选择 HSQL Database Engine Standalone ( 档案型资料库 )
Driver : org.hsqldb.jdbcDriver
URL : jdbc:hsqldb:test
sa ��d��, 如果该资料库 ( test ) 不存�? 他就会徏�?
test.properties �?test.script

可以直接�?fundad.script 加入 SQL 标准语法,
当程式�v来的时�? hsqldb 会自动汇�?script 中的资料到记忆体之中
语法�?T-SQL 相当, 可参�?http://hsqldb.sourceforge.net/doc/hsqlSyntax.html

(4)�l�论
如果你是��型��单的资料库运�? 可以采用�q�个 opensource
��其�?embedded application 的应�?
但是大型资料例如上百万笔, 除非你的 RAM 很大很大,
否则会导致速度�q�慢,
我尝试在我的�?sh��)�?P4-1.8G 512MB 安装 1百万�W�资�?( 每笔 4 栏位 )
��׃�� out of memory
如果强制 java -mx1024m -ms1024m 也要�׃��过一��时.... @@"
不过, 他有个很好用的地�? ��是 bundle �?Applet 之中
有兴��的人可以参考他的范�?

附带一�?

hibernate 中可以采�?HSQLDialect 去连�l�，HSQLDB�q�有支持分页的sql语句

PS: 1�?nbsp;在hibernate中，使用hsql中，如果讄��主键�c�d��用Idenetity�Q�那么java的field用Integer�c�d��Q�不能用Long�?BR>      2、目前HSQLDB版本已经升��?.8.0.2

風向逆轉 - ��p��爪哇 2006-03-14 02:51 发表评论

[收藏]Oracle性能调优原则

風向逆轉 - ��p��爪哇 — Sun, 05 Mar 2006 11:23:00 GMT

Oracle性能调优原则　

��M��事情都有它的源头�Q�要解决问题�Q�也得从源头开始，影响ORACLE性能的源头非常多�Q�主要包括如下方�?
　　数据库的��g配置:CPU、内存、网�l�条�?/P>
　　1. CPU:在�Q何机器中CPU的数据处理能力往往是衡量计��机性能的一个标志，�q�且ORACLE是一个提供�ƈ行能力的数据库系�l�，在CPU斚w��的要求就更高了，如果�q�行队列数目��过了CPU处理的数目，性能��׃��下降�Q�我们要解决的问题就是要适当增加CPU的数量了�Q�当然我们还可以��需要许多资源的�q�程KILL�?

　　2. 内存:衡量机器性能的另外一个指标就是内存的多少了，在ORACLE中内存和我们在徏数据库中的交换区�q�行数据的交换，��L��据时�Q�磁盘I(y��)/O必须�{�待物理I/O操作完成�Q�在出现ORACLE的内存瓶颈时�Q�我们第一个要考虑的是增加内存�Q�由于I/O的响应时间是影响ORACLE性能的主要参敎ͼ�我将在这斚w��q�行详细的讲�?/P>
　　3. �|�络条�g:NET*SQL负责数据在网�l�上的来往�Q�大量的SQL会��o�|�络速度变慢。比�?0M的网卡和100的网卡就对NET*SQL有非常明昄��影响�Q�还有交换机、集�U�器�{�等�|�络讑֤�的性能对网�l�的影响很明显，��在�Q何网�l�中不要试图�?个集�U�器来将�|�段互联�?/P>
　　OS参数的设�|?/P>
　　下表�l�出了OS的参数设�|�及说明�Q�DBA可以�Ҏ(gu��)��实际需要对�q�些参数�q�行讄��

　　内核参数�?/P>
　　说明

　　bufpages

　　对buffer�I�间不按静态分配，采用动态分配，使bufpages值随nbuf一起对buffer�I�间�q�行动态分配�?/P>
　　create_fastlinks

　　对HFS文�g�pȝ��允许快速符号链�?/P>
　　dbc_max_pct

　　加大最大动态buffer�I�间所占物理内存的癑ֈ�比，以满��_��用系�l�的��d��命中率的需要�?/P>
　　dbc_min_pct

　　讄��最��动态buffer�I�间所占物理内存的癑ֈ��?/P>
　　desfree

　　提高开始交换操作的最低空闲内存下限，保障�pȝ��的稳定性，防止出现不可预见的系�l�崩�?Crash)�?/P>
　　fs_async

　　允许�q�行��盘异步操作�Q�提高CPU和磁盘的利用�?/P>
　　lotsfree

　　提高�pȝ��解除换页操作的空闲内存的上限��|��保证应用�E�序有��够的可用内存�I�间�?/P>
　　maxdsiz

　　针对�pȝ��数据量大的特点，加大最大数据段的大��，保证应用的需要�?32�?

　　maxdsiz_64bit

　　maximum process data segment size for 64_bit

　　Maxssiz

　　加大最大堆栈段的大��?32_bit)

　　maxssiz_64bit

　　加大最大堆栈段的大��?64_bit)

　　Maxtsiz

　　提高最大代码段大小�Q�满��_��用要�?/P>
　　maxtsiz_64bit

　　原��D��大，应调?y��u)?/P>
　　Minfree

　　提高停止交换操作的自由内存的上限

　　Shmem

　　允许�q�行内存�׃�n�Q�以提高内存的利用率

　　Shmmax

　　讄��最大共享内存段的大��，完全满��目前的需�?/P>
　　Timeslice

　　�׃��pȝ��的瓶颈主要反映在��盘I(y��)/O上，因此　降低旉��片的大小�Q�一斚w��可避免因��盘I(y��)/O不畅造成CPU的等待，从而提高了CPU的综合利用率。另一斚w��减少了进�E�的��d��量�?/P>
　　unlockable_mem

　　提高了不可锁内存的大��，使可用于换页和交换的内存�I�间扩大,用以满��pȝ��对内存管理的要求�?/P>
　　用户SQL质量

　　以上讲的都是��g斚w��的东西，在条件有限的条�g下，我们可以调整应用�E�序的SQL质量:

　　1. 不要�q�行全表扫描(Full Table Scan):全表扫描��D��大量的I/O

　　2. ��量建好和��用好索引:建烦引也是有讲究的，在徏索引�Ӟ��也不是烦引越多越好，当一个表的烦引达�?个以上时�Q�ORACLE的性能可能�q�是改善不了�Q�因为OLTP�pȝ��每表��过5个烦引即会降低性能�Q�而且在一个sql 中， Oracle 从不能��用超�q?5个烦�?当我们用到GROUP BY和ORDER BY�?ORACLE��׃��自动�Ҏ(gu��)��据进行排�?而ORACLE在INIT.ORA中决定了sort_area_size区的大小,当排序不能在我们�l�定的排序区完成�?ORACLE��׃��在磁盘中�q�行排序,也就是我们讲的��时表�I�间中排�? �q�多的磁盘排序将会��o free buffer waits 的值变�?而这个区间�ƈ不只是用于排序的,对于开发�h员我提出如下忠告:

　　1)、select,update,delete 语句中的子查询应当有规律地查扑ְ��?0%的表�?如果一个语句查扄��行数��过总行数的20%,它将不能通过使用索引获得性能上的提高.

　　2)、烦引可能��生碎�?因�ؓ记录从表中删除时,相应也从表的索引中删�?表释攄��I�间可以再用,而烦引释攄��I�间却不能再�?频繁�q�行删除操作的被索引的表,应当阶段性地重徏索引,以避免在索引中造成�I�间��片,影响性能.在许可的条�g�?也可以阶�D�|��地truncate�?truncate命��o删除表中所有记�?也删除烦引碎�?

　　3)、在使用索引时一定要按烦引对应字�D늚��序�q�行引用�?/P>
　　4)、用(+)比用NOT IN更有效率�?/P>
　　降低ORACLE的竞�?

　　先讲几个ORACLE的几个参敎ͼ��q�几个参数关�p�d��ORACLE的竞�?

　　1)、freelists �?freelist �l?他们负责ORACLE的处理表和烦引的�I�间��理;

　　2)、pctfree �?pctused:该参数决定了freelists �?freelist �l�的行�ؓ�Q�pctfree 和pctused 参数的唯一目的��是��Z��控制块如何在 freelists 中进�?/P>
　　讄��好pctfree �?pctused对块在freelists的移走和��d��很重要�?/P>
　　其他参数的设�|?/P>
　　1)、包括SGA�?�pȝ��全局�?:�pȝ��全局�?SGA)是一个分配给Oracle 的包含一�?Oracle 实例的数据库的控制信息内存段�?/P>
　　主要包括数据库高速缓�?the database buffer cache)�Q?/P>
　　重演日志�~�存(the redo log buffer)�Q?/P>
　　�׃�n�?the shared pool)�Q?/P>
　　数据字典�~�存(the data dictionary cache)以及其它各方面的信息

　　2)、db_block_buffers(数据高速缓冲区)讉K��q�的数据都放在这一片内存区域，该参数越大，Oracle在内存中扑ֈ�相同数据的可能性就��大�Q�也卛_��快了查询速度�?/P>
　　3)、share_pool_size (SQL�׃�n�~�冲�?:该参数是库高速缓存和数据字典的高速缓存�?/P>
　　4)、Log_buffer (重演日志�~�冲�?

　　5)、sort_area_size(排序�?

　　6)、processes (同时�q�接的进�E�数)

　　7)、db_block_size (数据库块大小):Oracle默认块�ؓ2KB�Q�太��了�Q�因为如果我们有一�?KB的数据，�?KB块的数据库要�?�ơ盘�Q�才能读完，�?KB块的数据库只�?�ơ就��d��了，大大减少了I/O操作。数据库安装完成后，��׃��能再改变db_block_size的��g��Q�只能重新徏立数据库�q�且建库�Ӟ��要选择手工安装数据库�?/P>
　　8)、open_links (同时打开的链接数)

　　9)、dml_locks

　　10)、open_cursors (打开光标�?

　　11)、dbwr_io_slaves (后台写进�E�数)

風向逆轉 - ��p��爪哇 2006-03-05 19:23 发表评论

[收藏]JDBC入门�p�d��专题讲��

風向逆轉 - ��p��爪哇 — Sun, 05 Mar 2006 07:52:00 GMT
     摘要: 1. 介绍　　许多开发者和用户都在��L�� Java �E�序中访问数据库的便��h��法。由�? Java 是一个健壮，安全�Q�易于��用的�Q�易于理解且可以从网�l�中自动 download �Q�所以它成�ؓ开发数据库应用的一�U�良好的语言基础�? ...  阅读全文

風向逆轉 - ��p��爪哇 2006-03-05 15:52 发表评论

風向逆轉 - ��p��爪哇 — Sun, 05 Mar 2006 07:14:00 GMT
     摘要: JDBC �q�接各种数据库经验技巧集�? Java 数据库连接（ JDBC �Q�由一�l�用 Java �~�程语言�~�写的类和接口组成�? JDBC 为工�? / ...  阅读全文

風向逆轉 - ��p��爪哇 2006-03-05 15:14 发表评论

亚洲一区二区三区高清不卡,亚洲线精品一区二区三区,亚洲欧洲日产国码无码久久99

[收藏]JDBC�p�d��教程�Q�五�Q?--准备语句

[收藏]JDBC�p�d��教程�Q�四�Q?--�l�果讄���

[收藏]JDBC�p�d��教程�Q�三�Q?--语句

[收藏]JDBC�p�d��教程�Q�二�Q?--驱动讄���

[收藏]JDBC�p�d��教程�Q�一�Q?--�q�接

[收藏]Java�E�序员的存储�q�程

[收藏]JDBC�q�接Oracle数据库常见问题及解决�Ҏ(gu��)��

[收藏]JDBC数据库驱动下载网址大全 (好东西�{来分�?

[收藏]Oracle内存分配与调�?

[收藏]Oracle基本数据�c�d��存储格式���析�Q�一�Q�—（五）

[收藏]Windows环境下的Oracle服务

[收藏]数据库连接池Java实现���结

目的�Q?/h3>消除数据库频�J�连接带来的开销和瓶颈�?/li>

[收藏]Tomcat5配置Mysql JDBC数据库连接池

[收藏]Transact SQL 常用语句以及函数

[收藏]SQL优化

[收藏]Tomcat5配置Mysql/Oracle JDBC数据库连接池

[收藏]HSQLDB介绍

[收藏]Oracle性能调优原则

[收藏]JDBC入门�p�d��专题讲��

[收藏]JDBC�p�d��教程�Q�四�Q?--�l�果讄��

[收藏]JDBC�p�d��教程�Q�二�Q?--驱动讄��

[收藏]Oracle基本数据�c�d��存储格式��析�Q�一�Q�—（五）

[收藏]数据库连接池Java实现��结

目的�Q?/h3>
消除数据库频�J�连接带来的开销和瓶颈�?/li>