Library: Data
Package: Core
Header: Poco/Data/Transaction.h
Transaction helps with transactions in domain logic. When an Transaction object is created, it first checks whether a transaction is in progress. If not, a new transaction is created. When the Transaction is destroyed, and commit() has been called, nothing is done. Otherwise, the current transaction is rolled back. See Transaction for more detaisl nad purpose of this template.
Member Functions: commit, execute, getIsolation, hasIsolation, isActive, isIsolation, rollback, setIsolation, setLogger, transact
Transaction(
Poco::Data::Session & session,
Poco::Logger * pLogger = 0
);
Creates the Transaction and starts it, using the given database session and logger.
Transaction(
Poco::Data::Session & session,
bool start
);
Creates the Transaction, using the given database session. If start is true, transaction is started, otherwise begin() must be called to start the transaction.
template < typename T > Transaction(
Poco::Data::Session & rSession,
T & t,
Poco::Logger * pLogger = 0
);
Creates the Transaction, using the given database session, transactor and logger. The transactor type must provide operator () overload taking non-const Session reference as an argument.
When transaction is created using this constructor, it is executed and commited automatically. If no error occurs, rollback is disabled and does not occur at destruction time. If an error occurs resulting in exception being thrown, the transaction is rolled back and exception propagated to calling code.
Example usage:
struct Transactor { void operator () (Session& session) const {
// do something ...
} };
Transactor tr; Transaction tn(session, tr);
~Transaction();
Destroys the Transaction. Rolls back the current database transaction if it has not been commited (by calling commit()), or rolled back (by calling rollback()).
If an exception is thrown during rollback, the exception is logged and no further action is taken.
void commit();
Commits the current transaction.
void execute(
const std::string & sql,
bool doCommit = true
);
Executes and, if doCommit is true, commits the transaction. Passing true value for commit disables rollback during destruction of this Transaction object.
void execute(
const std::vector < std::string > & sql
);
Executes all the SQL statements supplied in the vector and, after the last one is sucesfully executed, commits the transaction. If an error occurs during execution, transaction is rolled back. Passing true value for commit disables rollback during destruction of this Transaction object.
Poco::UInt32 getIsolation();
Returns the transaction isolation level.
bool hasIsolation(
Poco::UInt32 ti
);
Returns true if and only if the transaction isolation level corresponding to the supplied bitmask is supported.
bool isActive();
Returns false after the transaction has been committed or rolled back, true if the transaction is ongoing.
bool isIsolation(
Poco::UInt32 ti
);
Returns true if and only if the transaction isolation level corresponds to the supplied bitmask.
void rollback();
Rolls back the current transaction.
void setIsolation(
Poco::UInt32 ti
);
Sets the transaction isolation level.
void setLogger(
Poco::Logger * pLogger
);
Sets the logger for this transaction. Transaction does not take the ownership of the pointer.
template < typename T > void transact(
T & t
);
Executes the transactor and, unless transactor throws an exception, commits the transaction.