diff --git a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java index b007058f164..a0cbe448507 100644 --- a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java +++ b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java @@ -540,6 +540,18 @@ public class CallMetaDataContext { return matchedParameters; } + public Map matchInParameterValuesWithCallParameters(Object[] parameterValues) { + Map matchedParameters = new HashMap(parameterValues.length); + int i = 0; + for (SqlParameter parameter : this.callParameters) { + if (parameter.isInputValueProvided()) { + String parameterName = parameter.getName(); + matchedParameters.put(parameterName, parameterValues[i++]); + } + } + return matchedParameters; + } + /** * Build the call string based on configuration and metadata information. * @return the call string to be used diff --git a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java index 16584753f76..b2873f7a1fd 100644 --- a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java +++ b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java @@ -341,6 +341,17 @@ public abstract class AbstractJdbcCall { return executeCallInternal(params); } + /** + * Method that provides execution of the call using the passed in array of parameters + * @param args array of parameter values; order must match the order declared for the stored procedure + * @return Map of out parameters + */ + protected Map doExecute(Object[] args) { + checkCompiled(); + Map params = matchInParameterValuesWithCallParameters(args); + return executeCallInternal(params); + } + /** * Method that provides execution of the call using the passed in Map of parameters * @param args Map of parameter name and values @@ -385,6 +396,16 @@ public abstract class AbstractJdbcCall { return this.callMetaDataContext.matchInParameterValuesWithCallParameters(parameterSource); } + /** + * Match the provided in parameter values with registered parameters and + * parameters defined via metadata processing. + * @param args the parameter values provided as an array + * @return Map with parameter names and values + */ + private Map matchInParameterValuesWithCallParameters(Object[] args) { + return this.callMetaDataContext.matchInParameterValuesWithCallParameters(args); + } + /** * Match the provided in parameter values with registered parameters and * parameters defined via metadata processing. diff --git a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java index b728cc36903..693c7d00da6 100644 --- a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java +++ b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java @@ -131,6 +131,10 @@ public class SimpleJdbcCall extends AbstractJdbcCall implements SimpleJdbcCallOp return this; } + @SuppressWarnings("unchecked") + public T executeFunction(Class returnType, Object... args) { + return (T) doExecute(args).get(getScalarOutParameterName()); + } @SuppressWarnings("unchecked") public T executeFunction(Class returnType, Map args) { @@ -142,6 +146,11 @@ public class SimpleJdbcCall extends AbstractJdbcCall implements SimpleJdbcCallOp return (T) doExecute(args).get(getScalarOutParameterName()); } + @SuppressWarnings("unchecked") + public T executeObject(Class returnType, Object... args) { + return (T) doExecute(args).get(getScalarOutParameterName()); + } + @SuppressWarnings("unchecked") public T executeObject(Class returnType, Map args) { return (T) doExecute(args).get(getScalarOutParameterName()); @@ -152,8 +161,8 @@ public class SimpleJdbcCall extends AbstractJdbcCall implements SimpleJdbcCallOp return (T) doExecute(args).get(getScalarOutParameterName()); } - public Map execute() { - return doExecute(new HashMap()); + public Map execute(Object... args) { + return doExecute(args); } public Map execute(Map args) { diff --git a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java index eec99c04e78..2bc96445c4d 100644 --- a/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java +++ b/org.springframework.jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java @@ -101,6 +101,14 @@ public interface SimpleJdbcCallOperations { SimpleJdbcCallOperations withoutProcedureColumnMetaDataAccess(); + /** + * Execute the stored function and return the results obtained as an Object of the specified return type. + * @param returnType the type of the value to return + * @param args optional array containing the in parameter values to be used in the call. Parameter values must + * be provided in the same order as the parameters are defined for the stored procedure. + */ + T executeFunction(Class returnType, Object... args); + /** * Execute the stored function and return the results obtained as an Object of the specified return type. * @param returnType the type of the value to return @@ -115,6 +123,16 @@ public interface SimpleJdbcCallOperations { */ T executeFunction(Class returnType, SqlParameterSource args); + /** + * Execute the stored procedure and return the single out parameter as an Object of the specified return type. + * In the case where there are multiple out parameters, the first one is returned and additional out parameters + * are ignored. + * @param returnType the type of the value to return + * @param args optional array containing the in parameter values to be used in the call. Parameter values must + * be provided in the same order as the parameters are defined for the stored procedure. + */ + T executeObject(Class returnType, Object... args); + /** * Execute the stored procedure and return the single out parameter as an Object of the specified return type. * In the case where there are multiple out parameters, the first one is returned and additional out parameters @@ -134,10 +152,12 @@ public interface SimpleJdbcCallOperations { T executeObject(Class returnType, SqlParameterSource args); /** - * Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.. + * Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations. + * @param args optional array containing the in parameter values to be used in the call. Parameter values must + * be provided in the same order as the parameters are defined for the stored procedure. * @return map of output params. */ - Map execute(); + Map execute(Object... args); /** * Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.. diff --git a/org.springframework.jdbc/src/test/java/org/springframework/jdbc/core/simple/SimpleJdbcCallTests.java b/org.springframework.jdbc/src/test/java/org/springframework/jdbc/core/simple/SimpleJdbcCallTests.java index 03d0315eb2a..3f69a453194 100644 --- a/org.springframework.jdbc/src/test/java/org/springframework/jdbc/core/simple/SimpleJdbcCallTests.java +++ b/org.springframework.jdbc/src/test/java/org/springframework/jdbc/core/simple/SimpleJdbcCallTests.java @@ -138,45 +138,11 @@ public class SimpleJdbcCallTests extends TestCase { } } - public void testAddInvoiceProcWithoutMetaData() throws Exception { + public void testAddInvoiceProcWithoutMetaDataUsingMapParamSource() throws Exception { final int amount = 1103; final int custid = 3; - mockDatabaseMetaData.getDatabaseProductName(); - ctrlDatabaseMetaData.setReturnValue("MyDB"); - mockDatabaseMetaData.getUserName(); - ctrlDatabaseMetaData.setReturnValue("me"); - mockDatabaseMetaData.supportsCatalogsInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.supportsSchemasInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.storesUpperCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.storesLowerCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(true); - - mockCallable.setObject(1, 1103, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(2, 3, 4); - ctrlCallable.setVoidCallable(); - mockCallable.registerOutParameter(3, 4); - ctrlCallable.setVoidCallable(); - mockCallable.execute(); - ctrlCallable.setReturnValue(false); - mockCallable.getUpdateCount(); - ctrlCallable.setReturnValue(-1); - mockCallable.getObject(3); - ctrlCallable.setReturnValue(new Long(4)); - if (debugEnabled) { - mockCallable.getWarnings(); - ctrlCallable.setReturnValue(null); - } - mockCallable.close(); - ctrlCallable.setVoidCallable(); - - mockConnection.prepareCall( - "{call add_invoice(?, ?, ?)}"); - ctrlConnection.setReturnValue(mockCallable); + initializeAddInvoiceWithoutMetaData(false); replay(); @@ -190,105 +156,27 @@ public class SimpleJdbcCallTests extends TestCase { assertEquals(4, newId.intValue()); } - public void testAddInvoiceProcWithMetaData() throws Exception { + public void testAddInvoiceProcWithoutMetaDataUsingArrayParams() throws Exception { final int amount = 1103; final int custid = 3; - MockControl ctrlResultSet = MockControl.createControl(ResultSet.class); - ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock(); - mockResultSet.next(); - ctrlResultSet.setReturnValue(true); - mockResultSet.getString("PROCEDURE_CAT"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getString("PROCEDURE_SCHEM"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getString("PROCEDURE_NAME"); - ctrlResultSet.setReturnValue("add_invoice"); - mockResultSet.next(); - ctrlResultSet.setReturnValue(false); - mockResultSet.close(); - ctrlResultSet.setVoidCallable(); - mockResultSet.next(); - ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue("amount"); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(1); - mockResultSet.getInt("DATA_TYPE"); - ctrlResultSet.setReturnValue(4); - mockResultSet.getString("TYPE_NAME"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getBoolean("NULLABLE"); - ctrlResultSet.setReturnValue(false); - mockResultSet.next(); - ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue("custid"); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(1); - mockResultSet.getInt("DATA_TYPE"); - ctrlResultSet.setReturnValue(4); - mockResultSet.getString("TYPE_NAME"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getBoolean("NULLABLE"); - ctrlResultSet.setReturnValue(false); - mockResultSet.next(); - ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue("newid"); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(4); - mockResultSet.getInt("DATA_TYPE"); - ctrlResultSet.setReturnValue(4); - mockResultSet.getString("TYPE_NAME"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getBoolean("NULLABLE"); - ctrlResultSet.setReturnValue(false); - mockResultSet.next(); - ctrlResultSet.setReturnValue(false); - mockResultSet.close(); - ctrlResultSet.setVoidCallable(); + initializeAddInvoiceWithoutMetaData(false); + replay(); - mockDatabaseMetaData.getDatabaseProductName(); - ctrlDatabaseMetaData.setReturnValue("Oracle"); - mockDatabaseMetaData.getUserName(); - ctrlDatabaseMetaData.setReturnValue("ME"); - mockDatabaseMetaData.supportsCatalogsInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.supportsSchemasInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.storesUpperCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(true); - mockDatabaseMetaData.storesLowerCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.getProcedures("", "ME", "ADD_INVOICE"); - ctrlDatabaseMetaData.setReturnValue(mockResultSet); - mockDatabaseMetaData.getProcedureColumns("", "ME", "ADD_INVOICE", null); - ctrlDatabaseMetaData.setReturnValue(mockResultSet); + SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withProcedureName("add_invoice"); + adder.declareParameters(new SqlParameter("amount", Types.INTEGER), + new SqlParameter("custid", Types.INTEGER), + new SqlOutParameter("newid", Types.INTEGER)); + Number newId = adder.executeObject(Number.class, amount, custid); + assertEquals(4, newId.intValue()); + } - mockCallable.setObject(1, 1103, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(2, 3, 4); - ctrlCallable.setVoidCallable(); - mockCallable.registerOutParameter(3, 4); - ctrlCallable.setVoidCallable(); - mockCallable.execute(); - ctrlCallable.setReturnValue(false); - mockCallable.getUpdateCount(); - ctrlCallable.setReturnValue(-1); - mockCallable.getObject(3); - ctrlCallable.setReturnValue(new Long(4)); - if (debugEnabled) { - mockCallable.getWarnings(); - ctrlCallable.setReturnValue(null); - } - mockCallable.close(); - ctrlCallable.setVoidCallable(); + public void testAddInvoiceProcWithMetaDataUsingMapParamSource() throws Exception { + final int amount = 1103; + final int custid = 3; - mockConnection.prepareCall( - "{call ADD_INVOICE(?, ?, ?)}"); - ctrlConnection.setReturnValue(mockCallable); + MockControl ctrlResultSet = initializeAddInvoiceWithMetaData(false); ctrlResultSet.replay(); replay(); @@ -302,45 +190,27 @@ public class SimpleJdbcCallTests extends TestCase { ctrlResultSet.verify(); } - public void testAddInvoiceFuncWithoutMetaData() throws Exception { + public void testAddInvoiceProcWithMetaDataUsingArrayParams() throws Exception { final int amount = 1103; final int custid = 3; - mockDatabaseMetaData.getDatabaseProductName(); - ctrlDatabaseMetaData.setReturnValue("MyDB"); - mockDatabaseMetaData.getUserName(); - ctrlDatabaseMetaData.setReturnValue("me"); - mockDatabaseMetaData.supportsCatalogsInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.supportsSchemasInProcedureCalls(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.storesUpperCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(false); - mockDatabaseMetaData.storesLowerCaseIdentifiers(); - ctrlDatabaseMetaData.setReturnValue(true); + MockControl ctrlResultSet = initializeAddInvoiceWithMetaData(false); - mockCallable.registerOutParameter(1, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(2, 1103, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(3, 3, 4); - ctrlCallable.setVoidCallable(); - mockCallable.execute(); - ctrlCallable.setReturnValue(false); - mockCallable.getUpdateCount(); - ctrlCallable.setReturnValue(-1); - mockCallable.getObject(1); - ctrlCallable.setReturnValue(new Long(4)); - if (debugEnabled) { - mockCallable.getWarnings(); - ctrlCallable.setReturnValue(null); - } - mockCallable.close(); - ctrlCallable.setVoidCallable(); + ctrlResultSet.replay(); + replay(); - mockConnection.prepareCall( - "{? = call add_invoice(?, ?)}"); - ctrlConnection.setReturnValue(mockCallable); + SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withProcedureName("add_invoice"); + Number newId = adder.executeObject(Number.class, amount, custid); + assertEquals(4, newId.intValue()); + + ctrlResultSet.verify(); + } + + public void testAddInvoiceFuncWithoutMetaDataUsingMapParamSource() throws Exception { + final int amount = 1103; + final int custid = 3; + + initializeAddInvoiceWithoutMetaData(true); replay(); @@ -354,10 +224,117 @@ public class SimpleJdbcCallTests extends TestCase { assertEquals(4, newId.intValue()); } - public void testAddInvoiceFuncWithMetaData() throws Exception { + public void testAddInvoiceFuncWithoutMetaDataUsingArrayParams() throws Exception { final int amount = 1103; final int custid = 3; + initializeAddInvoiceWithoutMetaData(true); + + replay(); + + SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withFunctionName("add_invoice"); + adder.declareParameters(new SqlOutParameter("return", Types.INTEGER), + new SqlParameter("amount", Types.INTEGER), + new SqlParameter("custid", Types.INTEGER)); + Number newId = adder.executeFunction(Number.class, amount, custid); + assertEquals(4, newId.intValue()); + } + + public void testAddInvoiceFuncWithMetaDataUsingMapParamSource() throws Exception { + final int amount = 1103; + final int custid = 3; + + MockControl ctrlResultSet = initializeAddInvoiceWithMetaData(true); + + ctrlResultSet.replay(); + replay(); + + SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withFunctionName("add_invoice"); + Number newId = adder.executeFunction(Number.class, new MapSqlParameterSource() + .addValue("amount", amount) + .addValue("custid", custid)); + assertEquals(4, newId.intValue()); + + ctrlResultSet.verify(); + } + + public void testAddInvoiceFuncWithMetaDataUsingArrayParams() throws Exception { + final int amount = 1103; + final int custid = 3; + + MockControl ctrlResultSet = initializeAddInvoiceWithMetaData(true); + + ctrlResultSet.replay(); + replay(); + + SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withFunctionName("add_invoice"); + Number newId = adder.executeFunction(Number.class, amount, custid); + assertEquals(4, newId.intValue()); + + ctrlResultSet.verify(); + } + + private void initializeAddInvoiceWithoutMetaData(boolean isFunction) throws SQLException { + mockDatabaseMetaData.getDatabaseProductName(); + ctrlDatabaseMetaData.setReturnValue("MyDB"); + mockDatabaseMetaData.getUserName(); + ctrlDatabaseMetaData.setReturnValue("me"); + mockDatabaseMetaData.supportsCatalogsInProcedureCalls(); + ctrlDatabaseMetaData.setReturnValue(false); + mockDatabaseMetaData.supportsSchemasInProcedureCalls(); + ctrlDatabaseMetaData.setReturnValue(false); + mockDatabaseMetaData.storesUpperCaseIdentifiers(); + ctrlDatabaseMetaData.setReturnValue(false); + mockDatabaseMetaData.storesLowerCaseIdentifiers(); + ctrlDatabaseMetaData.setReturnValue(true); + + if (isFunction) { + mockCallable.registerOutParameter(1, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(2, 1103, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(3, 3, 4); + ctrlCallable.setVoidCallable(); + } + else { + mockCallable.setObject(1, 1103, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(2, 3, 4); + ctrlCallable.setVoidCallable(); + mockCallable.registerOutParameter(3, 4); + ctrlCallable.setVoidCallable(); + } + mockCallable.execute(); + ctrlCallable.setReturnValue(false); + mockCallable.getUpdateCount(); + ctrlCallable.setReturnValue(-1); + if (isFunction) { + mockCallable.getObject(1); + } + else { + mockCallable.getObject(3); + } + ctrlCallable.setReturnValue(new Long(4)); + if (debugEnabled) { + mockCallable.getWarnings(); + ctrlCallable.setReturnValue(null); + } + mockCallable.close(); + ctrlCallable.setVoidCallable(); + + if (isFunction) { + mockConnection.prepareCall( + "{? = call add_invoice(?, ?)}"); + ctrlConnection.setReturnValue(mockCallable); + } + else { + mockConnection.prepareCall( + "{call add_invoice(?, ?, ?)}"); + ctrlConnection.setReturnValue(mockCallable); + } + } + + private MockControl initializeAddInvoiceWithMetaData(boolean isFunction) throws SQLException { MockControl ctrlResultSet = MockControl.createControl(ResultSet.class); ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock(); mockResultSet.next(); @@ -374,10 +351,18 @@ public class SimpleJdbcCallTests extends TestCase { ctrlResultSet.setVoidCallable(); mockResultSet.next(); ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue(null); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(5); + if (isFunction) { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue(null); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(5); + } + else { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue("amount"); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(1); + } mockResultSet.getInt("DATA_TYPE"); ctrlResultSet.setReturnValue(4); mockResultSet.getString("TYPE_NAME"); @@ -386,10 +371,18 @@ public class SimpleJdbcCallTests extends TestCase { ctrlResultSet.setReturnValue(false); mockResultSet.next(); ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue("amount"); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(1); + if (isFunction) { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue("amount"); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(1); + } + else { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue("custid"); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(1); + } mockResultSet.getInt("DATA_TYPE"); ctrlResultSet.setReturnValue(4); mockResultSet.getString("TYPE_NAME"); @@ -398,10 +391,18 @@ public class SimpleJdbcCallTests extends TestCase { ctrlResultSet.setReturnValue(false); mockResultSet.next(); ctrlResultSet.setReturnValue(true); - mockResultSet.getString("COLUMN_NAME"); - ctrlResultSet.setReturnValue("custid"); - mockResultSet.getInt("COLUMN_TYPE"); - ctrlResultSet.setReturnValue(1); + if (isFunction) { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue("custid"); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(1); + } + else { + mockResultSet.getString("COLUMN_NAME"); + ctrlResultSet.setReturnValue("newid"); + mockResultSet.getInt("COLUMN_TYPE"); + ctrlResultSet.setReturnValue(4); + } mockResultSet.getInt("DATA_TYPE"); ctrlResultSet.setReturnValue(4); mockResultSet.getString("TYPE_NAME"); @@ -413,7 +414,6 @@ public class SimpleJdbcCallTests extends TestCase { mockResultSet.close(); ctrlResultSet.setVoidCallable(); - mockDatabaseMetaData.getDatabaseProductName(); ctrlDatabaseMetaData.setReturnValue("Oracle"); mockDatabaseMetaData.getUserName(); @@ -431,18 +431,34 @@ public class SimpleJdbcCallTests extends TestCase { mockDatabaseMetaData.getProcedureColumns("", "ME", "ADD_INVOICE", null); ctrlDatabaseMetaData.setReturnValue(mockResultSet); - mockCallable.registerOutParameter(1, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(2, 1103, 4); - ctrlCallable.setVoidCallable(); - mockCallable.setObject(3, 3, 4); - ctrlCallable.setVoidCallable(); + if (isFunction) { + mockCallable.registerOutParameter(1, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(2, 1103, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(3, 3, 4); + ctrlCallable.setVoidCallable(); + } + else { + mockCallable.setObject(1, 1103, 4); + ctrlCallable.setVoidCallable(); + mockCallable.setObject(2, 3, 4); + ctrlCallable.setVoidCallable(); + mockCallable.registerOutParameter(3, 4); + ctrlCallable.setVoidCallable(); + } mockCallable.execute(); ctrlCallable.setReturnValue(false); mockCallable.getUpdateCount(); ctrlCallable.setReturnValue(-1); - mockCallable.getObject(1); - ctrlCallable.setReturnValue(new Long(4)); + if (isFunction) { + mockCallable.getObject(1); + ctrlCallable.setReturnValue(new Long(4)); + } + else { + mockCallable.getObject(3); + ctrlCallable.setReturnValue(new Long(4)); + } if (debugEnabled) { mockCallable.getWarnings(); ctrlCallable.setReturnValue(null); @@ -450,20 +466,17 @@ public class SimpleJdbcCallTests extends TestCase { mockCallable.close(); ctrlCallable.setVoidCallable(); - mockConnection.prepareCall( - "{? = call ADD_INVOICE(?, ?)}"); - ctrlConnection.setReturnValue(mockCallable); - - ctrlResultSet.replay(); - replay(); - - SimpleJdbcCall adder = new SimpleJdbcCall(mockDataSource).withFunctionName("add_invoice"); - Number newId = adder.executeFunction(Number.class, new MapSqlParameterSource() - .addValue("amount", amount) - .addValue("custid", custid)); - assertEquals(4, newId.intValue()); - - ctrlResultSet.verify(); + if (isFunction) { + mockConnection.prepareCall( + "{? = call ADD_INVOICE(?, ?)}"); + ctrlConnection.setReturnValue(mockCallable); + } + else { + mockConnection.prepareCall( + "{call ADD_INVOICE(?, ?, ?)}"); + ctrlConnection.setReturnValue(mockCallable); + } + return ctrlResultSet; } }