java存储过程游标
‘壹’ sql server存储过程的游标output后 java怎么接受它oracle返回的rs我会接受
1.存储过程中我定义了一个游标返回值
@CURSOR_subsidiaryaccounts CURSOR VARYING OUTPUT -- 返回明细账的游标
ALTER PROCEDURE [dbo].[p_ledger_subsidiaryaccounts]
@fyearGe int, --年
@fperiodGe int, --期
@fyearLe int, --年
@fperiodLe int, --期
@fposted int, --是否过账 1,表示包含未过账；0，表示不包含未过账数据
@facctId bigint, --科目ID
@fdetailId bigint, --核算项目ID
@CURSOR_subsidiaryaccounts CURSOR VARYING OUTPUT -- 返回明细账的游标
AS
BEGIN
SET NOCOUNT ON;
/*创建临时表*/
....
--1.对返回的游标进行数据的绑定
SET @CURSOR_subsidiaryaccounts = CURSOR
FORWARD_ONLY STATIC
FOR
SELECT ID,
FDate,
FYear,
FPeriod,
FVoucherId,
FNumber,
FExplanation,
Fdebit,
Fcridt,
Fdc,
Fendbalance
FROM #tmp
Order By ID asc,FYear,Fperiod
-- 2. 打开游标
OPEN @CURSOR_subsidiaryaccounts
END
2.我在JAVA代码中用JDBC模版执行这个存储过程，要注册个游标类型的返回值。
SQL Server的JDBC貌似不支持？？不知道怎么解决呢？java代码如下：
public List<Map> listSubsidiary(final int fyearGe,final int fperiodGe,final int fyearLe,
final int fperiodLe,final Long facctId,final Long fdetailId,final int fposted) {
return (List<Map>) this.jdbcTemplate.execute(new CallableStatementCreator() {
@Override
public CallableStatement createCallableStatement(Connection conn) throws SQLException {
String sql = "{call p_ledger_subsidiaryaccounts(?,?,?,?,?,?,?,?)}";
CallableStatement cs = conn.prepareCall(sql);
cs.setInt(1, fyearGe);
cs.setInt(2, fperiodGe);
cs.setInt(3, fyearLe);
cs.setInt(4, fperiodLe);
cs.setInt(5, fposted);
cs.setLong(6, facctId);
cs.setLong(7, fdetailId);
//cs.registerOutParameter(8, java.sql.Types.OTHER);
cs.registerOutParameter(8, -10);
return cs;
}
},new CallableStatementCallback() {
@Override
public Object doInCallableStatement(CallableStatement cs)
throws SQLException, DataAccessException {
cs.execute();
ResultSet rs = (ResultSet)cs.getObject(8);
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
while(rs.next()){
System.out.println(rs.getString("FNumber"));
}
return list;
}
});
}<span></span>
‘贰’ java调用存储过程，打开结果集报递归SQL级别1出现错误且超出打开游标的最大数 这是怎么回事
在命令窗口执行show parameter open_cursors;
看看你给数据库配置的游标数是多大，估计是150
需要调整的话，网络搜一下游标设置。
‘叁’ 存储过程的游标什么作用
①从表中检索出结果集，从中每次指向一条记录进行交互的机制。
②关系数据库中的操作是在完整的行集合上执行的。
由SELECT 语句返回的行集合包括满足该语句的WHERE 子句所列条件的所有行。由该语句返回完整的行集合叫做结果集。
应用程序，尤其是互动和在线应用程序，把完整的结果集作为一个单元处理并不总是有效的。
这些应用程序需要一种机制来一次处理一行或连续的几行。而游标是对提供这一机制的结果集的扩展。
‘肆’ 6、什么是存储过程什么是游标，何时使用、何时不用游标
存储过程是一组命名了的SQL语句集合，是为了完成特定功能汇集而成的。该集合编译后存放在数据库中，可根据实际情况重新编译，可直接运行，也可远程运行且存储过程直接在服务器端运行。
游标实际上是一种能从包括多条数据记录的结果集（结果集是select查询之后返回的所有行数据的集合）中每次提取一条记录的机制充当指针的作用，遍历结果中的所有行，但他一次只指向一行。
游标在循环处理字段的时候使用
建议：尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写；使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效；与临时表一样，游标并不是不可使用。
‘伍’ 如何用JAVA调用存储过程
已储存过程储存在数据库中。对已储存过程的调用是 CallableStatement对象所含的内容。这种调用是用一种换码语法来写的，有两种形式：一种形式带结果参，另一种形式不带结果参数。结果参数是一种输出 (OUT) 参数，是已储存过程的返回值。两种形式都可带有数量可变的输入（IN 参数）、输出（OUT 参数）或输入和输出（INOUT 参数）的参数。问号将用作参数的占位符。 在JDBC 中调用已储存过程的语法如下所示。注意，方括号表示其间的内容是可选项；方括号本身并不是语法的组成部份。{call 过程名[(?, ?, ...)]} 返回结果参数的过程的语法为：{? = call 过程名[(?, ?, ...)]} 不带参数的已储存过程的语法类似：{call 过程名} 通常，创建 CallableStatement 对象的人应当知道所用的 DBMS 是支持已储存过程的，并且知道这些过程都是些什么。然而，如果需要检查，多种DatabaseMetaData 方法都可以提供这样的信息。例如，如果 DBMS 支持已储存过程的调用，则supportsStoredProceres 方法将返回 true，而getProceres 方法将返回对已储存过程的描述。CallableStatement 继承 Statement 的方法（它们用于处理一般的 SQL 语句），还继承了 PreparedStatement 的方法（它们用于处理 IN 参）。 CallableStatement 中定义的所有方法都用于处理 OUT 参数或 INOUT 参数的输出部分：注册 OUT 参数的 JDBC 类型（一般 SQL 类型）、从这些参数中检索结果，或者检查所返回的值是否为 JDBC NULL。 1、创建 CallableStatement 对象 CallableStatement 对象是用 Connection 方法 prepareCall 创建的。下例创建 CallableStatement 的实例，其中含有对已储存过程 getTestData 调用。该过程有两个变量，但不含结果参数：CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}"); 其中?占位符为IN、OUT还是INOUT参数，取决于已储存过程getTestData。 2、IN和OUT参数 将IN参数传给 CallableStatement 对象是通过 setXXX 方法完成的。该方法继承自 PreparedStatement。所传入参数的类型决定了所用的setXXX方法（例如，用 setFloat 来传入 float 值等）。 如果已储存过程返回 OUT 参数，则在执行 CallableStatement 对象以前必须先注册每个 OUT 参数的 JDBC 类型（这是必需的，因为某些 DBMS 要求 JDBC 类型）。注册 JDBC 类型是用 registerOutParameter 方法来完成的。语句执行完后，CallableStatement 的 getXXX 方法将取回参数值。正确的 getXXX 方法是为各参数所注册的 JDBC 类型所对应的 Java 类型。换言之， registerOutParameter 使用的是 JDBC 类型（因此它与数据库返回的 JDBC 类型匹配），而 getXXX 将之转换为 Java 类型。 作为示例，下述代码先注册 OUT 参数，执行由 cstmt 所调用的已储存过程，然后检索在 OUT 参数中返回的值。方法 getByte 从第一个 OUT 参数中取出一个 Java 字节，而 getBigDecimal 从第二个 OUT 参数中取出一个 BigDecimal 对象（小数点后面带三位数）：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 不同，它不提供用增量方式检索大 OUT 值的特殊机制。3、INOUT参数 既支持输入又接受输出的参数（INOUT 参数）除了调用 registerOutParameter 方法外，还要求调用适当的 setXXX 方法（该方法是从 PreparedStatement 继承来的）。setXXX 方法将参数值设置为输入参数，而 registerOutParameter 方法将它的 JDBC 类型注册为输出参数。setXXX 方法提供一个 Java 值，而驱动程序先把这个值转换为 JDBC 值，然后将它送到数据库中。这种 IN 值的 JDBC 类型和提供给 registerOutParameter 方法的 JDBC 类型应该相同。然后，要检索输出值，就要用对应的 getXXX 方法。例如，Java 类型为byte 的参数应该使用方法 setByte 来赋输入值。应该给registerOutParameter 提供类型为 TINYINT 的 JDBC 类型，同时应使用 getByte 来检索输出值。 下例假设有一个已储存过程 reviseTotal，其唯一参数是 INOUT 参数。方法setByte 把此参数设为 25，驱动程序将把它作为 JDBC TINYINT 类型送到数据库中。接着，registerOutParameter 将该参数注册为 JDBC TINYINT。执行完该已储存过程后，将返回一个新的 JDBC TINYINT 值。方法 getByte 将把这个新值作为 Java byte 类型检索。CallableStatement cstmt = con.prepareCall("{call reviseTotal(?)}");
cstmt.setByte(1, 25);
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.executeUpdate();
byte x = cstmt.getByte(1); 4、先检索结果，再检索 OUT 参数 由于某些 DBMS 的限制，为了实现最大的可移植性，建议先检索由执行CallableStatement 对象所产生的结果，然后再用 CallableStatement.getXXX 方法来检索 OUT 参数。如果 CallableStatement 对象返回多个 ResultSet 对象（通过调用 execute 方法），在检索 OUT 参数前应先检索所有的结果。这种情况下，为确保对所有的结果都进行了访问，必须对 Statement 方法 getResultSet、getUpdateCount 和getMoreResults 进行调用，直到不再有结果为止。 检索完所有的结果后，就可用 CallableStatement.getXXX 方法来检索 OUT 参数中的值。 5、检索作为OUT参数的NULL值 返回到 OUT 参数中的值可能会是JDBC NULL。当出现这种情形时，将对 JDBC NULL 值进行转换以使 getXXX 方法所返回的值为 null、0 或 false，这取决于getXXX 方法类型。对于 ResultSet 对象，要知道0或false是否源于JDBCNULL的唯一方法，是用方法wasNull进行检测。如果 getXXX 方法读取的最后一个值是 JDBC NULL，则该方法返回 true，否则返回 flase。
复杂的返回值 关于存储过程的知识，很多人好像就熟悉我们所讨论的这些。如果这是存储过程的全部功能，那么存储过程就不是其它远程执行机制的替换方案了。存储过程的功能比这强大得多。
某些DBMS允许从存储过程中返回游标的一个引用。JDBC并不支持这个功能，但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针（pointer）。
设想列出所有没有活到退休年龄的诗人，下面是完成这个功能的存储过程，返回一个打开的游标，同样也使用PostgreSQL的pl/pgsql语言： create procere 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'; 下面是调用该存储过程的Java方法，将结果输出到PrintWriter：
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); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.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并不直接支持从存储过程中返回游标，我们使用Types.OTHER来指示存储过程的返回类型，然后调用getObject()方法并对返回值进行强制类型转换。
这个调用存储过程的Java方法是mapping的一个好例子。Mapping是对一个集上的操作进行抽象的方法。不是在这个过程上返回一个集，我们可以把操作传送进去执行。本例中，操作就是把ResultSet打印到一个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过程的另外一个方法实现： 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); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.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(); }} 这允许在ResultSet数据上执行任意的处理，而不需要改变或者复制获取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);} 这个方法使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath方法的一个实现，和我们上面的例子一样的方式把结果写入到输出流。当然，这个技巧并不是存储过程特有的，但是和存储过程中返回的ResultSet结合使用，是一个非常强大的工具。 结论存储过程可以帮助你在代码中分离逻辑，这基本上总是有益的。这个分离的好处有：
快速创建应用，使用和应用一起改变和改善的数据库模式。
数据库模式可以在以后改变而不影响Java对象，当我们完成应用后，可以重新设计更好的模式。
存储过程通过更好的SQL嵌入使得复杂的SQL更容易理解。
编写存储过程比在Java中编写嵌入的SQL拥有更好的工具－－大部分编辑器都提供语法高亮！
存储过程可以在任何SQL命令行中测试，这使得调试更加容易。 并不是所有的数据库都支持存储过程，但是存在许多很棒的实现，包括免费/开源的和非免费的，所以移植并不是一个问题。Oracle、PostgreSQL和DB2都有类似的存储过程语言，并且有在线的社区很好地支持。
存储过程工具很多，有像TOAD或TORA这样的编辑器、调试器和IDE，提供了编写、维护PL/SQL或pl/pgsql的强大的环境。
存储过程确实增加了你的代码的开销，但是它们和大多数的应用服务器相比，开销小得多。
‘陆’ 执行存储过程有多少种方法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结合使用，是一个非常强大的工具。
‘柒’ 如何在Java中调用一个返回游标的存储过程
import oracle.jdbc.*;
...
CallableStatement cstmt;
ResultSet cursor;
// Use a PL/SQL block to open the cursor
//Additional Oracle Type Extensions
cstmt = conn.prepareCall
("begin open ? for select ename from emp; end;";
cstmt.registerOutParameter(1, OracleTypes.CURSOR);
cstmt.execute();
cursor = ((OracleCallableStatement)cstmt).getCursor(1);
// Use the cursor like a normal ResultSet
while (cursor.next ())
{System.out.println (cursor.getString(1));}
‘捌’ java调用的存储过程，能否传入游标参数
调用存储过程是可以传数组的，首先oracle编写的存储过程是需要带有数组参数的
参考资料给出例子很典型。
‘玖’ java里面怎么调用存储过程
最近做一个自动发邮件的schele，由于取数据的sql太长，直接分割很麻烦，就想到调用PL/SQL，网上查了资料做了练习，在此做下小结。
1、只有输入参数而没有返回结果的存储过程。
sql：
1 create or replace procere prc_1(deptno in number,dname in varchar2,loc in varchar2)
2 is
3 begin
4 insert into dept values(deptno,dname,loc);
5 end prc_1;
java：
1 static void test1(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 try {
5 conn=JDBCUtils.getConnection();
6 conn.setAutoCommit(false);
7 csmt=conn.prepareCall("call prc_1(?,?,?)");
8 csmt.setInt(1,80);
9 csmt.setString(2,"ioc");
10 csmt.setString(3,"fhp");
11 csmt.execute();
12 conn.commit();
13 System.out.println("success insert data");
14 } catch (SQLException e) {
15 e.printStackTrace();
16 }
17 }
2、有输入参数且有一个返回值的存储过程。
sql：
1 create or replace procere prc_2(p_deptno in number,p_loc out varchar2) is
2 begin
3 select loc into p_loc from dept where deptno=p_deptno;
4 end prc_2;
java：
1 static void test2(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 try {
5 conn=JDBCUtils.getConnection();
6 conn.setAutoCommit(false);
7 csmt=conn.prepareCall("call prc_2(?,?)");
8 csmt.setInt(1,70);
9 csmt.registerOutParameter(2,Types.VARCHAR);
10 csmt.execute();
11 conn.commit();
12 System.out.println("MIS位置："+csmt.getString(2));
13 } catch (SQLException e) {
14 e.printStackTrace();
15 }
16 }
3、返回多行记录（游标）的存储过程。
sql：
首先要建立一个返回游标，以便接收返回结果。
1 create or replace package testpackage is
2 type test_cursor is ref cursor;
3 end testpackage;
4
5 create or replace procere prc_3(p_cursor out testpackage.test_cursor)is
6 begin
7 open p_cursor for
8 select * from dept order by deptno;
9 end prc_3;
java：
1 static void test3(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 ResultSet rs=null;
5 try {
6 conn=JDBCUtils.getConnection();
7 conn.setAutoCommit(false);
8 csmt=conn.prepareCall("call prc_3(?)");
9 csmt.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);
10 csmt.execute();
11 rs=(ResultSet) csmt.getObject(1);
12 while(rs.next()){
13 System.out.println(rs.getString("deptno")+'\t'+rs.getString("dname")+'\t'+rs.getString("loc"));
14 }
15 } catch (SQLException e) {
16 // TODO Auto-generated catch block
17 e.printStackTrace();
18 }finally{
19 JDBCUtils.free(rs, csmt, conn);
20 }
21 }
‘拾’ 存储过程中游标的使用
下面是一个样例，参考一下吧：
procere BAK_ONHAND(p_batch_code in varchar2,
p_calc_date_code in varchar2) is
r_onhand CUX_MTL_ONHAND_BAK_TEMP%rowtype;
v_bak_date date;
Cursor C1 is
select moq.inventory_item_id,
msib.segment1 item_code,
msib.description item_des,
msib.primary_unit_of_measure item_uom,
moq.subinventory_code,
moq.locator_id,
nvl(sum(moq.transaction_quantity), 0) trans_qty,
moq.organization_id
from mtl_onhand_quantities_detail moq, mtl_system_items_b msib
where moq.inventory_item_id = msib.inventory_item_id
and moq.organization_id = msib.organization_id
and msib.organization_id = g_organization_id
and exists (select 1
from CUX_ITEM_VENDOR_INFOR_T ci
where msib.inventory_item_id = ci.item_id
and msib.organization_id = ci.organization_id
and ci.plan_or_delivery = '计划')
group by moq.inventory_item_id,
msib.segment1,
msib.description,
msib.primary_unit_of_measure,
moq.subinventory_code,
moq.locator_id,
moq.organization_id
order by msib.segment1;
begin
v_bak_date := sysdate;
r_onhand.BATCH_CODE := p_batch_code;
r_onhand.catc_date_code := p_calc_date_code;
r_onhand.created_by := g_user_id;
r_onhand.creation_date := sysdate;
r_onhand.last_updated_by := g_user_id;
r_onhand.last_update_date := sysdate;
r_onhand.last_update_login := g_login_id;
for c11 in C1 loop
r_onhand.ITEM_ID := c11.inventory_item_id;
r_onhand.ITEM_CODE := c11.item_code;
r_onhand.ITEM_DES := c11.item_des;
r_onhand.ITEM_UOM := c11.item_uom;
r_onhand.SUB_CODE := c11.subinventory_code;
r_onhand.LOCATOR_ID := c11.locator_id;
r_onhand.TRANS_QTY := c11.trans_qty;
r_onhand.ORGANIZATION_ID := g_organization_id;
r_onhand.BAK_DATE := v_bak_date;
r_onhand.ATTRIBUTE1 := '';
r_onhand.ATTRIBUTE2 := '';
r_onhand.ATTRIBUTE3 := '';
r_onhand.ATTRIBUTE4 := '';
r_onhand.ATTRIBUTE5 := '';
insert into CUX_MTL_ONHAND_BAK_TEMP values r_onhand;
end loop; ---end C1
commit;
end BAK_ONHAND;