public abstract class SqlQuery<T> extends SqlOperation
Subclasses must implement the newRowMapper(java.lang.Object[], java.util.Map<?, ?>) method to provide
an object that can extract the results of iterating over the
ResultSet created during the execution of the query.
This class provides a number of public execute methods that are
analogous to the different convenient JDO query execute methods. Subclasses
can either rely on one of these inherited methods, or can add their own
custom execution methods, with meaningful names and typed parameters
(definitely a best practice). Each custom query method will invoke one of
this class's untyped query methods.
Like all RdbmsOperation classes that ship with the Spring
Framework, SqlQuery instances are thread-safe after their
initialization is complete. That is, after they are constructed and configured
via their setter methods, they can be used safely from multiple threads.
SqlUpdatelogger| Constructor and Description |
|---|
SqlQuery()
Constructor to allow use as a JavaBean.
|
SqlQuery(DataSource ds,
String sql)
Convenient constructor with a
DataSource and SQL string. |
| Modifier and Type | Method and Description |
|---|---|
List<T> |
execute()
Convenient method to execute without parameters nor context.
|
List<T> |
execute(int p1)
Convenient method to execute with a single int parameter.
|
List<T> |
execute(int p1,
int p2)
Convenient method to execute with two int parameters.
|
List<T> |
execute(int p1,
int p2,
Map<?,?> context)
Convenient method to execute with two int parameters and context.
|
List<T> |
execute(int p1,
Map<?,?> context)
Convenient method to execute with a single int parameter and context.
|
List<T> |
execute(long p1)
Convenient method to execute with a single long parameter.
|
List<T> |
execute(long p1,
Map<?,?> context)
Convenient method to execute with a single long parameter and context.
|
List<T> |
execute(Map<?,?> context)
Convenient method to execute without parameters.
|
List<T> |
execute(Object... params)
Convenient method to execute without context.
|
List<T> |
execute(Object[] params,
Map<?,?> context)
Central execution method.
|
List<T> |
execute(String p1)
Convenient method to execute with a single String parameter.
|
List<T> |
execute(String p1,
Map<?,?> context)
Convenient method to execute with a single String parameter and context.
|
List<T> |
executeByNamedParam(Map<String,?> paramMap)
Convenient method to execute without context.
|
List<T> |
executeByNamedParam(Map<String,?> paramMap,
Map<?,?> context)
Central execution method.
|
T |
findObject(int p1)
Convenient method to find a single object given a single int parameter.
|
T |
findObject(int p1,
int p2)
Convenient method to find a single object given two int parameters.
|
T |
findObject(int p1,
int p2,
Map<?,?> context)
Convenient method to find a single object given two int parameters
and a context.
|
T |
findObject(int p1,
Map<?,?> context)
Convenient method to find a single object given a single int parameter
and a context.
|
T |
findObject(long p1)
Convenient method to find a single object given a single long parameter.
|
T |
findObject(long p1,
Map<?,?> context)
Convenient method to find a single object given a single long parameter
and a context.
|
T |
findObject(Object... params)
Convenient method to find a single object without context.
|
T |
findObject(Object[] params,
Map<?,?> context)
Generic object finder method, used by all other
findObject methods. |
T |
findObject(String p1)
Convenient method to find a single object given a single String parameter.
|
T |
findObject(String p1,
Map<?,?> context)
Convenient method to find a single object given a single String parameter
and a context.
|
T |
findObjectByNamedParam(Map<String,?> paramMap)
Convenient method to execute without context.
|
T |
findObjectByNamedParam(Map<String,?> paramMap,
Map<?,?> context)
Generic object finder method for named parameters.
|
int |
getRowsExpected()
Get the number of rows expected.
|
protected abstract RowMapper<T> |
newRowMapper(Object[] parameters,
Map<?,?> context)
Subclasses must implement this method to extract an object per row, to be
returned by the
List. |
void |
setRowsExpected(int rowsExpected)
Set the number of rows expected.
|
compileInternal, getParsedSql, newPreparedStatementCreator, newPreparedStatementCreator, newPreparedStatementSetter, onCompileInternalafterPropertiesSet, allowsUnusedParameters, checkCompiled, compile, declareParameter, getDeclaredParameters, getGeneratedKeysColumnNames, getJdbcTemplate, getResultSetType, getSql, isCompiled, isReturnGeneratedKeys, isUpdatableResults, resolveSql, setDataSource, setFetchSize, setGeneratedKeysColumnNames, setJdbcTemplate, setMaxRows, setParameters, setQueryTimeout, setResultSetType, setReturnGeneratedKeys, setSql, setTypes, setUpdatableResults, supportsLobParameters, validateNamedParameters, validateParameterspublic SqlQuery()
The DataSource and SQL must be supplied before
compilation and use.
public SqlQuery(DataSource ds, String sql)
DataSource and SQL string.ds - the DataSource to use to get connectionssql - the SQL to execute; SQL can also be supplied at runtime
by overriding the RdbmsOperation.getSql() method.public void setRowsExpected(int rowsExpected)
This can be used to ensure efficient storage of results. The default behavior is not to expect any specific number of rows.
public int getRowsExpected()
public List<T> execute(@Nullable Object[] params, @Nullable Map<?,?> context) throws DataAccessException
params - parameters, similar to JDO query parameters.
Primitive parameters must be represented by their Object wrapper type.
The ordering of parameters is significant.context - contextual information passed to the mapRow
callback method. The JDBC operation itself doesn't rely on this parameter,
but it can be useful for creating the objects of the result list.DataAccessExceptionpublic List<T> execute(Object... params) throws DataAccessException
params - parameters for the query. Primitive parameters must
be represented by their Object wrapper type. The ordering of parameters is
significant.DataAccessExceptionpublic List<T> execute(Map<?,?> context) throws DataAccessException
context - the contextual information for object creationDataAccessExceptionpublic List<T> execute() throws DataAccessException
DataAccessExceptionpublic List<T> execute(int p1, @Nullable Map<?,?> context) throws DataAccessException
p1 - single int parametercontext - the contextual information for object creationDataAccessExceptionpublic List<T> execute(int p1) throws DataAccessException
p1 - single int parameterDataAccessExceptionpublic List<T> execute(int p1, int p2, @Nullable Map<?,?> context) throws DataAccessException
p1 - first int parameterp2 - second int parametercontext - the contextual information for object creationDataAccessExceptionpublic List<T> execute(int p1, int p2) throws DataAccessException
p1 - first int parameterp2 - second int parameterDataAccessExceptionpublic List<T> execute(long p1, @Nullable Map<?,?> context) throws DataAccessException
p1 - single long parametercontext - the contextual information for object creationDataAccessExceptionpublic List<T> execute(long p1) throws DataAccessException
p1 - single long parameterDataAccessExceptionpublic List<T> execute(String p1, @Nullable Map<?,?> context) throws DataAccessException
p1 - single String parametercontext - the contextual information for object creationDataAccessExceptionpublic List<T> execute(String p1) throws DataAccessException
p1 - single String parameterDataAccessExceptionpublic List<T> executeByNamedParam(Map<String,?> paramMap, @Nullable Map<?,?> context) throws DataAccessException
paramMap - parameters associated with the name specified while declaring
the SqlParameters. Primitive parameters must be represented by their Object wrapper
type. The ordering of parameters is not significant since they are supplied in a
SqlParameterMap which is an implementation of the Map interface.context - contextual information passed to the mapRow
callback method. The JDBC operation itself doesn't rely on this parameter,
but it can be useful for creating the objects of the result list.DataAccessExceptionpublic List<T> executeByNamedParam(Map<String,?> paramMap) throws DataAccessException
paramMap - parameters associated with the name specified while declaring
the SqlParameters. Primitive parameters must be represented by their Object wrapper
type. The ordering of parameters is not significant.DataAccessException@Nullable public T findObject(@Nullable Object[] params, @Nullable Map<?,?> context) throws DataAccessException
findObject methods.
Object finder methods are like EJB entity bean finders, in that it is
considered an error if they return more than one result.null if not found. Subclasses may
choose to treat this as an error and throw an exception.DataAccessExceptionDataAccessUtils.singleResult(java.util.Collection<T>)@Nullable public T findObject(Object... params) throws DataAccessException
DataAccessException@Nullable public T findObject(int p1, @Nullable Map<?,?> context) throws DataAccessException
DataAccessException@Nullable public T findObject(int p1) throws DataAccessException
DataAccessException@Nullable public T findObject(int p1, int p2, @Nullable Map<?,?> context) throws DataAccessException
DataAccessException@Nullable public T findObject(int p1, int p2) throws DataAccessException
DataAccessException@Nullable public T findObject(long p1, @Nullable Map<?,?> context) throws DataAccessException
DataAccessException@Nullable public T findObject(long p1) throws DataAccessException
DataAccessException@Nullable public T findObject(String p1, @Nullable Map<?,?> context) throws DataAccessException
DataAccessException@Nullable public T findObject(String p1) throws DataAccessException
DataAccessException@Nullable public T findObjectByNamedParam(Map<String,?> paramMap, @Nullable Map<?,?> context) throws DataAccessException
paramMap - Map of parameter name to parameter object,
matching named parameters specified in the SQL statement.
Ordering is not significant.context - contextual information passed to the mapRow
callback method. The JDBC operation itself doesn't rely on this parameter,
but it can be useful for creating the objects of the result list.DataAccessException@Nullable public T findObjectByNamedParam(Map<String,?> paramMap) throws DataAccessException
paramMap - Map of parameter name to parameter object,
matching named parameters specified in the SQL statement.
Ordering is not significant.DataAccessExceptionprotected abstract RowMapper<T> newRowMapper(@Nullable Object[] parameters, @Nullable Map<?,?> context)
List.parameters - the parameters to the execute() method,
in case subclass is interested; may be null if there
were no parameters.context - contextual information passed to the mapRow
callback method. The JDBC operation itself doesn't rely on this parameter,
but it can be useful for creating the objects of the result list.execute(java.lang.Object[], java.util.Map<?, ?>)