# Package org.springframework.dao

@NonNullApi @NonNullFields package org.springframework.dao
Exception hierarchy enabling sophisticated error handling independent of the data access approach in use. For example, when DAOs and data access frameworks use the exceptions in this package (and custom subclasses), calling code can detect and handle common problems such as deadlocks without being tied to a particular data access strategy, such as JDBC.

All these exceptions are unchecked, meaning that calling code can leave them uncaught and treat all data access exceptions as fatal.

The classes in this package are discussed in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).

Related Packages
Package
Description
org.springframework.dao.annotation
Annotation support for DAOs.
org.springframework.dao.support
Support classes for DAO implementations, providing miscellaneous utility methods.
Exceptions
Class
Description
CannotAcquireLockException
Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.
CannotSerializeTransactionException
Deprecated.
as of 6.0.3, in favor of `PessimisticLockingFailureException`/`CannotAcquireLockException`
CleanupFailureDataAccessException
Deprecated.
as of 6.0.3 since it is not in use within core JDBC/ORM support
ConcurrencyFailureException
Exception thrown on various data access concurrency failures.
DataAccessException
Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.
DataAccessResourceFailureException
Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
DataIntegrityViolationException
Exception thrown when an attempt to execute an SQL statement fails to map the given data, typically but no limited to an insert or update data results in violation of an integrity constraint.
DataRetrievalFailureException
Exception thrown if certain expected data could not be retrieved, for example, when looking up specific data via a known identifier.
DeadlockLoserDataAccessException
Deprecated.
as of 6.0.3, in favor of `PessimisticLockingFailureException`/`CannotAcquireLockException`
DuplicateKeyException
Exception thrown when an attempt to insert or update data results in violation of a primary key or unique constraint.
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.
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.
IncorrectUpdateSemanticsDataAccessException
Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
InvalidDataAccessApiUsageException
Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
InvalidDataAccessResourceUsageException
Root for exceptions thrown when we use a data access resource incorrectly.
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.
NonTransientDataAccessResourceException
Data access exception thrown when a resource fails completely and the failure is permanent.
OptimisticLockingFailureException
Exception thrown on an optimistic locking violation.
PermissionDeniedDataAccessException
Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
PessimisticLockingFailureException
Exception thrown on a pessimistic locking violation.
QueryTimeoutException
Exception to be thrown on a query timeout.
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.
TransientDataAccessException
Root of the hierarchy of data access exceptions that are considered transient - where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
TransientDataAccessResourceException
Data access exception thrown when a resource fails temporarily and the operation can be retried.
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.
UncategorizedDataAccessException
Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, an SQLException from JDBC we can't pinpoint more precisely.