org.springframework.jdbc.core.simple

## Class SimpleJdbcCall

- java.lang.Object
- - org.springframework.jdbc.core.simple.AbstractJdbcCall
  - - org.springframework.jdbc.core.simple.SimpleJdbcCall

- All Implemented Interfaces:
    SimpleJdbcCallOperations

      public class SimpleJdbcCall
      extends AbstractJdbcCall
      implements SimpleJdbcCallOperations

  A SimpleJdbcCall is a multithreaded, reusable object representing a call to a stored procedure or a stored function. It provides meta-data processing to simplify the code needed to access basic stored procedures/functions. All you need to provide is the name of the procedure/function and a Map containing the parameters when you execute the call. The names of the supplied parameters will be matched up with in and out parameters declared when the stored procedure was created.

  The meta-data processing is based on the DatabaseMetaData provided by the JDBC driver. Since we rely on the JDBC driver, this "auto-detection" can only be used for databases that are known to provide accurate meta-data. These currently include Derby, MySQL, Microsoft SQL Server, Oracle, DB2, Sybase and PostgreSQL. For any other databases you are required to declare all parameters explicitly. You can of course declare all parameters explicitly even if the database provides the necessary meta-data. In that case your declared parameters will take precedence. You can also turn off any meta-data processing if you want to use parameter names that do not match what is declared during the stored procedure compilation.

  The actual call is being handled using Spring's `JdbcTemplate`.

  Many of the configuration methods return the current instance of the SimpleJdbcCall in order to provide the ability to chain multiple ones together in a "fluent" interface style.

  Since:
    2.5
  Author:
    Thomas Risberg, Stephane Nicoll
  See Also:
    `DatabaseMetaData`, `JdbcTemplate`

- - ### Field Summary

    - ### Fields inherited from class org.springframework.jdbc.core.simple.AbstractJdbcCall

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleJdbcCall(DataSource dataSource)` Constructor that takes one parameter with the JDBC DataSource to use when creating the underlying JdbcTemplate.
    `SimpleJdbcCall(JdbcTemplate jdbcTemplate)` Alternative Constructor that takes one parameter with the JdbcTemplate to be used.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `SimpleJdbcCall` | `declareParameters(SqlParameter... sqlParameters)` Specify one or more parameters if desired.
    `Map<String,Object>` | `execute(Map<String,?> args)` Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
    `Map<String,Object>` | `execute(Object... args)` Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
    `Map<String,Object>` | `execute(SqlParameterSource parameterSource)` Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
    `<T> T` | `executeFunction(Class<T> returnType, Map<String,?> args)` Execute the stored function and return the results obtained as an Object of the specified return type.
    `<T> T` | `executeFunction(Class<T> returnType, Object... args)` Execute the stored function and return the results obtained as an Object of the specified return type.
    `<T> T` | `executeFunction(Class<T> returnType, SqlParameterSource args)` Execute the stored function and return the results obtained as an Object of the specified return type.
    `<T> T` | `executeObject(Class<T> returnType, Map<String,?> args)` Execute the stored procedure and return the single out parameter as an Object of the specified return type.
    `<T> T` | `executeObject(Class<T> returnType, Object... args)` Execute the stored procedure and return the single out parameter as an Object of the specified return type.
    `<T> T` | `executeObject(Class<T> returnType, SqlParameterSource args)` Execute the stored procedure and return the single out parameter as an Object of the specified return type.
    `SimpleJdbcCall` | `returningResultSet(String parameterName, RowMapper<?> rowMapper)` Used to specify when a ResultSet is returned by the stored procedure and you want it mapped by a `RowMapper`.
    `SimpleJdbcCall` | `useInParameterNames(String... inParameterNames)` Not used yet.
    `SimpleJdbcCall` | `withCatalogName(String catalogName)` Optionally, specify the name of the catalog that contins the stored procedure.
    `SimpleJdbcCall` | `withFunctionName(String functionName)` Specify the procedure name to be used - this implies that we will be calling a stored function.
    `SimpleJdbcCall` | `withNamedBinding()` Indicates that parameters should be bound by name.
    `SimpleJdbcCall` | `withoutProcedureColumnMetaDataAccess()` Turn off any processing of parameter meta-data information obtained via JDBC.
    `SimpleJdbcCall` | `withProcedureName(String procedureName)` Specify the procedure name to be used - this implies that we will be calling a stored procedure.
    `SimpleJdbcCall` | `withReturnValue()` Indicates the procedure's return value should be included in the results returned.
    `SimpleJdbcCall` | `withSchemaName(String schemaName)` Optionally, specify the name of the schema that contins the stored procedure.

    - ### Methods inherited from class org.springframework.jdbc.core.simple.AbstractJdbcCall

      `addDeclaredParameter, addDeclaredRowMapper, checkCompiled, compile, compileInternal, doExecute, doExecute, doExecute, getCallableStatementFactory, getCallParameters, getCallString, getCatalogName, getInParameterNames, getJdbcTemplate, getProcedureName, getScalarOutParameterName, getSchemaName, isCompiled, isFunction, isNamedBinding, isReturnValueRequired, matchInParameterValuesWithCallParameters, matchInParameterValuesWithCallParameters, onCompileInternal, setAccessCallParameterMetaData, setCatalogName, setFunction, setInParameterNames, setNamedBinding, setProcedureName, setReturnValueRequired, setSchemaName`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### SimpleJdbcCall

          public SimpleJdbcCall(DataSource dataSource)

      Constructor that takes one parameter with the JDBC DataSource to use when creating the underlying JdbcTemplate.
      Parameters:
        `dataSource` - the `DataSource` to use
      See Also:
        `JdbcAccessor.setDataSource(javax.sql.DataSource)`

    - #### SimpleJdbcCall

          public SimpleJdbcCall(JdbcTemplate jdbcTemplate)

      Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
      Parameters:
        `jdbcTemplate` - the `JdbcTemplate` to use
      See Also:
        `JdbcAccessor.setDataSource(javax.sql.DataSource)`

  - ### Method Detail

    - #### withProcedureName

          public SimpleJdbcCall withProcedureName(String procedureName)

      Description copied from interface: `SimpleJdbcCallOperations`
      Specify the procedure name to be used - this implies that we will be calling a stored procedure.
      Specified by:
        `withProcedureName` in interface `SimpleJdbcCallOperations`
      Parameters:
        `procedureName` - the name of the stored procedure
      Returns:
        the instance of this SimpleJdbcCall

    - #### withFunctionName

          public SimpleJdbcCall withFunctionName(String functionName)

      Description copied from interface: `SimpleJdbcCallOperations`
      Specify the procedure name to be used - this implies that we will be calling a stored function.
      Specified by:
        `withFunctionName` in interface `SimpleJdbcCallOperations`
      Parameters:
        `functionName` - the name of the stored function
      Returns:
        the instance of this SimpleJdbcCall

    - #### withSchemaName

          public SimpleJdbcCall withSchemaName(String schemaName)

      Description copied from interface: `SimpleJdbcCallOperations`
      Optionally, specify the name of the schema that contins the stored procedure.
      Specified by:
        `withSchemaName` in interface `SimpleJdbcCallOperations`
      Parameters:
        `schemaName` - the name of the schema
      Returns:
        the instance of this SimpleJdbcCall

    - #### withCatalogName

          public SimpleJdbcCall withCatalogName(String catalogName)

      Description copied from interface: `SimpleJdbcCallOperations`
      Optionally, specify the name of the catalog that contins the stored procedure.

      To provide consistency with the Oracle DatabaseMetaData, this is used to specify the package name if the procedure is declared as part of a package.

      Specified by:
        `withCatalogName` in interface `SimpleJdbcCallOperations`
      Parameters:
        `catalogName` - the catalog or package name
      Returns:
        the instance of this SimpleJdbcCall

    - #### withReturnValue

          public SimpleJdbcCall withReturnValue()

      Description copied from interface: `SimpleJdbcCallOperations`
      Indicates the procedure's return value should be included in the results returned.
      Specified by:
        `withReturnValue` in interface `SimpleJdbcCallOperations`
      Returns:
        the instance of this SimpleJdbcCall

    - #### declareParameters

          public SimpleJdbcCall declareParameters(SqlParameter... sqlParameters)

      Description copied from interface: `SimpleJdbcCallOperations`
      Specify one or more parameters if desired. These parameters will be supplemented with any parameter information retrieved from the database meta-data.

      Note that only parameters declared as `SqlParameter` and `SqlInOutParameter` will be used to provide input values. This is different from the `StoredProcedure` class which - for backwards compatibility reasons - allows input values to be provided for parameters declared as `SqlOutParameter`.

      Specified by:
        `declareParameters` in interface `SimpleJdbcCallOperations`
      Parameters:
        `sqlParameters` - the parameters to use
      Returns:
        the instance of this SimpleJdbcCall

    - #### useInParameterNames

          public SimpleJdbcCall useInParameterNames(String... inParameterNames)

      Description copied from interface: `SimpleJdbcCallOperations`
      Not used yet.
      Specified by:
        `useInParameterNames` in interface `SimpleJdbcCallOperations`

    - #### returningResultSet

          public SimpleJdbcCall returningResultSet(String parameterName,
                                                   RowMapper<?> rowMapper)

      Description copied from interface: `SimpleJdbcCallOperations`
      Used to specify when a ResultSet is returned by the stored procedure and you want it mapped by a `RowMapper`. The results will be returned using the parameter name specified. Multiple ResultSets must be declared in the correct order.

      If the database you are using uses ref cursors then the name specified must match the name of the parameter declared for the procedure in the database.

      Specified by:
        `returningResultSet` in interface `SimpleJdbcCallOperations`
      Parameters:
        `parameterName` - the name of the returned results and/or the name of the ref cursor parameter
        `rowMapper` - the RowMapper implementation that will map the data returned for each row

    - #### withoutProcedureColumnMetaDataAccess

          public SimpleJdbcCall withoutProcedureColumnMetaDataAccess()

      Description copied from interface: `SimpleJdbcCallOperations`
      Turn off any processing of parameter meta-data information obtained via JDBC.
      Specified by:
        `withoutProcedureColumnMetaDataAccess` in interface `SimpleJdbcCallOperations`
      Returns:
        the instance of this SimpleJdbcCall

    - #### withNamedBinding

          public SimpleJdbcCall withNamedBinding()

      Description copied from interface: `SimpleJdbcCallOperations`
      Indicates that parameters should be bound by name.
      Specified by:
        `withNamedBinding` in interface `SimpleJdbcCallOperations`
      Returns:
        the instance of this SimpleJdbcCall

    - #### executeFunction

          public <T> T executeFunction(Class<T> returnType,
                                       Object... args)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored function and return the results obtained as an Object of the specified return type.
      Specified by:
        `executeFunction` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `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.

    - #### executeFunction

          public <T> T executeFunction(Class<T> returnType,
                                       Map<String,?> args)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored function and return the results obtained as an Object of the specified return type.
      Specified by:
        `executeFunction` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `args` - a Map containing the parameter values to be used in the call

    - #### executeFunction

          public <T> T executeFunction(Class<T> returnType,
                                       SqlParameterSource args)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored function and return the results obtained as an Object of the specified return type.
      Specified by:
        `executeFunction` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `args` - the MapSqlParameterSource containing the parameter values to be used in the call

    - #### executeObject

          public <T> T executeObject(Class<T> returnType,
                                     Object... args)

      Description copied from interface: `SimpleJdbcCallOperations`
      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.
      Specified by:
        `executeObject` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `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.

    - #### executeObject

          public <T> T executeObject(Class<T> returnType,
                                     Map<String,?> args)

      Description copied from interface: `SimpleJdbcCallOperations`
      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.
      Specified by:
        `executeObject` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `args` - a Map containing the parameter values to be used in the call

    - #### executeObject

          public <T> T executeObject(Class<T> returnType,
                                     SqlParameterSource args)

      Description copied from interface: `SimpleJdbcCallOperations`
      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.
      Specified by:
        `executeObject` in interface `SimpleJdbcCallOperations`
      Parameters:
        `returnType` - the type of the value to return
        `args` - the MapSqlParameterSource containing the parameter values to be used in the call

    - #### execute

          public Map<String,Object> execute(Object... args)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
      Specified by:
        `execute` in interface `SimpleJdbcCallOperations`
      Parameters:
        `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.
      Returns:
        a Map of output params

    - #### execute

          public Map<String,Object> execute(Map<String,?> args)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
      Specified by:
        `execute` in interface `SimpleJdbcCallOperations`
      Parameters:
        `args` - a Map containing the parameter values to be used in the call
      Returns:
        a Map of output params

    - #### execute

          public Map<String,Object> execute(SqlParameterSource parameterSource)

      Description copied from interface: `SimpleJdbcCallOperations`
      Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
      Specified by:
        `execute` in interface `SimpleJdbcCallOperations`
      Parameters:
        `parameterSource` - the SqlParameterSource containing the parameter values to be used in the call
      Returns:
        a Map of output params