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

Fix typos related to indefinite articles for SQL acronym 

Closes gh-23603
This commit is contained in:
康智冬 2019-09-07 22:04:47 +08:00 committed by Sam Brannen
parent df7e4ad023
commit 0d742cf3d0
41 changed files with 63 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spring-jdbc/src/main/java/org/springframework/jdbc/SQLWarningException.java
View File

@ -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.

2
spring-jdbc/src/main/java/org/springframework/jdbc/UncategorizedSQLException.java
View File

@ -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

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

@ -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;

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

@ -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

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

@ -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

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

@ -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)

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

@ -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()
*/

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

@ -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

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

@ -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
*/

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

@ -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()
*/

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

@ -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;

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

@ -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;

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

@ -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[])

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

@ -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

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

@ -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;

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

@ -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
*/

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

@ -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;

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

@ -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

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

@ -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

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

@ -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

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

@ -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

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

@ -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
*/

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

@ -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)

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

@ -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
*/

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

@ -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);

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

@ -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
*/

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

@ -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)

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

@ -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 = "\"':&,;()|=+-*%/\\<>^";

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

@ -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;

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

@ -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)
*/

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

@ -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 {

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

@ -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

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

@ -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}

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

@ -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

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

@ -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.

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

@ -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)

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

@ -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()

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

@ -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
*/

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

@ -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;

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

@ -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.

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

@ -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
*/