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 @@ import org.springframework.dao.UncategorizedDataAccessException;
 /**
  * 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.dao.UncategorizedDataAccessException;
 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 @@ import org.springframework.lang.Nullable;
 
 /**
  * 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 @@ public interface JdbcOperations {
 
 	/**
 	 * 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 @@ public interface JdbcOperations {
 	 * @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 @@ public interface JdbcOperations {
 
 	/**
 	 * 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 @@ public interface JdbcOperations {
 	 * (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 @@ public interface JdbcOperations {
 	<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 class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	/**
 	 * 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 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	}
 
 	/**
-	 * 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 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 	}
 
 	/**
-	 * 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 @@ public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
 
 	/**
 	 * 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 @@ import org.springframework.util.Assert;
 
 /**
  * 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.lang.Nullable;
 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 @@ package org.springframework.jdbc.core;
 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 abstract class StatementCreatorUtils {
 	 * @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 abstract class StatementCreatorUtils {
 	 * @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 abstract class StatementCreatorUtils {
 	 * (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 @@ public class CallMetaDataContext {
 					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 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 typeName the type name of the parameter
 	 */

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

@@ -406,7 +406,7 @@ public interface NamedParameterJdbcOperations {
 
 	/**
 	 * Query given SQL to create a prepared statement from SQL and a
-	 * list of arguments to bind to the query, expecting a SqlRowSet.
+	 * list of 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
@@ -415,7 +415,7 @@ public interface NamedParameterJdbcOperations {
 	 * Sun's JDBC RowSet Implementations download (rowset.jar).
 	 * @param sql the SQL query to execute
 	 * @param paramSource container of arguments to bind to the query
-	 * @return a SqlRowSet representation (possibly a wrapper around a
+	 * @return an SqlRowSet representation (possibly a wrapper around a
 	 * {@code javax.sql.rowset.CachedRowSet})
 	 * @throws org.springframework.dao.DataAccessException if there is any problem executing the query
 	 * @see org.springframework.jdbc.core.JdbcTemplate#queryForRowSet(String)
@@ -426,7 +426,7 @@ public interface NamedParameterJdbcOperations {
 
 	/**
 	 * Query given SQL to create a prepared statement from SQL and a
-	 * list of arguments to bind to the query, expecting a SqlRowSet.
+	 * list of 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
@@ -436,7 +436,7 @@ public interface NamedParameterJdbcOperations {
 	 * @param sql the SQL query to execute
 	 * @param paramMap map of parameters to bind to the query
 	 * (leaving it to the PreparedStatement to guess the corresponding SQL type)
-	 * @return a SqlRowSet representation (possibly a wrapper around a
+	 * @return an SqlRowSet representation (possibly a wrapper around a
 	 * {@code javax.sql.rowset.CachedRowSet})
 	 * @throws org.springframework.dao.DataAccessException if there is any problem executing the query
 	 * @see org.springframework.jdbc.core.JdbcTemplate#queryForRowSet(String)

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

@@ -52,7 +52,7 @@ public abstract class NamedParameterUtils {
 
 	/**
 	 * Set of characters that qualify as parameter separators,
-	 * indicating that a parameter name in a SQL String has ended.
+	 * indicating that a parameter name in an SQL String has ended.
 	 */
 	private static final String PARAMETER_SEPARATORS = "\"':&,;()|=+-*%/\\<>^";
 

spring-jdbc/src/main/java/org/springframework/jdbc/core/support/AbstractInterruptibleBatchPreparedStatementSetter.java

@@ -71,7 +71,7 @@ public abstract class AbstractInterruptibleBatchPreparedStatementSetter
 	 * @return whether there were values to apply (that is, whether the applied
 	 * parameters should be added to the batch and this method should be called
 	 * for a further iteration)
-	 * @throws SQLException if a SQLException is encountered
+	 * @throws SQLException if an SQLException is encountered
 	 * (i.e. there is no need to catch SQLException)
 	 */
 	protected abstract boolean setValuesIfAvailable(PreparedStatement ps, int i) throws SQLException;

spring-jdbc/src/main/java/org/springframework/jdbc/core/support/AbstractSqlTypeValue.java

@@ -72,7 +72,7 @@ public abstract class AbstractSqlTypeValue implements SqlTypeValue {
 	 * @param sqlType the SQL type of the parameter we are setting
 	 * @param typeName the type name of the parameter
 	 * @return the type value
-	 * @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)
 	 * @see java.sql.PreparedStatement#setObject(int, Object, int)
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/datasource/SingleConnectionDataSource.java

@@ -175,7 +175,7 @@ public class SingleConnectionDataSource extends DriverManagerDataSource implemen
 	/**
 	 * Specifying a custom username and password doesn't make sense
 	 * with a single Connection. Returns the single Connection if given
-	 * the same username and password; throws a SQLException else.
+	 * the same username and password; throws an SQLException else.
 	 */
 	@Override
 	public Connection getConnection(String username, String password) throws SQLException {

spring-jdbc/src/main/java/org/springframework/jdbc/object/SqlCall.java

@@ -29,7 +29,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
- * RdbmsOperation using a JdbcTemplate and representing a SQL-based
+ * RdbmsOperation using a JdbcTemplate and representing an SQL-based
  * call such as a stored procedure or a stored function.
  *
  * <p>Configures a CallableStatementCreatorFactory based on the declared

spring-jdbc/src/main/java/org/springframework/jdbc/object/SqlOperation.java

@@ -25,7 +25,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
- * Operation object representing a SQL-based operation such as a query or update,
+ * Operation object representing an SQL-based operation such as a query or update,
  * as opposed to a stored procedure.
  *
  * <p>Configures a {@link org.springframework.jdbc.core.PreparedStatementCreatorFactory}

spring-jdbc/src/main/java/org/springframework/jdbc/object/SqlQuery.java

@@ -30,7 +30,7 @@ import org.springframework.jdbc.core.namedparam.ParsedSql;
 import org.springframework.lang.Nullable;
 
 /**
- * Reusable operation object representing a SQL query.
+ * Reusable operation object representing an SQL query.
  *
  * <p>Subclasses must implement the {@link #newRowMapper} method to provide
  * an object that can extract the results of iterating over the

spring-jdbc/src/main/java/org/springframework/jdbc/object/SqlUpdate.java

@@ -29,7 +29,7 @@ import org.springframework.jdbc.core.namedparam.ParsedSql;
 import org.springframework.jdbc.support.KeyHolder;
 
 /**
- * Reusable operation object representing a SQL update.
+ * Reusable operation object representing an SQL update.
  *
  * <p>This class provides a number of {@code update} methods,
  * analogous to the {@code execute} methods of query objects.

spring-jdbc/src/main/java/org/springframework/jdbc/support/DatabaseMetaDataCallback.java

@@ -37,7 +37,7 @@ public interface DatabaseMetaDataCallback {
 	 * @param dbmd the DatabaseMetaData to process
 	 * @return a result object extracted from the meta-data
 	 * (can be an arbitrary object, as needed by the implementation)
-	 * @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)
 	 * @throws MetaDataAccessException in case of other failures while
 	 * extracting meta-data (for example, reflection failure)

spring-jdbc/src/main/java/org/springframework/jdbc/support/JdbcAccessor.java

@@ -80,7 +80,7 @@ public abstract class JdbcAccessor implements InitializingBean {
 
 	/**
 	 * Specify the database product name for the DataSource that this accessor uses.
-	 * This allows to initialize a SQLErrorCodeSQLExceptionTranslator without
+	 * This allows to initialize an SQLErrorCodeSQLExceptionTranslator without
 	 * obtaining a Connection from the DataSource to get the meta-data.
 	 * @param dbName the database product name that identifies the error codes entry
 	 * @see SQLErrorCodeSQLExceptionTranslator#setDatabaseProductName
@@ -132,7 +132,7 @@ public abstract class JdbcAccessor implements InitializingBean {
 
 	/**
 	 * Set whether to lazily initialize the SQLExceptionTranslator for this accessor,
-	 * on first encounter of a SQLException. Default is "true"; can be switched to
+	 * on first encounter of an SQLException. Default is "true"; can be switched to
 	 * "false" for initialization on startup.
 	 * <p>Early initialization just applies if {@code afterPropertiesSet()} is called.
 	 * @see #getExceptionTranslator()

spring-jdbc/src/main/java/org/springframework/jdbc/support/SQLErrorCodeSQLExceptionTranslator.java

@@ -88,7 +88,7 @@ public class SQLErrorCodeSQLExceptionTranslator extends AbstractFallbackSQLExcep
 	}
 
 	/**
-	 * Create a SQL error code translator for the given DataSource.
+	 * Create an SQL error code translator for the given DataSource.
 	 * Invoking this constructor will cause a Connection to be obtained
 	 * from the DataSource to get the meta-data.
 	 * @param dataSource the DataSource to use to find meta-data and establish
@@ -101,7 +101,7 @@ public class SQLErrorCodeSQLExceptionTranslator extends AbstractFallbackSQLExcep
 	}
 
 	/**
-	 * Create a SQL error code translator for the given database product name.
+	 * Create an SQL error code translator for the given database product name.
 	 * Invoking this constructor will avoid obtaining a Connection from the
 	 * DataSource to get the meta-data.
 	 * @param dbName the database product name that identifies the error codes entry
@@ -114,7 +114,7 @@ public class SQLErrorCodeSQLExceptionTranslator extends AbstractFallbackSQLExcep
 	}
 
 	/**
-	 * Create a SQLErrorCode translator given these error codes.
+	 * Create an SQLErrorCode translator given these error codes.
 	 * Does not require a database meta-data lookup to be performed using a connection.
 	 * @param sec error codes
 	 */

spring-jdbc/src/main/java/org/springframework/jdbc/support/SqlValue.java

@@ -39,7 +39,7 @@ public interface SqlValue {
 	 * Set the value on the given PreparedStatement.
 	 * @param ps the PreparedStatement to work on
 	 * @param paramIndex the index of the parameter for which we need to set the value
-	 * @throws SQLException if a SQLException is encountered while setting parameter values
+	 * @throws SQLException if an SQLException is encountered while setting parameter values
 	 */
 	void setValue(PreparedStatement ps, int paramIndex)	throws SQLException;
 

spring-jdbc/src/main/java/org/springframework/jdbc/support/rowset/SqlRowSet.java

@@ -31,8 +31,8 @@ import org.springframework.jdbc.InvalidResultSetAccessException;
  * {@link java.sql.ResultSet} data.
  *
  * <p>The main difference to the standard JDBC RowSet is that a {@link java.sql.SQLException}
- * is never thrown here. This allows a SqlRowSet to be used without having to deal with
- * checked exceptions. A SqlRowSet will throw Spring's {@link InvalidResultSetAccessException}
+ * is never thrown here. This allows an SqlRowSet to be used without having to deal with
+ * checked exceptions. An SqlRowSet will throw Spring's {@link InvalidResultSetAccessException}
  * instead (when appropriate).
  *
  * <p>Note: This interface extends the {@code java.io.Serializable} marker interface.

spring-tx/src/main/java/org/springframework/dao/UncategorizedDataAccessException.java

@@ -21,7 +21,7 @@ import org.springframework.lang.Nullable;
 /**
  * Normal superclass when we can't distinguish anything more specific
  * than "something went wrong with the underlying resource": for example,
- * a SQLException from JDBC we can't pinpoint more precisely.
+ * an SQLException from JDBC we can't pinpoint more precisely.
  *
  * @author Rod Johnson
  */