root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Consistent Map<String, ?> declarations and use of LinkedHashMap for incoming JDBC operation parameters 

Issue: SPR-12462
This commit is contained in:
Juergen Hoeller 2014-11-24 13:59:09 +01:00
parent 223d849a14
commit 2b4004d176
9 changed files with 204 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2011 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -65,11 +65,8 @@ public class CallMetaDataContext {
/** List of SqlParameter objects to be used in call execution */
private List<SqlParameter> callParameters = new ArrayList<SqlParameter>();
/** Default name to use for the return value in the output map */
private String defaultFunctionReturnName = "return";
/** Actual name to use for the return value in the output map */
private String actualFunctionReturnName = null;
private String actualFunctionReturnName;
/** Set of in parameter names to exclude use for any not listed */
private Set<String> limitedInParameterNames = new HashSet<String>();
@ -77,16 +74,16 @@ public class CallMetaDataContext {
/** List of SqlParameter names for out parameters */
private List<String> outParameterNames = new ArrayList<String>();
/** should we access call parameter meta data info or not */
/** Indicates whether this is a procedure or a function **/
private boolean function = false;
/** Indicates whether this procedure's return value should be included **/
private boolean returnValueRequired = false;
/** Should we access call parameter meta data info or not */
private boolean accessCallParameterMetaData = true;
/** indicates whether this is a procedure or a function **/
private boolean function;
/** indicates whether this procedure's return value should be included **/
private boolean returnValueRequired;
/** the provider of call meta data */
/** The provider of call meta data */
private CallMetaDataProvider metaDataProvider;
@ -101,7 +98,7 @@ public class CallMetaDataContext {
* Get the name used for the return value of the function.
*/
public String getFunctionReturnName() {
return this.actualFunctionReturnName != null ? this.actualFunctionReturnName : this.defaultFunctionReturnName;
return (this.actualFunctionReturnName != null ? this.actualFunctionReturnName : "return");
}
/**
@ -571,15 +568,15 @@ public class CallMetaDataContext {
// and the catalog name since the cataog is used for the package name
if (this.metaDataProvider.isSupportsSchemasInProcedureCalls() &&
!this.metaDataProvider.isSupportsCatalogsInProcedureCalls()) {
schemaNameToUse = this.metaDataProvider.catalogNameToUse(this.getCatalogName());
catalogNameToUse = this.metaDataProvider.schemaNameToUse(this.getSchemaName());
schemaNameToUse = this.metaDataProvider.catalogNameToUse(getCatalogName());
catalogNameToUse = this.metaDataProvider.schemaNameToUse(getSchemaName());
}
else {
catalogNameToUse = this.metaDataProvider.catalogNameToUse(this.getCatalogName());
schemaNameToUse = this.metaDataProvider.schemaNameToUse(this.getSchemaName());
catalogNameToUse = this.metaDataProvider.catalogNameToUse(getCatalogName());
schemaNameToUse = this.metaDataProvider.schemaNameToUse(getSchemaName());
}
String procedureNameToUse = this.metaDataProvider.procedureNameToUse(this.getProcedureName());
if (this.isFunction() || this.isReturnValueRequired()) {
String procedureNameToUse = this.metaDataProvider.procedureNameToUse(getProcedureName());
if (isFunction() || isReturnValueRequired()) {
callString = "{? = call " +
(StringUtils.hasLength(catalogNameToUse) ? catalogNameToUse + "." : "") +
(StringUtils.hasLength(schemaNameToUse) ? schemaNameToUse + "." : "") +

16
spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java
View File

@ -17,8 +17,8 @@
package org.springframework.jdbc.core.metadata;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@ -39,6 +39,7 @@ import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
* and execution of operations on a database table.
*
* @author Thomas Risberg
* @author Juergen Hoeller
* @since 2.5
*/
public class TableMetaDataContext {
@ -217,7 +218,7 @@ public class TableMetaDataContext {
if (declaredColumns.size() > 0) {
return new ArrayList<String>(declaredColumns);
}
Set<String> keys = new HashSet<String>(generatedKeyNames.length);
Set<String> keys = new LinkedHashSet<String>(generatedKeyNames.length);
for (String key : generatedKeyNames) {
keys.add(key.toUpperCase());
}
@ -274,9 +275,9 @@ public class TableMetaDataContext {
* Match the provided column names and values with the list of columns used.
* @param inParameters the parameter names and values
*/
public List<Object> matchInParameterValuesWithInsertColumns(Map<String, Object> inParameters) {
public List<Object> matchInParameterValuesWithInsertColumns(Map<String, ?> inParameters) {
List<Object> values = new ArrayList<Object>();
Map<String, Object> source = new HashMap<String, Object>();
Map<String, Object> source = new LinkedHashMap<String, Object>(inParameters.size());
for (String key : inParameters.keySet()) {
source.put(key.toLowerCase(), inParameters.get(key));
}
@ -292,7 +293,7 @@ public class TableMetaDataContext {
* @return the insert string to be used
*/
public String createInsertString(String... generatedKeyNames) {
HashSet<String> keys = new HashSet<String>(generatedKeyNames.length);
Set<String> keys = new LinkedHashSet<String>(generatedKeyNames.length);
for (String key : generatedKeyNames) {
keys.add(key.toUpperCase());
}
@ -342,7 +343,8 @@ public class TableMetaDataContext {
public int[] createInsertTypes() {
int[] types = new int[this.getTableColumns().size()];
List<TableParameterMetaData> parameters = this.metaDataProvider.getTableParameterMetaData();
Map<String, TableParameterMetaData> parameterMap = new HashMap<String, TableParameterMetaData>(parameters.size());
Map<String, TableParameterMetaData> parameterMap =
new LinkedHashMap<String, TableParameterMetaData>(parameters.size());
for (TableParameterMetaData tpmd : parameters) {
parameterMap.put(tpmd.getParameterName().toUpperCase(), tpmd);
}

10
spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/MapSqlParameterSource.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,7 +17,7 @@
package org.springframework.jdbc.core.namedparam;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.jdbc.core.SqlParameterValue;
@ -29,8 +29,8 @@ import org.springframework.util.Assert;
* <p>This class is intended for passing in a simple Map of parameter values
* to the methods of the {@link NamedParameterJdbcTemplate} class.
*
* <p>The {@code addValue} methods on this class will make adding several
* values easier. The methods return a reference to the {@link MapSqlParameterSource}
* <p>The {@code addValue} methods on this class will make adding several values
* easier. The methods return a reference to the {@link MapSqlParameterSource}
* itself, so you can chain several method calls together within a single statement.
*
* @author Thomas Risberg
@ -43,7 +43,7 @@ import org.springframework.util.Assert;
*/
public class MapSqlParameterSource extends AbstractSqlParameterSource {
private final Map<String, Object> values = new HashMap<String, Object>();
private final Map<String, Object> values = new LinkedHashMap<String, Object>();
/**

57
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java
View File

@ -43,6 +43,7 @@ import org.springframework.util.StringUtils;
* This class provides the base SPI for {@link SimpleJdbcCall}.
*
* @author Thomas Risberg
* @author Juergen Hoeller
* @since 2.5
*/
public abstract class AbstractJdbcCall {
@ -63,9 +64,8 @@ public abstract class AbstractJdbcCall {
private final Map<String, RowMapper<?>> declaredRowMappers = new LinkedHashMap<String, RowMapper<?>>();
/**
* Has this operation been compiled? Compilation means at
* least checking that a DataSource and sql have been provided,
* but subclasses may also implement their own custom validation.
* Has this operation been compiled? Compilation means at least checking
* that a DataSource or JdbcTemplate has been provided.
*/
private boolean compiled = false;
@ -73,7 +73,7 @@ public abstract class AbstractJdbcCall {
private String callString;
/**
* Object enabling us to create CallableStatementCreators
* A delegate enabling us to create CallableStatementCreators
* efficiently, based on this class's declared parameters.
*/
private CallableStatementCreatorFactory callableStatementFactory;
@ -92,6 +92,7 @@ public abstract class AbstractJdbcCall {
* @param jdbcTemplate the JdbcTemplate to use
*/
protected AbstractJdbcCall(JdbcTemplate jdbcTemplate) {
Assert.notNull(jdbcTemplate, "JdbcTemplate must not be null");
this.jdbcTemplate = jdbcTemplate;
}
@ -161,6 +162,7 @@ public abstract class AbstractJdbcCall {
/**
* Specify whether this call is a function call.
* The default is {@code false}.
*/
public void setFunction(boolean function) {
this.callMetaDataContext.setFunction(function);
@ -174,7 +176,8 @@ public abstract class AbstractJdbcCall {
}
/**
* Specify whether the call requires a rerurn value.
* Specify whether the call requires a return value.
* The default is {@code false}.
*/
public void setReturnValueRequired(boolean returnValueRequired) {
this.callMetaDataContext.setReturnValueRequired(returnValueRequired);
@ -188,7 +191,8 @@ public abstract class AbstractJdbcCall {
}
/**
* Specify whether the parameter metadata for the call should be used. The default is true.
* Specify whether the parameter metadata for the call should be used.
* The default is {@code true}.
*/
public void setAccessCallParameterMetaData(boolean accessCallParameterMetaData) {
this.callMetaDataContext.setAccessCallParameterMetaData(accessCallParameterMetaData);
@ -211,10 +215,10 @@ public abstract class AbstractJdbcCall {
/**
* Add a declared parameter to the list of parameters for the call.
* Only parameters declared as {@code SqlParameter} and {@code SqlInOutParameter}
* will be used to provide input values. This is different from the {@code StoredProcedure} class
* which for backwards compatibility reasons allows input values to be provided for parameters declared
* as {@code SqlOutParameter}.
* <p>Only parameters declared as {@code SqlParameter} and {@code SqlInOutParameter} will
* be used to provide input values. This is different from the {@code StoredProcedure}
* class which - for backwards compatibility reasons - allows input values to be provided
* for parameters declared as {@code SqlOutParameter}.
* @param parameter the {@link SqlParameter} to add
*/
public void addDeclaredParameter(SqlParameter parameter) {
@ -247,9 +251,9 @@ public abstract class AbstractJdbcCall {
//-------------------------------------------------------------------------
/**
* Compile this JdbcCall using provided parameters and meta data plus other settings. This
* finalizes the configuration for this object and subsequent attempts to compile are ignored.
* This will be implicitly called the first time an un-compiled call is executed.
* Compile this JdbcCall using provided parameters and meta data plus other settings.
* <p>This finalizes the configuration for this object and subsequent attempts to compile are
* ignored. This will be implicitly called the first time an un-compiled call is executed.
* @throws org.springframework.dao.InvalidDataAccessApiUsageException if the object hasn't
* been correctly initialized, for example if no DataSource has been provided
*/
@ -267,19 +271,21 @@ public abstract class AbstractJdbcCall {
compileInternal();
this.compiled = true;
if (logger.isDebugEnabled()) {
logger.debug("SqlCall for " + (isFunction() ? "function" : "procedure") + " [" + getProcedureName() + "] compiled");
logger.debug("SqlCall for " + (isFunction() ? "function" : "procedure") +
" [" + getProcedureName() + "] compiled");
}
}
}
/**
* Method to perform the actual compilation. Subclasses can override this template method to perform
* their own compilation. Invoked after this base class's compilation is complete.
* Delegate method to perform the actual compilation.
* <p>Subclasses can override this template method to perform their own compilation.
* Invoked after this base class's compilation is complete.
*/
protected void compileInternal() {
this.callMetaDataContext.initializeMetaData(getJdbcTemplate().getDataSource());
// iterate over the declared RowMappers and register the corresponding SqlParameter
// Iterate over the declared RowMappers and register the corresponding SqlParameter
for (Map.Entry<String, RowMapper<?>> entry : this.declaredRowMappers.entrySet()) {
SqlParameter resultSetParameter =
this.callMetaDataContext.createReturnResultSetParameter(entry.getKey(), entry.getValue());
@ -332,7 +338,7 @@ public abstract class AbstractJdbcCall {
//-------------------------------------------------------------------------
/**
* Method that provides execution of the call using the passed in {@link SqlParameterSource}
* Delegate method that executes the call using the passed-in {@link SqlParameterSource}.
* @param parameterSource parameter names and values to be used in call
* @return Map of out parameters
*/
@ -343,18 +349,19 @@ public abstract class AbstractJdbcCall {
}
/**
* Method that provides execution of the call using the passed in array of parameters
* @param args array of parameter values; order must match the order declared for the stored procedure
* Delegate method that executes the call using the passed-in array of parameters.
* @param args array of parameter values. The order of values must match the order
* declared for the stored procedure.
* @return Map of out parameters
*/
protected Map<String, Object> doExecute(Object[] args) {
protected Map<String, Object> doExecute(Object... args) {
checkCompiled();
Map<String, ?> params = matchInParameterValuesWithCallParameters(args);
return executeCallInternal(params);
}
/**
* Method that provides execution of the call using the passed in Map of parameters
* Delegate method that executes the call using the passed-in Map of parameters.
* @param args Map of parameter name and values
* @return Map of out parameters
*/
@ -365,7 +372,7 @@ public abstract class AbstractJdbcCall {
}
/**
* Method to perform the actual call processing
* Delegate method to perform the actual call processing.
*/
private Map<String, Object> executeCallInternal(Map<String, ?> args) {
CallableStatementCreator csc = getCallableStatementFactory().newCallableStatementCreator(args);
@ -391,8 +398,8 @@ public abstract class AbstractJdbcCall {
}
/**
* Get a List of all the call parameters to be used for call. This includes any parameters added
* based on meta data processing.
* Get a List of all the call parameters to be used for call.
* This includes any parameters added based on meta data processing.
*/
protected List<SqlParameter> getCallParameters() {
return this.callMetaDataContext.getCallParameters();

123
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java
View File

@ -78,8 +78,7 @@ public abstract class AbstractJdbcInsert {
/**
* Has this operation been compiled? Compilation means at least checking
* that a DataSource or JdbcTemplate has been provided, but subclasses
* may also implement their own custom validation.
* that a DataSource or JdbcTemplate has been provided.
*/
private boolean compiled = false;
@ -91,14 +90,16 @@ public abstract class AbstractJdbcInsert {
/**
* Constructor for sublasses to delegate to for setting the DataSource.
* Constructor to be used when initializing using a {@link DataSource}.
* @param dataSource the DataSource to be used
*/
protected AbstractJdbcInsert(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
/**
* Constructor for sublasses to delegate to for setting the JdbcTemplate.
* Constructor to be used when initializing using a {@link JdbcTemplate}.
* @param jdbcTemplate the JdbcTemplate to use
*/
protected AbstractJdbcInsert(JdbcTemplate jdbcTemplate) {
Assert.notNull(jdbcTemplate, "JdbcTemplate must not be null");
@ -112,7 +113,7 @@ public abstract class AbstractJdbcInsert {
//-------------------------------------------------------------------------
/**
* Get the {@link JdbcTemplate} that is configured to be used.
* Get the configured {@link JdbcTemplate}.
*/
public JdbcTemplate getJdbcTemplate() {
return this.jdbcTemplate;
@ -271,8 +272,9 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method to perform the actual compilation. Subclasses can override this template method
* to perform their own compilation. Invoked after this base class's compilation is complete.
* Delegate method to perform the actual compilation.
* <p>Subclasses can override this template method to perform their own compilation.
* Invoked after this base class's compilation is complete.
*/
protected void compileInternal() {
this.tableMetaDataContext.processMetaData(
@ -287,7 +289,7 @@ public abstract class AbstractJdbcInsert {
/**
* Hook method that subclasses may override to react to compilation.
* This implementation does nothing.
* <p>This implementation is empty.
*/
protected void onCompileInternal() {
}
@ -329,20 +331,20 @@ public abstract class AbstractJdbcInsert {
//-------------------------------------------------------------------------
/**
* Method that provides execution of the insert using the passed in Map of parameters
* Delegate method that executes the insert using the passed-in Map of parameters.
* @param args Map with parameter names and values to be used in insert
* @return number of rows affected
* @return the number of rows affected
*/
protected int doExecute(Map<String, Object> args) {
protected int doExecute(Map<String, ?> args) {
checkCompiled();
List<Object> values = matchInParameterValuesWithInsertColumns(args);
return executeInsertInternal(values);
}
/**
* Method that provides execution of the insert using the passed in {@link SqlParameterSource}
* Delegate method that executes the insert using the passed-in {@link SqlParameterSource}.
* @param parameterSource parameter names and values to be used in insert
* @return number of rows affected
* @return the number of rows affected
*/
protected int doExecute(SqlParameterSource parameterSource) {
checkCompiled();
@ -351,9 +353,9 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method to execute the insert.
* Delegate method to execute the insert.
*/
private int executeInsertInternal(List<Object> values) {
private int executeInsertInternal(List<?> values) {
if (logger.isDebugEnabled()) {
logger.debug("The following parameters are used for insert " + getInsertString() + " with: " + values);
}
@ -361,22 +363,20 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method that provides execution of the insert using the passed in Map of parameters
* and returning a generated key
*
* Method that provides execution of the insert using the passed-in
* Map of parameters and returning a generated key.
* @param args Map with parameter names and values to be used in insert
* @return the key generated by the insert
*/
protected Number doExecuteAndReturnKey(Map<String, Object> args) {
protected Number doExecuteAndReturnKey(Map<String, ?> args) {
checkCompiled();
List<Object> values = matchInParameterValuesWithInsertColumns(args);
return executeInsertAndReturnKeyInternal(values);
}
/**
* Method that provides execution of the insert using the passed in {@link SqlParameterSource}
* and returning a generated key
*
* Method that provides execution of the insert using the passed-in
* {@link SqlParameterSource} and returning a generated key.
* @param parameterSource parameter names and values to be used in insert
* @return the key generated by the insert
*/
@ -387,22 +387,20 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method that provides execution of the insert using the passed in Map of parameters
* and returning all generated keys
*
* Method that provides execution of the insert using the passed-in
* Map of parameters and returning all generated keys.
* @param args Map with parameter names and values to be used in insert
* @return the KeyHolder containing keys generated by the insert
*/
protected KeyHolder doExecuteAndReturnKeyHolder(Map<String, Object> args) {
protected KeyHolder doExecuteAndReturnKeyHolder(Map<String, ?> args) {
checkCompiled();
List<Object> values = matchInParameterValuesWithInsertColumns(args);
return executeInsertAndReturnKeyHolderInternal(values);
}
/**
* Method that provides execution of the insert using the passed in {@link SqlParameterSource}
* and returning all generated keys
*
* Method that provides execution of the insert using the passed-in
* {@link SqlParameterSource} and returning all generated keys.
* @param parameterSource parameter names and values to be used in insert
* @return the KeyHolder containing keys generated by the insert
*/
@ -413,9 +411,9 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method to execute the insert generating single key
* Delegate method to execute the insert, generating a single key.
*/
private Number executeInsertAndReturnKeyInternal(final List<Object> values) {
private Number executeInsertAndReturnKeyInternal(final List<?> values) {
KeyHolder kh = executeInsertAndReturnKeyHolderInternal(values);
if (kh != null && kh.getKey() != null) {
return kh.getKey();
@ -427,9 +425,9 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method to execute the insert generating any number of keys
* Delegate method to execute the insert, generating any number of keys.
*/
private KeyHolder executeInsertAndReturnKeyHolderInternal(final List<Object> values) {
private KeyHolder executeInsertAndReturnKeyHolderInternal(final List<?> values) {
if (logger.isDebugEnabled()) {
logger.debug("The following parameters are used for call " + getInsertString() + " with: " + values);
}
@ -514,16 +512,14 @@ public abstract class AbstractJdbcInsert {
}
/**
* Create the PreparedStatement to be used for insert that have generated keys
*
* @param con the connection used
* @return PreparedStatement to use
* @throws SQLException
* Create a PreparedStatement to be used for an insert operation with generated keys.
* @param con the Connection to use
* @return the PreparedStatement
*/
private PreparedStatement prepareStatementForGeneratedKeys(Connection con) throws SQLException {
if (getGeneratedKeyNames().length < 1) {
throw new InvalidDataAccessApiUsageException("Generated Key Name(s) not specificed. " +
"Using the generated keys features requires specifying the name(s) of the generated column(s)");
throw new InvalidDataAccessApiUsageException("Generated Key Name(s) not specified. " +
"Using the generated keys features requires specifying the name(s) of the generated column(s).");
}
PreparedStatement ps;
if (this.tableMetaDataContext.isGeneratedKeysColumnNameArraySupported()) {
@ -542,56 +538,49 @@ public abstract class AbstractJdbcInsert {
}
/**
* Method that provides execution of a batch insert using the passed in Maps of parameters.
* Delegate method that executes a batch insert using the passed-in Maps of parameters.
* @param batch array of Maps with parameter names and values to be used in batch insert
* @return array of number of rows affected
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
protected int[] doExecuteBatch(Map<String, Object>[] batch) {
protected int[] doExecuteBatch(Map<String, ?>... batch) {
checkCompiled();
List[] batchValues = new ArrayList[batch.length];
int i = 0;
for (Map<String, Object> args : batch) {
List<Object> values = matchInParameterValuesWithInsertColumns(args);
batchValues[i++] = values;
List<List<Object>> batchValues = new ArrayList<List<Object>>(batch.length);
for (Map<String, ?> args : batch) {
batchValues.add(matchInParameterValuesWithInsertColumns(args));
}
return executeBatchInternal(batchValues);
}
/**
* Method that provides execution of a batch insert using the passed in array of {@link SqlParameterSource}
* Delegate method that executes a batch insert using the passed-in {@link SqlParameterSource}s.
* @param batch array of SqlParameterSource with parameter names and values to be used in insert
* @return array of number of rows affected
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
protected int[] doExecuteBatch(SqlParameterSource[] batch) {
protected int[] doExecuteBatch(SqlParameterSource... batch) {
checkCompiled();
List[] batchValues = new ArrayList[batch.length];
int i = 0;
List<List<Object>> batchValues = new ArrayList<List<Object>>(batch.length);
for (SqlParameterSource parameterSource : batch) {
List<Object> values = matchInParameterValuesWithInsertColumns(parameterSource);
batchValues[i++] = values;
batchValues.add(matchInParameterValuesWithInsertColumns(parameterSource));
}
return executeBatchInternal(batchValues);
}
/**
* Method to execute the batch insert.
* Delegate method to execute the batch insert.
*/
private int[] executeBatchInternal(final List<Object>[] batchValues) {
private int[] executeBatchInternal(final List<List<Object>> batchValues) {
if (logger.isDebugEnabled()) {
logger.debug("Executing statement " + getInsertString() + " with batch of size: " + batchValues.length);
logger.debug("Executing statement " + getInsertString() + " with batch of size: " + batchValues.size());
}
return getJdbcTemplate().batchUpdate(getInsertString(),
new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
List<Object> values = batchValues[i];
setParameterValues(ps, values, getInsertTypes());
setParameterValues(ps, batchValues.get(i), getInsertTypes());
}
@Override
public int getBatchSize() {
return batchValues.length;
return batchValues.size();
}
});
}
@ -601,7 +590,7 @@ public abstract class AbstractJdbcInsert {
* @param preparedStatement the PreparedStatement
* @param values the values to be set
*/
private void setParameterValues(PreparedStatement preparedStatement, List<Object> values, int[] columnTypes)
private void setParameterValues(PreparedStatement preparedStatement, List<?> values, int... columnTypes)
throws SQLException {
int colIndex = 0;
@ -617,8 +606,8 @@ public abstract class AbstractJdbcInsert {
}
/**
* Match the provided in parameter values with registered parameters and parameters defined
* via metadata processing.
* Match the provided in parameter values with registered parameters and parameters
* defined via metadata processing.
* @param parameterSource the parameter values provided as a {@link SqlParameterSource}
* @return Map with parameter names and values
*/
@ -627,12 +616,12 @@ public abstract class AbstractJdbcInsert {
}
/**
* Match the provided in parameter values with regitered parameters and parameters defined
* via metadata processing.
* Match the provided in parameter values with registered parameters and parameters
* defined via metadata processing.
* @param args the parameter values provided in a Map
* @return Map with parameter names and values
*/
protected List<Object> matchInParameterValuesWithInsertColumns(Map<String, Object> args) {
protected List<Object> matchInParameterValuesWithInsertColumns(Map<String, ?> args) {
return this.tableMetaDataContext.matchInParameterValuesWithInsertColumns(args);
}

6
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,7 +17,7 @@
package org.springframework.jdbc.core.simple;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import javax.sql.DataSource;
@ -123,7 +123,7 @@ public class SimpleJdbcCall extends AbstractJdbcCall implements SimpleJdbcCallOp
@Override
public SimpleJdbcCall useInParameterNames(String... inParameterNames) {
setInParameterNames(new HashSet<String>(Arrays.asList(inParameterNames)));
setInParameterNames(new LinkedHashSet<String>(Arrays.asList(inParameterNames)));
return this;
}

96
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -24,8 +24,8 @@ import org.springframework.jdbc.core.namedparam.SqlParameterSource;
/**
* Interface specifying the API for a Simple JDBC Call implemented by {@link SimpleJdbcCall}.
* This interface is not often used directly, but provides the
* option to enhance testability, as it can easily be mocked or stubbed.
* This interface is not often used directly, but provides the option to enhance testability,
* as it can easily be mocked or stubbed.
*
* @author Thomas Risberg
* @since 2.5
@ -55,8 +55,8 @@ public interface SimpleJdbcCallOperations {
/**
* Optionally, specify the name of the catalog that contins the stored procedure.
* To provide consistency with the Oracle DatabaseMetaData, this is used to specify the package name if
* the procedure is declared as part of a package.
* <p>To provide consistency with the Oracle DatabaseMetaData, this is used to specify the
* package name if the procedure is declared as part of a package.
* @param catalogName the catalog or package name
* @return the instance of this SimpleJdbcCall
*/
@ -69,12 +69,12 @@ public interface SimpleJdbcCallOperations {
SimpleJdbcCallOperations withReturnValue();
/**
* Specify one or more parameters if desired. These parameters will be supplemented with any
* parameter information retrieved from the database meta data.
* Note that only parameters declared as {@code SqlParameter} and {@code SqlInOutParameter}
* will be used to provide input values. This is different from the {@code StoredProcedure} class
* which for backwards compatibility reasons allows input values to be provided for parameters declared
* as {@code SqlOutParameter}.
* Specify one or more parameters if desired. These parameters will be supplemented with
* any parameter information retrieved from the database meta data.
* <p>Note that only parameters declared as {@code SqlParameter} and {@code SqlInOutParameter}
* will be used to provide input values. This is different from the {@code StoredProcedure}
* class which - for backwards compatibility reasons - allows input values to be provided
* for parameters declared as {@code SqlOutParameter}.
* @param sqlParameters the parameters to use
* @return the instance of this SimpleJdbcCall
*/
@ -84,11 +84,11 @@ public interface SimpleJdbcCallOperations {
SimpleJdbcCallOperations useInParameterNames(String... inParameterNames);
/**
* Used to specify when a ResultSet is returned by the stored procedure and you want it mapped
* by a RowMapper. The results will be returned using the parameter name specified. Multiple
* ResultSets must be declared in the correct order. If the database you are using uses ref cursors
* then the name specified must match the name of the parameter declared for the procedure in the
* database.
* Used to specify when a ResultSet is returned by the stored procedure and you want it
* mapped by a {@link RowMapper}. The results will be returned using the parameter name
* specified. Multiple ResultSets must be declared in the correct order.
* <p>If the database you are using uses ref cursors then the name specified must match
* the name of the parameter declared for the procedure in the database.
* @param parameterName the name of the returned results and/or the name of the ref cursor parameter
* @param rowMapper the RowMapper implementation that will map the data returned for each row
* */
@ -102,7 +102,8 @@ public interface SimpleJdbcCallOperations {
/**
* Execute the stored function and return the results obtained as an Object of the specified return type.
* Execute the stored function and return the results obtained as an Object of the
* specified return type.
* @param returnType the type of the value to return
* @param args optional array containing the in parameter values to be used in the call.
* Parameter values must be provided in the same order as the parameters are defined
@ -111,66 +112,73 @@ public interface SimpleJdbcCallOperations {
<T> T executeFunction(Class<T> returnType, Object... args);
/**
* Execute the stored function and return the results obtained as an Object of the specified return type.
* Execute the stored function and return the results obtained as an Object of the
* specified return type.
* @param returnType the type of the value to return
* @param args Map containing the parameter values to be used in the call.
* @param args Map containing the parameter values to be used in the call
*/
<T> T executeFunction(Class<T> returnType, Map<String, ?> args);
/**
* Execute the stored function and return the results obtained as an Object of the specified return type.
* Execute the stored function and return the results obtained as an Object of the
* specified return type.
* @param returnType the type of the value to return
* @param args MapSqlParameterSource containing the parameter values to be used in the call.
* @param args MapSqlParameterSource containing the parameter values to be used in the call
*/
<T> T executeFunction(Class<T> returnType, SqlParameterSource args);
/**
* Execute the stored procedure and return the single out parameter as an Object of the specified return type.
* In the case where there are multiple out parameters, the first one is returned and additional out parameters
* are ignored.
* Execute the stored procedure and return the single out parameter as an Object
* of the specified return type. In the case where there are multiple out parameters,
* the first one is returned and additional out parameters are ignored.
* @param returnType the type of the value to return
* @param args optional array containing the in parameter values to be used in the call. Parameter values must
* be provided in the same order as the parameters are defined for the stored procedure.
* @param args optional array containing the in parameter values to be used in the call.
* Parameter values must be provided in the same order as the parameters are defined for
* the stored procedure.
*/
<T> T executeObject(Class<T> returnType, Object... args);
/**
* Execute the stored procedure and return the single out parameter as an Object of the specified return type.
* In the case where there are multiple out parameters, the first one is returned and additional out parameters
* are ignored.
* Execute the stored procedure and return the single out parameter as an Object
* of the specified return type. In the case where there are multiple out parameters,
* the first one is returned and additional out parameters are ignored.
* @param returnType the type of the value to return
* @param args Map containing the parameter values to be used in the call.
* @param args Map containing the parameter values to be used in the call
*/
<T> T executeObject(Class<T> returnType, Map<String, ?> args);
/**
* Execute the stored procedure and return the single out parameter as an Object of the specified return type.
* In the case where there are multiple out parameters, the first one is returned and additional out parameters
* are ignored.
* Execute the stored procedure and return the single out parameter as an Object
* of the specified return type. In the case where there are multiple out parameters,
* the first one is returned and additional out parameters are ignored.
* @param returnType the type of the value to return
* @param args MapSqlParameterSource containing the parameter values to be used in the call.
* @param args MapSqlParameterSource containing the parameter values to be used in the call
*/
<T> T executeObject(Class<T> returnType, SqlParameterSource args);
/**
* Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations.
* @param args optional array containing the in parameter values to be used in the call. Parameter values must
* be provided in the same order as the parameters are defined for the stored procedure.
* @return map of output params.
* Execute the stored procedure and return a map of output params, keyed by name
* as in parameter declarations.
* @param args optional array containing the in parameter values to be used in the call.
* Parameter values must be provided in the same order as the parameters are defined for
* the stored procedure.
* @return Map of output params
*/
Map<String, Object> execute(Object... args);
/**
* Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations..
* @param args Map containing the parameter values to be used in the call.
* @return map of output params.
* Execute the stored procedure and return a map of output params, keyed by name
* as in parameter declarations.
* @param args Map containing the parameter values to be used in the call
* @return Map of output params
*/
Map<String, Object> execute(Map<String, ?> args);
/**
* Execute the stored procedure and return a map of output params, keyed by name as in parameter declarations..
* @param args SqlParameterSource containing the parameter values to be used in the call.
* @return map of output params.
* Execute the stored procedure and return a map of output params, keyed by name
* as in parameter declarations.
* @param args SqlParameterSource containing the parameter values to be used in the call
* @return Map of output params
*/
Map<String, Object> execute(SqlParameterSource args);

12
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -118,7 +118,7 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn
}
@Override
public int execute(Map<String, Object> args) {
public int execute(Map<String, ?> args) {
return doExecute(args);
}
@ -128,7 +128,7 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn
}
@Override
public Number executeAndReturnKey(Map<String, Object> args) {
public Number executeAndReturnKey(Map<String, ?> args) {
return doExecuteAndReturnKey(args);
}
@ -138,7 +138,7 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn
}
@Override
public KeyHolder executeAndReturnKeyHolder(Map<String, Object> args) {
public KeyHolder executeAndReturnKeyHolder(Map<String, ?> args) {
return doExecuteAndReturnKeyHolder(args);
}
@ -148,12 +148,12 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn
}
@Override
public int[] executeBatch(Map<String, Object>[] batch) {
public int[] executeBatch(Map<String, ?>... batch) {
return doExecuteBatch(batch);
}
@Override
public int[] executeBatch(SqlParameterSource[] batch) {
public int[] executeBatch(SqlParameterSource... batch) {
return doExecuteBatch(batch);
}

44
spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsertOperations.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -24,8 +24,8 @@ import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
/**
* Interface specifying the API for a Simple JDBC Insert implemented by {@link SimpleJdbcInsert}.
* This interface is not often used directly, but provides the
* option to enhance testability, as it can easily be mocked or stubbed.
* This interface is not often used directly, but provides the option to enhance testability,
* as it can easily be mocked or stubbed.
*
* @author Thomas Risberg
* @since 2.5
@ -98,7 +98,7 @@ public interface SimpleJdbcInsertOperations {
* @param args Map containing column names and corresponding value
* @return the number of rows affected as returned by the JDBC driver
*/
int execute(Map<String, Object> args);
int execute(Map<String, ?> args);
/**
* Execute the insert using the values passed in.
@ -108,36 +108,40 @@ public interface SimpleJdbcInsertOperations {
int execute(SqlParameterSource parameterSource);
/**
* Execute the insert using the values passed in and return the generated key. This requires that
* the name of the columns with auto generated keys have been specified. This method will always
* return a key or throw an exception if a key was not returned.
* Execute the insert using the values passed in and return the generated key.
* <p>This requires that the name of the columns with auto generated keys have been specified.
* This method will always return a KeyHolder but the caller must verify that it actually
* contains the generated keys.
* @param args Map containing column names and corresponding value
* @return the generated key value
*/
Number executeAndReturnKey(Map<String, Object> args);
Number executeAndReturnKey(Map<String, ?> args);
/**
* Execute the insert using the values passed in and return the generated key. This requires that
* the name of the columns with auto generated keys have been specified. This method will always
* return a key or throw an exception if a key was not returned.
* Execute the insert using the values passed in and return the generated key.
* <p>This requires that the name of the columns with auto generated keys have been specified.
* This method will always return a KeyHolder but the caller must verify that it actually
* contains the generated keys.
* @param parameterSource SqlParameterSource containing values to use for insert
* @return the generated key value.
*/
Number executeAndReturnKey(SqlParameterSource parameterSource);
/**
* Execute the insert using the values passed in and return the generated keys. This requires that
* the name of the columns with auto generated keys have been specified. This method will always return
* a KeyHolder but the caller must verify that it actually contains the generated keys.
* Execute the insert using the values passed in and return the generated keys.
* <p>This requires that the name of the columns with auto generated keys have been specified.
* This method will always return a KeyHolder but the caller must verify that it actually
* contains the generated keys.
* @param args Map containing column names and corresponding value
* @return the KeyHolder containing all generated keys
*/
KeyHolder executeAndReturnKeyHolder(Map<String, Object> args);
KeyHolder executeAndReturnKeyHolder(Map<String, ?> args);
/**
* Execute the insert using the values passed in and return the generated keys. This requires that
* the name of the columns with auto generated keys have been specified. This method will always return
* a KeyHolder but the caller must verify that it actually contains the generated keys.
* Execute the insert using the values passed in and return the generated keys.
* <p>This requires that the name of the columns with auto generated keys have been specified.
* This method will always return a KeyHolder but the caller must verify that it actually
* contains the generated keys.
* @param parameterSource SqlParameterSource containing values to use for insert
* @return the KeyHolder containing all generated keys
*/
@ -148,13 +152,13 @@ public interface SimpleJdbcInsertOperations {
* @param batch an array of Maps containing a batch of column names and corresponding value
* @return the array of number of rows affected as returned by the JDBC driver
*/
int[] executeBatch(Map<String, Object>[] batch);
int[] executeBatch(Map<String, ?>... batch);
/**
* Execute a batch insert using the batch of values passed in.
* @param batch an array of SqlParameterSource containing values for the batch
* @return the array of number of rows affected as returned by the JDBC driver
*/
int[] executeBatch(SqlParameterSource[] batch);
int[] executeBatch(SqlParameterSource... batch);
}