diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java index 80a00114869..70daa10b55d 100755 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java @@ -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 callParameters = new ArrayList(); - /** 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 limitedInParameterNames = new HashSet(); @@ -77,16 +74,16 @@ public class CallMetaDataContext { /** List of SqlParameter names for out parameters */ private List outParameterNames = new ArrayList(); - /** 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 + "." : "") + diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java index f3391db2394..c8aaf23b6b9 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java @@ -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(declaredColumns); } - Set keys = new HashSet(generatedKeyNames.length); + Set keys = new LinkedHashSet(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 matchInParameterValuesWithInsertColumns(Map inParameters) { + public List matchInParameterValuesWithInsertColumns(Map inParameters) { List values = new ArrayList(); - Map source = new HashMap(); + Map source = new LinkedHashMap(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 keys = new HashSet(generatedKeyNames.length); + Set keys = new LinkedHashSet(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 parameters = this.metaDataProvider.getTableParameterMetaData(); - Map parameterMap = new HashMap(parameters.size()); + Map parameterMap = + new LinkedHashMap(parameters.size()); for (TableParameterMetaData tpmd : parameters) { parameterMap.put(tpmd.getParameterName().toUpperCase(), tpmd); } diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/MapSqlParameterSource.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/MapSqlParameterSource.java index 1212c42c246..af40df75f30 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/MapSqlParameterSource.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/MapSqlParameterSource.java @@ -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; *

This class is intended for passing in a simple Map of parameter values * to the methods of the {@link NamedParameterJdbcTemplate} class. * - *

The {@code addValue} methods on this class will make adding several - * values easier. The methods return a reference to the {@link MapSqlParameterSource} + *

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 values = new HashMap(); + private final Map values = new LinkedHashMap(); /** diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java index b1e21e9cf27..56cf20842aa 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcCall.java @@ -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> declaredRowMappers = new LinkedHashMap>(); /** - * 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}. + *

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. + *

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. + *

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> 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 doExecute(Object[] args) { + protected Map doExecute(Object... args) { checkCompiled(); Map 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 executeCallInternal(Map 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 getCallParameters() { return this.callMetaDataContext.getCallParameters(); diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java index 2216fea5c42..e7b7d2fa513 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java @@ -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. + *

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. + *

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 args) { + protected int doExecute(Map args) { checkCompiled(); List 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 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 args) { + protected Number doExecuteAndReturnKey(Map args) { checkCompiled(); List 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 args) { + protected KeyHolder doExecuteAndReturnKeyHolder(Map args) { checkCompiled(); List 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 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 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[] batch) { + protected int[] doExecuteBatch(Map... batch) { checkCompiled(); - List[] batchValues = new ArrayList[batch.length]; - int i = 0; - for (Map args : batch) { - List values = matchInParameterValuesWithInsertColumns(args); - batchValues[i++] = values; + List> batchValues = new ArrayList>(batch.length); + for (Map 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> batchValues = new ArrayList>(batch.length); for (SqlParameterSource parameterSource : batch) { - List 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[] batchValues) { + private int[] executeBatchInternal(final List> 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 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 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 matchInParameterValuesWithInsertColumns(Map args) { + protected List matchInParameterValuesWithInsertColumns(Map args) { return this.tableMetaDataContext.matchInParameterValuesWithInsertColumns(args); } diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java index 06b9fad0305..df58d5d0164 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCall.java @@ -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(Arrays.asList(inParameterNames))); + setInParameterNames(new LinkedHashSet(Arrays.asList(inParameterNames))); return this; } diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java index 468856dbfe7..fcdca17f29a 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcCallOperations.java @@ -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. + *

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. + *

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. + *

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 executeFunction(Class 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 executeFunction(Class returnType, Map 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 executeFunction(Class 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 executeObject(Class 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 executeObject(Class returnType, Map 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 executeObject(Class 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 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 execute(Map 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 execute(SqlParameterSource args); diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java index 57c26df7081..d178cc615d3 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java @@ -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 args) { + public int execute(Map args) { return doExecute(args); } @@ -128,7 +128,7 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn } @Override - public Number executeAndReturnKey(Map args) { + public Number executeAndReturnKey(Map args) { return doExecuteAndReturnKey(args); } @@ -138,7 +138,7 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn } @Override - public KeyHolder executeAndReturnKeyHolder(Map args) { + public KeyHolder executeAndReturnKeyHolder(Map args) { return doExecuteAndReturnKeyHolder(args); } @@ -148,12 +148,12 @@ public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcIn } @Override - public int[] executeBatch(Map[] batch) { + public int[] executeBatch(Map... batch) { return doExecuteBatch(batch); } @Override - public int[] executeBatch(SqlParameterSource[] batch) { + public int[] executeBatch(SqlParameterSource... batch) { return doExecuteBatch(batch); } diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsertOperations.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsertOperations.java index 9386eaaf815..0e1dd15ceb5 100644 --- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsertOperations.java +++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsertOperations.java @@ -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 args); + int execute(Map 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. + *

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 args); + Number executeAndReturnKey(Map 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. + *

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. + *

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 args); + KeyHolder executeAndReturnKeyHolder(Map 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. + *

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[] batch); + int[] executeBatch(Map... 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); }