java存储过程返回游标
A. java连接Oracle调用存储过程提示实际返回的行数超出请求的行数异常，怎么解决
package com.yc.ycportal.ge.util;import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;import com.mysql.jdbc.ResultSet;public class TestOracle { private Connection conn=null;
private CallableStatement call=null;
private ResultSet rs=null; public TestOracle() {
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
setConn();
}
catch (ClassNotFoundException ex) {
}
} public void setConn(){
String url="jdbc:oracle:thin:@localhost:1521:hy";
try {
conn = DriverManager.getConnection(url, "system", "manager");
System.out.println("conn ok");
}
catch (SQLException ex) {
}
} public void closeConn(){
if(conn!=null){
try {
conn.close();
System.out.println("conn close");
}
catch (SQLException ex) {
}
}
} //调用单独的具有输出参数的过程
public void testShuchu(int salary ){
//实例化cal
try {
//cal = conn.prepareCall("{call hr.shuchu(?,?)}");
call=conn.prepareCall("begin hr.shuchu(?,?); end;");
call.setInt(1,salary);
//注册输出参数
//cal.registerOutParameter(2,java.sql.Types.VARCHAR);
call.registerOutParameter(2,oracle.jdbc.OracleTypes.VARCHAR);
call.execute();
//获得输出参数
// String str=cal.getString(2);
String str=(String)call.getObject(2);
System.out.println(str);
}
catch (SQLException ex) {
}
finally{
try {
call.close();
}
catch (SQLException ex1) {
}
} }// 调用函数
public void testHanshu(int num1,int num2){
try {
call = conn.prepareCall("begin ?:=hr.mypack.myfunc(?,?); end;");
call.setInt(2,num1);
call.setInt(3,num2);
call.registerOutParameter(1,oracle.jdbc.OracleTypes.NUMBER);
call.execute();
int num = call.getInt(1);
System.out.println(num);
}
catch (SQLException ex) {
}
finally{
try {
call.close();
}
catch (SQLException ex1) {
}
} }// 调用游标
public void testRs(int salary){
try {
call = conn.prepareCall("begin hr.mypack.shuchu(?,?); end;");
call.setInt(1,salary);
call.registerOutParameter(2,oracle.jdbc.OracleTypes.CURSOR);
call.execute();
rs=(ResultSet)call.getObject(2); if(rs!=null){
while (rs.next()) {
System.out.println(rs.getString(2));
}
}
else{
System.out.println("查无结果");
}
}
catch (SQLException ex) {
}
finally{
try {
rs.close();
call.close();
}
catch (SQLException ex1) {
} }
}
public static void main(String[] args) {
TestOracle dbUtil1 = new TestOracle();
dbUtil1.testRs(420);
}}package com.yc.ycportal.ge.util;import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;import com.mysql.jdbc.ResultSet;public class TestOracle { private Connection conn=null;
private CallableStatement call=null;
private ResultSet rs=null; public TestOracle() {
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
setConn();
}
catch (ClassNotFoundException ex) {
}
} public void setConn(){
String url="jdbc:oracle:thin:@localhost:1521:hy";
try {
conn = DriverManager.getConnection(url, "system", "manager");
System.out.println("conn ok");
}
catch (SQLException ex) {
}
} public void closeConn(){
if(conn!=null){
try {
conn.close();
System.out.println("conn close");
}
catch (SQLException ex) {
}
}
} //调用单独的具有输出参数的过程
public void testShuchu(int salary ){
//实例化cal
try {
//cal = conn.prepareCall("{call hr.shuchu(?,?)}");
call=conn.prepareCall("begin hr.shuchu(?,?); end;");
call.setInt(1,salary);
//注册输出参数
//cal.registerOutParameter(2,java.sql.Types.VARCHAR);
call.registerOutParameter(2,oracle.jdbc.OracleTypes.VARCHAR);
call.execute();
//获得输出参数
// String str=cal.getString(2);
String str=(String)call.getObject(2);
System.out.println(str);
}
catch (SQLException ex) {
}
finally{
try {
call.close();
}
catch (SQLException ex1) {
}
} }// 调用函数
public void testHanshu(int num1,int num2){
try {
call = conn.prepareCall("begin ?:=hr.mypack.myfunc(?,?); end;");
call.setInt(2,num1);
call.setInt(3,num2);
call.registerOutParameter(1,oracle.jdbc.OracleTypes.NUMBER);
call.execute();
int num = call.getInt(1);
System.out.println(num);
}
catch (SQLException ex) {
}
finally{
try {
call.close();
}
catch (SQLException ex1) {
}
} }// 调用游标
public void testRs(int salary){
try {
call = conn.prepareCall("begin hr.mypack.shuchu(?,?); end;");
call.setInt(1,salary);
call.registerOutParameter(2,oracle.jdbc.OracleTypes.CURSOR);
call.execute();
rs=(ResultSet)call.getObject(2); if(rs!=null){
while (rs.next()) {
System.out.println(rs.getString(2));
}
}
else{
System.out.println("查无结果");
}
}
catch (SQLException ex) {
}
finally{
try {
rs.close();
call.close();
}
catch (SQLException ex1) {
} }
}
public static void main(String[] args) {
TestOracle dbUtil1 = new TestOracle();
dbUtil1.testRs(420);
}}
B. oracle 存储过程返回结果集怎么实现用java如何调用这个存储过程比如表scott下的emp表
1：首先你需要创建一个包，并定义你返回的游标的类型、存储过程
create or replace package TEST_PKG is
type cur_emp is REF CURSOR;
procere test_proc (emps out cur_emp);
end TEST_PKG;
2：然后你再创建包体
create or replace package body TEST_PKG is
procere test_proc (emps out cur_emp)
as
begin
open emps for select * from emp;
end test_proc;
end TEST_PKG ;
3，通过JAVA调用
cstmt = conn.prepareCall("{call TEST_PKG .test_proc (?)}");
cstmt.registerOutParameter(1, OracleTypes.CURSOR);
cstmt.execute();
//获得结果集
rs = (ResultSet)cstmt.getObject(4);
while(rs.next()){......}
注意：游标类型需要你在连接未关闭之前进行本地持久化，不然连接关闭了就无法解析了哦^-^,如果还不懂可以联系我！
C. 存储过程以游标方式返回结果集，在应用程序中怎么关闭
关闭数据库连接即可。
因为数据库连接一旦显式关闭，那么这个连接进程会在服务器端也进行强制挂起，并进入关闭的队列，等待关闭。
--------------------------------
疑问，写了这么多年的存储过程了，还第一次见到存储过程是返回游标形式的。最好还是从你的业务入手修改程序吧。
D. Java调oracle函数，返回游标，当cstm.execute()时，报空指针的错误！
1.通过存储过程的出参，将“当前用户：user_id”连接串返回；
比如：
假设你的过程叫，prc_test，在参数列表中增加出参。
create or replace procere prc_test(入参 in 类型, 出参 out 类型) is
begin
-- 逻辑实现
end;
出参就是你要把内容放进去，用来传值的变量。
2.在过程中保存一张临时表，然后在java中查出这个临时表中保存的数据。
定义临时表table_temp
在过程中
insert into table_temp(msg) values ('当前用户：' || user_id);
E. oracle存储过程 中把临时表数据 返回结果集
用索引表快一些，然后使用select * from table(存储过程名（参数列表....）)输出。
F. sqlserver数据库存储过程返回值只能是integer类型吗 不能返回字符串吗
楼主所说的这种是返回语句执行后影响的行数，是只有int型的，如楼上定义的，可以返回多种类型，还可以返回记录集
如
create procere usp_select
@where nvarchar(100)
as
begin
select * from mytable where condition=@where
end
return
go
--------------------------------------
存储过程
当 SET NOCOUNT 为 ON 时，不返回计数（表示受 Transact-SQL 语句影响的行数）。
当 SET NOCOUNT 为 OFF 时，返回计数。
如果存储过程中包含的一些语句并不返回许多实际的数据，则该设置由于大量减少了网络流量，因此可显着提高性能。
G. 执行存储过程有多少种方法java
Java执行存储过程的方法：
简单的老的JDBC通过CallableStatement类支持存储过程的调用。该类实际上是PreparedStatement的一个子类。假设有一个poets数据库。数据库中有一个设置诗人逝世年龄的存储过程。下面是对老酒鬼Dylan Thomas（old soak Dylan Thomas，不指定是否有关典故、文化，请批评指正。译注）进行调用的详细代码：
try{
intage=39;
StringpoetName="dylanthomas";
CallableStatementproc=connection.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,poetName);
proc.setInt(2,age);
cs.execute();
}catch(SQLExceptione){//....}传给prepareCall方法的字串是存储过程调用的书写规范。它指定了存储过程的名称，？代表了需要指定的参数。
和JDBC集成是存储过程的一个很大的便利：为了从应用中调用存储过程，不需要存根（stub）类或者配置文件，除了你的DBMS的JDBC驱动程序外什么也不需要。
当这段代码执行时，数据库的存储过程就被调用。我们没有去获取结果，因为该存储过程并不返回结果。执行成功或失败将通过例外得知。失败可能意味着调用存储过程时的失败（比如提供的一个参数的类型不正确），或者一个应用程序的失败（比如抛出一个例外指示在poets数据库中并不存在“Dylan Thomas”）
结合SQL操作与存储过程
映射Java对象到SQL表中的行相当简单，但是通常需要执行几个SQL语句；可能是一个SELECT查找ID，然后一个INSERT插入指定ID的数据。在高度规格化（符合更高的范式，译注）的数据库模式中，可能需要多个表的更新，因此需要更多的语句。Java代码会很快地膨胀，每一个语句的网络开销也迅速增加。
将这些SQL语句转移到一个存储过程中将大大简化代码，仅涉及一次网络调用。所有关联的SQL操作都可以在数据库内部发生。并且，存储过程语言，例如PL/SQL，允许使用SQL语法，这比Java代码更加自然。早期的存储过程，使用Oracle的PL/SQL语言编写：
createprocereset_death_age(poetVARCHAR2,poet_ageNUMBER)
poet_idNUMBER;
beginSELECTidINTOpoet_idFROMpoetsWHEREname=poet;
INSERTINTOdeaths(mort_id,age)VALUES(poet_id,poet_age);
endset_death_age;
set_death_age几乎可以肯定是一个很烂的实现。应该在poets表中添加一列来存储逝世年龄。Java代码中并不关心数据库模式是怎么实现的，因为它仅调用存储过程。以后可以改变数据库模式以提高性能，但是不必修改代码。
下面是调用上面存储过程的Java代码：
publicstaticvoidsetDeathAge(PoetdyingBard,intage)throwsSQLException{
Connectioncon=null;
CallableStatementproc=null;
try{
con=connectionPool.getConnection();
proc=con.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,dyingBard.getName());
proc.setInt(2,age);
proc.execute();
}
finally{
try{proc.close();}
catch(SQLExceptione){}
con.close();
}
}为了确保可维护性，建议使用像这儿这样的static方法。这也使得调用存储过程的代码集中在一个简单的模版代码中。如果用到许多存储过程，就会发现仅需要拷贝、粘贴就可以创建新的方法。因为代码的模版化，甚至也可以通过脚本自动生产调用存储过程的代码。
Functions
存储过程可以有返回值，所以CallableStatement类有类似getResultSet这样的方法来获取返回值。当存储过程返回一个值时，必须使用registerOutParameter方法告诉JDBC驱动器该值的SQL类型是什么。也必须调整存储过程调用来指示该过程返回一个值。
下面接着上面的例子。这次查询Dylan Thomas逝世时的年龄。这次的存储过程使用PostgreSQL的pl/pgsql：
createfunctionsnuffed_it_when(VARCHAR)returnsinteger'declare
poet_idNUMBER;
poet_ageNUMBER;
begin
--.
SELECTidINTOpoet_idFROMpoetsWHEREname=$1;
--getandreturntheage.
SELECTageINTOpoet_ageFROMdeathsWHEREmort_id=poet_id;
returnage;
end;'language'pl/pgsql';
另外，注意pl/pgsql参数名通过Unix和DOS脚本的$n语法引用。同时，也注意嵌入的注释，这是和Java代码相比的另一个优越性。在Java中写这样的注释当然是可以的，但是看起来很凌乱，并且和SQL语句脱节，必须嵌入到Java String中。
下面是调用这个存储过程的Java代码：
connection.setAutoCommit(false);
CallableStatementproc=connection.prepareCall("{?=callsnuffed_it_when(?)}");
proc.registerOutParameter(1,Types.INTEGER);
proc.setString(2,poetName);
cs.execute();
intage=proc.getInt(2);
如果指定了错误的返回值类型会怎样？那么，当调用存储过程时将抛出一个RuntimeException，正如你在ResultSet操作中使用了一个错误的类型所碰到的一样。
复杂的返回值
如果这是存储过程的全部功能，那么存储过程就不是其它远程执行机制的替换方案了。存储过程的功能比这强大得多。
当执行一个SQL查询时，DBMS创建一个叫做cursor（游标）的数据库对象，用于在返回结果中迭代每一行。ResultSet是当前时间点的游标的一个表示。这就是为什么没有缓存或者特定数据库的支持，只能在ResultSet中向前移动。
某些DBMS允许从存储过程中返回游标的一个引用。JDBC并不支持这个功能，但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针（pointer）。
设想列出所有没有活到退休年龄的诗人，下面是完成这个功能的存储过程，返回一个打开的游标，同样也使用PostgreSQL的pl/pgsql语言：
createprocerelist_early_deaths()returnrefcursoras'declare
toesuprefcursor;
begin
opentoesupforSELECTpoets.name,deaths.ageFROMpoets,deaths--allentriesindeathsareforpoets.--butthetablemightbecomegeneric.
WHEREpoets.id=deaths.mort_idANDdeaths.age<60;
returntoesup;
end;'language'plpgsql';
下面是调用该存储过程的Java方法，将结果输出到PrintWriter：
PrintWriter:
staticvoidsendEarlyDeaths(PrintWriterout){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
//...con.
setAutoCommit(false);//Setupthecall.
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
out.println(name+"was"+age+"yearsold.");
}
rs.close();
}
catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();con.close();
}
}因为JDBC并不直接支持从存储过程中返回游标，使用Types.OTHER来指示存储过程的返回类型，然后调用getObject()方法并对返回值进行强制类型转换。
这个调用存储过程的Java方法是mapping的一个好例子。Mapping是对一个集上的操作进行抽象的方法。不是在这个过程上返回一个集，可以把操作传送进去执行。本例中，操作就是把ResultSet打印到一个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过程的另外一个方法实现：
publicclassProcessPoetDeaths{
publicabstractvoidsendDeath(Stringname,intage);
}
staticvoidmapEarlyDeaths(ProcessPoetDeathsmapper){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
con.setAutoCommit(false);
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
mapper.sendDeath(name,age);
}
rs.close();
}catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();
con.close();
}
}这允许在ResultSet数据上执行任意的处理，而不需要改变或者复制获取ResultSet的方法：
staticvoidsendEarlyDeaths(finalPrintWriterout){
ProcessPoetDeathsmyMapper=newProcessPoetDeaths(){
publicvoidsendDeath(Stringname,intage){
out.println(name+"was"+age+"yearsold.");
}
};
mapEarlyDeaths(myMapper);
}这个方法使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath方法的一个实现，和我们上面的例子一样的方式把结果写入到输出流。当然，这个技巧并不是存储过程特有的，但是和存储过程中返回的ResultSet结合使用，是一个非常强大的工具。
H. java调用存储过程返回游标的结果集无法关闭游标的问题
在过程里判断很简单呀
CREATE OR REPLACE PROCEDURE TESTPROC(CUR OUT SYS_REFCURSOR)
AS
default_c SYS_REFCURSOR;
BEGIN
OPEN CUR FOR SELECT * FROM AA;
if CUR%rowcount = 0 then
CUR:=default_c;
end if;
END;
定义一个默认空游标，没数据就返回它呗