T
- the result typepublic 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.
SqlUpdate
logger
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
execute method as an aggregated List . |
void |
setRowsExpected(int rowsExpected)
Set the number of rows expected.
|
compileInternal, getParsedSql, newPreparedStatementCreator, newPreparedStatementCreator, newPreparedStatementSetter, onCompileInternal
afterPropertiesSet, 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, validateParameters
public 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
- the 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
public 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.DataAccessException
public List<T> execute(Map<?,?> context) throws DataAccessException
context
- the contextual information for object creationDataAccessException
public List<T> execute() throws DataAccessException
DataAccessException
public List<T> execute(int p1, @Nullable Map<?,?> context) throws DataAccessException
p1
- single int parametercontext
- the contextual information for object creationDataAccessException
public List<T> execute(int p1) throws DataAccessException
p1
- single int parameterDataAccessException
public List<T> execute(int p1, int p2, @Nullable Map<?,?> context) throws DataAccessException
p1
- first int parameterp2
- second int parametercontext
- the contextual information for object creationDataAccessException
public List<T> execute(int p1, int p2) throws DataAccessException
p1
- first int parameterp2
- second int parameterDataAccessException
public List<T> execute(long p1, @Nullable Map<?,?> context) throws DataAccessException
p1
- single long parametercontext
- the contextual information for object creationDataAccessException
public List<T> execute(long p1) throws DataAccessException
p1
- single long parameterDataAccessException
public List<T> execute(String p1, @Nullable Map<?,?> context) throws DataAccessException
p1
- single String parametercontext
- the contextual information for object creationDataAccessException
public List<T> execute(String p1) throws DataAccessException
p1
- single String parameterDataAccessException
public 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
- the 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
public 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.DataAccessException
DataAccessUtils.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
- a Map of parameter name to parameter object,
matching named parameters specified in the SQL statement.
Ordering is not significant.context
- the 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
- a Map of parameter name to parameter object,
matching named parameters specified in the SQL statement.
Ordering is not significant.DataAccessException
protected abstract RowMapper<T> newRowMapper(@Nullable Object[] parameters, @Nullable Map<?,?> context)
execute
method as an aggregated List
.parameters
- the parameters to the execute()
method,
in case subclass is interested; may be null
if there
were no parameters.context
- the 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<?, ?>)