TransactionPair (Carbonado 1.2.3 API)

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)
+

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
    +
  +
+

Class TransactionPair

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TransactionPair

Method Detail

commit

exit

setForUpdate

isForUpdate

setDesiredLockTimeout

getIsolationLevel

detach

attach

preCommit