Fix typos related to indefinite articles for SQL acronym

Closes gh-23603

spring-jdbc/src/main/java/org/springframework/jdbc/SQLWarningException.java

@@ -23,7 +23,7 @@
 /**
  * Exception thrown when we're not ignoring {@link java.sql.SQLWarning SQLWarnings}.
  *
- * <p>If a SQLWarning is reported, the operation completed, so we will need
+ * <p>If an SQLWarning is reported, the operation completed, so we will need
  * to explicitly roll it back if we're not happy when looking at the warning.
  * We might choose to ignore (and log) the warning, or to wrap and throw it
  * in the shape of this SQLWarningException instead.

spring-jdbc/src/main/java/org/springframework/jdbc/UncategorizedSQLException.java

@@ -22,7 +22,7 @@
 import org.springframework.lang.Nullable;
 
 /**
- * Exception thrown when we can't classify a SQLException into
+ * Exception thrown when we can't classify an SQLException into
  * one of our generic data access exceptions.
  *
  * @author Rod Johnson

spring-jdbc/src/main/java/org/springframework/jdbc/core/BatchPreparedStatementSetter.java

@@ -42,7 +42,7 @@ public interface BatchPreparedStatementSetter {
 	 * Set parameter values on the given PreparedStatement.
 	 * @param ps the PreparedStatement to invoke setter methods on
 	 * @param i index of the statement we're issuing in the batch, starting from 0
-	 * @throws SQLException if a SQLException is encountered
+	 * @throws SQLException if an SQLException is encountered
 	 * (i.e. there is no need to catch SQLException)
 	 */
 	void setValues(PreparedStatement ps, int i) throws SQLException;

spring-jdbc/src/main/java/org/springframework/jdbc/core/CallableStatementCallback.java

@@ -72,7 +72,7 @@ public interface CallableStatementCallback<T> {
 	 * @param cs active JDBC CallableStatement
 	 * @return a result object, or {@code null} if none
 	 * @throws SQLException if thrown by a JDBC method, to be auto-converted
-	 * into a DataAccessException by a SQLExceptionTranslator
+	 * into a DataAccessException by an SQLExceptionTranslator
 	 * @throws DataAccessException in case of custom exceptions
 	 */
 	@Nullable

spring-jdbc/src/main/java/org/springframework/jdbc/core/CallableStatementCreatorFactory.java

@@ -30,7 +30,7 @@
 
 /**
  * Helper class that efficiently creates multiple {@link CallableStatementCreator}
- * objects with different parameters based on a SQL statement and a single
+ * objects with different parameters based on an SQL statement and a single
  * set of parameter declarations.
  *
  * @author Rod Johnson

spring-jdbc/src/main/java/org/springframework/jdbc/core/ConnectionCallback.java

@@ -59,7 +59,7 @@ public interface ConnectionCallback<T> {
 	 * @param con active JDBC Connection
 	 * @return a result object, or {@code null} if none
 	 * @throws SQLException if thrown by a JDBC method, to be auto-converted
-	 * to a DataAccessException by a SQLExceptionTranslator
+	 * to a DataAccessException by an SQLExceptionTranslator
 	 * @throws DataAccessException in case of custom exceptions
 	 * @see JdbcTemplate#queryForObject(String, Class)
 	 * @see JdbcTemplate#queryForRowSet(String)

spring-jdbc/src/main/java/org/springframework/jdbc/core/DisposableSqlTypeValue.java

@@ -29,7 +29,7 @@ public interface DisposableSqlTypeValue extends SqlTypeValue {
 
 	/**
 	 * Clean up resources held by this type value,
-	 * for example the LobCreator in case of a SqlLobValue.
+	 * for example the LobCreator in case of an SqlLobValue.
 	 * @see org.springframework.jdbc.core.support.SqlLobValue#cleanup()
 	 * @see org.springframework.jdbc.support.SqlValue#cleanup()
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcOperations.java

@@ -223,7 +223,7 @@ public interface JdbcOperations {
 	List<Map<String, Object>> queryForList(String sql) throws DataAccessException;
 
 	/**
-	 * Execute a query for a SqlRowSet, given static SQL.
+	 * Execute a query for an SqlRowSet, given static SQL.
 	 * <p>Uses a JDBC Statement, not a PreparedStatement. If you want to
 	 * execute a static query with a PreparedStatement, use the overloaded
 	 * {@code queryForRowSet} method with {@code null} as argument array.
@@ -234,7 +234,7 @@ public interface JdbcOperations {
 	 * class is used, which is part of JDK 1.5+ and also available separately as part of
 	 * Sun's JDBC RowSet Implementations download (rowset.jar).
 	 * @param sql the SQL query to execute
-	 * @return a SqlRowSet representation (possibly a wrapper around a
+	 * @return an SqlRowSet representation (possibly a wrapper around a
 	 * {@code javax.sql.rowset.CachedRowSet})
 	 * @throws DataAccessException if there is any problem executing the query
 	 * @see #queryForRowSet(String, Object[])
@@ -773,7 +773,7 @@ <T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> ele
 
 	/**
 	 * Query given SQL to create a prepared statement from SQL and a list of
-	 * arguments to bind to the query, expecting a SqlRowSet.
+	 * arguments to bind to the query, expecting an SqlRowSet.
 	 * <p>The results will be mapped to an SqlRowSet which holds the data in a
 	 * disconnected fashion. This wrapper will translate any SQLExceptions thrown.
 	 * <p>Note that, for the default implementation, JDBC RowSet support needs to
@@ -784,7 +784,7 @@ <T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> ele
 	 * @param args arguments to bind to the query
 	 * @param argTypes the SQL types of the arguments
 	 * (constants from {@code java.sql.Types})
-	 * @return a SqlRowSet representation (possibly a wrapper around a
+	 * @return an SqlRowSet representation (possibly a wrapper around a
 	 * {@code javax.sql.rowset.CachedRowSet})
 	 * @throws DataAccessException if there is any problem executing the query
 	 * @see #queryForRowSet(String)
@@ -796,7 +796,7 @@ <T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> ele
 
 	/**
 	 * Query given SQL to create a prepared statement from SQL and a list of
-	 * arguments to bind to the query, expecting a SqlRowSet.
+	 * arguments to bind to the query, expecting an SqlRowSet.
 	 * <p>The results will be mapped to an SqlRowSet which holds the data in a
 	 * disconnected fashion. This wrapper will translate any SQLExceptions thrown.
 	 * <p>Note that, for the default implementation, JDBC RowSet support needs to
@@ -808,7 +808,7 @@ <T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> ele
 	 * (leaving it to the PreparedStatement to guess the corresponding SQL type);
 	 * may also contain {@link SqlParameterValue} objects which indicate not
 	 * only the argument value but also the SQL type and optionally the scale
-	 * @return a SqlRowSet representation (possibly a wrapper around a
+	 * @return an SqlRowSet representation (possibly a wrapper around a
 	 * {@code javax.sql.rowset.CachedRowSet})
 	 * @throws DataAccessException if there is any problem executing the query
 	 * @see #queryForRowSet(String)
@@ -969,7 +969,7 @@ <T> int[][] batchUpdate(String sql, Collection<T> batchArgs, int batchSize,
 	<T> T execute(String callString, CallableStatementCallback<T> action) throws DataAccessException;
 
 	/**
-	 * Execute a SQL call using a CallableStatementCreator to provide SQL and
+	 * Execute an SQL call using a CallableStatementCreator to provide SQL and
 	 * any required parameters.
 	 * @param csc a callback that provides SQL and any necessary parameters
 	 * @param declaredParameters list of declared SqlParameter objects

spring-jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java

@@ -183,7 +183,7 @@ public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
 	/**
 	 * Set whether or not we want to ignore SQLWarnings.
 	 * <p>Default is "true", swallowing and logging all warnings. Switch this flag
-	 * to "false" to make the JdbcTemplate throw a SQLWarningException instead.
+	 * to "false" to make the JdbcTemplate throw an SQLWarningException instead.
 	 * @see java.sql.SQLWarning
 	 * @see org.springframework.jdbc.SQLWarningException
 	 * @see #handleWarnings
@@ -1396,7 +1396,7 @@ protected PreparedStatementSetter newArgTypePreparedStatementSetter(Object[] arg
 	}
 
 	/**
-	 * Throw a SQLWarningException if we're not ignoring warnings,
+	 * Throw an 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
@@ -1419,7 +1419,7 @@ protected void handleWarnings(Statement stmt) throws SQLException {
 	}
 
 	/**
-	 * Throw a SQLWarningException if encountering an actual warning.
+	 * Throw an 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
@@ -1447,7 +1447,7 @@ protected DataAccessException translateException(String task, @Nullable String s
 
 	/**
 	 * Determine SQL from potential provider object.
-	 * @param sqlProvider object which is potentially a SqlProvider
+	 * @param sqlProvider object which is potentially an SqlProvider
 	 * @return the SQL string, or {@code null} if not known
 	 * @see SqlProvider
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/core/ParameterDisposer.java

@@ -37,7 +37,7 @@ public interface ParameterDisposer {
 	/**
 	 * Close the resources allocated by parameters that the implementing
 	 * object holds, for example in case of a DisposableSqlTypeValue
-	 * (like a SqlLobValue).
+	 * (like an SqlLobValue).
 	 * @see DisposableSqlTypeValue#cleanup()
 	 * @see org.springframework.jdbc.core.support.SqlLobValue#cleanup()
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/core/ParameterMapper.java

@@ -40,7 +40,7 @@ public interface ParameterMapper {
 	 * implementation class. This class conceals such proprietary details. However,
 	 * it is best to avoid using such proprietary RDBMS features if possible.
 	 * @return a Map of input parameters, keyed by name (never {@code null})
-	 * @throws SQLException if a SQLException is encountered setting
+	 * @throws SQLException if an SQLException is encountered setting
 	 * parameter values (that is, there's no need to catch SQLException)
 	 */
 	Map<String, ?> createMap(Connection con) throws SQLException;

spring-jdbc/src/main/java/org/springframework/jdbc/core/ParameterizedPreparedStatementSetter.java

@@ -45,7 +45,7 @@ public interface ParameterizedPreparedStatementSetter<T> {
 	 * Set parameter values on the given PreparedStatement.
 	 * @param ps the PreparedStatement to invoke setter methods on
 	 * @param argument the object containing the values to be set
-	 * @throws SQLException if a SQLException is encountered (i.e. there is no need to catch SQLException)
+	 * @throws SQLException if an SQLException is encountered (i.e. there is no need to catch SQLException)
 	 */
 	void setValues(PreparedStatement ps, T argument) throws SQLException;
 

spring-jdbc/src/main/java/org/springframework/jdbc/core/PreparedStatementCallback.java

@@ -69,7 +69,7 @@ public interface PreparedStatementCallback<T> {
 	 * @param ps active JDBC PreparedStatement
 	 * @return a result object, or {@code null} if none
 	 * @throws SQLException if thrown by a JDBC method, to be auto-converted
-	 * to a DataAccessException by a SQLExceptionTranslator
+	 * to a DataAccessException by an SQLExceptionTranslator
 	 * @throws DataAccessException in case of custom exceptions
 	 * @see JdbcTemplate#queryForObject(String, Object[], Class)
 	 * @see JdbcTemplate#queryForList(String, Object[])

spring-jdbc/src/main/java/org/springframework/jdbc/core/PreparedStatementCreatorFactory.java

@@ -34,7 +34,7 @@
 
 /**
  * Helper class that efficiently creates multiple {@link PreparedStatementCreator}
- * objects with different parameters based on a SQL statement and a single
+ * objects with different parameters based on an SQL statement and a single
  * set of parameter declarations.
  *
  * @author Rod Johnson

spring-jdbc/src/main/java/org/springframework/jdbc/core/PreparedStatementSetter.java

@@ -46,7 +46,7 @@ public interface PreparedStatementSetter {
 	/**
 	 * Set parameter values on the given PreparedStatement.
 	 * @param ps the PreparedStatement to invoke setter methods on
-	 * @throws SQLException if a SQLException is encountered
+	 * @throws SQLException if an SQLException is encountered
 	 * (i.e. there is no need to catch SQLException)
 	 */
 	void setValues(PreparedStatement ps) throws SQLException;

spring-jdbc/src/main/java/org/springframework/jdbc/core/ResultSetExtractor.java

@@ -57,7 +57,7 @@ public interface ResultSetExtractor<T> {
 	 * not close this: it will be closed by the calling JdbcTemplate.
 	 * @return an arbitrary result object, or {@code null} if none
 	 * (the extractor will typically be stateful in the latter case).
-	 * @throws SQLException if a SQLException is encountered getting column
+	 * @throws SQLException if an SQLException is encountered getting column
 	 * values or navigating (that is, there's no need to catch SQLException)
 	 * @throws DataAccessException in case of custom exceptions
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/core/RowCallbackHandler.java

@@ -53,7 +53,7 @@ public interface RowCallbackHandler {
 	 * A trivial implementation might simply count rows, while another
 	 * implementation might build an XML document.
 	 * @param rs the ResultSet to process (pre-initialized for the current row)
-	 * @throws SQLException if a SQLException is encountered getting
+	 * @throws SQLException if an SQLException is encountered getting
 	 * column values (that is, there's no need to catch SQLException)
 	 */
 	void processRow(ResultSet rs) throws SQLException;

spring-jdbc/src/main/java/org/springframework/jdbc/core/RowMapper.java

@@ -58,7 +58,7 @@ public interface RowMapper<T> {
 	 * @param rs the ResultSet to map (pre-initialized for the current row)
 	 * @param rowNum the number of the current row
 	 * @return the result object for the current row (may be {@code null})
-	 * @throws SQLException if a SQLException is encountered getting
+	 * @throws SQLException if an SQLException is encountered getting
 	 * column values (that is, there's no need to catch SQLException)
 	 */
 	@Nullable

spring-jdbc/src/main/java/org/springframework/jdbc/core/SqlParameter.java

@@ -24,10 +24,10 @@
 import org.springframework.util.Assert;
 
 /**
- * Object to represent a SQL parameter definition.
+ * Object to represent an SQL parameter definition.
  *
  * <p>Parameters may be anonymous, in which case "name" is {@code null}.
- * However, all parameters must define a SQL type according to {@link java.sql.Types}.
+ * However, all parameters must define an SQL type according to {@link java.sql.Types}.
  *
  * @author Rod Johnson
  * @author Thomas Risberg

spring-jdbc/src/main/java/org/springframework/jdbc/core/SqlParameterValue.java

@@ -19,7 +19,7 @@
 import org.springframework.lang.Nullable;
 
 /**
- * Object to represent a SQL parameter value, including parameter meta-data
+ * Object to represent an SQL parameter value, including parameter meta-data
  * such as the SQL type and the scale for numeric values.
  *
  * <p>Designed for use with {@link JdbcTemplate}'s operations that take an array of

spring-jdbc/src/main/java/org/springframework/jdbc/core/SqlReturnType.java

@@ -42,7 +42,7 @@ public interface SqlReturnType {
 	/**
 	 * Constant that indicates an unknown (or unspecified) SQL type.
 	 * Passed into setTypeValue if the original operation method does
-	 * not specify a SQL type.
+	 * not specify an SQL type.
 	 * @see java.sql.Types
 	 * @see JdbcOperations#update(String, Object[])
 	 */
@@ -56,7 +56,7 @@ public interface SqlReturnType {
 	 * @param sqlType the SQL type of the parameter we are setting
 	 * @param typeName the type name of the parameter (optional)
 	 * @return the target value
-	 * @throws SQLException if a SQLException is encountered setting parameter values
+	 * @throws SQLException if an SQLException is encountered setting parameter values
 	 * (that is, there's no need to catch SQLException)
 	 * @see java.sql.Types
 	 * @see java.sql.CallableStatement#getObject

spring-jdbc/src/main/java/org/springframework/jdbc/core/SqlTypeValue.java

@@ -46,7 +46,7 @@ public interface SqlTypeValue {
 	/**
 	 * Constant that indicates an unknown (or unspecified) SQL type.
 	 * Passed into {@code setTypeValue} if the original operation method
-	 * does not specify a SQL type.
+	 * does not specify an SQL type.
 	 * @see java.sql.Types
 	 * @see JdbcOperations#update(String, Object[])
 	 */
@@ -59,7 +59,7 @@ public interface SqlTypeValue {
 	 * @param paramIndex the index of the parameter for which we need to set the value
 	 * @param sqlType the SQL type of the parameter we are setting
 	 * @param typeName the type name of the parameter (optional)
-	 * @throws SQLException if a SQLException is encountered while setting parameter values
+	 * @throws SQLException if an SQLException is encountered while setting parameter values
 	 * @see java.sql.Types
 	 * @see java.sql.PreparedStatement#setObject
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/core/StatementCallback.java

@@ -62,7 +62,7 @@ public interface StatementCallback<T> {
 	 * @param stmt active JDBC Statement
 	 * @return a result object, or {@code null} if none
 	 * @throws SQLException if thrown by a JDBC method, to be auto-converted
-	 * to a DataAccessException by a SQLExceptionTranslator
+	 * to a DataAccessException by an SQLExceptionTranslator
 	 * @throws DataAccessException in case of custom exceptions
 	 * @see JdbcTemplate#queryForObject(String, Class)
 	 * @see JdbcTemplate#queryForRowSet(String)

spring-jdbc/src/main/java/org/springframework/jdbc/core/StatementCreatorUtils.java

@@ -153,7 +153,7 @@ public static void setParameterValue(PreparedStatement ps, int paramIndex, SqlPa
 	 * @param ps the prepared statement or callable statement
 	 * @param paramIndex index of the parameter we are setting
 	 * @param sqlType the SQL type of the parameter
-	 * @param inValue the value to set (plain value or a SqlTypeValue)
+	 * @param inValue the value to set (plain value or an SqlTypeValue)
 	 * @throws SQLException if thrown by PreparedStatement methods
 	 * @see SqlTypeValue
 	 */
@@ -171,7 +171,7 @@ public static void setParameterValue(PreparedStatement ps, int paramIndex, int s
 	 * @param sqlType the SQL type of the parameter
 	 * @param typeName the type name of the parameter
 	 * (optional, only used for SQL NULL and SqlTypeValue)
-	 * @param inValue the value to set (plain value or a SqlTypeValue)
+	 * @param inValue the value to set (plain value or an SqlTypeValue)
 	 * @throws SQLException if thrown by PreparedStatement methods
 	 * @see SqlTypeValue
 	 */
@@ -191,7 +191,7 @@ public static void setParameterValue(PreparedStatement ps, int paramIndex, int s
 	 * (optional, only used for SQL NULL and SqlTypeValue)
 	 * @param scale the number of digits after the decimal point
 	 * (for DECIMAL and NUMERIC types)
-	 * @param inValue the value to set (plain value or a SqlTypeValue)
+	 * @param inValue the value to set (plain value or an SqlTypeValue)
 	 * @throws SQLException if thrown by PreparedStatement methods
 	 * @see SqlTypeValue
 	 */

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

@@ -391,7 +391,7 @@ protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters)
 					if (param == null) {
 						throw new InvalidDataAccessApiUsageException(
 								"Unable to locate declared parameter for function return value - " +
-								" add a SqlOutParameter with name '" + getFunctionReturnName() + "'");
+								" add an SqlOutParameter with name '" + getFunctionReturnName() + "'");
 					}
 					else if (paramName != null) {
 						setFunctionReturnName(paramName);

spring-jdbc/src/main/java/org/springframework/jdbc/core/namedparam/AbstractSqlParameterSource.java

@@ -47,7 +47,7 @@ public abstract class AbstractSqlParameterSource implements SqlParameterSource {
 
 
 	/**
-	 * Register a SQL type for the given parameter.
+	 * Register an SQL type for the given parameter.
 	 * @param paramName the name of the parameter
 	 * @param sqlType the SQL type of the parameter
 	 */
@@ -57,7 +57,7 @@ public void registerSqlType(String paramName, int sqlType) {
 	}
 
 	/**
-	 * Register a SQL type for the given parameter.
+	 * Register an SQL type for the given parameter.
 	 * @param paramName the name of the parameter
 	 * @param typeName the type name of the parameter
 	 */