Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.jdbc.object
Class StoredProcedure

    java.lang.Object
      org.springframework.jdbc.object.RdbmsOperation
          org.springframework.jdbc.object.SqlCall
              org.springframework.jdbc.object.StoredProcedure

All Implemented Interfaces:
  InitializingBean

    public abstract class StoredProcedure

extends SqlCall

Superclass for object abstractions of RDBMS stored procedures. This class is abstract and it is intended that subclasses will provide a typed method for invocation that delegates to the supplied `execute(java.util.Map)` method.

The inherited `sql` property is the name of the stored procedure in the RDBMS. Note that JDBC 3.0 introduces named parameters, although the other features provided by this class are still necessary in JDBC 3.0.

Author:
  Rod Johnson, Thomas Risberg
See Also:
  `RdbmsOperation.setSql(java.lang.String)`

Field Summary

Fields inherited from class org.springframework.jdbc.object.RdbmsOperation
`logger`

Constructor Summary
`protected` | `StoredProcedure()` Allow use as a bean.
`protected` | `StoredProcedure(DataSource ds, String name)` Create a new object wrapper for a stored procedure.
`protected` | `StoredProcedure(JdbcTemplate jdbcTemplate, String name)` Create a new object wrapper for a stored procedure.

Method Summary
`protected boolean` | `allowsUnusedParameters()` StoredProcedure parameter Maps are by default allowed to contain additional entries that are not actually used as parameters.
`void` | `declareParameter(SqlParameter param)` Declare a parameter.
`Map` | `execute(Map inParams)` Execute the stored procedure.
`Map` | `execute(ParameterMapper inParamMapper)` Execute the stored procedure.

Methods inherited from class org.springframework.jdbc.object.SqlCall
`compileInternal, getCallString, isFunction, isSqlReadyForUse, newCallableStatementCreator, newCallableStatementCreator, onCompileInternal, setFunction, setSqlReadyForUse`

Methods inherited from class org.springframework.jdbc.object.RdbmsOperation
`afterPropertiesSet, checkCompiled, compile, getDeclaredParameters, getGeneratedKeysColumnNames, getJdbcTemplate, getResultSetType, getSql, isCompiled, isReturnGeneratedKeys, isUpdatableResults, setDataSource, setFetchSize, setGeneratedKeysColumnNames, setJdbcTemplate, setMaxRows, setParameters, setQueryTimeout, setResultSetType, setReturnGeneratedKeys, setSql, setTypes, setUpdatableResults, supportsLobParameters, validateNamedParameters, validateParameters`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### StoredProcedure

    protected StoredProcedure()

  Allow use as a bean.

### StoredProcedure

    protected StoredProcedure(DataSource ds,
                              String name)

  Create a new object wrapper for a stored procedure.

  Parameters:
    `ds` - DataSource to use throughout the lifetime of this object to obtain connections
    `name` - name of the stored procedure in the database

### StoredProcedure

    protected StoredProcedure(JdbcTemplate jdbcTemplate,
                              String name)

  Create a new object wrapper for a stored procedure.

  Parameters:
    `jdbcTemplate` - JdbcTemplate which wraps DataSource
    `name` - name of the stored procedure in the database

Method Detail

### allowsUnusedParameters

    protected boolean allowsUnusedParameters()

  StoredProcedure parameter Maps are by default allowed to contain additional entries that are not actually used as parameters.

  Overrides:
    `allowsUnusedParameters` in class `RdbmsOperation`
  See Also:
    `StoredProcedure`

### declareParameter

    public void declareParameter(SqlParameter param)
                          throws InvalidDataAccessApiUsageException

  Declare a parameter. Overridden method. Parameters declared as `SqlParameter` and `SqlInOutParameter` will always be used to provide input values. In addition to this any parameter declared as `SqlOutParameter` where an non-null input value is provided will also be used as an input paraneter. Note: Calls to declareParameter must be made in the same order as they appear in the database's stored procedure parameter list. Names are purely used to help mapping.

  Overrides:
    `declareParameter` in class `RdbmsOperation`
  Parameters:
    `param` - parameter object
  Throws:
    `InvalidDataAccessApiUsageException` - if the operation is already compiled, and hence cannot be configured further

### execute

    public Map execute(Map inParams)
                throws DataAccessException

  Execute the stored procedure. Subclasses should define a strongly typed execute method (with a meaningful name) that invokes this method, populating the input map and extracting typed values from the output map. Subclass execute methods will often take domain objects as arguments and return values. Alternatively, they can return void.

  Parameters:
    `inParams` - map of input parameters, keyed by name as in parameter declarations. Output parameters need not (but can be) included in this map. It is legal for map entries to be `null`, and this will produce the correct behavior using a NULL argument to the stored procedure.
  Returns:
    map of output params, keyed by name as in parameter declarations. Output parameters will appear here, with their values after the stored procedure has been called.
  Throws:
    `DataAccessException`

### execute

    public Map execute(ParameterMapper inParamMapper)
                throws DataAccessException

  Execute the stored procedure. Subclasses should define a strongly typed execute method (with a meaningful name) that invokes this method, passing in a ParameterMapper that will populate the input map. This allows mapping database specific features since the ParameterMapper has access to the Connection object. The execute method is also responsible for extracting typed values from the output map. Subclass execute methods will often take domain objects as arguments and return values. Alternatively, they can return void.

  Parameters:
    `inParamMapper` - map of input parameters, keyed by name as in parameter declarations. Output parameters need not (but can be) included in this map. It is legal for map entries to be `null`, and this will produce the correct behavior using a NULL argument to the stored procedure.
  Returns:
    map of output params, keyed by name as in parameter declarations. Output parameters will appear here, with their values after the stored procedure has been called.
  Throws:
    `DataAccessException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2008 The Spring Framework.