## Uses of Class
org.springframework.dao.DataAccessException

- Packages that use DataAccessException
  Package | Description
  --- | ---
  org.springframework.dao | Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
  org.springframework.dao.support | Support classes for DAO implementations, providing miscellaneous utility methods.
  org.springframework.jca.cci | This package contains Spring's support for the Common Client Interface (CCI), as defined by the J2EE Connector Architecture.
  org.springframework.jca.cci.core | Provides the core JCA CCI support, based on CciTemplate and its associated callback interfaces.
  org.springframework.jca.cci.object | The classes in this package represent EIS operations as threadsafe, reusable objects.
  org.springframework.jdbc | The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
  org.springframework.jdbc.core | Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
  org.springframework.jdbc.core.namedparam | JdbcTemplate variant with named parameter support.
  org.springframework.jdbc.core.support | Classes supporting the `org.springframework.jdbc.core` package.
  org.springframework.jdbc.datasource.init | Provides extensible support for initializing databases through scripts.
  org.springframework.jdbc.datasource.lookup | Provides a strategy for looking up JDBC DataSources by name.
  org.springframework.jdbc.object | The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
  org.springframework.jdbc.support | Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
  org.springframework.jdbc.support.incrementer | Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
  org.springframework.jdbc.support.xml | Abstraction for handling fields of SQLXML data type.
  org.springframework.orm | Root package for Spring's O/R Mapping integration classes.
  org.springframework.orm.hibernate5 | Package providing integration of Hibernate 5.x with Spring concepts.
  org.springframework.orm.hibernate5.support | Classes supporting the `org.springframework.orm.hibernate5` package.
  org.springframework.orm.jpa | Package providing integration of JPA (Java Persistence API) with Spring concepts.
  org.springframework.orm.jpa.support | Classes supporting the `org.springframework.orm.jpa` package.
  org.springframework.orm.jpa.vendor | Support classes for adapting to specific JPA vendors.
  org.springframework.r2dbc | The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
  org.springframework.r2dbc.connection | Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
  org.springframework.r2dbc.connection.lookup | Provides a strategy for looking up R2DBC ConnectionFactories by name.
  org.springframework.r2dbc.core.binding | Classes providing an abstraction over SQL bind markers.
  org.springframework.test.context.junit4 | Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
  org.springframework.test.context.testng | Support classes for integrating the Spring TestContext Framework with TestNG.

- - ### Uses of DataAccessException in org.springframework.dao

    Subclasses of DataAccessException in org.springframework.dao
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CannotAcquireLockException` Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.
    `class` | `CannotSerializeTransactionException` Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.
    `class` | `CleanupFailureDataAccessException` Exception thrown when we couldn't clean up after a data access operation, but the actual operation went OK.
    `class` | `ConcurrencyFailureException` Exception thrown on various data access concurrency failures.
    `class` | `DataAccessResourceFailureException` Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
    `class` | `DataIntegrityViolationException` Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.
    `class` | `DataRetrievalFailureException` Exception thrown if certain expected data could not be retrieved, e.g.
    `class` | `DeadlockLoserDataAccessException` Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back.
    `class` | `DuplicateKeyException` Exception thrown when an attempt to insert or update data results in violation of a primary key or unique constraint.
    `class` | `EmptyResultDataAccessException` Data access exception thrown when a result was expected to have at least one row (or element) but zero rows (or elements) were actually returned.
    `class` | `IncorrectResultSizeDataAccessException` Data access exception thrown when a result was not of the expected size, for example when expecting a single row but getting 0 or more than 1 rows.
    `class` | `IncorrectUpdateSemanticsDataAccessException` Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
    `class` | `InvalidDataAccessApiUsageException` Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
    `class` | `InvalidDataAccessResourceUsageException` Root for exceptions thrown when we use a data access resource incorrectly.
    `class` | `NonTransientDataAccessException` Root of the hierarchy of data access exceptions that are considered non-transient - where a retry of the same operation would fail unless the cause of the Exception is corrected.
    `class` | `NonTransientDataAccessResourceException` Data access exception thrown when a resource fails completely and the failure is permanent.
    `class` | `OptimisticLockingFailureException` Exception thrown on an optimistic locking violation.
    `class` | `PermissionDeniedDataAccessException` Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
    `class` | `PessimisticLockingFailureException` Exception thrown on a pessimistic locking violation.
    `class` | `QueryTimeoutException` Exception to be thrown on a query timeout.
    `class` | `RecoverableDataAccessException` Data access exception thrown when a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
    `class` | `TransientDataAccessException` Root of the hierarchy of data access exceptions that are considered transient - where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
    `class` | `TransientDataAccessResourceException` Data access exception thrown when a resource fails temporarily and the operation can be retried.
    `class` | `TypeMismatchDataAccessException` Exception thrown on mismatch between Java type and database type: for example on an attempt to set an object of the wrong type in an RDBMS column.
    `class` | `UncategorizedDataAccessException` Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, an SQLException from JDBC we can't pinpoint more precisely.

  - ### Uses of DataAccessException in org.springframework.dao.support

    Methods in org.springframework.dao.support that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `DataAccessException` | ChainedPersistenceExceptionTranslator.`translateExceptionIfPossible(RuntimeException ex)`
    `DataAccessException` | PersistenceExceptionTranslator.`translateExceptionIfPossible(RuntimeException ex)` Translate the given runtime exception thrown by a persistence framework to a corresponding exception from Spring's generic `DataAccessException` hierarchy, if possible.

  - ### Uses of DataAccessException in org.springframework.jca.cci

    Subclasses of DataAccessException in org.springframework.jca.cci
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CannotCreateRecordException` Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
    `class` | `CannotGetCciConnectionException` Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
    `class` | `CciOperationNotSupportedException` Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
    `class` | `RecordTypeNotSupportedException` Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)

  - ### Uses of DataAccessException in org.springframework.jca.cci.core

    Methods in org.springframework.jca.cci.core that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `IndexedRecord` | CciTemplate.`createIndexedRecord(String name)` Deprecated. Create an indexed Record through the ConnectionFactory's RecordFactory.
    `MappedRecord` | CciTemplate.`createMappedRecord(String name)` Deprecated. Create a mapped Record from the ConnectionFactory's RecordFactory.
    `protected Record` | CciTemplate.`createRecord(RecordCreator recordCreator)` Deprecated. Invoke the given RecordCreator, converting JCA ResourceExceptions to Spring's DataAccessException hierarchy.
    `Record` | RecordCreator.`createRecord(RecordFactory recordFactory)` Deprecated. Create a CCI Record instance, usually based on the passed-in CCI RecordFactory.
    `protected <T> T` | CciTemplate.`doExecute(InteractionSpec spec, Record inputRecord, Record outputRecord, RecordExtractor<T> outputExtractor)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `T` | ConnectionCallback.`doInConnection(Connection connection, ConnectionFactory connectionFactory)` Deprecated. Gets called by `CciTemplate.execute` with an active CCI Connection.
    `T` | InteractionCallback.`doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)` Deprecated. Gets called by `CciTemplate.execute` with an active CCI Interaction.
    `<T> T` | CciOperations.`execute(ConnectionCallback<T> action)` Deprecated. Execute a request on an EIS with CCI, implemented as callback action working on a CCI Connection.
    `<T> T` | CciTemplate.`execute(ConnectionCallback<T> action)` Deprecated.
    `<T> T` | CciOperations.`execute(InteractionCallback<T> action)` Deprecated. Execute a request on an EIS with CCI, implemented as callback action working on a CCI Interaction.
    `<T> T` | CciTemplate.`execute(InteractionCallback<T> action)` Deprecated.
    `Record` | CciOperations.`execute(InteractionSpec spec, Record inputRecord)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `Record` | CciTemplate.`execute(InteractionSpec spec, Record inputRecord)` Deprecated.
    `Record` | CciOperations.`execute(InteractionSpec spec, RecordCreator inputCreator)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `Record` | CciTemplate.`execute(InteractionSpec spec, RecordCreator inputCreator)` Deprecated.
    `<T> T` | CciOperations.`execute(InteractionSpec spec, RecordCreator inputCreator, RecordExtractor<T> outputExtractor)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `<T> T` | CciTemplate.`execute(InteractionSpec spec, RecordCreator inputCreator, RecordExtractor<T> outputExtractor)` Deprecated.
    `void` | CciOperations.`execute(InteractionSpec spec, Record inputRecord, Record outputRecord)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `void` | CciTemplate.`execute(InteractionSpec spec, Record inputRecord, Record outputRecord)` Deprecated.
    `<T> T` | CciOperations.`execute(InteractionSpec spec, Record inputRecord, RecordExtractor<T> outputExtractor)` Deprecated. Execute the specified interaction on an EIS with CCI.
    `<T> T` | CciTemplate.`execute(InteractionSpec spec, Record inputRecord, RecordExtractor<T> outputExtractor)` Deprecated.
    `T` | RecordExtractor.`extractData(Record record)` Deprecated. Process the data in the given Record, creating a corresponding result object.

  - ### Uses of DataAccessException in org.springframework.jca.cci.object

    Methods in org.springframework.jca.cci.object that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract Object` | MappingCommAreaOperation.`bytesToObject(byte[] bytes)` Deprecated. Method used to convert the COMMAREA's bytes to an object.
    `protected abstract Record` | MappingRecordOperation.`createInputRecord(RecordFactory recordFactory, Object inputObject)` Deprecated. Subclasses must implement this method to generate an input Record from an input object passed into the `execute` method.
    `Record` | MappingRecordOperation.RecordCreatorImpl.`createRecord(RecordFactory recordFactory)`
    `Object` | MappingRecordOperation.`execute(Object inputObject)` Deprecated. Execute the interaction encapsulated by this operation object.
    `Record` | SimpleRecordOperation.`execute(Record inputRecord)` Deprecated. Execute the CCI interaction encapsulated by this operation object.
    `void` | SimpleRecordOperation.`execute(Record inputRecord, Record outputRecord)` Deprecated. Execute the CCI interaction encapsulated by this operation object.
    `Object` | MappingRecordOperation.RecordExtractorImpl.`extractData(Record record)`
    `protected Object` | MappingCommAreaOperation.`extractOutputData(Record record)` Deprecated.
    `protected abstract Object` | MappingRecordOperation.`extractOutputData(Record outputRecord)` Deprecated. Subclasses must implement this method to convert the Record returned by CCI execution into a result object for the `execute` method.
    `protected abstract byte[]` | MappingCommAreaOperation.`objectToBytes(Object inObject)` Deprecated. Method used to convert an object into COMMAREA bytes.

  - ### Uses of DataAccessException in org.springframework.jdbc

    Subclasses of DataAccessException in org.springframework.jdbc
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BadSqlGrammarException` Exception thrown when SQL specified is invalid.
    `class` | `CannotGetJdbcConnectionException` Fatal exception thrown when we can't connect to an RDBMS using JDBC.
    `class` | `IncorrectResultSetColumnCountException` Data access exception thrown when a result set did not have the correct column count, for example when expecting a single column but getting 0 or more than 1 column.
    `class` | `InvalidResultSetAccessException` Exception thrown when a ResultSet has been accessed in an invalid fashion.
    `class` | `JdbcUpdateAffectedIncorrectNumberOfRowsException` Exception thrown when a JDBC update affects an unexpected number of rows.
    `class` | `LobRetrievalFailureException` Exception to be thrown when a LOB could not be retrieved.
    `class` | `SQLWarningException` Exception thrown when we're not ignoring `SQLWarnings`.
    `class` | `UncategorizedSQLException` Exception thrown when we can't classify an SQLException into one of our generic data access exceptions.

  - ### Uses of DataAccessException in org.springframework.jdbc.core

    Methods in org.springframework.jdbc.core that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected DataAccessException` | JdbcTemplate.`translateException(String task, String sql, SQLException ex)` Translate the given `SQLException` into a generic `DataAccessException`.

    Methods in org.springframework.jdbc.core that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `int[]` | JdbcOperations.`batchUpdate(String... sql)` Issue multiple SQL updates on a single JDBC Statement using batching.
    `int[]` | JdbcTemplate.`batchUpdate(String... sql)`
    `int[]` | JdbcOperations.`batchUpdate(String sql, BatchPreparedStatementSetter pss)` Issue multiple update statements on a single PreparedStatement, using batch updates and a BatchPreparedStatementSetter to set values.
    `int[]` | JdbcTemplate.`batchUpdate(String sql, BatchPreparedStatementSetter pss)`
    `<T> int[][]` | JdbcOperations.`batchUpdate(String sql, Collection<T> batchArgs, int batchSize, ParameterizedPreparedStatementSetter<T> pss)` Execute multiple batches using the supplied SQL statement with the collect of supplied arguments.
    `<T> int[][]` | JdbcTemplate.`batchUpdate(String sql, Collection<T> batchArgs, int batchSize, ParameterizedPreparedStatementSetter<T> pss)`
    `int[]` | JdbcOperations.`batchUpdate(String sql, List<Object[]> batchArgs)` Execute a batch using the supplied SQL statement with the batch of supplied arguments.
    `int[]` | JdbcTemplate.`batchUpdate(String sql, List<Object[]> batchArgs)`
    `int[]` | JdbcOperations.`batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes)` Execute a batch using the supplied SQL statement with the batch of supplied arguments.
    `int[]` | JdbcTemplate.`batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes)`
    `Map<String,Object>` | JdbcOperations.`call(CallableStatementCreator csc, List<SqlParameter> declaredParameters)` Execute an SQL call using a CallableStatementCreator to provide SQL and any required parameters.
    `Map<String,Object>` | JdbcTemplate.`call(CallableStatementCreator csc, List<SqlParameter> declaredParameters)`
    `T` | CallableStatementCallback.`doInCallableStatement(CallableStatement cs)` Gets called by `JdbcTemplate.execute` with an active JDBC CallableStatement.
    `T` | ConnectionCallback.`doInConnection(Connection con)` Gets called by `JdbcTemplate.execute` with an active JDBC Connection.
    `T` | PreparedStatementCallback.`doInPreparedStatement(PreparedStatement ps)` Gets called by `JdbcTemplate.execute` with an active JDBC PreparedStatement.
    `T` | StatementCallback.`doInStatement(Statement stmt)` Gets called by `JdbcTemplate.execute` with an active JDBC Statement.
    `<T> T` | JdbcOperations.`execute(CallableStatementCreator csc, CallableStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC CallableStatement.
    `<T> T` | JdbcTemplate.`execute(CallableStatementCreator csc, CallableStatementCallback<T> action)`
    `<T> T` | JdbcOperations.`execute(ConnectionCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC Connection.
    `<T> T` | JdbcTemplate.`execute(ConnectionCallback<T> action)`
    `<T> T` | JdbcOperations.`execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
    `<T> T` | JdbcTemplate.`execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)`
    `<T> T` | JdbcOperations.`execute(StatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC Statement.
    `<T> T` | JdbcTemplate.`execute(StatementCallback<T> action)`
    `void` | JdbcOperations.`execute(String sql)` Issue a single SQL execute, typically a DDL statement.
    `void` | JdbcTemplate.`execute(String sql)`
    `<T> T` | JdbcOperations.`execute(String callString, CallableStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC CallableStatement.
    `<T> T` | JdbcTemplate.`execute(String callString, CallableStatementCallback<T> action)`
    `<T> T` | JdbcOperations.`execute(String sql, PreparedStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
    `<T> T` | JdbcTemplate.`execute(String sql, PreparedStatementCallback<T> action)`
    `T` | ResultSetExtractor.`extractData(ResultSet rs)` Implementations must implement this method to process the entire ResultSet.
    `<T> T` | JdbcTemplate.`query(PreparedStatementCreator psc, PreparedStatementSetter pss, ResultSetExtractor<T> rse)` Query using a prepared statement, allowing for a PreparedStatementCreator and a PreparedStatementSetter.
    `<T> T` | JdbcOperations.`query(PreparedStatementCreator psc, ResultSetExtractor<T> rse)` Query using a prepared statement, reading the ResultSet with a ResultSetExtractor.
    `<T> T` | JdbcTemplate.`query(PreparedStatementCreator psc, ResultSetExtractor<T> rse)`
    `void` | JdbcOperations.`query(PreparedStatementCreator psc, RowCallbackHandler rch)` Query using a prepared statement, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `void` | JdbcTemplate.`query(PreparedStatementCreator psc, RowCallbackHandler rch)`
    `<T> List<T>` | JdbcOperations.`query(PreparedStatementCreator psc, RowMapper<T> rowMapper)` Query using a prepared statement, mapping each row to a result object via a RowMapper.
    `<T> List<T>` | JdbcTemplate.`query(PreparedStatementCreator psc, RowMapper<T> rowMapper)`
    `<T> T` | JdbcOperations.`query(String sql, Object[] args, int[] argTypes, ResultSetExtractor<T> rse)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet with a ResultSetExtractor.
    `<T> T` | JdbcTemplate.`query(String sql, Object[] args, int[] argTypes, ResultSetExtractor<T> rse)`
    `void` | JdbcOperations.`query(String sql, Object[] args, int[] argTypes, RowCallbackHandler rch)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `void` | JdbcTemplate.`query(String sql, Object[] args, int[] argTypes, RowCallbackHandler rch)`
    `<T> List<T>` | JdbcOperations.`query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a result object via a RowMapper.
    `<T> List<T>` | JdbcTemplate.`query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)`
    `<T> T` | JdbcOperations.`query(String sql, Object[] args, ResultSetExtractor<T> rse)` Deprecated. as of 5.3, in favor of `JdbcOperations.query(String, ResultSetExtractor, Object...)`
    `<T> T` | JdbcTemplate.`query(String sql, Object[] args, ResultSetExtractor<T> rse)` Deprecated.
    `void` | JdbcOperations.`query(String sql, Object[] args, RowCallbackHandler rch)` Deprecated. as of 5.3, in favor of `JdbcOperations.query(String, RowCallbackHandler, Object...)`
    `void` | JdbcTemplate.`query(String sql, Object[] args, RowCallbackHandler rch)` Deprecated.
    `<T> List<T>` | JdbcOperations.`query(String sql, Object[] args, RowMapper<T> rowMapper)` Deprecated. as of 5.3, in favor of `JdbcOperations.query(String, RowMapper, Object...)`
    `<T> List<T>` | JdbcTemplate.`query(String sql, Object[] args, RowMapper<T> rowMapper)` Deprecated.
    `<T> T` | JdbcOperations.`query(String sql, PreparedStatementSetter pss, ResultSetExtractor<T> rse)` Query using a prepared statement, reading the ResultSet with a ResultSetExtractor.
    `<T> T` | JdbcTemplate.`query(String sql, PreparedStatementSetter pss, ResultSetExtractor<T> rse)`
    `void` | JdbcOperations.`query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch)` Query given SQL to create a prepared statement from SQL and a PreparedStatementSetter implementation that knows how to bind values to the query, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `void` | JdbcTemplate.`query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch)`
    `<T> List<T>` | JdbcOperations.`query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a PreparedStatementSetter implementation that knows how to bind values to the query, mapping each row to a result object via a RowMapper.
    `<T> List<T>` | JdbcTemplate.`query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)`
    `<T> T` | JdbcOperations.`query(String sql, ResultSetExtractor<T> rse)` Execute a query given static SQL, reading the ResultSet with a ResultSetExtractor.
    `<T> T` | JdbcTemplate.`query(String sql, ResultSetExtractor<T> rse)`
    `<T> T` | JdbcOperations.`query(String sql, ResultSetExtractor<T> rse, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet with a ResultSetExtractor.
    `<T> T` | JdbcTemplate.`query(String sql, ResultSetExtractor<T> rse, Object... args)`
    `void` | JdbcOperations.`query(String sql, RowCallbackHandler rch)` Execute a query given static SQL, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `void` | JdbcTemplate.`query(String sql, RowCallbackHandler rch)`
    `void` | JdbcOperations.`query(String sql, RowCallbackHandler rch, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `void` | JdbcTemplate.`query(String sql, RowCallbackHandler rch, Object... args)`
    `<T> List<T>` | JdbcOperations.`query(String sql, RowMapper<T> rowMapper)` Execute a query given static SQL, mapping each row to a result object via a RowMapper.
    `<T> List<T>` | JdbcTemplate.`query(String sql, RowMapper<T> rowMapper)`
    `<T> List<T>` | JdbcOperations.`query(String sql, RowMapper<T> rowMapper, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a result object via a RowMapper.
    `<T> List<T>` | JdbcTemplate.`query(String sql, RowMapper<T> rowMapper, Object... args)`
    `List<Map<String,Object>>` | JdbcOperations.`queryForList(String sql)` Execute a query for a result list, given static SQL.
    `List<Map<String,Object>>` | JdbcTemplate.`queryForList(String sql)`
    `<T> List<T>` | JdbcOperations.`queryForList(String sql, Class<T> elementType)` Execute a query for a result list, given static SQL.
    `<T> List<T>` | JdbcTemplate.`queryForList(String sql, Class<T> elementType)`
    `<T> List<T>` | JdbcOperations.`queryForList(String sql, Class<T> elementType, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `<T> List<T>` | JdbcTemplate.`queryForList(String sql, Class<T> elementType, Object... args)`
    `List<Map<String,Object>>` | JdbcOperations.`queryForList(String sql, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `List<Map<String,Object>>` | JdbcTemplate.`queryForList(String sql, Object... args)`
    `<T> List<T>` | JdbcOperations.`queryForList(String sql, Object[] args, Class<T> elementType)` Deprecated. as of 5.3, in favor of `JdbcOperations.queryForList(String, Class, Object...)`
    `<T> List<T>` | JdbcTemplate.`queryForList(String sql, Object[] args, Class<T> elementType)` Deprecated.
    `List<Map<String,Object>>` | JdbcOperations.`queryForList(String sql, Object[] args, int[] argTypes)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `List<Map<String,Object>>` | JdbcTemplate.`queryForList(String sql, Object[] args, int[] argTypes)`
    `<T> List<T>` | JdbcOperations.`queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `<T> List<T>` | JdbcTemplate.`queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType)`
    `Map<String,Object>` | JdbcOperations.`queryForMap(String sql)` Execute a query for a result map, given static SQL.
    `Map<String,Object>` | JdbcTemplate.`queryForMap(String sql)`
    `Map<String,Object>` | JdbcOperations.`queryForMap(String sql, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result map.
    `Map<String,Object>` | JdbcTemplate.`queryForMap(String sql, Object... args)`
    `Map<String,Object>` | JdbcOperations.`queryForMap(String sql, Object[] args, int[] argTypes)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result map.
    `Map<String,Object>` | JdbcTemplate.`queryForMap(String sql, Object[] args, int[] argTypes)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, Class<T> requiredType)` Execute a query for a result object, given static SQL.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Class<T> requiredType)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, Class<T> requiredType, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result object.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Class<T> requiredType, Object... args)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, Object[] args, Class<T> requiredType)` Deprecated. as of 5.3, in favor of `JdbcOperations.queryForObject(String, Class, Object...)`
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Object[] args, Class<T> requiredType)` Deprecated.
    `<T> T` | JdbcOperations.`queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result object.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping a single result row to a result object via a RowMapper.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)` Deprecated. as of 5.3, in favor of `JdbcOperations.queryForObject(String, RowMapper, Object...)`
    `<T> T` | JdbcTemplate.`queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)` Deprecated.
    `<T> T` | JdbcOperations.`queryForObject(String sql, RowMapper<T> rowMapper)` Execute a query given static SQL, mapping a single result row to a result object via a RowMapper.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, RowMapper<T> rowMapper)`
    `<T> T` | JdbcOperations.`queryForObject(String sql, RowMapper<T> rowMapper, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping a single result row to a result object via a RowMapper.
    `<T> T` | JdbcTemplate.`queryForObject(String sql, RowMapper<T> rowMapper, Object... args)`
    `SqlRowSet` | JdbcOperations.`queryForRowSet(String sql)` Execute a query for an SqlRowSet, given static SQL.
    `SqlRowSet` | JdbcTemplate.`queryForRowSet(String sql)`
    `SqlRowSet` | JdbcOperations.`queryForRowSet(String sql, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting an SqlRowSet.
    `SqlRowSet` | JdbcTemplate.`queryForRowSet(String sql, Object... args)`
    `SqlRowSet` | JdbcOperations.`queryForRowSet(String sql, Object[] args, int[] argTypes)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting an SqlRowSet.
    `SqlRowSet` | JdbcTemplate.`queryForRowSet(String sql, Object[] args, int[] argTypes)`
    `<T> Stream<T>` | JdbcTemplate.`queryForStream(PreparedStatementCreator psc, PreparedStatementSetter pss, RowMapper<T> rowMapper)` Query using a prepared statement, allowing for a PreparedStatementCreator and a PreparedStatementSetter.
    `<T> Stream<T>` | JdbcOperations.`queryForStream(PreparedStatementCreator psc, RowMapper<T> rowMapper)` Query using a prepared statement, mapping each row to a result object via a RowMapper, and turning it into an iterable and closeable Stream.
    `<T> Stream<T>` | JdbcTemplate.`queryForStream(PreparedStatementCreator psc, RowMapper<T> rowMapper)`
    `<T> Stream<T>` | JdbcOperations.`queryForStream(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a PreparedStatementSetter implementation that knows how to bind values to the query, mapping each row to a result object via a RowMapper, and turning it into an iterable and closeable Stream.
    `<T> Stream<T>` | JdbcTemplate.`queryForStream(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)`
    `<T> Stream<T>` | JdbcOperations.`queryForStream(String sql, RowMapper<T> rowMapper)` Execute a query given static SQL, mapping each row to a result object via a RowMapper, and turning it into an iterable and closeable Stream.
    `<T> Stream<T>` | JdbcTemplate.`queryForStream(String sql, RowMapper<T> rowMapper)`
    `<T> Stream<T>` | JdbcOperations.`queryForStream(String sql, RowMapper<T> rowMapper, Object... args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a result object via a RowMapper, and turning it into an iterable and closeable Stream.
    `<T> Stream<T>` | JdbcTemplate.`queryForStream(String sql, RowMapper<T> rowMapper, Object... args)`
    `int` | JdbcOperations.`update(PreparedStatementCreator psc)` Issue a single SQL update operation (such as an insert, update or delete statement) using a PreparedStatementCreator to provide SQL and any required parameters.
    `int` | JdbcTemplate.`update(PreparedStatementCreator psc)`
    `int` | JdbcOperations.`update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder)` Issue an update statement using a PreparedStatementCreator to provide SQL and any required parameters.
    `int` | JdbcTemplate.`update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder)`
    `protected int` | JdbcTemplate.`update(PreparedStatementCreator psc, PreparedStatementSetter pss)`
    `int` | JdbcOperations.`update(String sql)` Issue a single SQL update operation (such as an insert, update or delete statement).
    `int` | JdbcTemplate.`update(String sql)`
    `int` | JdbcOperations.`update(String sql, Object... args)` Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
    `int` | JdbcTemplate.`update(String sql, Object... args)`
    `int` | JdbcOperations.`update(String sql, Object[] args, int[] argTypes)` Issue a single SQL update operation (such as an insert, update or delete statement) via a prepared statement, binding the given arguments.
    `int` | JdbcTemplate.`update(String sql, Object[] args, int[] argTypes)`
    `int` | JdbcOperations.`update(String sql, PreparedStatementSetter pss)` Issue an update statement using a PreparedStatementSetter to set bind parameters, with given SQL.
    `int` | JdbcTemplate.`update(String sql, PreparedStatementSetter pss)`

  - ### Uses of DataAccessException in org.springframework.jdbc.core.namedparam

    Methods in org.springframework.jdbc.core.namedparam that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `<T> T` | NamedParameterJdbcTemplate.`execute(String sql, Map<String,?> paramMap, PreparedStatementCallback<T> action)`
    `<T> T` | NamedParameterJdbcOperations.`execute(String sql, Map<String,?> paramMap, PreparedStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
    `<T> T` | NamedParameterJdbcTemplate.`execute(String sql, PreparedStatementCallback<T> action)`
    `<T> T` | NamedParameterJdbcOperations.`execute(String sql, PreparedStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
    `<T> T` | NamedParameterJdbcTemplate.`execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback<T> action)`
    `<T> T` | NamedParameterJdbcOperations.`execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback<T> action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
    `<T> T` | NamedParameterJdbcTemplate.`query(String sql, Map<String,?> paramMap, ResultSetExtractor<T> rse)`
    `<T> T` | NamedParameterJdbcOperations.`query(String sql, Map<String,?> paramMap, ResultSetExtractor<T> rse)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet with a ResultSetExtractor.
    `void` | NamedParameterJdbcTemplate.`query(String sql, Map<String,?> paramMap, RowCallbackHandler rch)`
    `void` | NamedParameterJdbcOperations.`query(String sql, Map<String,?> paramMap, RowCallbackHandler rch)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `<T> List<T>` | NamedParameterJdbcTemplate.`query(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)`
    `<T> List<T>` | NamedParameterJdbcOperations.`query(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
    `<T> T` | NamedParameterJdbcTemplate.`query(String sql, ResultSetExtractor<T> rse)`
    `<T> T` | NamedParameterJdbcOperations.`query(String sql, ResultSetExtractor<T> rse)` Query given SQL to create a prepared statement from SQL, reading the ResultSet with a ResultSetExtractor.
    `void` | NamedParameterJdbcTemplate.`query(String sql, RowCallbackHandler rch)`
    `void` | NamedParameterJdbcOperations.`query(String sql, RowCallbackHandler rch)` Query given SQL to create a prepared statement from SQL, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `<T> List<T>` | NamedParameterJdbcTemplate.`query(String sql, RowMapper<T> rowMapper)`
    `<T> List<T>` | NamedParameterJdbcOperations.`query(String sql, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL, mapping each row to a Java object via a RowMapper.
    `<T> T` | NamedParameterJdbcTemplate.`query(String sql, SqlParameterSource paramSource, ResultSetExtractor<T> rse)`
    `<T> T` | NamedParameterJdbcOperations.`query(String sql, SqlParameterSource paramSource, ResultSetExtractor<T> rse)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet with a ResultSetExtractor.
    `void` | NamedParameterJdbcTemplate.`query(String sql, SqlParameterSource paramSource, RowCallbackHandler rch)`
    `void` | NamedParameterJdbcOperations.`query(String sql, SqlParameterSource paramSource, RowCallbackHandler rch)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, reading the ResultSet on a per-row basis with a RowCallbackHandler.
    `<T> List<T>` | NamedParameterJdbcTemplate.`query(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)`
    `<T> List<T>` | NamedParameterJdbcOperations.`query(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper.
    `List<Map<String,Object>>` | NamedParameterJdbcTemplate.`queryForList(String sql, Map<String,?> paramMap)`
    `List<Map<String,Object>>` | NamedParameterJdbcOperations.`queryForList(String sql, Map<String,?> paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `<T> List<T>` | NamedParameterJdbcTemplate.`queryForList(String sql, Map<String,?> paramMap, Class<T> elementType)`
    `<T> List<T>` | NamedParameterJdbcOperations.`queryForList(String sql, Map<String,?> paramMap, Class<T> elementType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `List<Map<String,Object>>` | NamedParameterJdbcTemplate.`queryForList(String sql, SqlParameterSource paramSource)`
    `List<Map<String,Object>>` | NamedParameterJdbcOperations.`queryForList(String sql, SqlParameterSource paramSource)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `<T> List<T>` | NamedParameterJdbcTemplate.`queryForList(String sql, SqlParameterSource paramSource, Class<T> elementType)`
    `<T> List<T>` | NamedParameterJdbcOperations.`queryForList(String sql, SqlParameterSource paramSource, Class<T> elementType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result list.
    `Map<String,Object>` | NamedParameterJdbcTemplate.`queryForMap(String sql, Map<String,?> paramMap)`
    `Map<String,Object>` | NamedParameterJdbcOperations.`queryForMap(String sql, Map<String,?> paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result Map.
    `Map<String,Object>` | NamedParameterJdbcTemplate.`queryForMap(String sql, SqlParameterSource paramSource)`
    `Map<String,Object>` | NamedParameterJdbcOperations.`queryForMap(String sql, SqlParameterSource paramSource)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result Map.
    `<T> T` | NamedParameterJdbcTemplate.`queryForObject(String sql, Map<String,?> paramMap, Class<T> requiredType)`
    `<T> T` | NamedParameterJdbcOperations.`queryForObject(String sql, Map<String,?> paramMap, Class<T> requiredType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result object.
    `<T> T` | NamedParameterJdbcTemplate.`queryForObject(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)`
    `<T> T` | NamedParameterJdbcOperations.`queryForObject(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping a single result row to a Java object via a RowMapper.
    `<T> T` | NamedParameterJdbcTemplate.`queryForObject(String sql, SqlParameterSource paramSource, Class<T> requiredType)`
    `<T> T` | NamedParameterJdbcOperations.`queryForObject(String sql, SqlParameterSource paramSource, Class<T> requiredType)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a result object.
    `<T> T` | NamedParameterJdbcTemplate.`queryForObject(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)`
    `<T> T` | NamedParameterJdbcOperations.`queryForObject(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping a single result row to a Java object via a RowMapper.
    `SqlRowSet` | NamedParameterJdbcTemplate.`queryForRowSet(String sql, Map<String,?> paramMap)`
    `SqlRowSet` | NamedParameterJdbcOperations.`queryForRowSet(String sql, Map<String,?> paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting an SqlRowSet.
    `SqlRowSet` | NamedParameterJdbcTemplate.`queryForRowSet(String sql, SqlParameterSource paramSource)`
    `SqlRowSet` | NamedParameterJdbcOperations.`queryForRowSet(String sql, SqlParameterSource paramSource)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting an SqlRowSet.
    `<T> Stream<T>` | NamedParameterJdbcTemplate.`queryForStream(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)`
    `<T> Stream<T>` | NamedParameterJdbcOperations.`queryForStream(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper, and turning it into an iterable and closeable Stream.
    `<T> Stream<T>` | NamedParameterJdbcTemplate.`queryForStream(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)`
    `<T> Stream<T>` | NamedParameterJdbcOperations.`queryForStream(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, mapping each row to a Java object via a RowMapper, and turning it into an iterable and closeable Stream.
    `int` | NamedParameterJdbcTemplate.`update(String sql, Map<String,?> paramMap)`
    `int` | NamedParameterJdbcOperations.`update(String sql, Map<String,?> paramMap)` Issue an update via a prepared statement, binding the given arguments.
    `int` | NamedParameterJdbcTemplate.`update(String sql, SqlParameterSource paramSource)`
    `int` | NamedParameterJdbcOperations.`update(String sql, SqlParameterSource paramSource)` Issue an update via a prepared statement, binding the given arguments.
    `int` | NamedParameterJdbcTemplate.`update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder)`
    `int` | NamedParameterJdbcOperations.`update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder)` Issue an update via a prepared statement, binding the given arguments, returning generated keys.
    `int` | NamedParameterJdbcTemplate.`update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder, String[] keyColumnNames)`
    `int` | NamedParameterJdbcOperations.`update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder, String[] keyColumnNames)` Issue an update via a prepared statement, binding the given arguments, returning generated keys.

  - ### Uses of DataAccessException in org.springframework.jdbc.core.support

    Methods in org.springframework.jdbc.core.support that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `Integer` | AbstractLobCreatingPreparedStatementCallback.`doInPreparedStatement(PreparedStatement ps)`
    `T` | AbstractLobStreamingResultSetExtractor.`extractData(ResultSet rs)` Delegates to handleNoRowFound, handleMultipleRowsFound and streamData, according to the ResultSet state.
    `protected void` | AbstractLobStreamingResultSetExtractor.`handleMultipleRowsFound()` Handle the case where the ResultSet contains multiple rows.
    `protected void` | AbstractLobStreamingResultSetExtractor.`handleNoRowFound()` Handle the case where the ResultSet does not contain a row.
    `protected abstract void` | AbstractLobCreatingPreparedStatementCallback.`setValues(PreparedStatement ps, LobCreator lobCreator)` Set values on the given PreparedStatement, using the given LobCreator for BLOB/CLOB arguments.
    `protected abstract void` | AbstractLobStreamingResultSetExtractor.`streamData(ResultSet rs)` Stream LOB content from the given ResultSet to some OutputStream.

  - ### Uses of DataAccessException in org.springframework.jdbc.datasource.init

    Subclasses of DataAccessException in org.springframework.jdbc.datasource.init
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CannotReadScriptException` Thrown by `ScriptUtils` if an SQL script cannot be read.
    `class` | `ScriptException` Root of the hierarchy of data access exceptions that are related to processing of SQL scripts.
    `class` | `ScriptParseException` Thrown by `ScriptUtils` if an SQL script cannot be properly parsed.
    `class` | `ScriptStatementFailedException` Thrown by `ScriptUtils` if a statement in an SQL script failed when executing it against the target database.
    `class` | `UncategorizedScriptException` Thrown when we cannot determine anything more specific than "something went wrong while processing an SQL script": for example, a `SQLException` from JDBC that we cannot pinpoint more precisely.

    Methods in org.springframework.jdbc.datasource.init that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `static void` | DatabasePopulatorUtils.`execute(DatabasePopulator populator, DataSource dataSource)` Execute the given `DatabasePopulator` against the given `DataSource`.

  - ### Uses of DataAccessException in org.springframework.jdbc.datasource.lookup

    Subclasses of DataAccessException in org.springframework.jdbc.datasource.lookup
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DataSourceLookupFailureException` Exception to be thrown by a DataSourceLookup implementation, indicating that the specified DataSource could not be obtained.

  - ### Uses of DataAccessException in org.springframework.jdbc.object

    Methods in org.springframework.jdbc.object that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `List<T>` | SqlQuery.`execute()` Convenient method to execute without parameters nor context.
    `List<T>` | SqlQuery.`execute(int p1)` Convenient method to execute with a single int parameter.
    `List<T>` | SqlQuery.`execute(int p1, int p2)` Convenient method to execute with two int parameters.
    `List<T>` | SqlQuery.`execute(int p1, int p2, Map<?,?> context)` Convenient method to execute with two int parameters and context.
    `List<T>` | SqlQuery.`execute(int p1, Map<?,?> context)` Convenient method to execute with a single int parameter and context.
    `List<T>` | SqlQuery.`execute(long p1)` Convenient method to execute with a single long parameter.
    `List<T>` | SqlQuery.`execute(long p1, Map<?,?> context)` Convenient method to execute with a single long parameter and context.
    `List<T>` | SqlQuery.`execute(Map<?,?> context)` Convenient method to execute without parameters.
    `Map<String,Object>` | StoredProcedure.`execute(Map<String,?> inParams)` Execute the stored procedure.
    `List<T>` | SqlQuery.`execute(Object... params)` Convenient method to execute without context.
    `List<T>` | SqlQuery.`execute(Object[] params, Map<?,?> context)` Central execution method.
    `Map<String,Object>` | StoredProcedure.`execute(ParameterMapper inParamMapper)` Execute the stored procedure.
    `List<T>` | SqlQuery.`execute(String p1)` Convenient method to execute with a single String parameter.
    `List<T>` | SqlQuery.`execute(String p1, Map<?,?> context)` Convenient method to execute with a single String parameter and context.
    `List<T>` | SqlQuery.`executeByNamedParam(Map<String,?> paramMap)` Convenient method to execute without context.
    `List<T>` | SqlQuery.`executeByNamedParam(Map<String,?> paramMap, Map<?,?> context)` Central execution method.
    `T` | SqlQuery.`findObject(int p1)` Convenient method to find a single object given a single int parameter.
    `T` | SqlQuery.`findObject(int p1, int p2)` Convenient method to find a single object given two int parameters.
    `T` | SqlQuery.`findObject(int p1, int p2, Map<?,?> context)` Convenient method to find a single object given two int parameters and a context.
    `T` | SqlQuery.`findObject(int p1, Map<?,?> context)` Convenient method to find a single object given a single int parameter and a context.
    `T` | SqlQuery.`findObject(long p1)` Convenient method to find a single object given a single long parameter.
    `T` | SqlQuery.`findObject(long p1, Map<?,?> context)` Convenient method to find a single object given a single long parameter and a context.
    `T` | SqlQuery.`findObject(Object... params)` Convenient method to find a single object without context.
    `T` | SqlQuery.`findObject(Object[] params, Map<?,?> context)` Generic object finder method, used by all other `findObject` methods.
    `T` | SqlQuery.`findObject(String p1)` Convenient method to find a single object given a single String parameter.
    `T` | SqlQuery.`findObject(String p1, Map<?,?> context)` Convenient method to find a single object given a single String parameter and a context.
    `T` | SqlQuery.`findObjectByNamedParam(Map<String,?> paramMap)` Convenient method to execute without context.
    `T` | SqlQuery.`findObjectByNamedParam(Map<String,?> paramMap, Map<?,?> context)` Generic object finder method for named parameters.
    `int` | SqlUpdate.`update()` Convenience method to execute an update with no parameters.
    `int` | SqlUpdate.`update(int p1)` Convenient method to execute an update given one int arg.
    `int` | SqlUpdate.`update(int p1, int p2)` Convenient method to execute an update given two int args.
    `int` | SqlUpdate.`update(long p1)` Convenient method to execute an update given one long arg.
    `int` | SqlUpdate.`update(long p1, long p2)` Convenient method to execute an update given two long args.
    `int` | BatchSqlUpdate.`update(Object... params)` Overridden version of `update` that adds the given statement parameters to the queue rather than executing them immediately.
    `int` | SqlUpdate.`update(Object... params)` Generic method to execute the update given parameters.
    `int` | SqlUpdate.`update(Object[] params, KeyHolder generatedKeyHolder)` Method to execute the update given arguments and retrieve the generated keys using a KeyHolder.
    `int` | SqlUpdate.`update(String p)` Convenient method to execute an update given one String arg.
    `int` | SqlUpdate.`update(String p1, String p2)` Convenient method to execute an update given two String args.
    `int` | SqlUpdate.`updateByNamedParam(Map<String,?> paramMap)` Generic method to execute the update given named parameters.
    `int` | SqlUpdate.`updateByNamedParam(Map<String,?> paramMap, KeyHolder generatedKeyHolder)` Method to execute the update given arguments and retrieve the generated keys using a KeyHolder.

  - ### Uses of DataAccessException in org.springframework.jdbc.support

    Methods in org.springframework.jdbc.support that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected DataAccessException` | SQLErrorCodeSQLExceptionTranslator.`createCustomException(String task, String sql, SQLException sqlEx, Class<?> exceptionClass)` Create a custom `DataAccessException`, based on a given exception class from a `CustomSQLErrorCodesTranslation` definition.
    `protected DataAccessException` | SQLErrorCodeSQLExceptionTranslator.`customTranslate(String task, String sql, SQLException sqlEx)` Subclasses can override this method to attempt a custom mapping from `SQLException` to `DataAccessException`.
    `protected abstract DataAccessException` | AbstractFallbackSQLExceptionTranslator.`doTranslate(String task, String sql, SQLException ex)` Template method for actually translating the given exception.
    `protected DataAccessException` | SQLErrorCodeSQLExceptionTranslator.`doTranslate(String task, String sql, SQLException ex)`
    `protected DataAccessException` | SQLStateSQLExceptionTranslator.`doTranslate(String task, String sql, SQLException ex)`
    `protected DataAccessException` | SQLExceptionSubclassTranslator.`doTranslate(String task, String sql, SQLException ex)`
    `DataAccessException` | SQLExceptionTranslator.`translate(String task, String sql, SQLException ex)` Translate the given `SQLException` into a generic `DataAccessException`.
    `DataAccessException` | AbstractFallbackSQLExceptionTranslator.`translate(String task, String sql, SQLException ex)` Pre-checks the arguments, calls `AbstractFallbackSQLExceptionTranslator.doTranslate(java.lang.String, java.lang.String, java.sql.SQLException)`, and invokes the `fallback translator` if necessary.

  - ### Uses of DataAccessException in org.springframework.jdbc.support.incrementer

    Methods in org.springframework.jdbc.support.incrementer that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected long` | AbstractSequenceMaxValueIncrementer.`getNextKey()` Executes the SQL as specified by `AbstractSequenceMaxValueIncrementer.getSequenceQuery()`.
    `protected long` | MySQLMaxValueIncrementer.`getNextKey()`
    `protected long` | AbstractIdentityColumnMaxValueIncrementer.`getNextKey()`
    `int` | DataFieldMaxValueIncrementer.`nextIntValue()` Increment the data store field's max value as int.
    `int` | AbstractDataFieldMaxValueIncrementer.`nextIntValue()`
    `long` | DataFieldMaxValueIncrementer.`nextLongValue()` Increment the data store field's max value as long.
    `long` | AbstractDataFieldMaxValueIncrementer.`nextLongValue()`
    `String` | DataFieldMaxValueIncrementer.`nextStringValue()` Increment the data store field's max value as String.
    `String` | AbstractDataFieldMaxValueIncrementer.`nextStringValue()`

  - ### Uses of DataAccessException in org.springframework.jdbc.support.xml

    Subclasses of DataAccessException in org.springframework.jdbc.support.xml
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SqlXmlFeatureNotImplementedException` Exception thrown when the underlying implementation does not support the requested feature of the API.

  - ### Uses of DataAccessException in org.springframework.orm

    Subclasses of DataAccessException in org.springframework.orm
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ObjectOptimisticLockingFailureException` Exception thrown on an optimistic locking violation for a mapped object.
    `class` | `ObjectRetrievalFailureException` Exception thrown if a mapped object could not be retrieved via its identifier.

  - ### Uses of DataAccessException in org.springframework.orm.hibernate5

    Subclasses of DataAccessException in org.springframework.orm.hibernate5
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HibernateJdbcException` Hibernate-specific subclass of UncategorizedDataAccessException, for JDBC exceptions that Hibernate wrapped.
    `class` | `HibernateObjectRetrievalFailureException` Hibernate-specific subclass of ObjectRetrievalFailureException.
    `class` | `HibernateOptimisticLockingFailureException` Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
    `class` | `HibernateQueryException` Hibernate-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid HQL query syntax.
    `class` | `HibernateSystemException` Hibernate-specific subclass of UncategorizedDataAccessException, for Hibernate system errors that do not match any concrete `org.springframework.dao` exceptions.

    Methods in org.springframework.orm.hibernate5 that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected DataAccessException` | HibernateExceptionTranslator.`convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
    `protected DataAccessException` | HibernateTransactionManager.`convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
    `static DataAccessException` | SessionFactoryUtils.`convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
    `DataAccessException` | HibernateExceptionTranslator.`translateExceptionIfPossible(RuntimeException ex)`

    Methods in org.springframework.orm.hibernate5 that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `void` | SpringSessionSynchronization.`beforeCommit(boolean readOnly)`
    `int` | HibernateOperations.`bulkUpdate(String queryString, Object... values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `int` | HibernateTemplate.`bulkUpdate(String queryString, Object... values)` Deprecated.
    `void` | HibernateOperations.`clear()` Remove all objects from the `Session` cache, and cancel all pending saves, updates and deletes.
    `void` | HibernateTemplate.`clear()`
    `void` | HibernateOperations.`closeIterator(Iterator<?> it)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `void` | HibernateTemplate.`closeIterator(Iterator<?> it)` Deprecated.
    `boolean` | HibernateOperations.`contains(Object entity)` Check whether the given object is in the Session cache.
    `boolean` | HibernateTemplate.`contains(Object entity)`
    `void` | HibernateOperations.`delete(Object entity)` Delete the given persistent instance.
    `void` | HibernateTemplate.`delete(Object entity)`
    `void` | HibernateOperations.`delete(Object entity, LockMode lockMode)` Delete the given persistent instance.
    `void` | HibernateTemplate.`delete(Object entity, LockMode lockMode)`
    `void` | HibernateOperations.`delete(String entityName, Object entity)` Delete the given persistent instance.
    `void` | HibernateTemplate.`delete(String entityName, Object entity)`
    `void` | HibernateOperations.`delete(String entityName, Object entity, LockMode lockMode)` Delete the given persistent instance.
    `void` | HibernateTemplate.`delete(String entityName, Object entity, LockMode lockMode)`
    `void` | HibernateOperations.`deleteAll(Collection<?> entities)` Delete all given persistent instances.
    `void` | HibernateTemplate.`deleteAll(Collection<?> entities)`
    `protected <T> T` | HibernateTemplate.`doExecute(HibernateCallback<T> action, boolean enforceNativeSession)` Execute the action specified by the given action object within a Session.
    `void` | HibernateOperations.`evict(Object entity)` Remove the given object from the `Session` cache.
    `void` | HibernateTemplate.`evict(Object entity)`
    `<T> T` | HibernateOperations.`execute(HibernateCallback<T> action)` Execute the action specified by the given action object within a `Session`.
    `<T> T` | HibernateTemplate.`execute(HibernateCallback<T> action)`
    `List<?>` | HibernateOperations.`find(String queryString, Object... values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`find(String queryString, Object... values)` Deprecated.
    `List<?>` | HibernateOperations.`findByCriteria(DetachedCriteria criteria)` Execute a query based on a given Hibernate criteria object.
    `List<?>` | HibernateTemplate.`findByCriteria(DetachedCriteria criteria)`
    `List<?>` | HibernateOperations.`findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)` Execute a query based on the given Hibernate criteria object.
    `List<?>` | HibernateTemplate.`findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)`
    `<T> List<T>` | HibernateOperations.`findByExample(String entityName, T exampleEntity)` Execute a query based on the given example entity object.
    `<T> List<T>` | HibernateTemplate.`findByExample(String entityName, T exampleEntity)`
    `<T> List<T>` | HibernateOperations.`findByExample(String entityName, T exampleEntity, int firstResult, int maxResults)` Execute a query based on a given example entity object.
    `<T> List<T>` | HibernateTemplate.`findByExample(String entityName, T exampleEntity, int firstResult, int maxResults)`
    `<T> List<T>` | HibernateOperations.`findByExample(T exampleEntity)` Execute a query based on the given example entity object.
    `<T> List<T>` | HibernateTemplate.`findByExample(T exampleEntity)`
    `<T> List<T>` | HibernateOperations.`findByExample(T exampleEntity, int firstResult, int maxResults)` Execute a query based on a given example entity object.
    `<T> List<T>` | HibernateTemplate.`findByExample(T exampleEntity, int firstResult, int maxResults)`
    `List<?>` | HibernateOperations.`findByNamedParam(String queryString, String[] paramNames, Object[] values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedParam(String queryString, String[] paramNames, Object[] values)` Deprecated.
    `List<?>` | HibernateOperations.`findByNamedParam(String queryString, String paramName, Object value)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedParam(String queryString, String paramName, Object value)` Deprecated.
    `List<?>` | HibernateOperations.`findByNamedQuery(String queryName, Object... values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedQuery(String queryName, Object... values)` Deprecated.
    `List<?>` | HibernateOperations.`findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)` Deprecated.
    `List<?>` | HibernateOperations.`findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)` Deprecated.
    `List<?>` | HibernateOperations.`findByNamedQueryAndValueBean(String queryName, Object valueBean)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByNamedQueryAndValueBean(String queryName, Object valueBean)` Deprecated.
    `List<?>` | HibernateOperations.`findByValueBean(String queryString, Object valueBean)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `List<?>` | HibernateTemplate.`findByValueBean(String queryString, Object valueBean)` Deprecated.
    `void` | HibernateOperations.`flush()` Flush all pending saves, updates and deletes to the database.
    `void` | HibernateTemplate.`flush()`
    `<T> T` | HibernateOperations.`get(Class<T> entityClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, or `null` if not found.
    `<T> T` | HibernateTemplate.`get(Class<T> entityClass, Serializable id)`
    `<T> T` | HibernateOperations.`get(Class<T> entityClass, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, or `null` if not found.
    `<T> T` | HibernateTemplate.`get(Class<T> entityClass, Serializable id, LockMode lockMode)`
    `Object` | HibernateOperations.`get(String entityName, Serializable id)` Return the persistent instance of the given entity class with the given identifier, or `null` if not found.
    `Object` | HibernateTemplate.`get(String entityName, Serializable id)`
    `Object` | HibernateOperations.`get(String entityName, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, or `null` if not found.
    `Object` | HibernateTemplate.`get(String entityName, Serializable id, LockMode lockMode)`
    `void` | HibernateOperations.`initialize(Object proxy)` Force initialization of a Hibernate proxy or persistent collection.
    `void` | HibernateTemplate.`initialize(Object proxy)`
    `Iterator<?>` | HibernateOperations.`iterate(String queryString, Object... values)` Deprecated. as of 5.0.4, in favor of a custom `HibernateCallback` lambda code block passed to the general `HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)` method
    `Iterator<?>` | HibernateTemplate.`iterate(String queryString, Object... values)` Deprecated.
    `<T> T` | HibernateOperations.`load(Class<T> entityClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
    `<T> T` | HibernateTemplate.`load(Class<T> entityClass, Serializable id)`
    `<T> T` | HibernateOperations.`load(Class<T> entityClass, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
    `<T> T` | HibernateTemplate.`load(Class<T> entityClass, Serializable id, LockMode lockMode)`
    `void` | HibernateOperations.`load(Object entity, Serializable id)` Load the persistent instance with the given identifier into the given object, throwing an exception if not found.
    `void` | HibernateTemplate.`load(Object entity, Serializable id)`
    `Object` | HibernateOperations.`load(String entityName, Serializable id)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
    `Object` | HibernateTemplate.`load(String entityName, Serializable id)`
    `Object` | HibernateOperations.`load(String entityName, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
    `Object` | HibernateTemplate.`load(String entityName, Serializable id, LockMode lockMode)`
    `<T> List<T>` | HibernateOperations.`loadAll(Class<T> entityClass)` Return all persistent instances of the given entity class.
    `<T> List<T>` | HibernateTemplate.`loadAll(Class<T> entityClass)`
    `void` | HibernateOperations.`lock(Object entity, LockMode lockMode)` Obtain the specified lock level upon the given object, implicitly checking whether the corresponding database entry still exists.
    `void` | HibernateTemplate.`lock(Object entity, LockMode lockMode)`
    `void` | HibernateOperations.`lock(String entityName, Object entity, LockMode lockMode)` Obtain the specified lock level upon the given object, implicitly checking whether the corresponding database entry still exists.
    `void` | HibernateTemplate.`lock(String entityName, Object entity, LockMode lockMode)`
    `<T> T` | HibernateOperations.`merge(String entityName, T entity)` Copy the state of the given object onto the persistent object with the same identifier.
    `<T> T` | HibernateTemplate.`merge(String entityName, T entity)`
    `<T> T` | HibernateOperations.`merge(T entity)` Copy the state of the given object onto the persistent object with the same identifier.
    `<T> T` | HibernateTemplate.`merge(T entity)`
    `void` | HibernateOperations.`persist(Object entity)` Persist the given transient instance.
    `void` | HibernateTemplate.`persist(Object entity)`
    `void` | HibernateOperations.`persist(String entityName, Object entity)` Persist the given transient instance.
    `void` | HibernateTemplate.`persist(String entityName, Object entity)`
    `void` | HibernateOperations.`refresh(Object entity)` Re-read the state of the given persistent instance.
    `void` | HibernateTemplate.`refresh(Object entity)`
    `void` | HibernateOperations.`refresh(Object entity, LockMode lockMode)` Re-read the state of the given persistent instance.
    `void` | HibernateTemplate.`refresh(Object entity, LockMode lockMode)`
    `void` | HibernateOperations.`replicate(Object entity, ReplicationMode replicationMode)` Persist the state of the given detached instance according to the given replication mode, reusing the current identifier value.
    `void` | HibernateTemplate.`replicate(Object entity, ReplicationMode replicationMode)`
    `void` | HibernateOperations.`replicate(String entityName, Object entity, ReplicationMode replicationMode)` Persist the state of the given detached instance according to the given replication mode, reusing the current identifier value.
    `void` | HibernateTemplate.`replicate(String entityName, Object entity, ReplicationMode replicationMode)`
    `Serializable` | HibernateOperations.`save(Object entity)` Persist the given transient instance.
    `Serializable` | HibernateTemplate.`save(Object entity)`
    `Serializable` | HibernateOperations.`save(String entityName, Object entity)` Persist the given transient instance.
    `Serializable` | HibernateTemplate.`save(String entityName, Object entity)`
    `void` | HibernateOperations.`saveOrUpdate(Object entity)` Save or update the given persistent instance, according to its id (matching the configured "unsaved-value"?).
    `void` | HibernateTemplate.`saveOrUpdate(Object entity)`
    `void` | HibernateOperations.`saveOrUpdate(String entityName, Object entity)` Save or update the given persistent instance, according to its id (matching the configured "unsaved-value"?).
    `void` | HibernateTemplate.`saveOrUpdate(String entityName, Object entity)`
    `void` | HibernateOperations.`update(Object entity)` Update the given persistent instance, associating it with the current Hibernate `Session`.
    `void` | HibernateTemplate.`update(Object entity)`
    `void` | HibernateOperations.`update(Object entity, LockMode lockMode)` Update the given persistent instance, associating it with the current Hibernate `Session`.
    `void` | HibernateTemplate.`update(Object entity, LockMode lockMode)`
    `void` | HibernateOperations.`update(String entityName, Object entity)` Update the given persistent instance, associating it with the current Hibernate `Session`.
    `void` | HibernateTemplate.`update(String entityName, Object entity)`
    `void` | HibernateOperations.`update(String entityName, Object entity, LockMode lockMode)` Update the given persistent instance, associating it with the current Hibernate `Session`.
    `void` | HibernateTemplate.`update(String entityName, Object entity, LockMode lockMode)`

  - ### Uses of DataAccessException in org.springframework.orm.hibernate5.support

    Methods in org.springframework.orm.hibernate5.support that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `void` | OpenSessionInViewInterceptor.`afterCompletion(WebRequest request, Exception ex)` Unbind the Hibernate `Session` from the thread and close it.
    `void` | OpenSessionInViewInterceptor.`preHandle(WebRequest request)` Open a new Hibernate `Session` according and bind it to the thread via the `TransactionSynchronizationManager`.

  - ### Uses of DataAccessException in org.springframework.orm.jpa

    Subclasses of DataAccessException in org.springframework.orm.jpa
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JpaObjectRetrievalFailureException` JPA-specific subclass of ObjectRetrievalFailureException.
    `class` | `JpaOptimisticLockingFailureException` JPA-specific subclass of ObjectOptimisticLockingFailureException.
    `class` | `JpaSystemException` JPA-specific subclass of UncategorizedDataAccessException, for JPA system errors that do not match any concrete `org.springframework.dao` exceptions.

    Methods in org.springframework.orm.jpa that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `static DataAccessException` | EntityManagerFactoryUtils.`convertJpaAccessExceptionIfPossible(RuntimeException ex)` Convert the given runtime exception to an appropriate exception from the `org.springframework.dao` hierarchy.
    `DataAccessException` | AbstractEntityManagerFactoryBean.`translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.
    `DataAccessException` | DefaultJpaDialect.`translateExceptionIfPossible(RuntimeException ex)` This implementation delegates to EntityManagerFactoryUtils.

  - ### Uses of DataAccessException in org.springframework.orm.jpa.support

    Methods in org.springframework.orm.jpa.support that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `void` | OpenEntityManagerInViewInterceptor.`afterCompletion(WebRequest request, Exception ex)`
    `void` | OpenEntityManagerInViewInterceptor.`preHandle(WebRequest request)`

  - ### Uses of DataAccessException in org.springframework.orm.jpa.vendor

    Methods in org.springframework.orm.jpa.vendor that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected DataAccessException` | HibernateJpaDialect.`convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
    `DataAccessException` | HibernateJpaDialect.`translateExceptionIfPossible(RuntimeException ex)`

  - ### Uses of DataAccessException in org.springframework.r2dbc

    Subclasses of DataAccessException in org.springframework.r2dbc
    Modifier and Type | Class and Description
    --- | ---
    `class` | `UncategorizedR2dbcException` Exception thrown when we can't classify a `R2dbcException` into one of our generic data access exceptions.

  - ### Uses of DataAccessException in org.springframework.r2dbc.connection

    Methods in org.springframework.r2dbc.connection that return DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `static DataAccessException` | ConnectionFactoryUtils.`convertR2dbcException(String task, String sql, io.r2dbc.spi.R2dbcException ex)` Translate the given `R2dbcException` into a generic `DataAccessException`.

  - ### Uses of DataAccessException in org.springframework.r2dbc.connection.lookup

    Subclasses of DataAccessException in org.springframework.r2dbc.connection.lookup
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ConnectionFactoryLookupFailureException` Exception to be thrown by a `ConnectionFactoryLookup` implementation, indicating that the specified `ConnectionFactory` could not be obtained.

  - ### Uses of DataAccessException in org.springframework.r2dbc.core.binding

    Subclasses of DataAccessException in org.springframework.r2dbc.core.binding
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `BindMarkersFactoryResolver.NoBindMarkersFactoryException` Exception thrown when `BindMarkersFactoryResolver` cannot resolve a `BindMarkersFactory`.

  - ### Uses of DataAccessException in org.springframework.test.context.junit4

    Methods in org.springframework.test.context.junit4 that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | AbstractTransactionalJUnit4SpringContextTests.`executeSqlScript(String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.

  - ### Uses of DataAccessException in org.springframework.test.context.testng

    Methods in org.springframework.test.context.testng that throw DataAccessException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | AbstractTransactionalTestNGSpringContextTests.`executeSqlScript(String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.