Update upstream source from tag 'upstream/4.3.23_git20190308'

Update to upstream version '4.3.23~git20190308'
with Debian dir 6d5a5b12f9bb323cd3b6fb67329b6f998e2ff19a

1 files changed, 61 insertions, 62 deletions

diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java
index 6f97a196..951e9441 100644
--- a/spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java
+++ b/spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -31,7 +31,6 @@ import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -672,11 +671,10 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	 * Query using a prepared statement, allowing for a PreparedStatementCreator
 	 * and a PreparedStatementSetter. Most other query methods use this method,
 	 * but application code will always work with either a creator or a setter.
-	 * @param psc Callback handler that can create a PreparedStatement given a
-	 * Connection
-	 * @param pss object that knows how to set values on the prepared statement.
-	 * If this is null, the SQL will be assumed to contain no bind parameters.
-	 * @param rse object that will extract results.
+	 * @param psc a callback that creates a PreparedStatement given a Connection
+	 * @param pss a callback that knows how to set values on the prepared statement.
+	 * If this is {@code null}, the SQL will be assumed to contain no bind parameters.
+	 * @param rse a callback that will extract results
 	 * @return an arbitrary result object, as returned by the ResultSetExtractor
 	 * @throws DataAccessException if there is any problem
 	 */
@@ -873,6 +871,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 			throws DataAccessException {
 
 		logger.debug("Executing prepared SQL update");
+
 		return execute(psc, new PreparedStatementCallback<Integer>() {
 			@Override
 			public Integer doInPreparedStatement(PreparedStatement ps) throws SQLException {
@@ -1054,6 +1053,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 		});
 	}
 
+
 	//-------------------------------------------------------------------------
 	// Methods dealing with callable statements
 	//-------------------------------------------------------------------------
@@ -1121,6 +1121,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 		final List<SqlParameter> updateCountParameters = new ArrayList<SqlParameter>();
 		final List<SqlParameter> resultSetParameters = new ArrayList<SqlParameter>();
 		final List<SqlParameter> callParameters = new ArrayList<SqlParameter>();
+
 		for (SqlParameter parameter : declaredParameters) {
 			if (parameter.isResultsParameter()) {
 				if (parameter instanceof SqlReturnResultSet) {
@@ -1134,6 +1135,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 				callParameters.add(parameter);
 			}
 		}
+
 		return execute(csc, new CallableStatementCallback<Map<String, Object>>() {
 			@Override
 			public Map<String, Object> doInCallableStatement(CallableStatement cs) throws SQLException {
@@ -1143,28 +1145,28 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 					logger.debug("CallableStatement.execute() returned '" + retVal + "'");
 					logger.debug("CallableStatement.getUpdateCount() returned " + updateCount);
 				}
-				Map<String, Object> returnedResults = createResultsMap();
+				Map<String, Object> resultsMap = createResultsMap();
 				if (retVal || updateCount != -1) {
-					returnedResults.putAll(extractReturnedResults(cs, updateCountParameters, resultSetParameters, updateCount));
+					resultsMap.putAll(extractReturnedResults(cs, updateCountParameters, resultSetParameters, updateCount));
 				}
-				returnedResults.putAll(extractOutputParameters(cs, callParameters));
-				return returnedResults;
+				resultsMap.putAll(extractOutputParameters(cs, callParameters));
+				return resultsMap;
 			}
 		});
 	}
 
 	/**
 	 * Extract returned ResultSets from the completed stored procedure.
-	 * @param cs JDBC wrapper for the stored procedure
-	 * @param updateCountParameters Parameter list of declared update count parameters for the stored procedure
-	 * @param resultSetParameters Parameter list of declared resultSet parameters for the stored procedure
-	 * @return Map that contains returned results
+	 * @param cs a JDBC wrapper for the stored procedure
+	 * @param updateCountParameters the parameter list of declared update count parameters for the stored procedure
+	 * @param resultSetParameters the parameter list of declared resultSet parameters for the stored procedure
+	 * @return a Map that contains returned results
 	 */
 	protected Map<String, Object> extractReturnedResults(CallableStatement cs,
 			List<SqlParameter> updateCountParameters, List<SqlParameter> resultSetParameters, int updateCount)
 			throws SQLException {
 
-		Map<String, Object> returnedResults = new HashMap<String, Object>();
+		Map<String, Object> results = new LinkedHashMap<String, Object>(4);
 		int rsIndex = 0;
 		int updateIndex = 0;
 		boolean moreResults;
@@ -1173,7 +1175,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 				if (updateCount == -1) {
 					if (resultSetParameters != null && resultSetParameters.size() > rsIndex) {
 						SqlReturnResultSet declaredRsParam = (SqlReturnResultSet) resultSetParameters.get(rsIndex);
-						returnedResults.putAll(processResultSet(cs.getResultSet(), declaredRsParam));
+						results.putAll(processResultSet(cs.getResultSet(), declaredRsParam));
 						rsIndex++;
 					}
 					else {
@@ -1183,7 +1185,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 							if (logger.isDebugEnabled()) {
 								logger.debug("Added default SqlReturnResultSet parameter named '" + rsName + "'");
 							}
-							returnedResults.putAll(processResultSet(cs.getResultSet(), undeclaredRsParam));
+							results.putAll(processResultSet(cs.getResultSet(), undeclaredRsParam));
 							rsIndex++;
 						}
 					}
@@ -1192,7 +1194,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 					if (updateCountParameters != null && updateCountParameters.size() > updateIndex) {
 						SqlReturnUpdateCount ucParam = (SqlReturnUpdateCount) updateCountParameters.get(updateIndex);
 						String declaredUcName = ucParam.getName();
-						returnedResults.put(declaredUcName, updateCount);
+						results.put(declaredUcName, updateCount);
 						updateIndex++;
 					}
 					else {
@@ -1201,7 +1203,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 							if (logger.isDebugEnabled()) {
 								logger.debug("Added default SqlReturnUpdateCount parameter named '" + undeclaredName + "'");
 							}
-							returnedResults.put(undeclaredName, updateCount);
+							results.put(undeclaredName, updateCount);
 							updateIndex++;
 						}
 					}
@@ -1214,19 +1216,19 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 			}
 			while (moreResults || updateCount != -1);
 		}
-		return returnedResults;
+		return results;
 	}
 
 	/**
 	 * Extract output parameters from the completed stored procedure.
-	 * @param cs JDBC wrapper for the stored procedure
+	 * @param cs the JDBC wrapper for the stored procedure
 	 * @param parameters parameter list for the stored procedure
-	 * @return Map that contains returned results
+	 * @return a Map that contains returned results
 	 */
 	protected Map<String, Object> extractOutputParameters(CallableStatement cs, List<SqlParameter> parameters)
 			throws SQLException {
 
-		Map<String, Object> returnedResults = new HashMap<String, Object>();
+		Map<String, Object> results = new LinkedHashMap<String, Object>(parameters.size());
 		int sqlColIndex = 1;
 		for (SqlParameter param : parameters) {
 			if (param instanceof SqlOutParameter) {
@@ -1234,25 +1236,25 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 				if (outParam.isReturnTypeSupported()) {
 					Object out = outParam.getSqlReturnType().getTypeValue(
 							cs, sqlColIndex, outParam.getSqlType(), outParam.getTypeName());
-					returnedResults.put(outParam.getName(), out);
+					results.put(outParam.getName(), out);
 				}
 				else {
 					Object out = cs.getObject(sqlColIndex);
 					if (out instanceof ResultSet) {
 						if (outParam.isResultSetSupported()) {
-							returnedResults.putAll(processResultSet((ResultSet) out, outParam));
+							results.putAll(processResultSet((ResultSet) out, outParam));
 						}
 						else {
 							String rsName = outParam.getName();
 							SqlReturnResultSet rsParam = new SqlReturnResultSet(rsName, getColumnMapRowMapper());
-							returnedResults.putAll(processResultSet((ResultSet) out, rsParam));
+							results.putAll(processResultSet((ResultSet) out, rsParam));
 							if (logger.isDebugEnabled()) {
 								logger.debug("Added default SqlReturnResultSet parameter named '" + rsName + "'");
 							}
 						}
 					}
 					else {
-						returnedResults.put(outParam.getName(), out);
+						results.put(outParam.getName(), out);
 					}
 				}
 			}
@@ -1260,48 +1262,46 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 				sqlColIndex++;
 			}
 		}
-		return returnedResults;
+		return results;
 	}
 
 	/**
 	 * Process the given ResultSet from a stored procedure.
 	 * @param rs the ResultSet to process
 	 * @param param the corresponding stored procedure parameter
-	 * @return Map that contains returned results
+	 * @return a Map that contains returned results
 	 */
 	@SuppressWarnings({"unchecked", "rawtypes"})
 	protected Map<String, Object> processResultSet(ResultSet rs, ResultSetSupportingSqlParameter param)
 			throws SQLException {
 
-		if (rs == null) {
-			return Collections.emptyMap();
-		}
-
-		Map<String, Object> returnedResults = new HashMap<String, Object>();
-		try {
-			ResultSet rsToUse = rs;
-			if (this.nativeJdbcExtractor != null) {
-				rsToUse = this.nativeJdbcExtractor.getNativeResultSet(rs);
-			}
-			if (param.getRowMapper() != null) {
-				RowMapper rowMapper = param.getRowMapper();
-				Object result = (new RowMapperResultSetExtractor(rowMapper)).extractData(rsToUse);
-				returnedResults.put(param.getName(), result);
-			}
-			else if (param.getRowCallbackHandler() != null) {
-				RowCallbackHandler rch = param.getRowCallbackHandler();
-				(new RowCallbackHandlerResultSetExtractor(rch)).extractData(rsToUse);
-				returnedResults.put(param.getName(), "ResultSet returned from stored procedure was processed");
+		if (rs != null) {
+			try {
+				ResultSet rsToUse = rs;
+				if (this.nativeJdbcExtractor != null) {
+					rsToUse = this.nativeJdbcExtractor.getNativeResultSet(rs);
+				}
+				if (param.getRowMapper() != null) {
+					RowMapper rowMapper = param.getRowMapper();
+					Object data = (new RowMapperResultSetExtractor(rowMapper)).extractData(rsToUse);
+					return Collections.singletonMap(param.getName(), data);
+				}
+				else if (param.getRowCallbackHandler() != null) {
+					RowCallbackHandler rch = param.getRowCallbackHandler();
+					(new RowCallbackHandlerResultSetExtractor(rch)).extractData(rsToUse);
+					return Collections.singletonMap(param.getName(),
+							(Object) "ResultSet returned from stored procedure was processed");
+				}
+				else if (param.getResultSetExtractor() != null) {
+					Object data = param.getResultSetExtractor().extractData(rsToUse);
+					return Collections.singletonMap(param.getName(), data);
+				}
 			}
-			else if (param.getResultSetExtractor() != null) {
-				Object result = param.getResultSetExtractor().extractData(rsToUse);
-				returnedResults.put(param.getName(), result);
+			finally {
+				JdbcUtils.closeResultSet(rs);
 			}
 		}
-		finally {
-			JdbcUtils.closeResultSet(rs);
-		}
-		return returnedResults;
+		return Collections.emptyMap();
 	}
 
 
@@ -1392,8 +1392,8 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	}
 
 	/**
-	 * Throw an SQLWarningException if we're not ignoring warnings,
-	 * else log the warnings (at debug level).
+	 * Throw a SQLWarningException if we're not ignoring warnings,
+	 * otherwise log the warnings at debug level.
 	 * @param stmt the current JDBC statement
 	 * @throws SQLWarningException if not ignoring warnings
 	 * @see org.springframework.jdbc.SQLWarningException
@@ -1415,7 +1415,7 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	}
 
 	/**
-	 * Throw an SQLWarningException if encountering an actual warning.
+	 * Throw a SQLWarningException if encountering an actual warning.
 	 * @param warning the warnings object from the current statement.
 	 * May be {@code null}, in which case this method does nothing.
 	 * @throws SQLWarningException in case of an actual warning to be raised
@@ -1428,8 +1428,8 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 
 	/**
 	 * Determine SQL from potential provider object.
-	 * @param sqlProvider object that's potentially a SqlProvider
-	 * @return the SQL string, or {@code null}
+	 * @param sqlProvider object which is potentially a SqlProvider
+	 * @return the SQL string, or {@code null} if not known
 	 * @see SqlProvider
 	 */
 	private static String getSql(Object sqlProvider) {
@@ -1456,7 +1456,6 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 		}
 
 		@Override
-		@SuppressWarnings("rawtypes")
 		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 			// Invocation on ConnectionProxy interface coming in...