Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV NEXT | FRAMES NO FRAMES

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

Packages that use DataAccessException
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.simple | Simplification layer over JdbcTemplate for Java 5 and above.
org.springframework.jdbc.core.support | Classes supporting the `org.springframework.jdbc.core` package.
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.hibernate3 | Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.hibernate3.support | Classes supporting the `org.springframework.orm.hibernate3` package.
org.springframework.orm.ibatis | Package providing integration of iBATIS Database Layer with Spring concepts.
org.springframework.orm.jdo | Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jdo.support | Classes supporting the `org.springframework.orm.jdo` 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.orm.toplink | Package providing integration of Oracle TopLink with Spring concepts.
org.springframework.orm.toplink.support | Classes supporting the `org.springframework.orm.toplink` package.
org.springframework.test | Superclasses for tests requiring Spring application contexts, including support for transactional execution of test cases, with automatic rollback on completion.
org.springframework.test.context.junit38 | Support classes for ApplicationContext-based and transactional tests run with JUnit 3.8 and the Spring TestContext Framework.
org.springframework.test.context.junit4 | Support classes for ApplicationContext-based and transactional tests run with JUnit 4.4 and the Spring TestContext Framework.
org.springframework.test.context.testng | Support classes for ApplicationContext-based and transactional tests run with TestNG and the Spring TestContext Framework.
org.springframework.test.jdbc | Support classes for tests based on JDBC.

Uses of DataAccessException in org.springframework.dao

Subclasses of DataAccessException in org.springframework.dao
`class` | `CannotAcquireLockException` Exception thrown on failure to aquire 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 cleanup after a data access operation, but the actual operation went OK.
`class` | `ConcurrencyFailureException` Exception thrown on concurrency failure.
`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` | `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` | `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 previoulsy 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, a 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
`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.
`DataAccessException` | `ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(RuntimeException ex)`

Uses of DataAccessException in org.springframework.jca.cci

Subclasses of DataAccessException in org.springframework.jca.cci
`class` | `CannotCreateRecordException` Exception thrown when the creating of a CCI Record failed for connector-internal reasons.
`class` | `CannotGetCciConnectionException` Fatal exception thrown when we can't connect to an EIS using CCI.
`class` | `CciOperationNotSupportedException` Exception thrown when the connector doesn't support a specific CCI operation.
`class` | `InvalidResultSetAccessException` Exception thrown when a ResultSet has been accessed in an invalid fashion.
`class` | `RecordTypeNotSupportedException` Exception thrown when the creating of a CCI Record failed because the connector doesn't support the desired CCI Record type.

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

Methods in org.springframework.jca.cci.core that throw DataAccessException
`IndexedRecord` | `CciTemplate.createIndexedRecord(String name)` Create an indexed Record through the ConnectionFactory's RecordFactory.
`MappedRecord` | `CciTemplate.createMappedRecord(String name)` Create a mapped Record from the ConnectionFactory's RecordFactory.
`protected Record` | `CciTemplate.createRecord(RecordCreator recordCreator)` Invoke the given RecordCreator, converting JCA ResourceExceptions to Spring's DataAccessException hierarchy.
`Record` | `RecordCreator.createRecord(RecordFactory recordFactory)` Create a CCI Record instance, usually based on the passed-in CCI RecordFactory.
`protected Object` | `CciTemplate.doExecute(InteractionSpec spec, Record inputRecord, Record outputRecord, RecordExtractor outputExtractor)` Execute the specified interaction on an EIS with CCI.
`Object` | `ConnectionCallback.doInConnection(Connection connection, ConnectionFactory connectionFactory)` Gets called by `CciTemplate.execute` with an active CCI Connection.
`Object` | `InteractionCallback.doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)` Gets called by `CciTemplate.execute` with an active CCI Interaction.
`Object` | `CciTemplate.execute(ConnectionCallback action)`
`Object` | `CciOperations.execute(ConnectionCallback action)` Execute a request on an EIS with CCI, implemented as callback action working on a CCI Connection.
`Object` | `CciTemplate.execute(InteractionCallback action)`
`Object` | `CciOperations.execute(InteractionCallback action)` Execute a request on an EIS with CCI, implemented as callback action working on a CCI Interaction.
`Record` | `CciTemplate.execute(InteractionSpec spec, Record inputRecord)`
`Record` | `CciOperations.execute(InteractionSpec spec, Record inputRecord)` Execute the specified interaction on an EIS with CCI.
`Record` | `CciTemplate.execute(InteractionSpec spec, RecordCreator inputCreator)`
`Record` | `CciOperations.execute(InteractionSpec spec, RecordCreator inputCreator)` Execute the specified interaction on an EIS with CCI.
`Object` | `CciTemplate.execute(InteractionSpec spec, RecordCreator inputCreator, RecordExtractor outputExtractor)`
`Object` | `CciOperations.execute(InteractionSpec spec, RecordCreator inputCreator, RecordExtractor outputExtractor)` Execute the specified interaction on an EIS with CCI.
`void` | `CciTemplate.execute(InteractionSpec spec, Record inputRecord, Record outputRecord)`
`void` | `CciOperations.execute(InteractionSpec spec, Record inputRecord, Record outputRecord)` Execute the specified interaction on an EIS with CCI.
`Object` | `CciTemplate.execute(InteractionSpec spec, Record inputRecord, RecordExtractor outputExtractor)`
`Object` | `CciOperations.execute(InteractionSpec spec, Record inputRecord, RecordExtractor outputExtractor)` Execute the specified interaction on an EIS with CCI.
`Object` | `RecordExtractor.extractData(Record record)` 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
`protected abstract Object` | `MappingCommAreaOperation.bytesToObject(byte[] bytes)` Method used to convert the COMMAREA's bytes to an object.
`protected abstract Record` | `MappingRecordOperation.createInputRecord(RecordFactory recordFactory, Object inputObject)` 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)` Execute the interaction encapsulated by this operation object.
`Record` | `SimpleRecordOperation.execute(Record inputRecord)` Execute the CCI interaction encapsulated by this operation object.
`void` | `SimpleRecordOperation.execute(Record inputRecord, Record outputRecord)` Execute the CCI interaction encapsulated by this operation object.
`Object` | `MappingRecordOperation.RecordExtractorImpl.extractData(Record record)`
`protected abstract Object` | `MappingRecordOperation.extractOutputData(Record outputRecord)` Subclasses must implement this method to convert the Record returned by CCI execution into a result object for the `execute` method.
`protected Object` | `MappingCommAreaOperation.extractOutputData(Record record)`
`protected abstract byte[]` | `MappingCommAreaOperation.objectToBytes(Object inObject)` Method used to convert an object into COMMAREA bytes.

Uses of DataAccessException in org.springframework.jdbc

Subclasses of DataAccessException in org.springframework.jdbc
`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 columns.
`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 a SQLException into one of our generic data access exceptions.

Uses of DataAccessException in org.springframework.jdbc.core

Methods in org.springframework.jdbc.core that throw DataAccessException
`int[]` | `JdbcTemplate.batchUpdate(String[] sql)`
`int[]` | `JdbcOperations.batchUpdate(String[] sql)` Issue multiple SQL updates on a single JDBC Statement using batching.
`int[]` | `JdbcTemplate.batchUpdate(String sql, BatchPreparedStatementSetter pss)`
`int[]` | `JdbcOperations.batchUpdate(String sql, BatchPreparedStatementSetter pss)` Issue multiple update statements on a single PreparedStatement, using batch updates and a BatchPreparedStatementSetter to set values.
`Map` | `JdbcTemplate.call(CallableStatementCreator csc, List declaredParameters)`
`Map` | `JdbcOperations.call(CallableStatementCreator csc, List declaredParameters)` Execute a SQL call using a CallableStatementCreator to provide SQL and any required parameters.
`Object` | `CallableStatementCallback.doInCallableStatement(CallableStatement cs)` Gets called by `JdbcTemplate.execute` with an active JDBC CallableStatement.
`Object` | `ConnectionCallback.doInConnection(Connection con)` Gets called by `JdbcTemplate.execute` with an active JDBC Connection.
`Object` | `PreparedStatementCallback.doInPreparedStatement(PreparedStatement ps)` Gets called by `JdbcTemplate.execute` with an active JDBC PreparedStatement.
`Object` | `StatementCallback.doInStatement(Statement stmt)` Gets called by `JdbcTemplate.execute` with an active JDBC Statement.
`Object` | `JdbcTemplate.execute(CallableStatementCreator csc, CallableStatementCallback action)`
`Object` | `JdbcOperations.execute(CallableStatementCreator csc, CallableStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC CallableStatement.
`Object` | `JdbcTemplate.execute(ConnectionCallback action)`
`Object` | `JdbcOperations.execute(ConnectionCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC Connection.
`Object` | `JdbcTemplate.execute(PreparedStatementCreator psc, PreparedStatementCallback action)`
`Object` | `JdbcOperations.execute(PreparedStatementCreator psc, PreparedStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
`Object` | `JdbcTemplate.execute(StatementCallback action)`
`Object` | `JdbcOperations.execute(StatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC Statement.
`void` | `JdbcTemplate.execute(String sql)`
`void` | `JdbcOperations.execute(String sql)` Issue a single SQL execute, typically a DDL statement.
`Object` | `JdbcTemplate.execute(String callString, CallableStatementCallback action)`
`Object` | `JdbcOperations.execute(String callString, CallableStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC CallableStatement.
`Object` | `JdbcTemplate.execute(String sql, PreparedStatementCallback action)`
`Object` | `JdbcOperations.execute(String sql, PreparedStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
`Object` | `ResultSetExtractor.extractData(ResultSet rs)` Implementations must implement this method to process the entire ResultSet.
`Object` | `JdbcTemplate.query(PreparedStatementCreator psc, PreparedStatementSetter pss, ResultSetExtractor rse)` Query using a prepared statement, allowing for a PreparedStatementCreator and a PreparedStatementSetter.
`Object` | `JdbcTemplate.query(PreparedStatementCreator psc, ResultSetExtractor rse)`
`Object` | `JdbcOperations.query(PreparedStatementCreator psc, ResultSetExtractor rse)` Query using a prepared statement, reading the ResultSet with a ResultSetExtractor.
`void` | `JdbcTemplate.query(PreparedStatementCreator psc, RowCallbackHandler rch)`
`void` | `JdbcOperations.query(PreparedStatementCreator psc, RowCallbackHandler rch)` Query using a prepared statement, reading the ResultSet on a per-row basis with a RowCallbackHandler.
`List` | `JdbcTemplate.query(PreparedStatementCreator psc, RowMapper rowMapper)`
`List` | `JdbcOperations.query(PreparedStatementCreator psc, RowMapper rowMapper)` Query using a prepared statement, mapping each row to a Java object via a RowMapper.
`Object` | `JdbcTemplate.query(String sql, Object[] args, int[] argTypes, ResultSetExtractor rse)`
`Object` | `JdbcOperations.query(String sql, Object[] args, int[] argTypes, ResultSetExtractor 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` | `JdbcTemplate.query(String sql, Object[] args, int[] argTypes, RowCallbackHandler rch)`
`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.
`List` | `JdbcTemplate.query(String sql, Object[] args, int[] argTypes, RowMapper rowMapper)`
`List` | `JdbcOperations.query(String sql, Object[] args, int[] argTypes, RowMapper 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.
`Object` | `JdbcTemplate.query(String sql, Object[] args, ResultSetExtractor rse)`
`Object` | `JdbcOperations.query(String sql, Object[] args, ResultSetExtractor 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` | `JdbcTemplate.query(String sql, Object[] args, RowCallbackHandler rch)`
`void` | `JdbcOperations.query(String sql, Object[] args, 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.
`List` | `JdbcTemplate.query(String sql, Object[] args, RowMapper rowMapper)`
`List` | `JdbcOperations.query(String sql, Object[] args, RowMapper 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.
`Object` | `JdbcTemplate.query(String sql, PreparedStatementSetter pss, ResultSetExtractor rse)`
`Object` | `JdbcOperations.query(String sql, PreparedStatementSetter pss, ResultSetExtractor rse)` Query using a prepared statement, reading the ResultSet with a ResultSetExtractor.
`void` | `JdbcTemplate.query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch)`
`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.
`List` | `JdbcTemplate.query(String sql, PreparedStatementSetter pss, RowMapper rowMapper)`
`List` | `JdbcOperations.query(String sql, PreparedStatementSetter pss, RowMapper 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 Java object via a RowMapper.
`Object` | `JdbcTemplate.query(String sql, ResultSetExtractor rse)`
`Object` | `JdbcOperations.query(String sql, ResultSetExtractor rse)` Execute a query given static SQL, reading the ResultSet with a ResultSetExtractor.
`void` | `JdbcTemplate.query(String sql, RowCallbackHandler rch)`
`void` | `JdbcOperations.query(String sql, RowCallbackHandler rch)` Execute a query given static SQL, reading the ResultSet on a per-row basis with a RowCallbackHandler.
`List` | `JdbcTemplate.query(String sql, RowMapper rowMapper)`
`List` | `JdbcOperations.query(String sql, RowMapper rowMapper)` Execute a query given static SQL, mapping each row to a Java object via a RowMapper.
`int` | `JdbcTemplate.queryForInt(String sql)`
`int` | `JdbcOperations.queryForInt(String sql)` Execute a query that results in an int value, given static SQL.
`int` | `JdbcTemplate.queryForInt(String sql, Object[] args)`
`int` | `JdbcOperations.queryForInt(String sql, Object[] args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in an int value.
`int` | `JdbcTemplate.queryForInt(String sql, Object[] args, int[] argTypes)`
`int` | `JdbcOperations.queryForInt(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, resulting in an int value.
`List` | `JdbcTemplate.queryForList(String sql)`
`List` | `JdbcOperations.queryForList(String sql)` Execute a query for a result list, given static SQL.
`List` | `JdbcTemplate.queryForList(String sql, Class elementType)`
`List` | `JdbcOperations.queryForList(String sql, Class elementType)` Execute a query for a result list, given static SQL.
`List` | `JdbcTemplate.queryForList(String sql, Object[] args)`
`List` | `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` | `JdbcTemplate.queryForList(String sql, Object[] args, Class elementType)`
`List` | `JdbcOperations.queryForList(String sql, Object[] args, Class 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` | `JdbcTemplate.queryForList(String sql, Object[] args, int[] argTypes)`
`List` | `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` | `JdbcTemplate.queryForList(String sql, Object[] args, int[] argTypes, Class elementType)`
`List` | `JdbcOperations.queryForList(String sql, Object[] args, int[] argTypes, Class 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.
`long` | `JdbcTemplate.queryForLong(String sql)`
`long` | `JdbcOperations.queryForLong(String sql)` Execute a query that results in a long value, given static SQL.
`long` | `JdbcTemplate.queryForLong(String sql, Object[] args)`
`long` | `JdbcOperations.queryForLong(String sql, Object[] args)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in a long value.
`long` | `JdbcTemplate.queryForLong(String sql, Object[] args, int[] argTypes)`
`long` | `JdbcOperations.queryForLong(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, resulting in a long value.
`Map` | `JdbcTemplate.queryForMap(String sql)`
`Map` | `JdbcOperations.queryForMap(String sql)` Execute a query for a result Map, given static SQL.
`Map` | `JdbcTemplate.queryForMap(String sql, Object[] args)`
`Map` | `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` | `JdbcTemplate.queryForMap(String sql, Object[] args, int[] argTypes)`
`Map` | `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.
`Object` | `JdbcTemplate.queryForObject(String sql, Class requiredType)`
`Object` | `JdbcOperations.queryForObject(String sql, Class requiredType)` Execute a query for a result object, given static SQL.
`Object` | `JdbcTemplate.queryForObject(String sql, Object[] args, Class requiredType)`
`Object` | `JdbcOperations.queryForObject(String sql, Object[] args, Class 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.
`Object` | `JdbcTemplate.queryForObject(String sql, Object[] args, int[] argTypes, Class requiredType)`
`Object` | `JdbcOperations.queryForObject(String sql, Object[] args, int[] argTypes, Class 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.
`Object` | `JdbcTemplate.queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper)`
`Object` | `JdbcOperations.queryForObject(String sql, Object[] args, int[] argTypes, RowMapper 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.
`Object` | `JdbcTemplate.queryForObject(String sql, Object[] args, RowMapper rowMapper)`
`Object` | `JdbcOperations.queryForObject(String sql, Object[] args, RowMapper 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.
`Object` | `JdbcTemplate.queryForObject(String sql, RowMapper rowMapper)`
`Object` | `JdbcOperations.queryForObject(String sql, RowMapper rowMapper)` Execute a query given static SQL, mapping a single result row to a Java object via a RowMapper.
`SqlRowSet` | `JdbcTemplate.queryForRowSet(String sql)`
`SqlRowSet` | `JdbcOperations.queryForRowSet(String sql)` Execute a query for a SqlRowSet, given static SQL.
`SqlRowSet` | `JdbcTemplate.queryForRowSet(String sql, Object[] args)`
`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 a SqlRowSet.
`SqlRowSet` | `JdbcTemplate.queryForRowSet(String sql, Object[] args, int[] argTypes)`
`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 a SqlRowSet.
`int` | `JdbcTemplate.update(PreparedStatementCreator psc)`
`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, KeyHolder generatedKeyHolder)`
`int` | `JdbcOperations.update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder)` Issue an update statement using a PreparedStatementCreator to provide SQL and any required parameters.
`protected int` | `JdbcTemplate.update(PreparedStatementCreator psc, PreparedStatementSetter pss)`
`int` | `JdbcTemplate.update(String sql)`
`int` | `JdbcOperations.update(String sql)` Issue a single SQL update operation (such as an insert, update or delete statement).
`int` | `JdbcTemplate.update(String sql, Object[] args)`
`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[] argTypes)`
`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, PreparedStatementSetter pss)`
`int` | `JdbcOperations.update(String sql, PreparedStatementSetter pss)` Issue an update statement using a PreparedStatementSetter to set bind parameters, with given SQL.

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

Methods in org.springframework.jdbc.core.namedparam that throw DataAccessException
`Object` | `NamedParameterJdbcTemplate.execute(String sql, Map paramMap, PreparedStatementCallback action)`
`Object` | `NamedParameterJdbcOperations.execute(String sql, Map paramMap, PreparedStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
`Object` | `NamedParameterJdbcTemplate.execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback action)`
`Object` | `NamedParameterJdbcOperations.execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback action)` Execute a JDBC data access operation, implemented as callback action working on a JDBC PreparedStatement.
`Object` | `NamedParameterJdbcTemplate.query(String sql, Map paramMap, ResultSetExtractor rse)`
`Object` | `NamedParameterJdbcOperations.query(String sql, Map paramMap, ResultSetExtractor 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 paramMap, RowCallbackHandler rch)`
`void` | `NamedParameterJdbcOperations.query(String sql, Map 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.
`List` | `NamedParameterJdbcTemplate.query(String sql, Map paramMap, RowMapper rowMapper)`
`List` | `NamedParameterJdbcOperations.query(String sql, Map paramMap, RowMapper 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.
`Object` | `NamedParameterJdbcTemplate.query(String sql, SqlParameterSource paramSource, ResultSetExtractor rse)`
`Object` | `NamedParameterJdbcOperations.query(String sql, SqlParameterSource paramSource, ResultSetExtractor 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.
`List` | `NamedParameterJdbcTemplate.query(String sql, SqlParameterSource paramSource, RowMapper rowMapper)`
`List` | `NamedParameterJdbcOperations.query(String sql, SqlParameterSource paramSource, RowMapper 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.
`int` | `NamedParameterJdbcTemplate.queryForInt(String sql, Map paramMap)`
`int` | `NamedParameterJdbcOperations.queryForInt(String sql, Map paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in an int value.
`int` | `NamedParameterJdbcTemplate.queryForInt(String sql, SqlParameterSource paramSource)`
`int` | `NamedParameterJdbcOperations.queryForInt(String sql, SqlParameterSource paramSource)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in an int value.
`List` | `NamedParameterJdbcTemplate.queryForList(String sql, Map paramMap)`
`List` | `NamedParameterJdbcOperations.queryForList(String sql, Map 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.
`List` | `NamedParameterJdbcTemplate.queryForList(String sql, Map paramMap, Class elementType)`
`List` | `NamedParameterJdbcOperations.queryForList(String sql, Map paramMap, Class 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` | `NamedParameterJdbcTemplate.queryForList(String sql, SqlParameterSource paramSource)`
`List` | `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.
`List` | `NamedParameterJdbcTemplate.queryForList(String sql, SqlParameterSource paramSource, Class elementType)`
`List` | `NamedParameterJdbcOperations.queryForList(String sql, SqlParameterSource paramSource, Class 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.
`long` | `NamedParameterJdbcTemplate.queryForLong(String sql, Map paramMap)`
`long` | `NamedParameterJdbcOperations.queryForLong(String sql, Map paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in a long value.
`long` | `NamedParameterJdbcTemplate.queryForLong(String sql, SqlParameterSource paramSource)`
`long` | `NamedParameterJdbcOperations.queryForLong(String sql, SqlParameterSource paramSource)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, resulting in a long value.
`Map` | `NamedParameterJdbcTemplate.queryForMap(String sql, Map paramMap)`
`Map` | `NamedParameterJdbcOperations.queryForMap(String sql, Map 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` | `NamedParameterJdbcTemplate.queryForMap(String sql, SqlParameterSource paramSource)`
`Map` | `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.
`Object` | `NamedParameterJdbcTemplate.queryForObject(String sql, Map paramMap, Class requiredType)`
`Object` | `NamedParameterJdbcOperations.queryForObject(String sql, Map paramMap, Class 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.
`Object` | `NamedParameterJdbcTemplate.queryForObject(String sql, Map paramMap, RowMapper rowMapper)`
`Object` | `NamedParameterJdbcOperations.queryForObject(String sql, Map paramMap, RowMapper 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.
`Object` | `NamedParameterJdbcTemplate.queryForObject(String sql, SqlParameterSource paramSource, Class requiredType)`
`Object` | `NamedParameterJdbcOperations.queryForObject(String sql, SqlParameterSource paramSource, Class 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.
`Object` | `NamedParameterJdbcTemplate.queryForObject(String sql, SqlParameterSource paramSource, RowMapper rowMapper)`
`Object` | `NamedParameterJdbcOperations.queryForObject(String sql, SqlParameterSource paramSource, RowMapper 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 paramMap)`
`SqlRowSet` | `NamedParameterJdbcOperations.queryForRowSet(String sql, Map paramMap)` Query given SQL to create a prepared statement from SQL and a list of arguments to bind to the query, expecting a 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 a SqlRowSet.
`int` | `NamedParameterJdbcTemplate.update(String sql, Map paramMap)`
`int` | `NamedParameterJdbcOperations.update(String sql, Map 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.simple

Methods in org.springframework.jdbc.core.simple that throw DataAccessException
`
`<T> List<T>`
` | `SimpleJdbcTemplate.query(String sql, ParameterizedRowMapper<T> rm, Map args)`
`
`<T> List<T>`
` | `SimpleJdbcOperations.query(String sql, ParameterizedRowMapper<T> rm, Map args)` Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`
`<T> List<T>`
` | `SimpleJdbcTemplate.query(String sql, ParameterizedRowMapper<T> rm, Object... args)`
`
`<T> List<T>`
` | `SimpleJdbcOperations.query(String sql, ParameterizedRowMapper<T> rm, Object... args)` Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`
`<T> List<T>`
` | `SimpleJdbcTemplate.query(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)`
`
`<T> List<T>`
` | `SimpleJdbcOperations.query(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)` Query for a `List` of `Objects` of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`int` | `SimpleJdbcTemplate.queryForInt(String sql, Map args)`
`int` | `SimpleJdbcOperations.queryForInt(String sql, Map args)` Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.
`int` | `SimpleJdbcTemplate.queryForInt(String sql, Object... args)`
`int` | `SimpleJdbcOperations.queryForInt(String sql, Object... args)` Query for an `int` passing in a SQL query using the standard '?'
`int` | `SimpleJdbcTemplate.queryForInt(String sql, SqlParameterSource args)`
`int` | `SimpleJdbcOperations.queryForInt(String sql, SqlParameterSource args)` Query for an `int` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.
`List<Map<String,Object>>` | `SimpleJdbcTemplate.queryForList(String sql, Map args)`
`List<Map<String,Object>>` | `SimpleJdbcOperations.queryForList(String sql, Map args)` Execute the supplied query with the supplied arguments.
`List<Map<String,Object>>` | `SimpleJdbcTemplate.queryForList(String sql, Object... args)`
`List<Map<String,Object>>` | `SimpleJdbcOperations.queryForList(String sql, Object... args)` Execute the supplied query with the (optional) supplied arguments.
`List<Map<String,Object>>` | `SimpleJdbcTemplate.queryForList(String sql, SqlParameterSource args)`
`List<Map<String,Object>>` | `SimpleJdbcOperations.queryForList(String sql, SqlParameterSource args)` Execute the supplied query with the supplied arguments.
`long` | `SimpleJdbcTemplate.queryForLong(String sql, Map args)`
`long` | `SimpleJdbcOperations.queryForLong(String sql, Map args)` Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a map containing the arguments.
`long` | `SimpleJdbcTemplate.queryForLong(String sql, Object... args)`
`long` | `SimpleJdbcOperations.queryForLong(String sql, Object... args)` Query for an `long` passing in a SQL query using the standard '?'
`long` | `SimpleJdbcTemplate.queryForLong(String sql, SqlParameterSource args)`
`long` | `SimpleJdbcOperations.queryForLong(String sql, SqlParameterSource args)` Query for an `long` passing in a SQL query using the named parameter support provided by the `NamedParameterJdbcTemplate` and a `SqlParameterSource` containing the arguments.
`Map<String,Object>` | `SimpleJdbcTemplate.queryForMap(String sql, Map args)`
`Map<String,Object>` | `SimpleJdbcOperations.queryForMap(String sql, Map args)` Execute the supplied query with the supplied arguments.
`Map<String,Object>` | `SimpleJdbcTemplate.queryForMap(String sql, Object... args)`
`Map<String,Object>` | `SimpleJdbcOperations.queryForMap(String sql, Object... args)` Execute the supplied query with the (optional) supplied arguments.
`Map<String,Object>` | `SimpleJdbcTemplate.queryForMap(String sql, SqlParameterSource args)`
`Map<String,Object>` | `SimpleJdbcOperations.queryForMap(String sql, SqlParameterSource args)` Execute the supplied query with the supplied arguments.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, Class<T> requiredType, Map args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, Class<T> requiredType, Map args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, Class<T> requiredType, Object... args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, Class<T> requiredType, Object... args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, Class<T> requiredType, SqlParameterSource args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, Class<T> requiredType, SqlParameterSource args)` Query for an object of type `T` identified by the supplied @`Class`.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, ParameterizedRowMapper<T> rm, Map args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, ParameterizedRowMapper<T> rm, Map args)` Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, ParameterizedRowMapper<T> rm, Object... args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, ParameterizedRowMapper<T> rm, Object... args)` Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`
`<T> T`
` | `SimpleJdbcTemplate.queryForObject(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)`
`
`<T> T`
` | `SimpleJdbcOperations.queryForObject(String sql, ParameterizedRowMapper<T> rm, SqlParameterSource args)` Query for an object of type `T` using the supplied `ParameterizedRowMapper` to the query results to the object.
`int` | `SimpleJdbcTemplate.update(String sql, Map args)`
`int` | `SimpleJdbcOperations.update(String sql, Map args)` Execute the supplied SQL statement with (optional) supplied arguments.
`int` | `SimpleJdbcTemplate.update(String sql, Object... args)`
`int` | `SimpleJdbcOperations.update(String sql, Object... args)` Execute the supplied SQL statement with supplied arguments.
`int` | `SimpleJdbcTemplate.update(String sql, SqlParameterSource args)`
`int` | `SimpleJdbcOperations.update(String sql, SqlParameterSource args)` Execute the supplied SQL statement with supplied arguments.

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

Methods in org.springframework.jdbc.core.support that throw DataAccessException
`Object` | `AbstractLobCreatingPreparedStatementCallback.doInPreparedStatement(PreparedStatement ps)`
`Object` | `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.lookup

Subclasses of DataAccessException in org.springframework.jdbc.datasource.lookup
`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
`List` | `SqlQuery.execute()` Convenient method to execute without parameters nor context.
`List` | `SqlQuery.execute(int p1)` Convenient method to execute with a single int parameter.
`List` | `SqlQuery.execute(int p1, int p2)` Convenient method to execute with two int parameters.
`List` | `SqlQuery.execute(int p1, int p2, Map context)` Convenient method to execute with two int parameters and context.
`List` | `SqlQuery.execute(int p1, Map context)` Convenient method to execute with a single int parameter and context.
`List` | `SqlQuery.execute(long p1)` Convenient method to execute with a single long parameter.
`List` | `SqlQuery.execute(long p1, Map context)` Convenient method to execute with a single long parameter and context.
`Map` | `StoredProcedure.execute(Map inParams)` Execute the stored procedure.
`List` | `SqlQuery.execute(Map context)` Convenient method to execute without parameters.
`List` | `SqlQuery.execute(Object[] params)` Convenient method to execute without context.
`List` | `SqlQuery.execute(Object[] params, Map context)` Central execution method.
`Map` | `StoredProcedure.execute(ParameterMapper inParamMapper)` Execute the stored procedure.
`List` | `SqlQuery.execute(String p1)` Convenient method to execute with a single String parameter.
`List` | `SqlQuery.execute(String p1, Map context)` Convenient method to execute with a single String parameter and context.
`List` | `SqlQuery.executeByNamedParam(Map paramMap)` Convenient method to execute without context.
`List` | `SqlQuery.executeByNamedParam(Map paramMap, Map context)` Central execution method.
`Object` | `SqlQuery.findObject(int p1)` Convenient method to find a single object given a single int parameter.
`Object` | `SqlQuery.findObject(int p1, int p2)` Convenient method to find a single object given two int parameters.
`Object` | `SqlQuery.findObject(int p1, int p2, Map context)` Convenient method to find a single object given two int parameters and a context.
`Object` | `SqlQuery.findObject(int p1, Map context)` Convenient method to find a single object given a single int parameter and a context.
`Object` | `SqlQuery.findObject(long p1)` Convenient method to find a single object given a single long parameter.
`Object` | `SqlQuery.findObject(long p1, Map context)` Convenient method to find a single object given a single long parameter and a context.
`Object` | `SqlQuery.findObject(Object[] params)` Convenient method to find a single object without context.
`Object` | `SqlQuery.findObject(Object[] params, Map context)` Generic object finder method, used by all other `findObject` methods.
`Object` | `SqlQuery.findObject(String p1)` Convenient method to find a single object given a single String parameter.
`Object` | `SqlQuery.findObject(String p1, Map context)` Convenient method to find a single object given a single String parameter and a context.
`Object` | `SqlQuery.findObjectByNamedParam(Map paramMap)` Convenient method to execute without context.
`Object` | `SqlQuery.findObjectByNamedParam(Map 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` | `SqlUpdate.update(Object[] params)` Generic method to execute the update given parameters.
`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, 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 paramMap)` Generic method to execute the update given named parameters.
`int` | `SqlUpdate.updateByNamedParam(Map 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
`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.
`DataAccessException` | `SQLErrorCodeSQLExceptionTranslator.translate(String task, String sql, SQLException sqlEx)`
`DataAccessException` | `SQLStateSQLExceptionTranslator.translate(String task, String sql, SQLException ex)`
`DataAccessException` | `SQLExceptionSubclassTranslator.translate(String task, String sql, SQLException ex)`
`DataAccessException` | `SQLExceptionTranslator.translate(String task, String sql, SQLException ex)` Translate the given `SQLException` into a generic `DataAccessException`.

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

Methods in org.springframework.jdbc.support.incrementer that throw DataAccessException
`protected long` | `SybaseMaxValueIncrementer.getNextKey()`
`protected long` | `SqlServerMaxValueIncrementer.getNextKey()`
`protected long` | `DerbyMaxValueIncrementer.getNextKey()`
`protected long` | `HsqlMaxValueIncrementer.getNextKey()`
`protected long` | `MySQLMaxValueIncrementer.getNextKey()`
`protected long` | `AbstractSequenceMaxValueIncrementer.getNextKey()` Executes the SQL as specified by `AbstractSequenceMaxValueIncrementer.getSequenceQuery()`.
`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
`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
`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.hibernate3

Subclasses of DataAccessException in org.springframework.orm.hibernate3
`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.hibernate3 that return DataAccessException
`static DataAccessException` | `SessionFactoryUtils.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.
`DataAccessException` | `HibernateAccessor.convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected DataAccessException` | `AbstractSessionFactoryBean.convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected DataAccessException` | `HibernateTransactionManager.convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)` Convert the given Hibernate JDBCException to an appropriate exception from the `org.springframework.dao` hierarchy, using the given SQLExceptionTranslator.
`protected DataAccessException` | `HibernateAccessor.convertJdbcAccessException(JDBCException ex, SQLExceptionTranslator translator)` Convert the given Hibernate JDBCException to an appropriate exception from the `org.springframework.dao` hierarchy, using the given SQLExceptionTranslator.
`protected DataAccessException` | `HibernateAccessor.convertJdbcAccessException(SQLException ex)` Convert the given SQLException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `AbstractSessionFactoryBean.translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

Methods in org.springframework.orm.hibernate3 that throw DataAccessException
`int` | `HibernateTemplate.bulkUpdate(String queryString)`
`int` | `HibernateOperations.bulkUpdate(String queryString)` Update/delete all objects according to the given query.
`int` | `HibernateTemplate.bulkUpdate(String queryString, Object value)`
`int` | `HibernateOperations.bulkUpdate(String queryString, Object value)` Update/delete all objects according to the given query, binding one value to a "?"
`int` | `HibernateTemplate.bulkUpdate(String queryString, Object[] values)`
`int` | `HibernateOperations.bulkUpdate(String queryString, Object[] values)` Update/delete all objects according to the given query, binding a number of values to "?"
`void` | `HibernateTemplate.clear()`
`void` | `HibernateOperations.clear()` Remove all objects from the `Session` cache, and cancel all pending saves, updates and deletes.
`void` | `HibernateTemplate.closeIterator(Iterator it)`
`void` | `HibernateOperations.closeIterator(Iterator it)` Immediately close an `Iterator` created by any of the various `iterate(..)`
`boolean` | `HibernateTemplate.contains(Object entity)`
`boolean` | `HibernateOperations.contains(Object entity)` Check whether the given object is in the Session cache.
`void` | `LocalSessionFactoryBean.createDatabaseSchema()` Execute schema creation script, determined by the Configuration object used for creating the SessionFactory.
`void` | `HibernateTemplate.delete(Object entity)`
`void` | `HibernateOperations.delete(Object entity)` Delete the given persistent instance.
`void` | `HibernateTemplate.delete(Object entity, LockMode lockMode)`
`void` | `HibernateOperations.delete(Object entity, LockMode lockMode)` Delete the given persistent instance.
`void` | `HibernateTemplate.delete(String entityName, Object entity)`
`void` | `HibernateOperations.delete(String entityName, Object entity)` Delete the given persistent instance.
`void` | `HibernateTemplate.delete(String entityName, Object entity, LockMode lockMode)`
`void` | `HibernateOperations.delete(String entityName, Object entity, LockMode lockMode)` Delete the given persistent instance.
`void` | `HibernateTemplate.deleteAll(Collection entities)`
`void` | `HibernateOperations.deleteAll(Collection entities)` Delete all given persistent instances.
`protected Object` | `HibernateTemplate.doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession)` Execute the action specified by the given action object within a Session.
`void` | `LocalSessionFactoryBean.dropDatabaseSchema()` Execute schema drop script, determined by the Configuration object used for creating the SessionFactory.
`void` | `HibernateTemplate.evict(Object entity)`
`void` | `HibernateOperations.evict(Object entity)` Remove the given object from the `Session` cache.
`Object` | `HibernateTemplate.execute(HibernateCallback action)`
`Object` | `HibernateOperations.execute(HibernateCallback action)` Execute the action specified by the given action object within a `Session`.
`Object` | `HibernateTemplate.execute(HibernateCallback action, boolean enforceNativeSession)` Deprecated. as of Spring 2.5, in favor of `HibernateTemplate.executeWithNativeSession(org.springframework.orm.hibernate3.HibernateCallback)`
`List` | `HibernateTemplate.executeFind(HibernateCallback action)`
`List` | `HibernateOperations.executeFind(HibernateCallback action)` Execute the specified action assuming that the result object is a `List`.
`List` | `HibernateTemplate.find(String queryString)`
`List` | `HibernateOperations.find(String queryString)` Execute an HQL query.
`List` | `HibernateTemplate.find(String queryString, Object value)`
`List` | `HibernateOperations.find(String queryString, Object value)` Execute an HQL query, binding one value to a "?"
`List` | `HibernateTemplate.find(String queryString, Object[] values)`
`List` | `HibernateOperations.find(String queryString, Object[] values)` Execute an HQL query, binding a number of values to "?"
`List` | `HibernateTemplate.findByCriteria(DetachedCriteria criteria)`
`List` | `HibernateOperations.findByCriteria(DetachedCriteria criteria)` Execute a query based on a given Hibernate criteria object.
`List` | `HibernateTemplate.findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)`
`List` | `HibernateOperations.findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)` Execute a query based on the given Hibernate criteria object.
`List` | `HibernateTemplate.findByExample(Object exampleEntity)`
`List` | `HibernateOperations.findByExample(Object exampleEntity)` Execute a query based on the given example entity object.
`List` | `HibernateTemplate.findByExample(Object exampleEntity, int firstResult, int maxResults)`
`List` | `HibernateOperations.findByExample(Object exampleEntity, int firstResult, int maxResults)` Execute a query based on a given example entity object.
`List` | `HibernateTemplate.findByExample(String entityName, Object exampleEntity)`
`List` | `HibernateOperations.findByExample(String entityName, Object exampleEntity)` Execute a query based on the given example entity object.
`List` | `HibernateTemplate.findByExample(String entityName, Object exampleEntity, int firstResult, int maxResults)`
`List` | `HibernateOperations.findByExample(String entityName, Object exampleEntity, int firstResult, int maxResults)` Execute a query based on a given example entity object.
`List` | `HibernateTemplate.findByNamedParam(String queryString, String[] paramNames, Object[] values)`
`List` | `HibernateOperations.findByNamedParam(String queryString, String[] paramNames, Object[] values)` Execute an HQL query, binding a number of values to ":" named parameters in the query string.
`List` | `HibernateTemplate.findByNamedParam(String queryString, String paramName, Object value)`
`List` | `HibernateOperations.findByNamedParam(String queryString, String paramName, Object value)` Execute an HQL query, binding one value to a ":" named parameter in the query string.
`List` | `HibernateTemplate.findByNamedQuery(String queryName)`
`List` | `HibernateOperations.findByNamedQuery(String queryName)` Execute a named query.
`List` | `HibernateTemplate.findByNamedQuery(String queryName, Object value)`
`List` | `HibernateOperations.findByNamedQuery(String queryName, Object value)` Execute a named query, binding one value to a "?"
`List` | `HibernateTemplate.findByNamedQuery(String queryName, Object[] values)`
`List` | `HibernateOperations.findByNamedQuery(String queryName, Object[] values)` Execute a named query binding a number of values to "?"
`List` | `HibernateTemplate.findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)`
`List` | `HibernateOperations.findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)` Execute a named query, binding a number of values to ":" named parameters in the query string.
`List` | `HibernateTemplate.findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)`
`List` | `HibernateOperations.findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)` Execute a named query, binding one value to a ":" named parameter in the query string.
`List` | `HibernateTemplate.findByNamedQueryAndValueBean(String queryName, Object valueBean)`
`List` | `HibernateOperations.findByNamedQueryAndValueBean(String queryName, Object valueBean)` Execute a named query, binding the properties of the given bean to ":" named parameters in the query string.
`List` | `HibernateTemplate.findByValueBean(String queryString, Object valueBean)`
`List` | `HibernateOperations.findByValueBean(String queryString, Object valueBean)` Execute an HQL query, binding the properties of the given bean to named parameters in the query string.
`void` | `HibernateTemplate.flush()`
`void` | `HibernateOperations.flush()` Flush all pending saves, updates and deletes to the database.
`Object` | `HibernateTemplate.get(Class entityClass, Serializable id)`
`Object` | `HibernateOperations.get(Class entityClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, or `null` if not found.
`Object` | `HibernateTemplate.get(Class entityClass, Serializable id, LockMode lockMode)`
`Object` | `HibernateOperations.get(Class entityClass, 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)`
`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, LockMode lockMode)`
`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.
`void` | `HibernateTemplate.initialize(Object proxy)`
`void` | `HibernateOperations.initialize(Object proxy)` Force initialization of a Hibernate proxy or persistent collection.
`Iterator` | `HibernateTemplate.iterate(String queryString)`
`Iterator` | `HibernateOperations.iterate(String queryString)` Execute a query for persistent instances.
`Iterator` | `HibernateTemplate.iterate(String queryString, Object value)`
`Iterator` | `HibernateOperations.iterate(String queryString, Object value)` Execute a query for persistent instances, binding one value to a "?"
`Iterator` | `HibernateTemplate.iterate(String queryString, Object[] values)`
`Iterator` | `HibernateOperations.iterate(String queryString, Object[] values)` Execute a query for persistent instances, binding a number of values to "?"
`Object` | `HibernateTemplate.load(Class entityClass, Serializable id)`
`Object` | `HibernateOperations.load(Class entityClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
`Object` | `HibernateTemplate.load(Class entityClass, Serializable id, LockMode lockMode)`
`Object` | `HibernateOperations.load(Class entityClass, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, throwing an exception if not found.
`void` | `HibernateTemplate.load(Object entity, Serializable id)`
`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.
`Object` | `HibernateTemplate.load(String entityName, 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, LockMode lockMode)`
`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.
`List` | `HibernateTemplate.loadAll(Class entityClass)`
`List` | `HibernateOperations.loadAll(Class entityClass)` Return all persistent instances of the given entity class.
`void` | `HibernateTemplate.lock(Object entity, LockMode lockMode)`
`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(String entityName, 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.
`Object` | `HibernateTemplate.merge(Object entity)`
`Object` | `HibernateOperations.merge(Object entity)` Copy the state of the given object onto the persistent object with the same identifier.
`Object` | `HibernateTemplate.merge(String entityName, Object entity)`
`Object` | `HibernateOperations.merge(String entityName, Object entity)` Copy the state of the given object onto the persistent object with the same identifier.
`void` | `HibernateTemplate.persist(Object entity)`
`void` | `HibernateOperations.persist(Object entity)` Persist the given transient instance.
`void` | `HibernateTemplate.persist(String entityName, Object entity)`
`void` | `HibernateOperations.persist(String entityName, Object entity)` Persist the given transient instance.
`void` | `HibernateTemplate.refresh(Object entity)`
`void` | `HibernateOperations.refresh(Object entity)` Re-read the state of the given persistent instance.
`void` | `HibernateTemplate.refresh(Object entity, LockMode lockMode)`
`void` | `HibernateOperations.refresh(Object entity, LockMode lockMode)` Re-read the state of the given persistent instance.
`void` | `HibernateTemplate.replicate(Object entity, ReplicationMode replicationMode)`
`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(String entityName, 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.
`Serializable` | `HibernateTemplate.save(Object entity)`
`Serializable` | `HibernateOperations.save(Object entity)` Persist the given transient instance.
`Serializable` | `HibernateTemplate.save(String entityName, Object entity)`
`Serializable` | `HibernateOperations.save(String entityName, Object entity)` Persist the given transient instance.
`void` | `HibernateTemplate.saveOrUpdate(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(String entityName, 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.saveOrUpdateAll(Collection entities)`
`void` | `HibernateOperations.saveOrUpdateAll(Collection entities)` Deprecated. as of Spring 2.5, in favor of individual `saveOrUpdate` or `merge` usage
`void` | `HibernateTemplate.update(Object entity)`
`void` | `HibernateOperations.update(Object entity)` Update the given persistent instance, associating it with the current Hibernate `Session`.
`void` | `HibernateTemplate.update(Object entity, LockMode lockMode)`
`void` | `HibernateOperations.update(Object entity, LockMode lockMode)` 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)` Update the given persistent instance, associating it with the current Hibernate `Session`.
`void` | `HibernateTemplate.update(String entityName, Object entity, LockMode lockMode)`
`void` | `HibernateOperations.update(String entityName, Object entity, LockMode lockMode)` Update the given persistent instance, associating it with the current Hibernate `Session`.
`void` | `LocalSessionFactoryBean.updateDatabaseSchema()` Execute schema update script, determined by the Configuration object used for creating the SessionFactory.

Uses of DataAccessException in org.springframework.orm.hibernate3.support

Methods in org.springframework.orm.hibernate3.support that return DataAccessException
`protected DataAccessException` | `HibernateDaoSupport.convertHibernateAccessException(HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.

Methods in org.springframework.orm.hibernate3.support that throw DataAccessException
`void` | `OpenSessionInViewInterceptor.afterCompletion(WebRequest request, Exception ex)` Unbind the Hibernate `Session` from the thread and close it (in single session mode), or process deferred close for all sessions that have been opened during the current request (in deferred close mode).
`void` | `OpenSessionInViewInterceptor.postHandle(WebRequest request, ModelMap model)` Flush the Hibernate `Session` before view rendering, if necessary.
`void` | `OpenSessionInViewInterceptor.preHandle(WebRequest request)` Open a new Hibernate `Session` according to the settings of this `HibernateAccessor` and bind it to the thread via the `TransactionSynchronizationManager`.

Uses of DataAccessException in org.springframework.orm.ibatis

Methods in org.springframework.orm.ibatis that throw DataAccessException
`int` | `SqlMapClientTemplate.delete(String statementName)`
`int` | `SqlMapClientOperations.delete(String statementName)`
`int` | `SqlMapClientTemplate.delete(String statementName, Object parameterObject)`
`int` | `SqlMapClientOperations.delete(String statementName, Object parameterObject)`
`void` | `SqlMapClientTemplate.delete(String statementName, Object parameterObject, int requiredRowsAffected)`
`void` | `SqlMapClientOperations.delete(String statementName, Object parameterObject, int requiredRowsAffected)` Convenience method provided by Spring: execute a delete operation with an automatic check that the delete affected the given required number of rows.
`Object` | `SqlMapClientTemplate.execute(SqlMapClientCallback action)` Execute the given data access action on a SqlMapExecutor.
`List` | `SqlMapClientTemplate.executeWithListResult(SqlMapClientCallback action)` Execute the given data access action on a SqlMapExecutor, expecting a List result.
`Map` | `SqlMapClientTemplate.executeWithMapResult(SqlMapClientCallback action)` Execute the given data access action on a SqlMapExecutor, expecting a Map result.
`Object` | `SqlMapClientTemplate.insert(String statementName)`
`Object` | `SqlMapClientOperations.insert(String statementName)`
`Object` | `SqlMapClientTemplate.insert(String statementName, Object parameterObject)`
`Object` | `SqlMapClientOperations.insert(String statementName, Object parameterObject)`
`List` | `SqlMapClientTemplate.queryForList(String statementName)`
`List` | `SqlMapClientOperations.queryForList(String statementName)`
`List` | `SqlMapClientTemplate.queryForList(String statementName, int skipResults, int maxResults)`
`List` | `SqlMapClientOperations.queryForList(String statementName, int skipResults, int maxResults)`
`List` | `SqlMapClientTemplate.queryForList(String statementName, Object parameterObject)`
`List` | `SqlMapClientOperations.queryForList(String statementName, Object parameterObject)`
`List` | `SqlMapClientTemplate.queryForList(String statementName, Object parameterObject, int skipResults, int maxResults)`
`List` | `SqlMapClientOperations.queryForList(String statementName, Object parameterObject, int skipResults, int maxResults)`
`Map` | `SqlMapClientTemplate.queryForMap(String statementName, Object parameterObject, String keyProperty)`
`Map` | `SqlMapClientOperations.queryForMap(String statementName, Object parameterObject, String keyProperty)`
`Map` | `SqlMapClientTemplate.queryForMap(String statementName, Object parameterObject, String keyProperty, String valueProperty)`
`Map` | `SqlMapClientOperations.queryForMap(String statementName, Object parameterObject, String keyProperty, String valueProperty)`
`Object` | `SqlMapClientTemplate.queryForObject(String statementName)`
`Object` | `SqlMapClientOperations.queryForObject(String statementName)`
`Object` | `SqlMapClientTemplate.queryForObject(String statementName, Object parameterObject)`
`Object` | `SqlMapClientOperations.queryForObject(String statementName, Object parameterObject)`
`Object` | `SqlMapClientTemplate.queryForObject(String statementName, Object parameterObject, Object resultObject)`
`Object` | `SqlMapClientOperations.queryForObject(String statementName, Object parameterObject, Object resultObject)`
`com.ibatis.common.util.PaginatedList` | `SqlMapClientTemplate.queryForPaginatedList(String statementName, int pageSize)` Deprecated. as of iBATIS 2.3.0
`com.ibatis.common.util.PaginatedList` | `SqlMapClientOperations.queryForPaginatedList(String statementName, int pageSize)` Deprecated. as of iBATIS 2.3.0
`com.ibatis.common.util.PaginatedList` | `SqlMapClientTemplate.queryForPaginatedList(String statementName, Object parameterObject, int pageSize)` Deprecated. as of iBATIS 2.3.0
`com.ibatis.common.util.PaginatedList` | `SqlMapClientOperations.queryForPaginatedList(String statementName, Object parameterObject, int pageSize)` Deprecated. as of iBATIS 2.3.0
`void` | `SqlMapClientTemplate.queryWithRowHandler(String statementName, Object parameterObject, com.ibatis.sqlmap.client.event.RowHandler rowHandler)`
`void` | `SqlMapClientOperations.queryWithRowHandler(String statementName, Object parameterObject, com.ibatis.sqlmap.client.event.RowHandler rowHandler)`
`void` | `SqlMapClientTemplate.queryWithRowHandler(String statementName, com.ibatis.sqlmap.client.event.RowHandler rowHandler)`
`void` | `SqlMapClientOperations.queryWithRowHandler(String statementName, com.ibatis.sqlmap.client.event.RowHandler rowHandler)`
`int` | `SqlMapClientTemplate.update(String statementName)`
`int` | `SqlMapClientOperations.update(String statementName)`
`int` | `SqlMapClientTemplate.update(String statementName, Object parameterObject)`
`int` | `SqlMapClientOperations.update(String statementName, Object parameterObject)`
`void` | `SqlMapClientTemplate.update(String statementName, Object parameterObject, int requiredRowsAffected)`
`void` | `SqlMapClientOperations.update(String statementName, Object parameterObject, int requiredRowsAffected)` Convenience method provided by Spring: execute an update operation with an automatic check that the update affected the given required number of rows.

Uses of DataAccessException in org.springframework.orm.jdo

Subclasses of DataAccessException in org.springframework.orm.jdo
`class` | `JdoObjectRetrievalFailureException` JDO-specific subclass of ObjectRetrievalFailureException.
`class` | `JdoOptimisticLockingFailureException` JDO-specific subclass of ObjectOptimisticLockingFailureException.
`class` | `JdoResourceFailureException` JDO-specific subclass of DataAccessResourceFailureException.
`class` | `JdoSystemException` JDO-specific subclass of UncategorizedDataAccessException, for JDO system errors that do not match any concrete `org.springframework.dao` exceptions.
`class` | `JdoUsageException` JDO-specific subclass of InvalidDataAccessApiUsageException.

Methods in org.springframework.orm.jdo that return DataAccessException
`static DataAccessException` | `PersistenceManagerFactoryUtils.convertJdoAccessException(javax.jdo.JDOException ex)` Convert the given JDOException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected DataAccessException` | `JdoTransactionManager.convertJdoAccessException(javax.jdo.JDOException ex)` Convert the given JDOException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `JdoAccessor.convertJdoAccessException(javax.jdo.JDOException ex)` Convert the given JDOException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `JdoDialect.translateException(javax.jdo.JDOException ex)` Translate the given JDOException to a corresponding exception from Spring's generic DataAccessException hierarchy.
`DataAccessException` | `DefaultJdoDialect.translateException(javax.jdo.JDOException ex)` This implementation delegates to PersistenceManagerFactoryUtils.
`DataAccessException` | `LocalPersistenceManagerFactoryBean.translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.
`DataAccessException` | `DefaultJdoDialect.translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

Methods in org.springframework.orm.jdo that throw DataAccessException
`void` | `JdoTemplate.deletePersistent(Object entity)`
`void` | `JdoOperations.deletePersistent(Object entity)` Delete the given persistent instance.
`void` | `JdoTemplate.deletePersistentAll(Collection entities)`
`void` | `JdoOperations.deletePersistentAll(Collection entities)` Delete all given persistent instances.
`void` | `JdoTemplate.evict(Object entity)`
`void` | `JdoOperations.evict(Object entity)` Remove the given object from the PersistenceManager cache.
`void` | `JdoTemplate.evictAll()`
`void` | `JdoOperations.evictAll()` Remove all objects from the PersistenceManager cache.
`void` | `JdoTemplate.evictAll(Collection entities)`
`void` | `JdoOperations.evictAll(Collection entities)` Remove all given objects from the PersistenceManager cache.
`Object` | `JdoTemplate.execute(JdoCallback action)`
`Object` | `JdoOperations.execute(JdoCallback action)` Execute the action specified by the given action object within a PersistenceManager.
`Object` | `JdoTemplate.execute(JdoCallback action, boolean exposeNativePersistenceManager)` Execute the action specified by the given action object within a PersistenceManager.
`Collection` | `JdoTemplate.executeFind(JdoCallback action)`
`Collection` | `JdoOperations.executeFind(JdoCallback action)` Execute the specified action assuming that the result object is a Collection.
`Collection` | `JdoTemplate.find(Class entityClass)`
`Collection` | `JdoOperations.find(Class entityClass)` Find all persistent instances of the given class.
`Collection` | `JdoTemplate.find(Class entityClass, String filter)`
`Collection` | `JdoOperations.find(Class entityClass, String filter)` Find all persistent instances of the given class that match the given JDOQL filter.
`Collection` | `JdoTemplate.find(Class entityClass, String filter, String ordering)`
`Collection` | `JdoOperations.find(Class entityClass, String filter, String ordering)` Find all persistent instances of the given class that match the given JDOQL filter, with the given result ordering.
`Collection` | `JdoTemplate.find(Class entityClass, String filter, String parameters, Map values)`
`Collection` | `JdoOperations.find(Class entityClass, String filter, String parameters, Map values)` Find all persistent instances of the given class that match the given JDOQL filter, using the given parameter declarations and parameter values.
`Collection` | `JdoTemplate.find(Class entityClass, String filter, String parameters, Map values, String ordering)`
`Collection` | `JdoOperations.find(Class entityClass, String filter, String parameters, Map values, String ordering)` Find all persistent instances of the given class that match the given JDOQL filter, using the given parameter declarations and parameter values, with the given result ordering.
`Collection` | `JdoTemplate.find(Class entityClass, String filter, String parameters, Object[] values)`
`Collection` | `JdoOperations.find(Class entityClass, String filter, String parameters, Object[] values)` Find all persistent instances of the given class that match the given JDOQL filter, using the given parameter declarations and parameter values.
`Collection` | `JdoTemplate.find(Class entityClass, String filter, String parameters, Object[] values, String ordering)`
`Collection` | `JdoOperations.find(Class entityClass, String filter, String parameters, Object[] values, String ordering)` Find all persistent instances of the given class that match the given JDOQL filter, using the given parameter declarations and parameter values, with the given result ordering.
`Collection` | `JdoTemplate.find(String queryString)`
`Collection` | `JdoOperations.find(String queryString)` Find persistent instances through the given single-string JDOQL query.
`Collection` | `JdoTemplate.find(String queryString, Map values)`
`Collection` | `JdoOperations.find(String queryString, Map values)` Find persistent instances through the given single-string JDOQL query.
`Collection` | `JdoTemplate.find(String language, Object queryObject)`
`Collection` | `JdoOperations.find(String language, Object queryObject)` Find persistent instances through the given query object in the specified query language.
`Collection` | `JdoTemplate.find(String queryString, Object[] values)`
`Collection` | `JdoOperations.find(String queryString, Object[] values)` Find persistent instances through the given single-string JDOQL query.
`Collection` | `JdoTemplate.findByNamedQuery(Class entityClass, String queryName)`
`Collection` | `JdoOperations.findByNamedQuery(Class entityClass, String queryName)` Find persistent instances through the given named query.
`Collection` | `JdoTemplate.findByNamedQuery(Class entityClass, String queryName, Map values)`
`Collection` | `JdoOperations.findByNamedQuery(Class entityClass, String queryName, Map values)` Find persistent instances through the given named query.
`Collection` | `JdoTemplate.findByNamedQuery(Class entityClass, String queryName, Object[] values)`
`Collection` | `JdoOperations.findByNamedQuery(Class entityClass, String queryName, Object[] values)` Find persistent instances through the given named query.
`void` | `JdoTemplate.flush()`
`void` | `JdoOperations.flush()` Flush all transactional modifications to the database.
`Object` | `JdoTemplate.getObjectById(Class entityClass, Object idValue)`
`Object` | `JdoOperations.getObjectById(Class entityClass, Object idValue)` Return the persistent instance of the given entity class with the given id value, throwing an exception if not found.
`Object` | `JdoTemplate.getObjectById(Object objectId)`
`Object` | `JdoOperations.getObjectById(Object objectId)` Return the persistent instance with the given JDO object id, throwing an exception if not found.
`Object` | `JdoTemplate.makePersistent(Object entity)`
`Object` | `JdoOperations.makePersistent(Object entity)` Make the given transient instance persistent.
`Collection` | `JdoTemplate.makePersistentAll(Collection entities)`
`Collection` | `JdoOperations.makePersistentAll(Collection entities)` Make the given transient instances persistent.
`void` | `JdoTemplate.refresh(Object entity)`
`void` | `JdoOperations.refresh(Object entity)` Re-read the state of the given persistent instance.
`void` | `JdoTemplate.refreshAll()`
`void` | `JdoOperations.refreshAll()` Re-read the state of all persistent instances.
`void` | `JdoTemplate.refreshAll(Collection entities)`
`void` | `JdoOperations.refreshAll(Collection entities)` Re-read the state of all given persistent instances.

Uses of DataAccessException in org.springframework.orm.jdo.support

Methods in org.springframework.orm.jdo.support that return DataAccessException
`protected DataAccessException` | `JdoDaoSupport.convertJdoAccessException(javax.jdo.JDOException ex)` Convert the given JDOException to an appropriate exception from the org.springframework.dao hierarchy.

Methods in org.springframework.orm.jdo.support that throw DataAccessException
`void` | `OpenPersistenceManagerInViewInterceptor.afterCompletion(WebRequest request, Exception ex)`
`void` | `OpenPersistenceManagerInViewInterceptor.preHandle(WebRequest request)`

Uses of DataAccessException in org.springframework.orm.jpa

Subclasses of DataAccessException in org.springframework.orm.jpa
`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
`static DataAccessException` | `EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(RuntimeException ex)` Convert the given runtime exception to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `DefaultJpaDialect.translateExceptionIfPossible(RuntimeException ex)` This implementation delegates to EntityManagerFactoryUtils.
`DataAccessException` | `AbstractEntityManagerFactoryBean.translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

Methods in org.springframework.orm.jpa that throw DataAccessException
`boolean` | `JpaTemplate.contains(Object entity)`
`boolean` | `JpaOperations.contains(Object entity)`
`Object` | `JpaTemplate.execute(JpaCallback action)`
`Object` | `JpaOperations.execute(JpaCallback action)`
`Object` | `JpaTemplate.execute(JpaCallback action, boolean exposeNativeEntityManager)` Execute the action specified by the given action object within a EntityManager.
`List` | `JpaTemplate.executeFind(JpaCallback action)`
`List` | `JpaOperations.executeFind(JpaCallback action)`
`
`<T> T`
` | `JpaTemplate.find(Class<T> entityClass, Object id)`
`
`<T> T`
` | `JpaOperations.find(Class<T> entityClass, Object id)`
`List` | `JpaTemplate.find(String queryString)`
`List` | `JpaOperations.find(String queryString)`
`List` | `JpaTemplate.find(String queryString, Object... values)`
`List` | `JpaOperations.find(String queryString, Object... values)`
`List` | `JpaTemplate.findByNamedParams(String queryString, Map<String,?> params)`
`List` | `JpaOperations.findByNamedParams(String queryString, Map<String,? extends Object> params)`
`List` | `JpaTemplate.findByNamedQuery(String queryName)`
`List` | `JpaOperations.findByNamedQuery(String queryName)`
`List` | `JpaTemplate.findByNamedQuery(String queryName, Object... values)`
`List` | `JpaOperations.findByNamedQuery(String queryName, Object... values)`
`List` | `JpaTemplate.findByNamedQueryAndNamedParams(String queryName, Map<String,?> params)`
`List` | `JpaOperations.findByNamedQueryAndNamedParams(String queryName, Map<String,? extends Object> params)`
`void` | `JpaTemplate.flush()`
`void` | `JpaOperations.flush()`
`
`<T> T`
` | `JpaTemplate.getReference(Class<T> entityClass, Object id)`
`
`<T> T`
` | `JpaOperations.getReference(Class<T> entityClass, Object id)`
`
`<T> T`
` | `JpaTemplate.merge(T entity)`
`
`<T> T`
` | `JpaOperations.merge(T entity)`
`void` | `JpaTemplate.persist(Object entity)`
`void` | `JpaOperations.persist(Object entity)`
`void` | `JpaTemplate.refresh(Object entity)`
`void` | `JpaOperations.refresh(Object entity)`
`void` | `JpaTemplate.remove(Object entity)`
`void` | `JpaOperations.remove(Object entity)`

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

Methods in org.springframework.orm.jpa.support that throw DataAccessException
`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
`DataAccessException` | `HibernateJpaDialect.translateExceptionIfPossible(RuntimeException ex)`

Uses of DataAccessException in org.springframework.orm.toplink

Subclasses of DataAccessException in org.springframework.orm.toplink
`class` | `TopLinkJdbcException` TopLink-specific subclass of DataAccessException, for JDBC exceptions that TopLink rethrew.
`class` | `TopLinkOptimisticLockingFailureException` TopLink-specific subclass of ObjectOptimisticLockingFailureException.
`class` | `TopLinkQueryException` TopLink-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid TopLink query syntax or behavior.
`class` | `TopLinkSystemException` TopLink-specific subclass of UncategorizedDataAccessException, for TopLink system errors that do not match any concrete `org.springframework.dao` exceptions.

Methods in org.springframework.orm.toplink that return DataAccessException
`protected DataAccessException` | `TopLinkTransactionManager.convertTopLinkAccessException(oracle.toplink.exceptions.TopLinkException ex)` Convert the given TopLinkException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `TopLinkAccessor.convertTopLinkAccessException(oracle.toplink.exceptions.TopLinkException ex)` Convert the given TopLinkException to an appropriate exception from the `org.springframework.dao` hierarchy.
`static DataAccessException` | `SessionFactoryUtils.convertTopLinkAccessException(oracle.toplink.exceptions.TopLinkException ex)` Convert the given TopLinkException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `LocalSessionFactoryBean.convertTopLinkAccessException(oracle.toplink.exceptions.TopLinkException ex)` Convert the given TopLinkException to an appropriate exception from the `org.springframework.dao` hierarchy.
`DataAccessException` | `LocalSessionFactoryBean.translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

Methods in org.springframework.orm.toplink that throw DataAccessException
`Object` | `TopLinkTemplate.copy(Object entity)`
`Object` | `TopLinkOperations.copy(Object entity)` Create a detached copy of the given entity object, using TopLink's default ObjectCopyingPolicy.
`Object` | `TopLinkTemplate.copy(Object entity, oracle.toplink.sessions.ObjectCopyingPolicy copyingPolicy)`
`Object` | `TopLinkOperations.copy(Object entity, oracle.toplink.sessions.ObjectCopyingPolicy copyingPolicy)` Create a detached copy of the given entity object.
`List` | `TopLinkTemplate.copyAll(Collection entities)`
`List` | `TopLinkOperations.copyAll(Collection entities)` Create detached copies of all given entity objects, using TopLink's default ObjectCopyingPolicy.
`List` | `TopLinkTemplate.copyAll(Collection entities, oracle.toplink.sessions.ObjectCopyingPolicy copyingPolicy)`
`List` | `TopLinkOperations.copyAll(Collection entities, oracle.toplink.sessions.ObjectCopyingPolicy copyingPolicy)` Create detached copies of all given entity objects.
`Object` | `TopLinkTemplate.deepMerge(Object entity)`
`Object` | `TopLinkOperations.deepMerge(Object entity)` Reassociate the given entity copy with the current UnitOfWork, using deep merging of all contained entities.
`void` | `TopLinkTemplate.delete(Object entity)`
`void` | `TopLinkOperations.delete(Object entity)` Delete the given entity.
`void` | `TopLinkTemplate.deleteAll(Collection entities)`
`void` | `TopLinkOperations.deleteAll(Collection entities)` Delete all given entities.
`Object` | `TopLinkTemplate.execute(TopLinkCallback action)`
`Object` | `TopLinkOperations.execute(TopLinkCallback action)` Execute the action specified by the given action object within a TopLink Session.
`List` | `TopLinkTemplate.executeFind(TopLinkCallback action)`
`List` | `TopLinkOperations.executeFind(TopLinkCallback action)` Execute the specified action assuming that the result object is a Collection.
`Object` | `TopLinkTemplate.executeNamedQuery(Class entityClass, String queryName)`
`Object` | `TopLinkOperations.executeNamedQuery(Class entityClass, String queryName)` Execute a given named query with the given arguments.
`Object` | `TopLinkTemplate.executeNamedQuery(Class entityClass, String queryName, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.executeNamedQuery(Class entityClass, String queryName, boolean enforceReadOnly)` Execute a given named query with the given arguments.
`Object` | `TopLinkTemplate.executeNamedQuery(Class entityClass, String queryName, Object[] args)`
`Object` | `TopLinkOperations.executeNamedQuery(Class entityClass, String queryName, Object[] args)` Execute a given named query with the given arguments.
`Object` | `TopLinkTemplate.executeNamedQuery(Class entityClass, String queryName, Object[] args, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.executeNamedQuery(Class entityClass, String queryName, Object[] args, boolean enforceReadOnly)` Execute a given named query with the given arguments.
`Object` | `TopLinkTemplate.executeQuery(oracle.toplink.queryframework.DatabaseQuery query)`
`Object` | `TopLinkOperations.executeQuery(oracle.toplink.queryframework.DatabaseQuery query)` Execute the given query object with the given arguments.
`Object` | `TopLinkTemplate.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, boolean enforceReadOnly)` Execute the given query object with the given arguments.
`Object` | `TopLinkTemplate.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, Object[] args)`
`Object` | `TopLinkOperations.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, Object[] args)` Execute the given query object with the given arguments.
`Object` | `TopLinkTemplate.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, Object[] args, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.executeQuery(oracle.toplink.queryframework.DatabaseQuery query, Object[] args, boolean enforceReadOnly)` Execute the given query object with the given arguments.
`Object` | `TopLinkTemplate.merge(Object entity)`
`Object` | `TopLinkOperations.merge(Object entity)` Reassociate the given entity copy with the current UnitOfWork, using simple merging.
`Object` | `TopLinkTemplate.mergeWithReferences(Object entity)`
`Object` | `TopLinkOperations.mergeWithReferences(Object entity)` Reassociate the given entity copy with the current UnitOfWork, using merging with all references from this clone.
`Object` | `TopLinkTemplate.read(Class entityClass, oracle.toplink.queryframework.Call call)`
`Object` | `TopLinkOperations.read(Class entityClass, oracle.toplink.queryframework.Call call)` Read an entity instance of the given class, as returned by the given call.
`Object` | `TopLinkTemplate.read(Class entityClass, oracle.toplink.queryframework.Call call, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.read(Class entityClass, oracle.toplink.queryframework.Call call, boolean enforceReadOnly)` Read an entity instance of the given class, as returned by the given call.
`Object` | `TopLinkTemplate.read(Class entityClass, oracle.toplink.expressions.Expression expression)`
`Object` | `TopLinkOperations.read(Class entityClass, oracle.toplink.expressions.Expression expression)` Read an entity instance of the given class that matches the given expression.
`Object` | `TopLinkTemplate.read(Class entityClass, oracle.toplink.expressions.Expression expression, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.read(Class entityClass, oracle.toplink.expressions.Expression expression, boolean enforceReadOnly)` Read an entity instance of the given class that matches the given expression.
`List` | `TopLinkTemplate.readAll(Class entityClass)`
`List` | `TopLinkOperations.readAll(Class entityClass)` Read all entity instances of the given class.
`List` | `TopLinkTemplate.readAll(Class entityClass, boolean enforceReadOnly)`
`List` | `TopLinkOperations.readAll(Class entityClass, boolean enforceReadOnly)` Read all entity instances of the given class.
`List` | `TopLinkTemplate.readAll(Class entityClass, oracle.toplink.queryframework.Call call)`
`List` | `TopLinkOperations.readAll(Class entityClass, oracle.toplink.queryframework.Call call)` Read all entity instances of the given class, as returned by the given call.
`List` | `TopLinkTemplate.readAll(Class entityClass, oracle.toplink.queryframework.Call call, boolean enforceReadOnly)`
`List` | `TopLinkOperations.readAll(Class entityClass, oracle.toplink.queryframework.Call call, boolean enforceReadOnly)` Read all entity instances of the given class, as returned by the given call.
`List` | `TopLinkTemplate.readAll(Class entityClass, oracle.toplink.expressions.Expression expression)`
`List` | `TopLinkOperations.readAll(Class entityClass, oracle.toplink.expressions.Expression expression)` Read all entity instances of the given class that match the given expression.
`List` | `TopLinkTemplate.readAll(Class entityClass, oracle.toplink.expressions.Expression expression, boolean enforceReadOnly)`
`List` | `TopLinkOperations.readAll(Class entityClass, oracle.toplink.expressions.Expression expression, boolean enforceReadOnly)` Read all entity instances of the given class that match the given expression.
`Object` | `TopLinkTemplate.readAndCopy(Class entityClass, Object id)`
`Object` | `TopLinkOperations.readAndCopy(Class entityClass, Object id)` Read the entity instance of the given class with the given id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readAndCopy(Class entityClass, Object[] keys)`
`Object` | `TopLinkOperations.readAndCopy(Class entityClass, Object[] keys)` Read the entity instance of the given class with the given composite id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readAndCopy(Class entityClass, Object[] keys, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.readAndCopy(Class entityClass, Object[] keys, boolean enforceReadOnly)` Read the entity instance of the given class with the given composite id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readAndCopy(Class entityClass, Object id, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.readAndCopy(Class entityClass, Object id, boolean enforceReadOnly)` Read the entity instance of the given class with the given id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readById(Class entityClass, Object id)`
`Object` | `TopLinkOperations.readById(Class entityClass, Object id)` Read the entity instance of the given class with the given id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readById(Class entityClass, Object[] keys)`
`Object` | `TopLinkOperations.readById(Class entityClass, Object[] keys)` Read the entity instance of the given class with the given composite id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readById(Class entityClass, Object[] keys, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.readById(Class entityClass, Object[] keys, boolean enforceReadOnly)` Read the entity instance of the given class with the given composite id, throwing an exception if not found.
`Object` | `TopLinkTemplate.readById(Class entityClass, Object id, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.readById(Class entityClass, Object id, boolean enforceReadOnly)` Read the entity instance of the given class with the given id, throwing an exception if not found.
`Object` | `TopLinkTemplate.refresh(Object entity)`
`Object` | `TopLinkOperations.refresh(Object entity)` Refresh the given entity object, returning the refreshed object.
`Object` | `TopLinkTemplate.refresh(Object entity, boolean enforceReadOnly)`
`Object` | `TopLinkOperations.refresh(Object entity, boolean enforceReadOnly)` Refresh the given entity object, returning the refreshed object.
`List` | `TopLinkTemplate.refreshAll(Collection entities)`
`List` | `TopLinkOperations.refreshAll(Collection entities)` Refresh the given entity objects, returning the corresponding refreshed objects.
`List` | `TopLinkTemplate.refreshAll(Collection entities, boolean enforceReadOnly)`
`List` | `TopLinkOperations.refreshAll(Collection entities, boolean enforceReadOnly)` Refresh the given entity objects, returning the corresponding refreshed objects.
`Object` | `TopLinkTemplate.shallowMerge(Object entity)`
`Object` | `TopLinkOperations.shallowMerge(Object entity)` Reassociate the given entity copy with the current UnitOfWork, using shallow merging of the entity instance.

Uses of DataAccessException in org.springframework.orm.toplink.support

Methods in org.springframework.orm.toplink.support that return DataAccessException
`protected DataAccessException` | `TopLinkDaoSupport.convertTopLinkAccessException(oracle.toplink.exceptions.TopLinkException ex)` Convert the given TopLinkException to an appropriate exception from the `org.springframework.dao` hierarchy.

Uses of DataAccessException in org.springframework.test

Methods in org.springframework.test that throw DataAccessException
`protected void` | `AbstractTransactionalDataSourceSpringContextTests.executeSqlScript(String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.

Uses of DataAccessException in org.springframework.test.context.junit38

Methods in org.springframework.test.context.junit38 that throw DataAccessException
`protected void` | `AbstractTransactionalJUnit38SpringContextTests.executeSqlScript(String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.

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

Methods in org.springframework.test.context.junit4 that throw DataAccessException
`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
`protected void` | `AbstractTransactionalTestNGSpringContextTests.executeSqlScript(String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.

Uses of DataAccessException in org.springframework.test.jdbc

Methods in org.springframework.test.jdbc that throw DataAccessException
`static void` | `SimpleJdbcTestUtils.executeSqlScript(SimpleJdbcTemplate simpleJdbcTemplate, EncodedResource resource, boolean continueOnError)` Execute the given SQL script.
`static void` | `SimpleJdbcTestUtils.executeSqlScript(SimpleJdbcTemplate simpleJdbcTemplate, Resource resource, boolean continueOnError)` Execute the given SQL script.
`static void` | `SimpleJdbcTestUtils.executeSqlScript(SimpleJdbcTemplate simpleJdbcTemplate, ResourceLoader resourceLoader, String sqlResourcePath, boolean continueOnError)` Execute the given SQL script.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV NEXT | FRAMES NO FRAMES

Copyright © 2002-2008 The Spring Framework.