ORACLE EXECUTE IMMEDIATE
2014-11-04 18:54
323 查看
ORACLE EXECUTE IMMEDIATE 用法
EXECUTE IMMEDIATE 代替了以前Oracle8i中DBMS_SQL package包.
它解析并马上执行动态的SQL语句或非运行时创建的PL/SQL块.动态创建和执行SQL语句性能超前，EXECUTE IMMEDIATE的目标在于减小企业费用并获得较高的性能，较之以前它相当容易编码.尽管DBMS_SQL仍然可用，但是推荐使用EXECUTE IMMEDIATE,因为它获的收益在包之上。
-- 使用技巧
1. EXECUTE IMMEDIATE将不会提交一个DML事务执行，应该显式提交
如果通过EXECUTE IMMEDIATE处理DML命令，
那么在完成以前需要显式提交或者作为EXECUTE IMMEDIATE自己的一部分.
如果通过EXECUTE IMMEDIATE处理DDL命令,它提交所有以前改变的数据
2. 不支持返回多行的查询,这种交互将用临时表来存储记录(参照例子如下)或者用REF cursors.
3. 当执行SQL语句时，不要用分号，当执行PL/SQL块时，在其尾部用分号.
4. 在Oracle手册中，未详细覆盖这些功能。
下面的例子展示了所有用到Execute immediate的可能方面.希望能给你带来方便.
5. 对于Forms开发者,当在PL/SQL 8.0.6.3.版本中，Forms 6i不能使用此功能.
EXECUTE IMMEDIATE -- 用法例子
1. 在PL/SQL运行DDL语句
Sql代码
begin
execute immediate 'set role all';
end;
2. 给动态语句传值(USING 子句)
Sql代码
declare
l_depnam varchar2(20) := 'testing';
l_loc varchar2(10) := 'D?i';
begin
execute immediate 'insert into dept vals (:1, :2, :3)'
using 50, l_depnam, l_loc;
commit;
end;
3. 从动态语句检索值(INTO子句)
Sql代码
declare
l_cnt varchar2(20);
begin
execute immediate 'select count(1) from emp'
into l_cnt;
dbms_output.put_line(l_cnt);
end;
4. 动态调用例程.例程中用到的绑定变量参数必须指定参数类型.
黓认为IN类型,其它类型必须显式指定
Sql代码
declare
l_routin varchar2(100) := 'gen2161.get_rowcnt';
l_tblnam varchar2(20) := 'emp';
l_cnt number;
l_status varchar2(200);
begin
execute immediate 'begin ' || l_routin || '(:2, :3, :4); end;'
using in l_tblnam, out l_cnt, in out l_status;
if l_status != 'OK' then
dbms_output.put_line('error');
end if;
end;
5. 将返回值传递到PL/SQL记录类型;同样也可用%rowtype变量
Sql代码
declare
type empdtlrec is record (empno number(4),
ename varchar2(20),
deptno number(2));
empdtl empdtlrec;
begin
execute immediate 'select empno, ename, deptno ' ||
'from emp where empno = 7934'
into empdtl;
end;
6. 传递并检索值.INTO子句用在USING子句前
Sql代码
declare
l_dept pls_integer := 20;
l_nam varchar2(20);
l_loc varchar2(20);
begin
execute immediate 'select dname, loc from dept where deptno = :1'
into l_nam, l_loc
using l_dept ;
end;
7. 多行查询选项.对此选项用insert语句填充临时表，
用临时表进行进一步的处理,也可以用REF cursors纠正此缺憾.
Sql代码
declare
l_sal pls_integer := 2000;
begin
execute immediate 'insert into temp(empno, ename) '||'select empno, ename from emp '||'where sal > :1'
using l_sal;
commit;
end;
对于处理动态语句,EXECUTE IMMEDIATE 比以前可能用到的更容易并且更高效.
当意图执行动态语句时，适当地处理异常更加重要.应该关注于捕获所有可能的异常.15:40 | 添加评论 | 固定链接 | 写入日志 | SQLoracle中insert into select的用法
/* Formatted on 2008/06/02 15:37 (Formatter Plus v4.8.7) */
INSERT INTO t_work
(f_recid, f_jobid, f_ruleid, f_jobtype, f_operid, f_opername,
f_btime, f_assigntime, f_downtime, f_worktimes, f_finishtime)
SELECT SYS_GUID () AS f_recid, f_jobid, f_ruleid, f_jobtype, f_operid,
f_opername, f_btime, f_assigntime,f_downtime,
DECODE (f_downtime, null,1, f_downtime + 1) as f_worktimes,
TO_CHAR (SYSDATE, 'yyyy-MM-dd hh:mm:ss') AS finishtime
FROM t_bfer
WHERE f_jobid = '21'
说明将t_bfer中的一条记录添加到t_work表中。
其中b_bfer中没有的列有f_recid和t_finishtime;
f_worktimes需要加1。
SYS_GUID()的意思是生成一个32位的永不重复的字符串。
DECODE(f_downtime, null,1, f_downtime + 1)的意思是如果f_downtime为空（null）得到的值为1,否则为f_downtime+1。
TO_CHAR(SYSDATE, 'yyyy-MM-dd hh:mm:ss')为格式化时间格式;在表t_work中f_finishtime的数据类型为varchar2.
15:22 | 添加评论 | 固定链接 | 写入日志 | SQLPL/SQL开发中动态SQL的使用方法
原文来自：http://blog.chinaunix.net/u/19673/showart_272022.html
一般的PL/SQL程序设计中，在DML和事务控制的语句中可以直接使用SQL，但是DDL语句及系统控制语句却不能在PL/SQL中直接使用，要想实现在PL/SQL中使用DDL语句及系统控制语句，可以通过使用动态SQL来实现。
首先我们应该了解什么是动态SQL，在Oracle数据库开发PL/SQL块中我们使用的SQL分为：静态SQL语句和动态SQL语句。所谓静态SQL 指在PL/SQL块中使用的SQL语句在编译时是明确的，执行的是确定对象。而动态SQL是指在PL/SQL块编译时SQL语句是不确定的，如根据用户输入的参数的不同而执行不同的操作。编译程序对动态语句部分不进行处理，只是在程序运行时动态地创建语句、对语句进行语法分析并执行该语句。
Oracle中动态SQL可以通过本地动态SQL来执行，也可以通过DBMS_SQL包来执行。下面就这两种情况分别进行说明：
一、本地动态SQL
本地动态SQL是使用EXECUTE IMMEDIATE语句来实现的。
1、本地动态SQL执行DDL语句：
需求：根据用户输入的表名及字段名等参数动态建表。
create or replace procedure proc_test
(
table_name in varchar2, --表名
field1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
) as
str_sql varchar2(500);
begin
str_sql:=’create table ’||table_name||’(’||field1||’ ’||datatype1||’,’||field2||’ ’||datatype2||’)’;
execute immediate str_sql; --动态执行DDL语句
exception
when others then
null;
end ;
以上是编译通过的存储过程代码。下面执行存储过程动态建表。
SQL> execute proc_test(’dinya_test’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure s?ssfully completed
SQL> desc dinya_test;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
到这里，就实现了我们的需求，使用本地动态SQL根据用户输入的表名及字段名、字段类型等参数来实现动态执行DDL语句。
2、本地动态SQL执行DML语句。
需求：将用户输入的值插入到上例中建好的dinya_test表中。
create or replace procedure proc_insert
(
id in number, --输入序号
name in varchar2 --输入姓名
) as
str_sql varchar2(500);
begin
str_sql:=’insert into dinya_test vals(:1,:2)’;
execute immediate str_sql using id,name; --动态执行插入操作
exception
when others then
null;
end ;
执行存储过程，插入数据到测试表中。
SQL> execute proc_insert(1,’dinya’);
PL/SQL procedure s?ssfully completed
SQL> select * from dinya_test;
ID NAME
1 dinya
在上例中，本地动态SQL执行DML语句时使用了using子句，按顺序将输入的值绑定到变量，如果需要输出参数，可以在执行动态SQL的时候，使用RETURNING INTO 子句，如：
declare
p_id number:=1;
v_count number;
begin
v_string:=’select count(*) from table_name a where a.id=:id’;
execute immediate v_string into v_count using p_id;
end ;
更多的关于动态SQL中关于返回值及为输出输入绑定变量执行参数模式的问题，请读者自行做测试。
二、使用DBMS_SQL包
使用DBMS_SQL包实现动态SQL的步骤如下：A、先将要执行的SQL语句或一个语句块放到一个字符串变量中。B、使用DBMS_SQL包的 parse过程来分析该字符串。C、使用DBMS_SQL包的bind_variable过程来绑定变量。D、使用DBMS_SQL包的execute函数来执行语句。
1、使用DBMS_SQL包执行DDL语句
需求：使用DBMS_SQL包根据用户输入的表名、字段名及字段类型建表。
create or replace procedure proc_dbms_sql
(
table_name in varchar2, --表名
field_name1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field_name2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
)as
v_cursor number; --定义光标
v_string varchar2(200); --定义字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’create table ’||table_name||’(’||field_name1||’ ’||datatype1||’,’||field_name2||’ ’||datatype2||’)’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
v_row:=dbms_sql.execute(v_cursor); --执行语句
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
以上过程编译通过后，执行过程创建表结构：
SQL> execute proc_dbms_sql(’dinya_test2’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure s?ssfully completed
SQL> desc dinya_test2;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
2、使用DBMS_SQL包执行DML语句
需求：使用DBMS_SQL包根据用户输入的值更新表中相对应的记录。
查看表中已有记录：
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 CSDN
3 ERP
SQL>
建存储过程，并编译通过：
create or replace procedure proc_dbms_sql_update
(
id number,
name varchar2
)as
v_cursor number; --定义光标
v_string varchar2(200); --字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’update dinya_test2 a set a.name=:p_name where a.id=:p_id’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
dbms_sql.bind_variable(v_cursor,’:p_name’,name); --绑定变量
dbms_sql.bind_variable(v_cursor,’:p_id’,id); --绑定变量
v_row:=dbms_sql.execute(v_cursor); --执行动态ＳＱＬ
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
执行过程，根据用户输入的参数更新表中的数据：
SQL> execute proc_dbms_sql_update(2,’csdn_dinya’);
PL/SQL procedure s?ssfully completed
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 csdn_dinya
3 ERP
SQL>
执行过程后将第二条的name字段的数据更新为新值csdn_dinya。这样就完成了使用dbms_sql包来执行DML语句的功能。
使用DBMS_SQL中，如果要执行的动态语句不是查询语句，使用DBMS_SQL.Execute或 DBMS_SQL.Variable_Val来执行，如果要执行动态语句是查询语句，则要使用DBMS_SQL.define_column定义输出变量，然后使用DBMS_SQL.Execute, DBMS_SQL.Fetch_Rows, DBMS_SQL.Column_Val及DBMS_SQL.Variable_Val来执行查询并得到结果。
总结说明：
在Oracle开发过程中，我们可以使用动态SQL来执行DDL语句、DML语句、事务控制语句及系统控制语句。但是需要注意的是，PL/SQL块中使用动态SQL执行DDL语句的时候与别的不同，在DDL中使用绑定变量是非法的（bind_variable(v_cursor,’:p_name’, name)），分析后不需要执行DBMS_SQL.Bind_Variable，直接将输入的变量加到字符串中即可。另外，DDL是在调用 DBMS_SQL.PARSE时执行的，所以DBMS_SQL.EXECUTE也可以不用，即在上例中的v_row:=dbms_sql.execute
(v_cursor)部分可以不要。
15:14 | 添加评论 | 固定链接 | 写入日志 | SQL11月17日
ResultSet大全
开发的朋友，在操作数据库的时候，相信绝大部分人都用过它。但它不仅仅就是一个结果集的纯载体，仅仅只有存储的功能。下面就简略说一下它的功能。
结果集大体上可以分为四类，它们各有特点，基本上都和Statement语句的创建方式有关。
1、基本型（最基本，用得最广泛）
创建方式：无参数创建型
Statement st = conn.CreateStatement
ResultSet rs = Statement.excuteQry(sqlStr);
特点：这种最简单，没有特别的功能（不支持滚动、更新等等），只能用next()逐个单方向去读取数据。
2、滚动型
创建方式：参数创建型
Statement st = conn.createStatement(int resultSetType, int resultSetConcurrency)
ResultSet rs = st.executeQry(sqlStr)
参数：
resultSetType是设置ResultSet对象的类型可滚动
resultSetConcurency是设置ResultSet对象能够修改的
具体的参数值见ResultSet.
特点：（和具体参数的设置有关。）这种类型支持滚动获取记录，可以向前向后操作，类似于分页功能的操作方式。如支持：next()、previous()、first()、absolute(int n)等等。
3、更新型
创建方式：（和2一样，不过参数选取不同）
Statement st = createstatement(Result.TYPE_SCROLL_INSENSITIVE,Result.CONCUR_UPDATABLE)
特点：可以完成对数据库的更新操作。更新的方法是，把ResultSet的游标移动到你要更新的行，然后调用updateXXX()，再用updateRow()完成对数据库的写入。
限制/要求：（1）对单表操作。（2）不包含join或者group by子句。
4、保持型
创建方式：
Statement st=createStatement(int resultsetscrollable,int resultsetupdateable,int resultsetSetHoldability)
ResultSet rs = st.excuteQry(sqlStr);
参数：只介绍第三个resultsetSetHoldability，表示在结果集提交后结果集是否打开，其值为
ResultSet.HOLD_CURSORS_OVER_COMMIT:表示修改提交时，不关闭数据库。
ResultSet.CLOSE_CURSORS_AT_COMMIT：表示修改提交时ResultSet关闭
特点：一般情况下，在使用Statement执行完一个查询，又去执行另一个查询的时候，第一个查询的结果集就会被关闭。该方式可以自由设定是否关闭结果集。
限制/要求：（1）只是在JDBC3.0的驱动下才能成立。
可更新的结果集：
更新一行：
UpdateXXX（）è cancelRowUpdates（）èupdateRow（）èrowUpdated（）。
UpadateXXX（）方法只能修改当前行的数据，并不能修改数据库中的数据，所以在调用updateXXX（）后，还要调用updateRow（）方法，用当前行中的新数据更新数据库。
CancelRowUpdates（）方法用来放弃对当前行的修改，注意，要让这个方法有效，必须在调用updteRow（）方法之前调用它。
rowUpdated（）方法来判断当前行是否被更新。
插入行：
moveToInsertRow（）方法移动游标到插入行，插入行是一个与可更新的结果集相联系的特殊的缓存行。
moveToInsertRow（）èupdateXXX（）ègetXXX（）èinsertRow（）èrowInserted（）
insertRow（）将新行传递给数据库，从而在新数据库中真正插入一行数据
rowInserted（）方法来判断当前行是否是插入行。
删除一行：
deletRow（）从结果集中和数据库中删除一行，当游标指向插入行的时候，不能调用这个方法。一个被删除的行可能在结果集中留下一个空的位置，可以调用 rowDeleted（）方法来判断一行是否被删除。
可更新结果集的使用必须满足下面3个条件：
1， 只能是针对数据库中单张表单的查询
2， 查询语句中不能包含任何的join操作。
3， 查询操作的表中必须有主键，而且在查询的结果集中必须包含作为主键的字段。
结果集中执行插入操作，还应该满足下面两个条件
1， 查询操作必须选择数据库表中所有不能为空的列
2， 查询操作必须选择所有没有默认值的列。
判断ResultSet是否为空
ResultSet rs=stmt.executeQry(sql);
rs == null;
rs.size()这个方法没有的
rs为ResultSet的引用，即使结果集里有0条记录，rs也不为空，所以用rs == null来判断结果集里是否有0条记录是错误的，而要用 rs.getRow(); 为0则表示没有记录--使用的时候也有问题
使用rs.next()是否为tr来判断，会使游标前移一位，可能丢掉一条记录，不合适
boolean hasRows = false;
下面的方法较合适
while (rs.next()){
hasRows = tr;
//Do your stf
}
if (!hasRows ){
//Empty result set
}
//You dont have to test for null result set
19:50 | 添加评论 | 固定链接 | 写入日志 | Java10月14日
把本地硬盘里的图片存储到oracle数据库里blob的实现
转自：黑色头发
http://heisetoa.javaeye.com
数据库是oracle，字段是blob,代码语言是java，上传的可以是图片也可以是其他大文件，显示在浏览器里和保存在硬盘上不写在这篇文章里，写在下篇里
import java.io.BferedInputStream;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Write
{
p lic static void main(String[] args)
{
try {
Writewatdb = new Write();
watdb.sendToDb();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Write() throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void sendToDb()
{
int amount = 0;
OutputStream out = null;
BferedInputStream in = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
conn.setAutoCommit(false);
stmt.executeUpdate("insert into dzjc_img(img) vals (empty_blob())");
rs = stmt.executeQry("select img from dzjc_img for update");
if (rs.next())
{
Blob blob = rs.getBlob("img");
out = ( (oracle.sql.BLOB) blob).getBinaryOutputStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
in = new BferedInputStream(new FileInputStream(pathname), bferSize);
byte[] b = new byte[bferSize];
int count = in.read(b, 0, bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("处理了" + amount + "字节.");
count = in.read(b, 0, bferSize);
System.out.println("处理了" + amount + "字节,成功.");
}
out.close();
out = null;
in.close();
in = null;
conn.commit();
}
}
catch (Exception e)
{
e.printStackTrace();
try
{
conn.rollback();
}
catch (Exception ignored) {}
}
finally
{
if (out!=null) try{out.close();} catch(Exception igored){}
if (in!=null) try{in.close();} catch(Exception igored){}
}
}
}
可直接运行
数据库就自己建吧，建个类型为blob型的就行了
18:24 | 添加评论 | 固定链接 | 写入日志 | Java把图片从oracle数据库的blob字段中取出来，存在硬盘上
转：
import java.io.BferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Read
{
p lic static void main(String[] args)
{
try {
Read rfdb = new Read ();
rfdb.readFromDB();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Read ()throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void readFromDB()
{
String pathname, name;
int amount = 0;
InputStream in = null;
BferedOutputStream out = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
rs = stmt.executeQry("select img from dzjc_img");
if (rs.next())
{
Blob blob = rs.getBlob(1);
in = blob.getBinaryStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
out = new BferedOutputStream(new FileOutputStream(pathname),(int) bferSize);
byte[] b = new byte[ (int) bferSize];
int count = in.read(b, 0, (int) bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("已经处理了" + amount + "字节.");
count = in.read(b, 0, (int) bferSize);
}
System.out.println("成功处理完毕字节数:" + amount);
out.close();
out = null;
in.close();
in = null;
}
else
{
System.out.println("文档:" + name + "未找到.");
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (out != null)
{
try
{
out.close();
}
catch (Exception ignored) {}
}
if (in != null)
{
try
{
in.close();
}
catch (Exception ignored) {}
}
}
}
}
上篇文章是从硬盘上存到数据库里，这次来个存到数据库里再取出来的存到硬盘上的类，还有一个是，下篇文章再发一个从数据库里取出来再显示在浏览器上的
贴代码先
import java.io.BferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Read
{
p lic static void main(String[] args)
{
try {
Read rfdb = new Read ();
rfdb.readFromDB();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Read ()throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void readFromDB()
{
String pathname, name;
int amount = 0;
InputStream in = null;
BferedOutputStream out = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
rs = stmt.executeQry("select img from dzjc_img");
if (rs.next())
{
Blob blob = rs.getBlob(1);
in = blob.getBinaryStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
out = new BferedOutputStream(new FileOutputStream(pathname),(int) bferSize);
byte[] b = new byte[ (int) bferSize];
int count = in.read(b, 0, (int) bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("已经处理了" + amount + "字节.");
count = in.read(b, 0, (int) bferSize);
}
System.out.println("成功处理完毕字节数:" + amount);
out.close();
out = null;
in.close();
in = null;
}
else
{
System.out.println("文档:" + name + "未找到.");
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (out != null)
{
try
{
out.close();
}
catch (Exception ignored) {}
}
if (in != null)
{
try
{
in.close();
}
catch (Exception ignored) {}
}
}
}
}
要保证数据库里有图片，打开的对话框显示为打开而不是保存，没关系，自己找个地方，输个文件名，一点打开，图片就会被保存在那个位置了
18:21 | 添加评论 | 固定链接 | 写入日志 | JavaJava存取OracleBlob字段，图片存储，Blob和BLOB的问题，Clob，oracle
本文转自：http://166.111.60.177/DevelopWiki/Wiki.jsp?page=Java%E5%AD%98%E5%8F%96OracleBlob%E5%AD%97%E6%AE%B5
1、Blob和BLOB的问题
java.sql.Blob
oracle.sql.BLOB
这两个blob仅仅是大小写不同，但是差异很大，java.sql.Blob是一个接口，而oracle.sql.BLOB是一个实现java.sql.Blob的类，并且还有很多扩展的属性和方法，注意不要搞混了。
2、JDBC2.0和JDBC3.0的问题
classes12.zip实现了JDBC2.0(JDK1.3)，而JDBC2.0对于Blob的操作只有读，没有写，所以classes12.zip只好自己扩展了一套对Blob进行写的API，我的例子就是用了这套API。
ojdbc14.jar实现了JDBC3.0(JDK1.4)，JDBC3.0已经包括了对Blob写的操作，而ojdbc14.jar也实现了该API。
总之注意这些问题。
你用的是什么容器？是不是weblogic？如果是weblogic，并且通过datasourse获取connection，取出来的就不是 oracle.sql.BLOB，而是weblogic封装过的OracleThinBlob，所以cast的时候肯定会出错，但是如果在程序里面 cast成OracleThinBlob，就会造成对weblogic的依赖，所以我在dao的impl中用反射解耦。并且这个只是在使用oracle的 thin驱动的时候才会出现的问题
写CLOB的代码片段：
File blobFile = new File("image.jpg");
int file_length = (int)blobFile.length();
FileInputStream blobInStream = new FileInputStream(blobFile);
PreparedStatement insert_prepared = null;
insert_prepared = m_conn.prepareStatement(qry);
insert_prepared.setString(1, id);
insert_prepared.setBinaryStream(2, blobInStream, file_length);
insert_prepared.setString(3, tel);
insert_prepared.executeUpdate();
m_conn.commit();
String SqlStr = "update TextInfo set Content=empty_clob() where TextInfoKey=" + Integer.toString(textinfokey);
myConn.setAutoCommit(false);
java.sql.PreparedStatement pstmt = myConn.prepareStatement(SqlStr);
pstmt.executeUpdate();
SqlStr = "select Content from TextInfo where TextInfoKey=" + Integer.toString(textinfokey) + " for update";
java.sql.Statement st = myConn.createStatement();
java.sql.ResultSet rs = st.executeQry(SqlStr);
java.sql.Clob clob ;
if (rs.next()) {
clob = rs.getClob("Content");
weblogic.jdbc.rmi.SerialOracleClob cast1 =(weblogic.jdbc.rmi.SerialOracleClob)clob;
weblogic.jdbc.rmi.internal.OracleTClobImpl cast2 =(weblogic.jdbc.rmi.internal.OracleTClobImpl)cast1.getTheRealClob();
CLOB myClob = (oracle.sql.CLOB)cast2.getTheRealClob();
java.io.Writer out=myClob.getCharacterOutputStream();
out.write(content);
out.flush();
out.close();
}-------------------------------------------------------------------------------------------------
存取BLOB出现这么多问题，我认为大半是由数据库开发商、应用服务器商在JDBC驱动上的不兼容性带来的。而实际应用中，每个人的开发运行环境不同，使得某个网友的solution没有办法在别人的应用中重现，以至于骂声一片。至于为什么会不兼容、有哪些问题，我没有时间去弄清，这里只说说我们怎样解决了问题的。
基于上述原因，先列出我们的开发环境，免得有人配不出来，招人唾骂。
数据库 Oracle 9i
应用服务器 BEA Weblogic 8.11
开发工具 JBuilder X
在JSP实现文件Upload/Download可以分成这样几块 ：文件提交到形成InputSteam；InputSteam以BLOB格式入库；数据从库中读出为InputSteam；InputStream输出到页面形成下载文件。先说BLOB吧。
1． BLOB入库
（1） 直接获得数据库连接的情况
这是Oracle提供的标准方式，先插入一个空BLOB对象，然后Update这个空对象。代码如下：
//得到数据库连接（驱动包是weblogic的，没有下载任何新版本）
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:testdb", "test", "test");
//处理事务
con.setAutoCommit(false);
Statement st = con.createStatement();
//插入一个空对象
st.executeUpdate("insert into BLOBIMG vals(103,empty_blob())");
//用for update方式锁定数据行
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 for update");
if (rs.next()) {
//得到java.sql.Blob对象，然后Cast为oracle.sql.BLOB
oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob(1).;
//到数据库的输出流
OutputStream outStream = blob.getBinaryOutputStream();
//这里用一个文件模拟输入流
File file = new File("d:\\proxy.txt");
InputStream fin = new FileInputStream(file);
//将输入流写到输出流
byte[] b = new byte[blob.getBferSize()];
int len = 0;
while ( (len = fin.read(b)) != -1) {
outStream.write(b, 0, len);
//blob.putBytes(1,b);
}
//依次关闭（注意顺序）
fin.close();
outStream.flush();
outStream.close();
con.commit();
con.close();（2）通过JNDI获得数据库连接
在Weblogic中配置到Oracle的JDBC Connection Pool和DataSource，绑定到Context中，假定绑定名为”orads”。
为了得到数据库连接，做一个连接工厂，主要代码如下：
Context context = new InitialContext();
ds = (DataSource) context.lookup("orads");
return ds.getConnection();
以下是BLOB写入数据库的代码：
Connection con = ConnectionFactory.getConnection();
con.setAutoCommit(false);
Statement st = con.createStatement();
st.executeUpdate("insert into BLOBIMG vals(103,empty_blob())");
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 for update");
if (rs.next()) {
//上面代码不变
//这里不能用oracle.sql.BLOB，会报ClassCast 异常
weblogic.jdbc.vendor.oracle.OracleThinBlob blob = (weblogic.jdbc.vendor.oracle.OracleThinBlob) rs.getBlob(1);
//以后代码也不变
OutputStream outStream = blob.getBinaryOutputStream();
File file = new File("d:\\proxy.txt");
InputStream fin = new FileInputStream(file);
byte[] b = new byte[blob.getBferSize()];
int len = 0;
while ( (len = fin.read(b)) != -1) {
outStream.write(b, 0, len);
}
fin.close();
outStream.flush();
outStream.close();
con.commit();
con.close();2． BLOB出库
从数据库中读出BLOB数据没有上述由于连接池的不同带来的差异，只需要J2SE的标准类java.sql.Blob就可以取得输出流（注意区别java.sql.Blob和oracle.sql.BLOB）。代码如下：
Connection con = ConnectionFactory.getConnection();
con.setAutoCommit(false);
Statement st = con.createStatement();
//这里的SQL语句不再需要”for update”
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 ");
if (rs.next()) {
java.sql.Blob blob = rs.getBlob(1);
InputStream ins = blob.getBinaryStream();
//用文件模拟输出流
File file = new File("d:\\output.txt");
OutputStream fout = new FileOutputStream(file);
//下面将BLOB数据写入文件
byte[] b = new byte[1024];
int len = 0;
while ( (len = ins.read(b)) != -1) {
fout.write(b, 0, len);
}
//依次关闭
fout.close();
ins.close();
con.commit();
con.close();3． 从JSP页面提交文件到数据库<form action="handle.jsp" enctype="multipart/form-data" method="post" >
<input type="hidden" name="id" val="103"/>
<input type="file" name="fileToUpload">
<input type="s mit" val="Upload">
</form>
（2） 由于JSP没有提供文件上传的处理能力，只有使用第三方的开发包。网络上开源的包有很多，我们这里选择Apache Jakarta的FileUpload，在http://jakarta.apache.org/commons/fileupload /index.html 可以得到下载包和完整的API文档。法奥为adajspException
处理页面（handle.jsp）的代码如下：
<%
boolean isMultipart = FileUpload.isMultipartContent(reqst);
if (isMultipart) {
// 建立一个新的Upload对象
DiskFileUpload upload = new DiskFileUpload();
// 设置上载文件的参数
//upload.setSizeThreshold(yourMaxMemorySize);
//upload.setSizeMax(yourMaxReqstSize);
String rootPath = getServletConfig().getServletContext().getRealPath("/") ;
upload.setRepositoryPath(rootPath+"\\uploads");
// 分析reqst中的传来的文件流，返回Item的集合，
// 轮询Items，如果不是表单域，就是一个文件对象。
List items = upload.parseReqst(reqst);
Iterator iter = items.iterator();
while (iter.hasNext()) {
FileItem item = (FileItem) iter.next();
//如果是文件对象
if (!item.isFormField()) {
//如果是文本文件，可以直接显示
//out.println(item.getString());
//将上载的文件写到服务器的\WEB-INF\webstart\下，文件名为test.txt
//File uploadedFile = new File(rootPath+"\\uploads\\test.txt");
//item.write(uploadedFile);
//下面的代码是将文件入库（略）：
//注意输入流的获取
…
InputStream uploadedStream = item.getInputStream();
…
}
FROM:
http://blog.csdn.net/xiooix2012/article/details/6895594
EXECUTE IMMEDIATE 代替了以前Oracle8i中DBMS_SQL package包.
它解析并马上执行动态的SQL语句或非运行时创建的PL/SQL块.动态创建和执行SQL语句性能超前，EXECUTE IMMEDIATE的目标在于减小企业费用并获得较高的性能，较之以前它相当容易编码.尽管DBMS_SQL仍然可用，但是推荐使用EXECUTE IMMEDIATE,因为它获的收益在包之上。
-- 使用技巧
1. EXECUTE IMMEDIATE将不会提交一个DML事务执行，应该显式提交
如果通过EXECUTE IMMEDIATE处理DML命令，
那么在完成以前需要显式提交或者作为EXECUTE IMMEDIATE自己的一部分.
如果通过EXECUTE IMMEDIATE处理DDL命令,它提交所有以前改变的数据
2. 不支持返回多行的查询,这种交互将用临时表来存储记录(参照例子如下)或者用REF cursors.
3. 当执行SQL语句时，不要用分号，当执行PL/SQL块时，在其尾部用分号.
4. 在Oracle手册中，未详细覆盖这些功能。
下面的例子展示了所有用到Execute immediate的可能方面.希望能给你带来方便.
5. 对于Forms开发者,当在PL/SQL 8.0.6.3.版本中，Forms 6i不能使用此功能.
EXECUTE IMMEDIATE -- 用法例子
1. 在PL/SQL运行DDL语句
Sql代码
begin
execute immediate 'set role all';
end;
2. 给动态语句传值(USING 子句)
Sql代码
declare
l_depnam varchar2(20) := 'testing';
l_loc varchar2(10) := 'D?i';
begin
execute immediate 'insert into dept vals (:1, :2, :3)'
using 50, l_depnam, l_loc;
commit;
end;
3. 从动态语句检索值(INTO子句)
Sql代码
declare
l_cnt varchar2(20);
begin
execute immediate 'select count(1) from emp'
into l_cnt;
dbms_output.put_line(l_cnt);
end;
4. 动态调用例程.例程中用到的绑定变量参数必须指定参数类型.
黓认为IN类型,其它类型必须显式指定
Sql代码
declare
l_routin varchar2(100) := 'gen2161.get_rowcnt';
l_tblnam varchar2(20) := 'emp';
l_cnt number;
l_status varchar2(200);
begin
execute immediate 'begin ' || l_routin || '(:2, :3, :4); end;'
using in l_tblnam, out l_cnt, in out l_status;
if l_status != 'OK' then
dbms_output.put_line('error');
end if;
end;
5. 将返回值传递到PL/SQL记录类型;同样也可用%rowtype变量
Sql代码
declare
type empdtlrec is record (empno number(4),
ename varchar2(20),
deptno number(2));
empdtl empdtlrec;
begin
execute immediate 'select empno, ename, deptno ' ||
'from emp where empno = 7934'
into empdtl;
end;
6. 传递并检索值.INTO子句用在USING子句前
Sql代码
declare
l_dept pls_integer := 20;
l_nam varchar2(20);
l_loc varchar2(20);
begin
execute immediate 'select dname, loc from dept where deptno = :1'
into l_nam, l_loc
using l_dept ;
end;
7. 多行查询选项.对此选项用insert语句填充临时表，
用临时表进行进一步的处理,也可以用REF cursors纠正此缺憾.
Sql代码
declare
l_sal pls_integer := 2000;
begin
execute immediate 'insert into temp(empno, ename) '||'select empno, ename from emp '||'where sal > :1'
using l_sal;
commit;
end;
对于处理动态语句,EXECUTE IMMEDIATE 比以前可能用到的更容易并且更高效.
当意图执行动态语句时，适当地处理异常更加重要.应该关注于捕获所有可能的异常.15:40 | 添加评论 | 固定链接 | 写入日志 | SQLoracle中insert into select的用法
/* Formatted on 2008/06/02 15:37 (Formatter Plus v4.8.7) */
INSERT INTO t_work
(f_recid, f_jobid, f_ruleid, f_jobtype, f_operid, f_opername,
f_btime, f_assigntime, f_downtime, f_worktimes, f_finishtime)
SELECT SYS_GUID () AS f_recid, f_jobid, f_ruleid, f_jobtype, f_operid,
f_opername, f_btime, f_assigntime,f_downtime,
DECODE (f_downtime, null,1, f_downtime + 1) as f_worktimes,
TO_CHAR (SYSDATE, 'yyyy-MM-dd hh:mm:ss') AS finishtime
FROM t_bfer
WHERE f_jobid = '21'
说明将t_bfer中的一条记录添加到t_work表中。
其中b_bfer中没有的列有f_recid和t_finishtime;
f_worktimes需要加1。
SYS_GUID()的意思是生成一个32位的永不重复的字符串。
DECODE(f_downtime, null,1, f_downtime + 1)的意思是如果f_downtime为空（null）得到的值为1,否则为f_downtime+1。
TO_CHAR(SYSDATE, 'yyyy-MM-dd hh:mm:ss')为格式化时间格式;在表t_work中f_finishtime的数据类型为varchar2.
15:22 | 添加评论 | 固定链接 | 写入日志 | SQLPL/SQL开发中动态SQL的使用方法
原文来自：http://blog.chinaunix.net/u/19673/showart_272022.html
一般的PL/SQL程序设计中，在DML和事务控制的语句中可以直接使用SQL，但是DDL语句及系统控制语句却不能在PL/SQL中直接使用，要想实现在PL/SQL中使用DDL语句及系统控制语句，可以通过使用动态SQL来实现。
首先我们应该了解什么是动态SQL，在Oracle数据库开发PL/SQL块中我们使用的SQL分为：静态SQL语句和动态SQL语句。所谓静态SQL 指在PL/SQL块中使用的SQL语句在编译时是明确的，执行的是确定对象。而动态SQL是指在PL/SQL块编译时SQL语句是不确定的，如根据用户输入的参数的不同而执行不同的操作。编译程序对动态语句部分不进行处理，只是在程序运行时动态地创建语句、对语句进行语法分析并执行该语句。
Oracle中动态SQL可以通过本地动态SQL来执行，也可以通过DBMS_SQL包来执行。下面就这两种情况分别进行说明：
一、本地动态SQL
本地动态SQL是使用EXECUTE IMMEDIATE语句来实现的。
1、本地动态SQL执行DDL语句：
需求：根据用户输入的表名及字段名等参数动态建表。
create or replace procedure proc_test
(
table_name in varchar2, --表名
field1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
) as
str_sql varchar2(500);
begin
str_sql:=’create table ’||table_name||’(’||field1||’ ’||datatype1||’,’||field2||’ ’||datatype2||’)’;
execute immediate str_sql; --动态执行DDL语句
exception
when others then
null;
end ;
以上是编译通过的存储过程代码。下面执行存储过程动态建表。
SQL> execute proc_test(’dinya_test’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure s?ssfully completed
SQL> desc dinya_test;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
到这里，就实现了我们的需求，使用本地动态SQL根据用户输入的表名及字段名、字段类型等参数来实现动态执行DDL语句。
2、本地动态SQL执行DML语句。
需求：将用户输入的值插入到上例中建好的dinya_test表中。
create or replace procedure proc_insert
(
id in number, --输入序号
name in varchar2 --输入姓名
) as
str_sql varchar2(500);
begin
str_sql:=’insert into dinya_test vals(:1,:2)’;
execute immediate str_sql using id,name; --动态执行插入操作
exception
when others then
null;
end ;
执行存储过程，插入数据到测试表中。
SQL> execute proc_insert(1,’dinya’);
PL/SQL procedure s?ssfully completed
SQL> select * from dinya_test;
ID NAME
1 dinya
在上例中，本地动态SQL执行DML语句时使用了using子句，按顺序将输入的值绑定到变量，如果需要输出参数，可以在执行动态SQL的时候，使用RETURNING INTO 子句，如：
declare
p_id number:=1;
v_count number;
begin
v_string:=’select count(*) from table_name a where a.id=:id’;
execute immediate v_string into v_count using p_id;
end ;
更多的关于动态SQL中关于返回值及为输出输入绑定变量执行参数模式的问题，请读者自行做测试。
二、使用DBMS_SQL包
使用DBMS_SQL包实现动态SQL的步骤如下：A、先将要执行的SQL语句或一个语句块放到一个字符串变量中。B、使用DBMS_SQL包的 parse过程来分析该字符串。C、使用DBMS_SQL包的bind_variable过程来绑定变量。D、使用DBMS_SQL包的execute函数来执行语句。
1、使用DBMS_SQL包执行DDL语句
需求：使用DBMS_SQL包根据用户输入的表名、字段名及字段类型建表。
create or replace procedure proc_dbms_sql
(
table_name in varchar2, --表名
field_name1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field_name2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
)as
v_cursor number; --定义光标
v_string varchar2(200); --定义字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’create table ’||table_name||’(’||field_name1||’ ’||datatype1||’,’||field_name2||’ ’||datatype2||’)’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
v_row:=dbms_sql.execute(v_cursor); --执行语句
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
以上过程编译通过后，执行过程创建表结构：
SQL> execute proc_dbms_sql(’dinya_test2’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure s?ssfully completed
SQL> desc dinya_test2;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
2、使用DBMS_SQL包执行DML语句
需求：使用DBMS_SQL包根据用户输入的值更新表中相对应的记录。
查看表中已有记录：
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 CSDN
3 ERP
SQL>
建存储过程，并编译通过：
create or replace procedure proc_dbms_sql_update
(
id number,
name varchar2
)as
v_cursor number; --定义光标
v_string varchar2(200); --字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’update dinya_test2 a set a.name=:p_name where a.id=:p_id’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
dbms_sql.bind_variable(v_cursor,’:p_name’,name); --绑定变量
dbms_sql.bind_variable(v_cursor,’:p_id’,id); --绑定变量
v_row:=dbms_sql.execute(v_cursor); --执行动态ＳＱＬ
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
执行过程，根据用户输入的参数更新表中的数据：
SQL> execute proc_dbms_sql_update(2,’csdn_dinya’);
PL/SQL procedure s?ssfully completed
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 csdn_dinya
3 ERP
SQL>
执行过程后将第二条的name字段的数据更新为新值csdn_dinya。这样就完成了使用dbms_sql包来执行DML语句的功能。
使用DBMS_SQL中，如果要执行的动态语句不是查询语句，使用DBMS_SQL.Execute或 DBMS_SQL.Variable_Val来执行，如果要执行动态语句是查询语句，则要使用DBMS_SQL.define_column定义输出变量，然后使用DBMS_SQL.Execute, DBMS_SQL.Fetch_Rows, DBMS_SQL.Column_Val及DBMS_SQL.Variable_Val来执行查询并得到结果。
总结说明：
在Oracle开发过程中，我们可以使用动态SQL来执行DDL语句、DML语句、事务控制语句及系统控制语句。但是需要注意的是，PL/SQL块中使用动态SQL执行DDL语句的时候与别的不同，在DDL中使用绑定变量是非法的（bind_variable(v_cursor,’:p_name’, name)），分析后不需要执行DBMS_SQL.Bind_Variable，直接将输入的变量加到字符串中即可。另外，DDL是在调用 DBMS_SQL.PARSE时执行的，所以DBMS_SQL.EXECUTE也可以不用，即在上例中的v_row:=dbms_sql.execute
(v_cursor)部分可以不要。
15:14 | 添加评论 | 固定链接 | 写入日志 | SQL11月17日
ResultSet大全
开发的朋友，在操作数据库的时候，相信绝大部分人都用过它。但它不仅仅就是一个结果集的纯载体，仅仅只有存储的功能。下面就简略说一下它的功能。
结果集大体上可以分为四类，它们各有特点，基本上都和Statement语句的创建方式有关。
1、基本型（最基本，用得最广泛）
创建方式：无参数创建型
Statement st = conn.CreateStatement
ResultSet rs = Statement.excuteQry(sqlStr);
特点：这种最简单，没有特别的功能（不支持滚动、更新等等），只能用next()逐个单方向去读取数据。
2、滚动型
创建方式：参数创建型
Statement st = conn.createStatement(int resultSetType, int resultSetConcurrency)
ResultSet rs = st.executeQry(sqlStr)
参数：
resultSetType是设置ResultSet对象的类型可滚动
resultSetConcurency是设置ResultSet对象能够修改的
具体的参数值见ResultSet.
特点：（和具体参数的设置有关。）这种类型支持滚动获取记录，可以向前向后操作，类似于分页功能的操作方式。如支持：next()、previous()、first()、absolute(int n)等等。
3、更新型
创建方式：（和2一样，不过参数选取不同）
Statement st = createstatement(Result.TYPE_SCROLL_INSENSITIVE,Result.CONCUR_UPDATABLE)
特点：可以完成对数据库的更新操作。更新的方法是，把ResultSet的游标移动到你要更新的行，然后调用updateXXX()，再用updateRow()完成对数据库的写入。
限制/要求：（1）对单表操作。（2）不包含join或者group by子句。
4、保持型
创建方式：
Statement st=createStatement(int resultsetscrollable,int resultsetupdateable,int resultsetSetHoldability)
ResultSet rs = st.excuteQry(sqlStr);
参数：只介绍第三个resultsetSetHoldability，表示在结果集提交后结果集是否打开，其值为
ResultSet.HOLD_CURSORS_OVER_COMMIT:表示修改提交时，不关闭数据库。
ResultSet.CLOSE_CURSORS_AT_COMMIT：表示修改提交时ResultSet关闭
特点：一般情况下，在使用Statement执行完一个查询，又去执行另一个查询的时候，第一个查询的结果集就会被关闭。该方式可以自由设定是否关闭结果集。
限制/要求：（1）只是在JDBC3.0的驱动下才能成立。
可更新的结果集：
更新一行：
UpdateXXX（）è cancelRowUpdates（）èupdateRow（）èrowUpdated（）。
UpadateXXX（）方法只能修改当前行的数据，并不能修改数据库中的数据，所以在调用updateXXX（）后，还要调用updateRow（）方法，用当前行中的新数据更新数据库。
CancelRowUpdates（）方法用来放弃对当前行的修改，注意，要让这个方法有效，必须在调用updteRow（）方法之前调用它。
rowUpdated（）方法来判断当前行是否被更新。
插入行：
moveToInsertRow（）方法移动游标到插入行，插入行是一个与可更新的结果集相联系的特殊的缓存行。
moveToInsertRow（）èupdateXXX（）ègetXXX（）èinsertRow（）èrowInserted（）
insertRow（）将新行传递给数据库，从而在新数据库中真正插入一行数据
rowInserted（）方法来判断当前行是否是插入行。
删除一行：
deletRow（）从结果集中和数据库中删除一行，当游标指向插入行的时候，不能调用这个方法。一个被删除的行可能在结果集中留下一个空的位置，可以调用 rowDeleted（）方法来判断一行是否被删除。
可更新结果集的使用必须满足下面3个条件：
1， 只能是针对数据库中单张表单的查询
2， 查询语句中不能包含任何的join操作。
3， 查询操作的表中必须有主键，而且在查询的结果集中必须包含作为主键的字段。
结果集中执行插入操作，还应该满足下面两个条件
1， 查询操作必须选择数据库表中所有不能为空的列
2， 查询操作必须选择所有没有默认值的列。
判断ResultSet是否为空
ResultSet rs=stmt.executeQry(sql);
rs == null;
rs.size()这个方法没有的
rs为ResultSet的引用，即使结果集里有0条记录，rs也不为空，所以用rs == null来判断结果集里是否有0条记录是错误的，而要用 rs.getRow(); 为0则表示没有记录--使用的时候也有问题
使用rs.next()是否为tr来判断，会使游标前移一位，可能丢掉一条记录，不合适
boolean hasRows = false;
下面的方法较合适
while (rs.next()){
hasRows = tr;
//Do your stf
}
if (!hasRows ){
//Empty result set
}
//You dont have to test for null result set
19:50 | 添加评论 | 固定链接 | 写入日志 | Java10月14日
把本地硬盘里的图片存储到oracle数据库里blob的实现
转自：黑色头发
http://heisetoa.javaeye.com
数据库是oracle，字段是blob,代码语言是java，上传的可以是图片也可以是其他大文件，显示在浏览器里和保存在硬盘上不写在这篇文章里，写在下篇里
import java.io.BferedInputStream;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Write
{
p lic static void main(String[] args)
{
try {
Writewatdb = new Write();
watdb.sendToDb();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Write() throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void sendToDb()
{
int amount = 0;
OutputStream out = null;
BferedInputStream in = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
conn.setAutoCommit(false);
stmt.executeUpdate("insert into dzjc_img(img) vals (empty_blob())");
rs = stmt.executeQry("select img from dzjc_img for update");
if (rs.next())
{
Blob blob = rs.getBlob("img");
out = ( (oracle.sql.BLOB) blob).getBinaryOutputStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
in = new BferedInputStream(new FileInputStream(pathname), bferSize);
byte[] b = new byte[bferSize];
int count = in.read(b, 0, bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("处理了" + amount + "字节.");
count = in.read(b, 0, bferSize);
System.out.println("处理了" + amount + "字节,成功.");
}
out.close();
out = null;
in.close();
in = null;
conn.commit();
}
}
catch (Exception e)
{
e.printStackTrace();
try
{
conn.rollback();
}
catch (Exception ignored) {}
}
finally
{
if (out!=null) try{out.close();} catch(Exception igored){}
if (in!=null) try{in.close();} catch(Exception igored){}
}
}
}
可直接运行
数据库就自己建吧，建个类型为blob型的就行了
18:24 | 添加评论 | 固定链接 | 写入日志 | Java把图片从oracle数据库的blob字段中取出来，存在硬盘上
转：
import java.io.BferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Read
{
p lic static void main(String[] args)
{
try {
Read rfdb = new Read ();
rfdb.readFromDB();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Read ()throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void readFromDB()
{
String pathname, name;
int amount = 0;
InputStream in = null;
BferedOutputStream out = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
rs = stmt.executeQry("select img from dzjc_img");
if (rs.next())
{
Blob blob = rs.getBlob(1);
in = blob.getBinaryStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
out = new BferedOutputStream(new FileOutputStream(pathname),(int) bferSize);
byte[] b = new byte[ (int) bferSize];
int count = in.read(b, 0, (int) bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("已经处理了" + amount + "字节.");
count = in.read(b, 0, (int) bferSize);
}
System.out.println("成功处理完毕字节数:" + amount);
out.close();
out = null;
in.close();
in = null;
}
else
{
System.out.println("文档:" + name + "未找到.");
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (out != null)
{
try
{
out.close();
}
catch (Exception ignored) {}
}
if (in != null)
{
try
{
in.close();
}
catch (Exception ignored) {}
}
}
}
}
上篇文章是从硬盘上存到数据库里，这次来个存到数据库里再取出来的存到硬盘上的类，还有一个是，下篇文章再发一个从数据库里取出来再显示在浏览器上的
贴代码先
import java.io.BferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JFileChooser;
import oracle.jdbc.driver.OracleConnection;
p lic class Read
{
p lic static void main(String[] args)
{
try {
Read rfdb = new Read ();
rfdb.readFromDB();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Connection conn;
Statement stmt;
ResultSet rs;
int bferSize;
p lic Read ()throws SQLException, ClassNotFoundException
{
String connectString;
Class.forName("oracle.jdbc.driver.OracleDriver");
connectString = "jdbc:oracle:thin:@192.168.1.134:1521:zhpt";
conn = (OracleConnection)
DriverManager.getConnection(connectString, "dzjc","dzjc");
stmt = conn.createStatement();
}
p lic void readFromDB()
{
String pathname, name;
int amount = 0;
InputStream in = null;
BferedOutputStream out = null;
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION)
{
pathname = chooser.getSelectedFile().getAbsolutePath();
name = chooser.getSelectedFile().getName();
chooser = null;
}
else
{
System.out.println("没有找到文件！");
System.out.println("程序非正常结束...");
return;
}
try
{
rs = stmt.executeQry("select img from dzjc_img");
if (rs.next())
{
Blob blob = rs.getBlob(1);
in = blob.getBinaryStream();
bferSize = ( (oracle.sql.BLOB) blob).getBferSize();
out = new BferedOutputStream(new FileOutputStream(pathname),(int) bferSize);
byte[] b = new byte[ (int) bferSize];
int count = in.read(b, 0, (int) bferSize);
while (count != -1)
{
out.write(b, 0, count);
amount += count;
System.out.println("已经处理了" + amount + "字节.");
count = in.read(b, 0, (int) bferSize);
}
System.out.println("成功处理完毕字节数:" + amount);
out.close();
out = null;
in.close();
in = null;
}
else
{
System.out.println("文档:" + name + "未找到.");
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (out != null)
{
try
{
out.close();
}
catch (Exception ignored) {}
}
if (in != null)
{
try
{
in.close();
}
catch (Exception ignored) {}
}
}
}
}
要保证数据库里有图片，打开的对话框显示为打开而不是保存，没关系，自己找个地方，输个文件名，一点打开，图片就会被保存在那个位置了
18:21 | 添加评论 | 固定链接 | 写入日志 | JavaJava存取OracleBlob字段，图片存储，Blob和BLOB的问题，Clob，oracle
本文转自：http://166.111.60.177/DevelopWiki/Wiki.jsp?page=Java%E5%AD%98%E5%8F%96OracleBlob%E5%AD%97%E6%AE%B5
1、Blob和BLOB的问题
java.sql.Blob
oracle.sql.BLOB
这两个blob仅仅是大小写不同，但是差异很大，java.sql.Blob是一个接口，而oracle.sql.BLOB是一个实现java.sql.Blob的类，并且还有很多扩展的属性和方法，注意不要搞混了。
2、JDBC2.0和JDBC3.0的问题
classes12.zip实现了JDBC2.0(JDK1.3)，而JDBC2.0对于Blob的操作只有读，没有写，所以classes12.zip只好自己扩展了一套对Blob进行写的API，我的例子就是用了这套API。
ojdbc14.jar实现了JDBC3.0(JDK1.4)，JDBC3.0已经包括了对Blob写的操作，而ojdbc14.jar也实现了该API。
总之注意这些问题。
你用的是什么容器？是不是weblogic？如果是weblogic，并且通过datasourse获取connection，取出来的就不是 oracle.sql.BLOB，而是weblogic封装过的OracleThinBlob，所以cast的时候肯定会出错，但是如果在程序里面 cast成OracleThinBlob，就会造成对weblogic的依赖，所以我在dao的impl中用反射解耦。并且这个只是在使用oracle的 thin驱动的时候才会出现的问题
写CLOB的代码片段：
File blobFile = new File("image.jpg");
int file_length = (int)blobFile.length();
FileInputStream blobInStream = new FileInputStream(blobFile);
PreparedStatement insert_prepared = null;
insert_prepared = m_conn.prepareStatement(qry);
insert_prepared.setString(1, id);
insert_prepared.setBinaryStream(2, blobInStream, file_length);
insert_prepared.setString(3, tel);
insert_prepared.executeUpdate();
m_conn.commit();
String SqlStr = "update TextInfo set Content=empty_clob() where TextInfoKey=" + Integer.toString(textinfokey);
myConn.setAutoCommit(false);
java.sql.PreparedStatement pstmt = myConn.prepareStatement(SqlStr);
pstmt.executeUpdate();
SqlStr = "select Content from TextInfo where TextInfoKey=" + Integer.toString(textinfokey) + " for update";
java.sql.Statement st = myConn.createStatement();
java.sql.ResultSet rs = st.executeQry(SqlStr);
java.sql.Clob clob ;
if (rs.next()) {
clob = rs.getClob("Content");
weblogic.jdbc.rmi.SerialOracleClob cast1 =(weblogic.jdbc.rmi.SerialOracleClob)clob;
weblogic.jdbc.rmi.internal.OracleTClobImpl cast2 =(weblogic.jdbc.rmi.internal.OracleTClobImpl)cast1.getTheRealClob();
CLOB myClob = (oracle.sql.CLOB)cast2.getTheRealClob();
java.io.Writer out=myClob.getCharacterOutputStream();
out.write(content);
out.flush();
out.close();
}-------------------------------------------------------------------------------------------------
存取BLOB出现这么多问题，我认为大半是由数据库开发商、应用服务器商在JDBC驱动上的不兼容性带来的。而实际应用中，每个人的开发运行环境不同，使得某个网友的solution没有办法在别人的应用中重现，以至于骂声一片。至于为什么会不兼容、有哪些问题，我没有时间去弄清，这里只说说我们怎样解决了问题的。
基于上述原因，先列出我们的开发环境，免得有人配不出来，招人唾骂。
数据库 Oracle 9i
应用服务器 BEA Weblogic 8.11
开发工具 JBuilder X
在JSP实现文件Upload/Download可以分成这样几块 ：文件提交到形成InputSteam；InputSteam以BLOB格式入库；数据从库中读出为InputSteam；InputStream输出到页面形成下载文件。先说BLOB吧。
1． BLOB入库
（1） 直接获得数据库连接的情况
这是Oracle提供的标准方式，先插入一个空BLOB对象，然后Update这个空对象。代码如下：
//得到数据库连接（驱动包是weblogic的，没有下载任何新版本）
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:testdb", "test", "test");
//处理事务
con.setAutoCommit(false);
Statement st = con.createStatement();
//插入一个空对象
st.executeUpdate("insert into BLOBIMG vals(103,empty_blob())");
//用for update方式锁定数据行
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 for update");
if (rs.next()) {
//得到java.sql.Blob对象，然后Cast为oracle.sql.BLOB
oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob(1).;
//到数据库的输出流
OutputStream outStream = blob.getBinaryOutputStream();
//这里用一个文件模拟输入流
File file = new File("d:\\proxy.txt");
InputStream fin = new FileInputStream(file);
//将输入流写到输出流
byte[] b = new byte[blob.getBferSize()];
int len = 0;
while ( (len = fin.read(b)) != -1) {
outStream.write(b, 0, len);
//blob.putBytes(1,b);
}
//依次关闭（注意顺序）
fin.close();
outStream.flush();
outStream.close();
con.commit();
con.close();（2）通过JNDI获得数据库连接
在Weblogic中配置到Oracle的JDBC Connection Pool和DataSource，绑定到Context中，假定绑定名为”orads”。
为了得到数据库连接，做一个连接工厂，主要代码如下：
Context context = new InitialContext();
ds = (DataSource) context.lookup("orads");
return ds.getConnection();
以下是BLOB写入数据库的代码：
Connection con = ConnectionFactory.getConnection();
con.setAutoCommit(false);
Statement st = con.createStatement();
st.executeUpdate("insert into BLOBIMG vals(103,empty_blob())");
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 for update");
if (rs.next()) {
//上面代码不变
//这里不能用oracle.sql.BLOB，会报ClassCast 异常
weblogic.jdbc.vendor.oracle.OracleThinBlob blob = (weblogic.jdbc.vendor.oracle.OracleThinBlob) rs.getBlob(1);
//以后代码也不变
OutputStream outStream = blob.getBinaryOutputStream();
File file = new File("d:\\proxy.txt");
InputStream fin = new FileInputStream(file);
byte[] b = new byte[blob.getBferSize()];
int len = 0;
while ( (len = fin.read(b)) != -1) {
outStream.write(b, 0, len);
}
fin.close();
outStream.flush();
outStream.close();
con.commit();
con.close();2． BLOB出库
从数据库中读出BLOB数据没有上述由于连接池的不同带来的差异，只需要J2SE的标准类java.sql.Blob就可以取得输出流（注意区别java.sql.Blob和oracle.sql.BLOB）。代码如下：
Connection con = ConnectionFactory.getConnection();
con.setAutoCommit(false);
Statement st = con.createStatement();
//这里的SQL语句不再需要”for update”
ResultSet rs = st.executeQry(
"select contents from BLOBIMG where id=103 ");
if (rs.next()) {
java.sql.Blob blob = rs.getBlob(1);
InputStream ins = blob.getBinaryStream();
//用文件模拟输出流
File file = new File("d:\\output.txt");
OutputStream fout = new FileOutputStream(file);
//下面将BLOB数据写入文件
byte[] b = new byte[1024];
int len = 0;
while ( (len = ins.read(b)) != -1) {
fout.write(b, 0, len);
}
//依次关闭
fout.close();
ins.close();
con.commit();
con.close();3． 从JSP页面提交文件到数据库<form action="handle.jsp" enctype="multipart/form-data" method="post" >
<input type="hidden" name="id" val="103"/>
<input type="file" name="fileToUpload">
<input type="s mit" val="Upload">
</form>
（2） 由于JSP没有提供文件上传的处理能力，只有使用第三方的开发包。网络上开源的包有很多，我们这里选择Apache Jakarta的FileUpload，在http://jakarta.apache.org/commons/fileupload /index.html 可以得到下载包和完整的API文档。法奥为adajspException
处理页面（handle.jsp）的代码如下：
<%
boolean isMultipart = FileUpload.isMultipartContent(reqst);
if (isMultipart) {
// 建立一个新的Upload对象
DiskFileUpload upload = new DiskFileUpload();
// 设置上载文件的参数
//upload.setSizeThreshold(yourMaxMemorySize);
//upload.setSizeMax(yourMaxReqstSize);
String rootPath = getServletConfig().getServletContext().getRealPath("/") ;
upload.setRepositoryPath(rootPath+"\\uploads");
// 分析reqst中的传来的文件流，返回Item的集合，
// 轮询Items，如果不是表单域，就是一个文件对象。
List items = upload.parseReqst(reqst);
Iterator iter = items.iterator();
while (iter.hasNext()) {
FileItem item = (FileItem) iter.next();
//如果是文件对象
if (!item.isFormField()) {
//如果是文本文件，可以直接显示
//out.println(item.getString());
//将上载的文件写到服务器的\WEB-INF\webstart\下，文件名为test.txt
//File uploadedFile = new File(rootPath+"\\uploads\\test.txt");
//item.write(uploadedFile);
//下面的代码是将文件入库（略）：
//注意输入流的获取
…
InputStream uploadedStream = item.getInputStream();
…
}
FROM:
http://blog.csdn.net/xiooix2012/article/details/6895594
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- oracle execute immediate 权限不足ora-01031
- ORACLE EXECUTE IMMEDIATE 小结
- oracle execute immediate 动态执行SQL存储过程
- Oracle EXECUTE IMMEDIATE语句
- oracle execute immediate
- [转]ORACLE EXECUTE IMMEDIATE 小结
- ORACLE EXECUTE IMMEDIATE 小结
- ORACLE EXECUTE IMMEDIATE 小结
- ORACLE EXECUTE IMMEDIATE 小结
- ORACLE EXECUTE IMMEDIATE
- oracle 存储过程 execute immediate 'create table' 报 insufficient privileges错误解决及用户权限的理解-开发系列（二）
- Oracle （触发器）execute immediate 'sql语句'
- ORACLE EXECUTE IMMEDIATE 用法
- ORACLE EXECUTE IMMEDIATE 用法
- oracle EXECUTE IMMEDIATE动态执行sql及异常信息打印
- oracle execute immediate
- ORACLE EXECUTE IMMEDIATE 小结
- ORACLE EXECUTE IMMEDIATE 小结
- Oracle execute immediate 拼接条件 参数化
- Oracle 动态查询，EXECUTE IMMEDIATE select into使用方法