![]() | |
|
A transaction is a logical unit of work.
Transactional support allows applications to ensure the following:
All the steps to complete a logical unit of work are followed.
When one of the steps to the unit of work files fails, all the work done as part of that logical unit of work can be undone and the database can return to its previous state before the transaction began.
Transactions are used to provide data integrity, correct application semantics, and a consistent view of data during concurrent access. All Java Database Connectivity (JDBC) compliant drivers must support transactions.
All transactional work is handled at the Connection
object level. When the work for
a transaction completes, it can be finalized by calling the commit()
method. If the
application aborts the transaction, the rollback()
method is called.
All Statement
objects under a Connection
are a part of the transaction.
This means is that if an application creates three Statement
objects and uses each
object to make changes to the database, when a commit or rollback call happens, the work for all
three statements either becomes permanent or is discarded.
JDBC auto-commit mode
By default, JDBC uses an operation mode called auto-commit. This means that every update to the database is immediately made permanent.
Any situation where a logical unit of work requires more than one update to the database cannot be done safely in auto-commit mode. If something happens to the application or the system after one update is made and before any other updates are made, the first change cannot be undone when running in auto-commit mode.
Because changes are instantly made permanent in auto-commit mode, there is no need for the
application to call the commit()
method or the rollback()
method. This
makes applications easier to write.
Auto-commit mode can be enabled and disabled dynamically during a connection's existence. Auto-commit can be disabled in the following way, assuming that data source already exists:
Connection conn = dataSource.getConnection(); conn.setAutoCommit(false); // Disables auto-commit
NOTE: If the auto-commit setting is changed in the middle of a transaction,
any pending work is automatically committed. If setAutoCommit(...)
is
called and the auto-commit mode is not changed, the call is a no-op.
NOTE: there is NO Connection.begin()
method to begin a transaction!
The first call of Connection.setAutoCommit(false)
and each call of
Connection.commit()
implicitly mark the start of a transaction. Transactions can
be undone before they are committed by calling Connection.rollback()
.
![]() ![]() ![]() |