It simplifies the use of JDBC and helps to avoid common errors.
It executes core JDBC workflow, leaving application code to provide SQL
and extract results. This class executes SQL queries or updates, initiating
iteration over ResultSets and catching JDBC exceptions and translating
them to the generic, more informative exception hierarchy defined in the
Code using this class need only implement callback interfaces, giving
them a clearly defined contract. The PreparedStatementCreator callback
interface creates a prepared statement given a Connection, providing SQL and
any necessary parameters. The ResultSetExtractor interface extracts
values from a ResultSet. See also PreparedStatementSetter and
RowMapper for two popular alternative callback interfaces.
Can be used within a service implementation via direct instantiation
with a DataSource reference, or get prepared in an application context
and given to services as bean reference. Note: The DataSource should
always be configured as a bean in the application context, in the first case
given to the service directly, in the second case to the prepared template.
All SQL operations performed by this class are logged at debug level,
using "org.springframework.jdbc.core.JdbcTemplate" as log category.
| Method from org.springframework.jdbc.core.JdbcTemplate Detail: |
|---|
 protected void applyStatementSettings(Statement stmt) throws SQLException {
int fetchSize = getFetchSize();
if (fetchSize > 0) {
stmt.setFetchSize(fetchSize);
}
int maxRows = getMaxRows();
if (maxRows > 0) {
stmt.setMaxRows(maxRows);
}
DataSourceUtils.applyTimeout(stmt, getDataSource(), getQueryTimeout());
}
Prepare the given JDBC Statement (or PreparedStatement or CallableStatement),
applying statement settings such as fetch size, max rows, and query timeout. |
public int[] batchUpdate(String[] sql) throws DataAccessException {
Assert.notEmpty(sql, "SQL array must not be empty");
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL batch update of " + sql.length + " statements");
}
class BatchUpdateStatementCallback implements StatementCallback, SqlProvider {
private String currSql;
public Object doInStatement(Statement stmt) throws SQLException, DataAccessException {
int[] rowsAffected = new int[sql.length];
if (JdbcUtils.supportsBatchUpdates(stmt.getConnection())) {
for (int i = 0; i < sql.length; i++) {
this.currSql = sql[i];
stmt.addBatch(sql[i]);
}
rowsAffected = stmt.executeBatch();
}
else {
for (int i = 0; i < sql.length; i++) {
this.currSql = sql[i];
if (!stmt.execute(sql[i])) {
rowsAffected[i] = stmt.getUpdateCount();
}
else {
throw new InvalidDataAccessApiUsageException("Invalid batch SQL statement: " + sql[i]);
}
}
}
return rowsAffected;
}
public String getSql() {
return currSql;
}
}
return (int[]) execute(new BatchUpdateStatementCallback());
} |
public int[] batchUpdate(String sql,
BatchPreparedStatementSetter pss) throws DataAccessException {
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL batch update [" + sql + "]");
}
return (int[]) execute(sql, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
try {
int batchSize = pss.getBatchSize();
InterruptibleBatchPreparedStatementSetter ipss =
(pss instanceof InterruptibleBatchPreparedStatementSetter ?
(InterruptibleBatchPreparedStatementSetter) pss : null);
if (JdbcUtils.supportsBatchUpdates(ps.getConnection())) {
for (int i = 0; i < batchSize; i++) {
pss.setValues(ps, i);
if (ipss != null && ipss.isBatchExhausted(i)) {
break;
}
ps.addBatch();
}
return ps.executeBatch();
}
else {
List rowsAffected = new ArrayList();
for (int i = 0; i < batchSize; i++) {
pss.setValues(ps, i);
if (ipss != null && ipss.isBatchExhausted(i)) {
break;
}
rowsAffected.add(new Integer(ps.executeUpdate()));
}
int[] rowsAffectedArray = new int[rowsAffected.size()];
for (int i = 0; i < rowsAffectedArray.length; i++) {
rowsAffectedArray[i] = ((Integer) rowsAffected.get(i)).intValue();
}
return rowsAffectedArray;
}
}
finally {
if (pss instanceof ParameterDisposer) {
((ParameterDisposer) pss).cleanupParameters();
}
}
}
});
} |
public Map call(CallableStatementCreator csc,
List declaredParameters) throws DataAccessException {
final List updateCountParameters = new ArrayList();
final List resultSetParameters = new ArrayList();
final List callParameters = new ArrayList();
for (int i = 0; i < declaredParameters.size(); i++) {
SqlParameter parameter = (SqlParameter) declaredParameters.get(i);
if (parameter.isResultsParameter()) {
if (parameter instanceof SqlReturnResultSet) {
resultSetParameters.add(parameter);
}
else {
updateCountParameters.add(parameter);
}
}
else {
callParameters.add(parameter);
}
}
return (Map) execute(csc, new CallableStatementCallback() {
public Object doInCallableStatement(CallableStatement cs) throws SQLException {
boolean retVal = cs.execute();
int updateCount = cs.getUpdateCount();
if (logger.isDebugEnabled()) {
logger.debug("CallableStatement.execute() returned '" + retVal + "'");
logger.debug("CallableStatement.getUpdateCount() returned " + updateCount);
}
Map returnedResults = createResultsMap();
if (retVal || updateCount != -1) {
returnedResults.putAll(extractReturnedResults(cs, updateCountParameters, resultSetParameters, updateCount));
}
returnedResults.putAll(extractOutputParameters(cs, callParameters));
return returnedResults;
}
});
} |
protected Connection createConnectionProxy(Connection con) {
return (Connection) Proxy.newProxyInstance(
ConnectionProxy.class.getClassLoader(),
new Class[] {ConnectionProxy.class},
new CloseSuppressingInvocationHandler(con));
} Create a close-suppressing proxy for the given JDBC Connection.
Called by the execute method.
The proxy also prepares returned JDBC Statements, applying
statement settings such as fetch size, max rows, and query timeout. |
protected Map createResultsMap() {
if (isResultsMapCaseInsensitive()) {
return CollectionFactory.createLinkedCaseInsensitiveMapIfPossible(10);
}
else {
return new LinkedHashMap();
}
} Create a Map instance to be used as results map.
If "isResultsMapCaseInsensitive" has been set to true, a linked case-insensitive Map
will be created if possible, else a plain HashMap (see Spring's CollectionFactory). |
public Object execute(ConnectionCallback action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Connection con = DataSourceUtils.getConnection(getDataSource());
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null) {
// Extract native JDBC Connection, castable to OracleConnection or the like.
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
else {
// Create close-suppressing Connection proxy, also preparing returned Statements.
conToUse = createConnectionProxy(con);
}
return action.doInConnection(conToUse);
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("ConnectionCallback", getSql(action), ex);
}
finally {
DataSourceUtils.releaseConnection(con, getDataSource());
}
} |
public Object execute(StatementCallback action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
stmt = conToUse.createStatement();
applyStatementSettings(stmt);
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
Object result = action.doInStatement(stmtToUse);
handleWarnings(stmt);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
JdbcUtils.closeStatement(stmt);
stmt = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
}
} |
public void execute(String sql) throws DataAccessException {
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL statement [" + sql + "]");
}
class ExecuteStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
stmt.execute(sql);
return null;
}
public String getSql() {
return sql;
}
}
execute(new ExecuteStatementCallback());
} |
public Object execute(PreparedStatementCreator psc,
PreparedStatementCallback action) throws DataAccessException {
Assert.notNull(psc, "PreparedStatementCreator must not be null");
Assert.notNull(action, "Callback object must not be null");
if (logger.isDebugEnabled()) {
String sql = getSql(psc);
logger.debug("Executing prepared SQL statement" + (sql != null ? " [" + sql + "]" : ""));
}
Connection con = DataSourceUtils.getConnection(getDataSource());
PreparedStatement ps = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativePreparedStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
ps = psc.createPreparedStatement(conToUse);
applyStatementSettings(ps);
PreparedStatement psToUse = ps;
if (this.nativeJdbcExtractor != null) {
psToUse = this.nativeJdbcExtractor.getNativePreparedStatement(ps);
}
Object result = action.doInPreparedStatement(psToUse);
handleWarnings(ps);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
if (psc instanceof ParameterDisposer) {
((ParameterDisposer) psc).cleanupParameters();
}
String sql = getSql(psc);
psc = null;
JdbcUtils.closeStatement(ps);
ps = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("PreparedStatementCallback", sql, ex);
}
finally {
if (psc instanceof ParameterDisposer) {
((ParameterDisposer) psc).cleanupParameters();
}
JdbcUtils.closeStatement(ps);
DataSourceUtils.releaseConnection(con, getDataSource());
}
} |
public Object execute(String sql,
PreparedStatementCallback action) throws DataAccessException {
return execute(new SimplePreparedStatementCreator(sql), action);
} |
public Object execute(CallableStatementCreator csc,
CallableStatementCallback action) throws DataAccessException {
Assert.notNull(csc, "CallableStatementCreator must not be null");
Assert.notNull(action, "Callback object must not be null");
if (logger.isDebugEnabled()) {
String sql = getSql(csc);
logger.debug("Calling stored procedure" + (sql != null ? " [" + sql + "]" : ""));
}
Connection con = DataSourceUtils.getConnection(getDataSource());
CallableStatement cs = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
cs = csc.createCallableStatement(conToUse);
applyStatementSettings(cs);
CallableStatement csToUse = cs;
if (this.nativeJdbcExtractor != null) {
csToUse = this.nativeJdbcExtractor.getNativeCallableStatement(cs);
}
Object result = action.doInCallableStatement(csToUse);
handleWarnings(cs);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
if (csc instanceof ParameterDisposer) {
((ParameterDisposer) csc).cleanupParameters();
}
String sql = getSql(csc);
csc = null;
JdbcUtils.closeStatement(cs);
cs = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("CallableStatementCallback", sql, ex);
}
finally {
if (csc instanceof ParameterDisposer) {
((ParameterDisposer) csc).cleanupParameters();
}
JdbcUtils.closeStatement(cs);
DataSourceUtils.releaseConnection(con, getDataSource());
}
} |
public Object execute(String callString,
CallableStatementCallback action) throws DataAccessException {
return execute(new SimpleCallableStatementCreator(callString), action);
} |
protected Map extractOutputParameters(CallableStatement cs,
List parameters) throws SQLException {
Map returnedResults = new HashMap();
int sqlColIndex = 1;
for (int i = 0; i < parameters.size(); i++) {
SqlParameter param = (SqlParameter) parameters.get(i);
if (param instanceof SqlOutParameter) {
SqlOutParameter outParam = (SqlOutParameter) param;
if (outParam.isReturnTypeSupported()) {
Object out = outParam.getSqlReturnType().getTypeValue(
cs, sqlColIndex, outParam.getSqlType(), outParam.getTypeName());
returnedResults.put(outParam.getName(), out);
}
else {
Object out = cs.getObject(sqlColIndex);
if (out instanceof ResultSet) {
if (outParam.isResultSetSupported()) {
returnedResults.putAll(processResultSet((ResultSet) out, outParam));
}
else {
String rsName = outParam.getName();
SqlReturnResultSet rsParam = new SqlReturnResultSet(rsName, new ColumnMapRowMapper());
returnedResults.putAll(processResultSet(cs.getResultSet(), rsParam));
logger.info("Added default SqlReturnResultSet parameter named " + rsName);
}
}
else {
returnedResults.put(outParam.getName(), out);
}
}
}
if (!(param.isResultsParameter())) {
sqlColIndex++;
}
}
return returnedResults;
} Extract output parameters from the completed stored procedure. |
protected Map extractReturnedResults(CallableStatement cs,
List updateCountParameters,
List resultSetParameters,
int updateCount) throws SQLException {
Map returnedResults = new HashMap();
int rsIndex = 0;
int updateIndex = 0;
boolean moreResults;
if (!skipResultsProcessing) {
do {
if (updateCount == -1) {
if (resultSetParameters != null && resultSetParameters.size() > rsIndex) {
SqlReturnResultSet declaredRsParam = (SqlReturnResultSet)resultSetParameters.get(rsIndex);
returnedResults.putAll(processResultSet(cs.getResultSet(), declaredRsParam));
rsIndex++;
}
else {
if (!skipUndeclaredResults) {
String rsName = RETURN_RESULT_SET_PREFIX + (rsIndex + 1);
SqlReturnResultSet undeclaredRsParam = new SqlReturnResultSet(rsName, new ColumnMapRowMapper());
logger.info("Added default SqlReturnResultSet parameter named " + rsName);
returnedResults.putAll(processResultSet(cs.getResultSet(), undeclaredRsParam));
rsIndex++;
}
}
}
else {
if (updateCountParameters != null && updateCountParameters.size() > updateIndex) {
SqlReturnUpdateCount ucParam = (SqlReturnUpdateCount)updateCountParameters.get(updateIndex);
String declaredUcName = ucParam.getName();
returnedResults.put(declaredUcName, new Integer(updateCount));
updateIndex++;
}
else {
if (!skipUndeclaredResults) {
String undeclaredUcName = RETURN_UPDATE_COUNT_PREFIX + (updateIndex + 1);
logger.info("Added default SqlReturnUpdateCount parameter named " + undeclaredUcName);
returnedResults.put(undeclaredUcName, new Integer(updateCount));
updateIndex++;
}
}
}
moreResults = cs.getMoreResults();
updateCount = cs.getUpdateCount();
if (logger.isDebugEnabled()) {
logger.debug("CallableStatement.getUpdateCount() returned " + updateCount);
}
}
while (moreResults || updateCount != -1);
}
return returnedResults;
} Extract returned ResultSets from the completed stored procedure. |
protected RowMapper getColumnMapRowMapper() {
return new ColumnMapRowMapper();
} Create a new RowMapper for reading columns as key-value pairs. |
public int getFetchSize() {
return this.fetchSize;
} Return the fetch size specified for this JdbcTemplate. |
public int getMaxRows() {
return this.maxRows;
} Return the maximum number of rows specified for this JdbcTemplate. |
public NativeJdbcExtractor getNativeJdbcExtractor() {
return this.nativeJdbcExtractor;
} Return the current NativeJdbcExtractor implementation. |
public int getQueryTimeout() {
return this.queryTimeout;
} Return the query timeout for statements that this JdbcTemplate executes. |
protected RowMapper getSingleColumnRowMapper(Class requiredType) {
return new SingleColumnRowMapper(requiredType);
} Create a new RowMapper for reading result objects from a single column. |
protected void handleWarnings(Statement stmt) throws SQLException {
if (isIgnoreWarnings()) {
if (logger.isDebugEnabled()) {
SQLWarning warningToLog = stmt.getWarnings();
while (warningToLog != null) {
logger.debug("SQLWarning ignored: SQL state '" + warningToLog.getSQLState() + "', error code '" +
warningToLog.getErrorCode() + "', message [" + warningToLog.getMessage() + "]");
warningToLog = warningToLog.getNextWarning();
}
}
}
else {
handleWarnings(stmt.getWarnings());
}
} Throw an SQLWarningException if we're not ignoring warnings,
else log the warnings (at debug level). |
protected void handleWarnings(SQLWarning warning) throws SQLWarningException {
if (warning != null) {
throw new SQLWarningException("Warning not ignored", warning);
}
} Throw an SQLWarningException if encountering an actual warning. |
public boolean isIgnoreWarnings() {
return this.ignoreWarnings;
} Return whether or not we ignore SQLWarnings. |
public boolean isResultsMapCaseInsensitive() {
return this.resultsMapCaseInsensitive;
} Return whether execution of a CallableStatement will return the results in a Map
that uses case insensitive names for the parameters. |
public boolean isSkipResultsProcessing() {
return this.skipResultsProcessing;
} Return whether results processing should be skipped. |
public boolean isSkipUndeclaredResults() {
return this.skipUndeclaredResults;
} Return whether undeclared results should be skipped. |
protected Map processResultSet(ResultSet rs,
ResultSetSupportingSqlParameter param) throws SQLException {
if (rs == null) {
return Collections.EMPTY_MAP;
}
Map returnedResults = new HashMap();
try {
ResultSet rsToUse = rs;
if (this.nativeJdbcExtractor != null) {
rsToUse = this.nativeJdbcExtractor.getNativeResultSet(rs);
}
if (param.getRowMapper() != null) {
RowMapper rowMapper = param.getRowMapper();
Object result = (new RowMapperResultSetExtractor(rowMapper)).extractData(rsToUse);
returnedResults.put(param.getName(), result);
}
else if (param.getRowCallbackHandler() != null) {
RowCallbackHandler rch = param.getRowCallbackHandler();
(new RowCallbackHandlerResultSetExtractor(rch)).extractData(rsToUse);
returnedResults.put(param.getName(), "ResultSet returned from stored procedure was processed");
}
else if (param.getResultSetExtractor() != null) {
Object result = param.getResultSetExtractor().extractData(rsToUse);
returnedResults.put(param.getName(), result);
}
}
finally {
JdbcUtils.closeResultSet(rs);
}
return returnedResults;
} Process the given ResultSet from a stored procedure. |
public Object query(String sql,
ResultSetExtractor rse) throws DataAccessException {
Assert.notNull(sql, "SQL must not be null");
Assert.notNull(rse, "ResultSetExtractor must not be null");
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL query [" + sql + "]");
}
class QueryStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
ResultSet rs = null;
try {
rs = stmt.executeQuery(sql);
ResultSet rsToUse = rs;
if (nativeJdbcExtractor != null) {
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
}
return rse.extractData(rsToUse);
}
finally {
JdbcUtils.closeResultSet(rs);
}
}
public String getSql() {
return sql;
}
}
return execute(new QueryStatementCallback());
} |
public void query(String sql,
RowCallbackHandler rch) throws DataAccessException {
query(sql, new RowCallbackHandlerResultSetExtractor(rch));
} |
public List query(String sql,
RowMapper rowMapper) throws DataAccessException {
return (List) query(sql, new RowMapperResultSetExtractor(rowMapper));
} |
public Object query(PreparedStatementCreator psc,
ResultSetExtractor rse) throws DataAccessException {
return query(psc, null, rse);
} |
public void query(PreparedStatementCreator psc,
RowCallbackHandler rch) throws DataAccessException {
query(psc, new RowCallbackHandlerResultSetExtractor(rch));
} |
public List query(PreparedStatementCreator psc,
RowMapper rowMapper) throws DataAccessException {
return (List) query(psc, new RowMapperResultSetExtractor(rowMapper));
} |
public Object query(PreparedStatementCreator psc,
PreparedStatementSetter pss,
ResultSetExtractor rse) throws DataAccessException {
Assert.notNull(rse, "ResultSetExtractor must not be null");
logger.debug("Executing prepared SQL query");
return execute(psc, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
ResultSet rs = null;
try {
if (pss != null) {
pss.setValues(ps);
}
rs = ps.executeQuery();
ResultSet rsToUse = rs;
if (nativeJdbcExtractor != null) {
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
}
return rse.extractData(rsToUse);
}
finally {
JdbcUtils.closeResultSet(rs);
if (pss instanceof ParameterDisposer) {
((ParameterDisposer) pss).cleanupParameters();
}
}
}
});
} Query using a prepared statement, allowing for a PreparedStatementCreator
and a PreparedStatementSetter. Most other query methods use this method,
but application code will always work with either a creator or a setter. |
public Object query(String sql,
PreparedStatementSetter pss,
ResultSetExtractor rse) throws DataAccessException {
return query(new SimplePreparedStatementCreator(sql), pss, rse);
} |
public Object query(String sql,
Object[] args,
ResultSetExtractor rse) throws DataAccessException {
return query(sql, new ArgPreparedStatementSetter(args), rse);
} |
public void query(String sql,
PreparedStatementSetter pss,
RowCallbackHandler rch) throws DataAccessException {
query(sql, pss, new RowCallbackHandlerResultSetExtractor(rch));
} |
public void query(String sql,
Object[] args,
RowCallbackHandler rch) throws DataAccessException {
query(sql, new ArgPreparedStatementSetter(args), rch);
} |
public List query(String sql,
PreparedStatementSetter pss,
RowMapper rowMapper) throws DataAccessException {
return (List) query(sql, pss, new RowMapperResultSetExtractor(rowMapper));
} |
public List query(String sql,
Object[] args,
RowMapper rowMapper) throws DataAccessException {
return (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper));
} |
public Object query(String sql,
Object[] args,
int[] argTypes,
ResultSetExtractor rse) throws DataAccessException {
return query(sql, new ArgTypePreparedStatementSetter(args, argTypes), rse);
} |
public void query(String sql,
Object[] args,
int[] argTypes,
RowCallbackHandler rch) throws DataAccessException {
query(sql, new ArgTypePreparedStatementSetter(args, argTypes), rch);
} |
public List query(String sql,
Object[] args,
int[] argTypes,
RowMapper rowMapper) throws DataAccessException {
return (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper));
} |
public int queryForInt(String sql) throws DataAccessException {
Number number = (Number) queryForObject(sql, Integer.class);
return (number != null ? number.intValue() : 0);
} |
public int queryForInt(String sql,
Object[] args) throws DataAccessException {
Number number = (Number) queryForObject(sql, args, Integer.class);
return (number != null ? number.intValue() : 0);
} |
public int queryForInt(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
Number number = (Number) queryForObject(sql, args, argTypes, Integer.class);
return (number != null ? number.intValue() : 0);
} |
public List queryForList(String sql) throws DataAccessException {
return query(sql, getColumnMapRowMapper());
} |
public List queryForList(String sql,
Class elementType) throws DataAccessException {
return query(sql, getSingleColumnRowMapper(elementType));
} |
public List queryForList(String sql,
Object[] args) throws DataAccessException {
return query(sql, args, getColumnMapRowMapper());
} |
public List queryForList(String sql,
Object[] args,
Class elementType) throws DataAccessException {
return query(sql, args, getSingleColumnRowMapper(elementType));
} |
public List queryForList(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
return query(sql, args, argTypes, getColumnMapRowMapper());
} |
public List queryForList(String sql,
Object[] args,
int[] argTypes,
Class elementType) throws DataAccessException {
return query(sql, args, argTypes, getSingleColumnRowMapper(elementType));
} |
public long queryForLong(String sql) throws DataAccessException {
Number number = (Number) queryForObject(sql, Long.class);
return (number != null ? number.longValue() : 0);
} |
public long queryForLong(String sql,
Object[] args) throws DataAccessException {
Number number = (Number) queryForObject(sql, args, Long.class);
return (number != null ? number.longValue() : 0);
} |
public long queryForLong(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
Number number = (Number) queryForObject(sql, args, argTypes, Long.class);
return (number != null ? number.longValue() : 0);
} |
public Map queryForMap(String sql) throws DataAccessException {
return (Map) queryForObject(sql, getColumnMapRowMapper());
} |
public Map queryForMap(String sql,
Object[] args) throws DataAccessException {
return (Map) queryForObject(sql, args, getColumnMapRowMapper());
} |
public Map queryForMap(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
return (Map) queryForObject(sql, args, argTypes, getColumnMapRowMapper());
} |
public Object queryForObject(String sql,
RowMapper rowMapper) throws DataAccessException {
List results = query(sql, rowMapper);
return DataAccessUtils.requiredSingleResult(results);
} |
public Object queryForObject(String sql,
Class requiredType) throws DataAccessException {
return queryForObject(sql, getSingleColumnRowMapper(requiredType));
} |
public Object queryForObject(String sql,
Object[] args,
RowMapper rowMapper) throws DataAccessException {
List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));
return DataAccessUtils.requiredSingleResult(results);
} |
public Object queryForObject(String sql,
Object[] args,
Class requiredType) throws DataAccessException {
return queryForObject(sql, args, getSingleColumnRowMapper(requiredType));
} |
public Object queryForObject(String sql,
Object[] args,
int[] argTypes,
RowMapper rowMapper) throws DataAccessException {
List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));
return DataAccessUtils.requiredSingleResult(results);
} |
public Object queryForObject(String sql,
Object[] args,
int[] argTypes,
Class requiredType) throws DataAccessException {
return queryForObject(sql, args, argTypes, getSingleColumnRowMapper(requiredType));
} |
public SqlRowSet queryForRowSet(String sql) throws DataAccessException {
return (SqlRowSet) query(sql, new SqlRowSetResultSetExtractor());
} |
public SqlRowSet queryForRowSet(String sql,
Object[] args) throws DataAccessException {
return (SqlRowSet) query(sql, args, new SqlRowSetResultSetExtractor());
} |
public SqlRowSet queryForRowSet(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
return (SqlRowSet) query(sql, args, argTypes, new SqlRowSetResultSetExtractor());
} |
public void setFetchSize(int fetchSize) {
this.fetchSize = fetchSize;
} Set the fetch size for this JdbcTemplate. This is important for processing
large result sets: Setting this higher than the default value will increase
processing speed at the cost of memory consumption; setting this lower can
avoid transferring row data that will never be read by the application.
Default is 0, indicating to use the JDBC driver's default. |
public void setIgnoreWarnings(boolean ignoreWarnings) {
this.ignoreWarnings = ignoreWarnings;
} Set whether or not we want to ignore SQLWarnings.
Default is "true", swallowing and logging all warnings. Switch this flag
to "false" to make the JdbcTemplate throw a SQLWarningException instead. |
public void setMaxRows(int maxRows) {
this.maxRows = maxRows;
} Set the maximum number of rows for this JdbcTemplate. This is important
for processing subsets of large result sets, avoiding to read and hold
the entire result set in the database or in the JDBC driver if we're
never interested in the entire result in the first place (for example,
when performing searches that might return a large number of matches).
Default is 0, indicating to use the JDBC driver's default. |
public void setNativeJdbcExtractor(NativeJdbcExtractor extractor) {
this.nativeJdbcExtractor = extractor;
} Set a NativeJdbcExtractor to extract native JDBC objects from wrapped handles.
Useful if native Statement and/or ResultSet handles are expected for casting
to database-specific implementation classes, but a connection pool that wraps
JDBC objects is used (note: any pool will return wrapped Connections). |
public void setQueryTimeout(int queryTimeout) {
this.queryTimeout = queryTimeout;
} Set the query timeout for statements that this JdbcTemplate executes.
Default is 0, indicating to use the JDBC driver's default.
Note: Any timeout specified here will be overridden by the remaining
transaction timeout when executing within a transaction that has a
timeout specified at the transaction level. |
public void setResultsMapCaseInsensitive(boolean resultsMapCaseInsensitive) {
this.resultsMapCaseInsensitive = resultsMapCaseInsensitive;
} Set whether execution of a CallableStatement will return the results in a Map
that uses case insensitive names for the parameters. |
public void setSkipResultsProcessing(boolean skipResultsProcessing) {
this.skipResultsProcessing = skipResultsProcessing;
} Set whether results processing should be skipped. Can be used to optimize callable
statement processing when we know that no results are being passed back - the processing
of out parameter will still take place. This can be used to avoid a bug in some older
Oracle JDBC drivers like 10.1.0.2. |
public void setSkipUndeclaredResults(boolean skipUndeclaredResults) {
this.skipUndeclaredResults = skipUndeclaredResults;
} Set whether undelared results should be skipped. |
public int update(String sql) throws DataAccessException {
Assert.notNull(sql, "SQL must not be null");
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL update [" + sql + "]");
}
class UpdateStatementCallback implements StatementCallback, SqlProvider {
public Object doInStatement(Statement stmt) throws SQLException {
int rows = stmt.executeUpdate(sql);
if (logger.isDebugEnabled()) {
logger.debug("SQL update affected " + rows + " rows");
}
return new Integer(rows);
}
public String getSql() {
return sql;
}
}
return ((Integer) execute(new UpdateStatementCallback())).intValue();
} |
public int update(PreparedStatementCreator psc) throws DataAccessException {
return update(psc, (PreparedStatementSetter) null);
} |
protected int update(PreparedStatementCreator psc,
PreparedStatementSetter pss) throws DataAccessException {
logger.debug("Executing prepared SQL update");
Integer result = (Integer) execute(psc, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
try {
if (pss != null) {
pss.setValues(ps);
}
int rows = ps.executeUpdate();
if (logger.isDebugEnabled()) {
logger.debug("SQL update affected " + rows + " rows");
}
return new Integer(rows);
}
finally {
if (pss instanceof ParameterDisposer) {
((ParameterDisposer) pss).cleanupParameters();
}
}
}
});
return result.intValue();
} |
public int update(PreparedStatementCreator psc,
KeyHolder generatedKeyHolder) throws DataAccessException {
Assert.notNull(generatedKeyHolder, "KeyHolder must not be null");
logger.debug("Executing SQL update and returning generated keys");
Integer result = (Integer) execute(psc, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
int rows = ps.executeUpdate();
List generatedKeys = generatedKeyHolder.getKeyList();
generatedKeys.clear();
ResultSet keys = ps.getGeneratedKeys();
if (keys != null) {
try {
RowMapper rowMapper = getColumnMapRowMapper();
RowMapperResultSetExtractor rse = new RowMapperResultSetExtractor(rowMapper, 1);
generatedKeys.addAll((List) rse.extractData(keys));
}
finally {
JdbcUtils.closeResultSet(keys);
}
}
if (logger.isDebugEnabled()) {
logger.debug("SQL update affected " + rows + " rows and returned " + generatedKeys.size() + " keys");
}
return new Integer(rows);
}
});
return result.intValue();
} |
public int update(String sql,
PreparedStatementSetter pss) throws DataAccessException {
return update(new SimplePreparedStatementCreator(sql), pss);
} |
public int update(String sql,
Object[] args) throws DataAccessException {
return update(sql, new ArgPreparedStatementSetter(args));
} |
public int update(String sql,
Object[] args,
int[] argTypes) throws DataAccessException {
return update(sql, new ArgTypePreparedStatementSetter(args, argTypes));
} |
org.springframework.jdbc.support.JdbcAccessor
Save This Page