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

## org.springframework.jdbc.core.simple
Interface SimpleJdbcOperations

All Known Implementing Classes:
  SimpleJdbcTemplate

    public interface SimpleJdbcOperations

JDBC operations interface usable on Java 5 and above, exposing a set of common JDBC operations, whose interface is simplified through the use of varargs and autoboxing.

Since:
  2.0
Author:
  Rod Johnson, Rob Harrop, Thomas Risberg
See Also:
  `NamedParameterJdbcTemplate`, `SimpleJdbcTemplate`, `JdbcOperations`

Method Summary
`int[]` | `batchUpdate(String sql, List<Object[]> batchArgs)` Execute a batch using the supplied SQL statement with the batch of supplied arguments.
`int[]` | `batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes)` Execute a batch using the supplied SQL statement with the batch of supplied arguments.
`int[]` | `batchUpdate(String sql, Map<String,?>[] batchValues)` Executes a batch using the supplied SQL statement with the batch of supplied arguments.
`int[]` | `batchUpdate(String sql, SqlParameterSource[] batchArgs)` Execute a batch using the supplied SQL statement with the batch of supplied arguments.
`JdbcOperations` | `getJdbcOperations()` Expose the classic Spring JdbcTemplate to allow invocation of less commonly used methods.
`NamedParameterJdbcOperations` | `getNamedParameterJdbcOperations()` Expose the Spring NamedParameterJdbcTemplate to allow invocation of less commonly used methods.
`
`<T> List<T>`
` | `query(String sql, ParameterizedRowMapper<T> rm, Map<String,?> args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> List<T>`
` | `query(String sql, ParameterizedRowMapper<T> rm, Object... args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> List<T>`
` | `query(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> List<T>`
` | `query(String sql, RowMapper<T> rm, Map<String,?> args)` Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object.
`
`<T> List<T>`
` | `query(String sql, RowMapper<T> rm, Object... args)` Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object.
`
`<T> List<T>`
` | `query(String sql, RowMapper<T> rm, SqlParameterSource args)` Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object.
`int` | `queryForInt(String sql, Map<String,?> args)` Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.
`int` | `queryForInt(String sql, Object... args)` Query for an `int` passing in a SQL query using the standard '?' placeholders for parameters and a variable number of arguments.
`int` | `queryForInt(String sql, SqlParameterSource args)` Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.
`List<Map<String,Object>>` | `queryForList(String sql, Map<String,?> args)` Execute the supplied query with the supplied arguments.
`List<Map<String,Object>>` | `queryForList(String sql, Object... args)` Execute the supplied query with the (optional) supplied arguments.
`List<Map<String,Object>>` | `queryForList(String sql, SqlParameterSource args)` Execute the supplied query with the supplied arguments.
`long` | `queryForLong(String sql, Map<String,?> args)` Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.
`long` | `queryForLong(String sql, Object... args)` Query for an `long` passing in a SQL query using the standard '?' placeholders for parameters and a variable number of arguments.
`long` | `queryForLong(String sql, SqlParameterSource args)` Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.
`Map<String,Object>` | `queryForMap(String sql, Map<String,?> args)` Execute the supplied query with the supplied arguments.
`Map<String,Object>` | `queryForMap(String sql, Object... args)` Execute the supplied query with the (optional) supplied arguments.
`Map<String,Object>` | `queryForMap(String sql, SqlParameterSource args)` Execute the supplied query with the supplied arguments.
`
`<T> T`
` | `queryForObject(String sql, Class<T> requiredType, Map<String,?> args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `queryForObject(String sql, Class<T> requiredType, Object... args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `queryForObject(String sql, Class<T> requiredType, SqlParameterSource args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `queryForObject(String sql, ParameterizedRowMapper<T> rm, Map<String,?> args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> T`
` | `queryForObject(String sql, ParameterizedRowMapper<T> rm, Object... args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> T`
` | `queryForObject(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)` Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.
`
`<T> T`
` | `queryForObject(String sql, RowMapper<T> rm, Map<String,?> args)` Query for an object of type `T` using the supplied `RowMapper` to the query results to the object.
`
`<T> T`
` | `queryForObject(String sql, RowMapper<T> rm, Object... args)` Query for an object of type `T` using the supplied `RowMapper` to the query results to the object.
`
`<T> T`
` | `queryForObject(String sql, RowMapper<T> rm, SqlParameterSource args)` Query for an object of type `T` using the supplied `RowMapper` to the query results to the object.
`int` | `update(String sql, Map<String,?> args)` Execute the supplied SQL statement with (optional) supplied arguments.
`int` | `update(String sql, Object... args)` Execute the supplied SQL statement with supplied arguments.
`int` | `update(String sql, SqlParameterSource args)` Execute the supplied SQL statement with supplied arguments.

Method Detail

### getJdbcOperations

    JdbcOperations getJdbcOperations()

  Expose the classic Spring JdbcTemplate to allow invocation of less commonly used methods.

### getNamedParameterJdbcOperations

    NamedParameterJdbcOperations getNamedParameterJdbcOperations()

  Expose the Spring NamedParameterJdbcTemplate to allow invocation of less commonly used methods.

### queryForInt

    int queryForInt(String sql,
                    Map<String,?> args)
                    throws DataAccessException

  Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`

### queryForInt

    int queryForInt(String sql,
                    SqlParameterSource args)
                    throws DataAccessException

  Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the `SqlParameterSource` containing the arguments for the query.
  Throws:
    `DataAccessException`

### queryForInt

    int queryForInt(String sql,
                    Object... args)
                    throws DataAccessException

  Query for an `int` passing in a SQL query using the standard '?' placeholders for parameters and a variable number of arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`

### queryForLong

    long queryForLong(String sql,
                      Map<String,?> args)
                      throws DataAccessException

  Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`

### queryForLong

    long queryForLong(String sql,
                      SqlParameterSource args)
                      throws DataAccessException

  Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`

### queryForLong

    long queryForLong(String sql,
                      Object... args)
                      throws DataAccessException

  Query for an `long` passing in a SQL query using the standard '?' placeholders for parameters and a variable number of arguments.

  Parameters:
    `sql` - the SQL query to run.
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`

### queryForObject

    <T> T queryForObject(String sql,
                         Class<T> requiredType,
                         Map<String,?> args)
                     throws DataAccessException

  Query for an object of type `T` identified by the supplied @`Class`. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `requiredType` - the required type of the return value
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, Class)`, `JdbcOperations.queryForObject(String, Object[], Class)`

### queryForObject

    <T> T queryForObject(String sql,
                         Class<T> requiredType,
                         SqlParameterSource args)
                     throws DataAccessException

  Query for an object of type `T` identified by the supplied @`Class`. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `requiredType` - the required type of the return value
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, Class)`, `JdbcOperations.queryForObject(String, Object[], Class)`

### queryForObject

    <T> T queryForObject(String sql,
                         Class<T> requiredType,
                         Object... args)
                     throws DataAccessException

  Query for an object of type `T` identified by the supplied @`Class`. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `requiredType` - the required type of the return value
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, Class)`, `JdbcOperations.queryForObject(String, Object[], Class)`

### queryForObject

    <T> T queryForObject(String sql,
                         RowMapper<T> rm,
                         Map<String,?> args)
                     throws DataAccessException

  Query for an object of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForObject

    @Deprecated
    <T> T queryForObject(String sql,
                                    ParameterizedRowMapper<T> rm,
                                    Map<String,?> args)
                     throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForObject

    <T> T queryForObject(String sql,
                         RowMapper<T> rm,
                         SqlParameterSource args)
                     throws DataAccessException

  Query for an object of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForObject

    @Deprecated
    <T> T queryForObject(String sql,
                                    ParameterizedRowMapper<T> rm,
                                    SqlParameterSource args)
                     throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForObject

    <T> T queryForObject(String sql,
                         RowMapper<T> rm,
                         Object... args)
                     throws DataAccessException

  Query for an object of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForObject

    @Deprecated
    <T> T queryForObject(String sql,
                                    ParameterizedRowMapper<T> rm,
                                    Object... args)
                     throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    <T> List<T> query(String sql,
                      RowMapper<T> rm,
                      Map<String,?> args)
                  throws DataAccessException

  Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    @Deprecated
    <T> List<T> query(String sql,
                                 ParameterizedRowMapper<T> rm,
                                 Map<String,?> args)
                  throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    <T> List<T> query(String sql,
                      RowMapper<T> rm,
                      SqlParameterSource args)
                  throws DataAccessException

  Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    @Deprecated
    <T> List<T> query(String sql,
                                 ParameterizedRowMapper<T> rm,
                                 SqlParameterSource args)
                  throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    <T> List<T> query(String sql,
                      RowMapper<T> rm,
                      Object... args)
                  throws DataAccessException

  Query for a `List` of `Objects` of type `T` using the supplied `RowMapper` to the query results to the object. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`RowMapper` to use for result mapping
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### query

    @Deprecated
    <T> List<T> query(String sql,
                                 ParameterizedRowMapper<T> rm,
                                 Object... args)
                  throws DataAccessException

  Deprecated. as of Spring 3.0: Use the method using the newly genericized RowMapper interface instead since the RowMapper and ParameterizedRowMapper interfaces are equivalent now.

  Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `rm` - the @`ParameterizedRowMapper` to use for result mapping
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForObject(String, org.springframework.jdbc.core.RowMapper)`, `JdbcOperations.queryForObject(String, Object[], org.springframework.jdbc.core.RowMapper)`

### queryForMap

    Map<String,Object> queryForMap(String sql,
                                   Map<String,?> args)
                                   throws DataAccessException

  Execute the supplied query with the supplied arguments.

  The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key). Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForMap(String)`, `JdbcOperations.queryForMap(String, Object[])`

### queryForMap

    Map<String,Object> queryForMap(String sql,
                                   SqlParameterSource args)
                                   throws DataAccessException

  Execute the supplied query with the supplied arguments.

  The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key). Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForMap(String)`, `JdbcOperations.queryForMap(String, Object[])`

### queryForMap

    Map<String,Object> queryForMap(String sql,
                                   Object... args)
                                   throws DataAccessException

  Execute the supplied query with the (optional) supplied arguments.

  The query is expected to be a single row query; the result row will be mapped to a Map (one entry for each column, using the column name as the key). Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForMap(String)`, `JdbcOperations.queryForMap(String, Object[])`

### queryForList

    List<Map<String,Object>> queryForList(String sql,
                                          Map<String,?> args)
                                          throws DataAccessException

  Execute the supplied query with the supplied arguments.

  Each element in the returned `List` is constructed as a `Map` as described in `queryForMap(java.lang.String, java.util.Map)` Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `args` - the map containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForList(String)`, `JdbcOperations.queryForList(String, Object[])`

### queryForList

    List<Map<String,Object>> queryForList(String sql,
                                          SqlParameterSource args)
                                          throws DataAccessException

  Execute the supplied query with the supplied arguments.

  Each element in the returned `List` is constructed as a `Map` as described in `queryForMap(java.lang.String, java.util.Map)` Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL query to run
    `args` - the `SqlParameterSource` containing the arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForList(String)`, `JdbcOperations.queryForList(String, Object[])`

### queryForList

    List<Map<String,Object>> queryForList(String sql,
                                          Object... args)
                                          throws DataAccessException

  Execute the supplied query with the (optional) supplied arguments.

  Each element in the returned `List` is constructed as a `Map` as described in `queryForMap(java.lang.String, java.util.Map)` Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL query to run
    `args` - the variable number of arguments for the query
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.queryForList(String)`, `JdbcOperations.queryForList(String, Object[])`

### update

    int update(String sql,
               Map<String,?> args)
               throws DataAccessException

  Execute the supplied SQL statement with (optional) supplied arguments. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL statement to execute
    `args` - the map containing the arguments for the query
  Returns:
    the numbers of rows affected by the update
  Throws:
    `DataAccessException`
  See Also:
    `NamedParameterJdbcOperations.update(String, Map)`

### update

    int update(String sql,
               SqlParameterSource args)
               throws DataAccessException

  Execute the supplied SQL statement with supplied arguments. Uses sql with the named parameter support provided by the `NamedParameterJdbcTemplate`

  Parameters:
    `sql` - the SQL statement to execute
    `args` - the `SqlParameterSource` containing the arguments for the statement
  Returns:
    the numbers of rows affected by the update
  Throws:
    `DataAccessException`
  See Also:
    `NamedParameterJdbcOperations.update(String, SqlParameterSource)`

### update

    int update(String sql,
               Object... args)
               throws DataAccessException

  Execute the supplied SQL statement with supplied arguments. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL statement to execute
    `args` - the variable number of arguments for the query
  Returns:
    the numbers of rows affected by the update
  Throws:
    `DataAccessException`
  See Also:
    `JdbcOperations.update(String)`, `JdbcOperations.update(String, Object[])`

### batchUpdate

    int[] batchUpdate(String sql,
                      Map<String,?>[] batchValues)

  Executes a batch using the supplied SQL statement with the batch of supplied arguments. Uses sql with the named parameter support.

  Parameters:
    `sql` - the SQL statement to execute
    `batchValues` - the array of Maps containing the batch of arguments for the query
  Returns:
    an array containing the numbers of rows affected by each update in the batch

### batchUpdate

    int[] batchUpdate(String sql,
                      SqlParameterSource[] batchArgs)

  Execute a batch using the supplied SQL statement with the batch of supplied arguments. Uses sql with the named parameter support.

  Parameters:
    `sql` - the SQL statement to execute
    `batchArgs` - the array of `SqlParameterSource` containing the batch of arguments for the query
  Returns:
    an array containing the numbers of rows affected by each update in the batch

### batchUpdate

    int[] batchUpdate(String sql,
                      List<Object[]> batchArgs)

  Execute a batch using the supplied SQL statement with the batch of supplied arguments. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL statement to execute
    `batchArgs` - the List of Object arrays containing the batch of arguments for the query
  Returns:
    an array containing the numbers of rows affected by each update in the batch

### batchUpdate

    int[] batchUpdate(String sql,
                      List<Object[]> batchArgs,
                      int[] argTypes)

  Execute a batch using the supplied SQL statement with the batch of supplied arguments. Uses sql with the standard '?' placeholders for parameters

  Parameters:
    `sql` - the SQL statement to execute.
    `batchArgs` - the List of Object arrays containing the batch of arguments for the query
    `argTypes` - SQL types of the arguments (constants from `java.sql.Types`)
  Returns:
    an array containing the numbers of rows affected by each update in the batch

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