com.amazon.carbonado.txn

Class TransactionPair

java.lang.Object

com.amazon.carbonado.txn.TransactionPair

All Implemented Interfaces:

Transaction

public class TransactionPair
extends java.lang.Object
implements Transaction

Pairs two transaction together into one. The transaction cannot be atomic, however. Inconsistencies can result if the primary transaction succeeds in committing, but the secondary fails. Therefore, the designated primary transaction should be the one that is more likely to fail. For example, the primary transaction might rely on the network, but the secondary operates locally.

Author:

Don Schneider, Brian S O'Neill

Constructor Summary

Constructors

Constructor and Description
TransactionPair(Transaction primaryTransaction, Transaction secondaryTransaction)

Method Summary

Methods

Modifier and Type	Method and Description
void	attach() Attaches this transaction to the current thread, if it has been detached.
void	commit() If currently in a transaction, commits all changes to the storage layer since the last commit within the transaction.
void	detach() Detaches this transaction from the current thread.
void	exit() Closes the current transaction, aborting all changes since the last commit.
IsolationLevel	getIsolationLevel() Returns the isolation level of this transaction.
boolean	isForUpdate() Returns true if this transaction is in update mode, which is adjusted by calling Transaction.setForUpdate(boolean).
boolean	preCommit() Calling this method commits all nested child transactions, closes all scoped cursors, and locks out some interactions from other threads.
void	setDesiredLockTimeout(int timeout, java.util.concurrent.TimeUnit unit) Specify a desired timeout for aquiring locks within this transaction.
void	setForUpdate(boolean forUpdate) Set to true to force all read operations within this transaction to acquire upgradable or write locks.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TransactionPair

public TransactionPair(Transaction primaryTransaction,
               Transaction secondaryTransaction)

Parameters:

primaryTransaction - is committed first, exited last

secondaryTransaction - is exited first, commited last

Method Detail

commit

public void commit()
            throws PersistException

Description copied from interface: Transaction

If currently in a transaction, commits all changes to the storage layer since the last commit within the transaction.

Specified by:

commit in interface Transaction

Throws:

PersistException - if storage layer throws an exception

exit

public void exit()
          throws PersistException

Description copied from interface: Transaction

Closes the current transaction, aborting all changes since the last commit.

Specified by:

exit in interface Transaction

Throws:

PersistException - if storage layer throws an exception

setForUpdate

public void setForUpdate(boolean forUpdate)

Description copied from interface: Transaction

Set to true to force all read operations within this transaction to acquire upgradable or write locks. This option eliminates deadlocks that may occur when updating records, except it may increase contention.

Specified by:

setForUpdate in interface Transaction

isForUpdate

public boolean isForUpdate()

Description copied from interface: Transaction

Returns true if this transaction is in update mode, which is adjusted by calling Transaction.setForUpdate(boolean).

Specified by:

isForUpdate in interface Transaction

setDesiredLockTimeout

public void setDesiredLockTimeout(int timeout,
                         java.util.concurrent.TimeUnit unit)

Description copied from interface: Transaction

Specify a desired timeout for aquiring locks within this transaction. Calling this method may have have no effect at all, if the repository does not support this feature. In addition, the lock timeout might not be alterable if the transaction contains uncommitted data.

Also, the range of lock timeout values supported might be small. For example, only a timeout value of zero might be supported. In that case, the transaction is configured to not wait at all when trying to acquire locks. Expect immediate timeout exceptions when locks cannot be granted.

Nested transactions inherit the desired lock timeout of their parent. Top transactions always begin with the default lock timeout.

Specified by:

setDesiredLockTimeout in interface Transaction

Parameters:

timeout - Desired lock timeout. If negative, revert lock timeout to default value.

unit - Time unit for timeout. If null, revert lock timeout to default value.

getIsolationLevel

public IsolationLevel getIsolationLevel()

Description copied from interface: Transaction

Returns the isolation level of this transaction.

Specified by:

getIsolationLevel in interface Transaction

detach

public void detach()

Description copied from interface: Transaction

Detaches this transaction from the current thread. It can be attached later, and to any thread which currently has no thread-local transaction.

Detaching a transaction also detaches any parent and nested child transactions. Attaching any of them achieves the same result as attaching this transaction.

Specified by:

detach in interface Transaction

attach

public void attach()

Description copied from interface: Transaction

Attaches this transaction to the current thread, if it has been detached. Attaching a transaction also attaches any parent and nested child transactions.

Specified by:

attach in interface Transaction

preCommit

public boolean preCommit()
                  throws PersistException

Description copied from interface: Transaction

Calling this method commits all nested child transactions, closes all scoped cursors, and locks out some interactions from other threads. The commit method must still be called to finish the commit. Most applications have no use for pre-commit and should only ever call commit.

The intent of this method is to complete as many operations as possible leading up to the actual commit. If pre-commit succeeds, then commit will most likely succeed as well. While in a pre-commit state, the transaction can still be used by the current thread. Calling pre-commit again ensures that child transactions and cursors are closed.

Specified by:

preCommit in interface Transaction

Returns:

false if transaction has exited

Throws:

PersistException