GridCacheTxEx (gridgain-core 6.1.9 API)

All Superinterfaces:

AutoCloseable, GridCacheTx, GridMetadataAware, GridTimeoutObject, Serializable

All Known Subinterfaces:

GridCacheTxLocalEx<K,V>, GridCacheTxRemoteEx<K,V>

All Known Implementing Classes:

GridCacheTxAdapter, GridCacheTxLocalAdapter, GridDhtColocatedTxLocal, GridDhtTxLocal, GridDhtTxLocalAdapter, GridDhtTxRemote, GridDistributedTxRemoteAdapter, GridNearTxRemote
```
public interface GridCacheTxEx<K,V>
extends GridCacheTx, GridTimeoutObject
```
Transaction managed by cache ('Ex' stands for external).

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class GridCacheTxEx.FinalizationStatus

Nested Classes
Modifier and Type	Interface and Description
`static class`	`GridCacheTxEx.FinalizationStatus`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addInvalidPartition(int part)`
`void`	`addLocalCandidates(K key, Collection<GridCacheMvccCandidate<K>> cands)`
`Collection<GridCacheTxEntry<K,V>>`	`allEntries()`
`Collection<GridCacheVersion>`	`alternateVersions()`
`boolean`	`colocated()`
`GridCacheVersion`	`commitVersion()`
`boolean`	`commitVersion(GridCacheVersion commitVer)`
`void`	`completedVersions(GridCacheVersion base, Collection<GridCacheVersion> committed, Collection<GridCacheVersion> rolledback)`
`boolean`	`dht()`
`boolean`	`done()`
`boolean`	`empty()`
`GridCacheVersion`	`endVersion()`
`void`	`endVersion(GridCacheVersion endVer)`
`boolean`	`enforceSerializable()` For Partitioned caches, this flag is `false` for remote DHT and remote NEAR transactions because serializability of transaction is enforced on primary node.
`GridCacheTxEntry<K,V>`	`entry(K key)`
`UUID`	`eventNodeId()`
`GridFuture<GridCacheTx>`	`finishFuture()`
`boolean`	`groupLock()`
`Object`	`groupLockKey()`
`boolean`	`hasReadKey(K key)`
`boolean`	`hasWriteKey(K key)`
`boolean`	`implicitSingle()`
`boolean`	`internal()`
`void`	`invalidate(boolean invalidate)`
`Set<Integer>`	`invalidPartitions()`
`boolean`	`isSystemInvalidate()`
`boolean`	`local()`
`Map<K,Collection<GridCacheMvccCandidate<K>>>`	`localCandidates()`
`boolean`	`markFinalizing(GridCacheTxEx.FinalizationStatus status)`
`boolean`	`markPreparing()`
`Collection<UUID>`	`masterNodeIds()`
`boolean`	`near()`
`GridCacheVersion`	`nearXidVersion()`
`boolean`	`needsCompletedVersions()`
`boolean`	`onePhaseCommit()`
`boolean`	`onOwnerChanged(GridCacheEntryEx<K,V> entry, GridCacheMvccCandidate<K> owner)` Callback invoked whenever there is a lock that has been acquired by this transaction for any of the participating entries.
`boolean`	`optimistic()`
`Collection<GridCacheTxEntry<K,V>>`	`optimisticLockEntries()` Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
`UUID`	`originatingNodeId()` Gets node ID which directly started this transaction.
`UUID`	`otherNodeId()` Gets ID of additional node involved.
`GridCacheVersion`	`ownedVersion(K key)` Gets owned version for near remote transaction.
`boolean`	`ownsLock(GridCacheEntryEx<K,V> entry)`
`boolean`	`ownsLockUnsafe(GridCacheEntryEx<K,V> entry)`
`GridTuple<V>`	`peek(boolean failFast, K key, GridPredicate<GridCacheEntry<K,V>>[] filter)`
`boolean`	`pessimistic()`
`void`	`prepare()` Prepare state.
`GridFuture<GridCacheTxEx<K,V>>`	`prepareAsync()` Prepare stage.
`boolean`	`readCommitted()`
`Collection<GridCacheTxEntry<K,V>>`	`readEntries()`
`Map<K,GridCacheTxEntry<K,V>>`	`readMap()`
`Set<K>`	`readSet()`
`Collection<GridCacheTxEntry<K,V>>`	`recoveryWrites()` Gets pessimistic recovery writes, i.e.
`long`	`remainingTime()` Gets allowed remaining time for this transaction.
`boolean`	`removed(K key)` Checks whether given key has been removed within transaction.
`boolean`	`repeatableRead()`
`boolean`	`replicated()`
`GridFuture<GridCacheTx>`	`rollbackAsync()` TODO-gg-4004 Put rollback async on public API? Asynchronously rollback this transaction.
`void`	`seal()` Seals transaction for updates.
`boolean`	`serializable()`
`int`	`size()`
`GridCacheVersion`	`startVersion()`
`boolean`	`state(GridCacheTxState state)`
`UUID`	`subjectId()`
`boolean`	`syncCommit()`
`boolean`	`syncRollback()`
`void`	`systemInvalidate(boolean sysInvalidate)`
`boolean`	`timedOut()`
`long`	`topologyVersion()`
`long`	`topologyVersion(long topVer)` Attempts to set topology version and returns the current value.
`Map<UUID,Collection<UUID>>`	`transactionNodes()`
`boolean`	`user()`
`Collection<GridCacheTxEntry<K,V>>`	`writeEntries()`
`Map<K,GridCacheTxEntry<K,V>>`	`writeMap()`
`Set<K>`	`writeSet()`
`GridCacheVersion`	`writeVersion()`
`void`	`writeVersion(GridCacheVersion ver)` Sets write version.
`GridCacheVersion`	`xidVersion()`

Methods inherited from interface org.gridgain.grid.cache.GridCacheTx
close, commit, commitAsync, concurrency, implicit, isInvalidate, isolation, isRollbackOnly, nodeId, rollback, setRollbackOnly, startTime, state, threadId, timeout, timeout, xid

Methods inherited from interface org.gridgain.grid.GridMetadataAware
addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

Methods inherited from interface org.gridgain.grid.kernal.processors.timeout.GridTimeoutObject
endTime, onTimeout, timeoutId

- Method Detail
  - size
```
int size()
```
    Returns:
    Size of the transaction.
  - topologyVersion
```
long topologyVersion()
```
    Returns:
    Last recorded topology version.
  - implicitSingle
```
boolean implicitSingle()
```
    Returns:
    Flag indicating whether transaction is implicit with only one key.
  - topologyVersion
```
long topologyVersion(long topVer)
```
    Attempts to set topology version and returns the current value. If topology version was previously set, then it's value will be returned (but not updated).
    
    Parameters:
    topVer - Topology version.
    
    Returns:
    Recorded topology version.
  - empty
```
boolean empty()
```
    Returns:
    True if transaction is empty.
  - groupLock
```
boolean groupLock()
```
    Returns:
    True if transaction group-locked.
  - groupLockKey
```
@Nullable
Object groupLockKey()
```
    Returns:
    Group lock key if groupLock() is true.
  - markPreparing
```
boolean markPreparing()
```
    Returns:
    True if preparing flag was set with this call.
  - markFinalizing
```
boolean markFinalizing(GridCacheTxEx.FinalizationStatus status)
```
    Parameters:
    status - Finalization status to set.
    
    Returns:
    True if could mark was set.
  - addInvalidPartition
```
void addInvalidPartition(int part)
```
    Parameters:
    part - Invalid partition.
  - invalidPartitions
```
Set<Integer> invalidPartitions()
```
    Returns:
    Invalid partitions.
  - ownedVersion
```
@Nullable
GridCacheVersion ownedVersion(K key)
```
    Gets owned version for near remote transaction.
    
    Parameters:
    key - Key to get version for.
    
    Returns:
    Owned version, if any.
  - otherNodeId
```
@Nullable
UUID otherNodeId()
```
    Gets ID of additional node involved. For example, in DHT case, other node is near node ID.
    
    Returns:
    Parent node IDs.
  - eventNodeId
```
UUID eventNodeId()
```
    Returns:
    Event node ID.
  - originatingNodeId
```
UUID originatingNodeId()
```
    Gets node ID which directly started this transaction. In case of DHT local transaction it will be near node ID, in case of DHT remote transaction it will be primary node ID, in case of replicated remote transaction it will be starter node ID.
    
    Returns:
    Originating node ID.
  - masterNodeIds
```
Collection<UUID> masterNodeIds()
```
    Returns:
    Master node IDs.
  - nearXidVersion
```
@Nullable
GridCacheVersion nearXidVersion()
```
    Returns:
    Near transaction ID.
  - transactionNodes
```
@Nullable
Map<UUID,Collection<UUID>> transactionNodes()
```
    Returns:
    Transaction nodes mapping (primary node -> related backup nodes).
  - ownsLock
```
boolean ownsLock(GridCacheEntryEx<K,V> entry)
                 throws GridCacheEntryRemovedException
```
    Parameters:
    entry - Entry to check.
    
    Returns:
    True if lock is owned.
    
    Throws:
    
    GridCacheEntryRemovedException - If entry has been removed.
  - ownsLockUnsafe
```
boolean ownsLockUnsafe(GridCacheEntryEx<K,V> entry)
```
    Parameters:
    entry - Entry to check.
    
    Returns:
    True if lock is owned.
  - enforceSerializable
```
boolean enforceSerializable()
```
    For Partitioned caches, this flag is false for remote DHT and remote NEAR transactions because serializability of transaction is enforced on primary node. All other transaction types must enforce it.
    
    Returns:
    Enforce serializable flag.
  - near
```
boolean near()
```
    Returns:
    True if near transaction.
  - dht
```
boolean dht()
```
    Returns:
    True if DHT transaction.
  - colocated
```
boolean colocated()
```
    Returns:
    True if dht colocated transaction.
  - local
```
boolean local()
```
    Returns:
    True if transaction is local, false if it's remote.
  - replicated
```
boolean replicated()
```
    Returns:
    True if transaction is replicated.
  - subjectId
```
UUID subjectId()
```
    Returns:
    Subject ID initiated this transaction.
  - user
```
boolean user()
```
    Returns:
    True if transaction is user transaction, which means:
    
    Explicit
    
    Local
    
    Not DHT
  - syncCommit
```
boolean syncCommit()
```
    Returns:
    True if transaction is configured with synchronous commit flag.
  - syncRollback
```
boolean syncRollback()
```
    Returns:
    True if transaction is configured with synchronous rollback flag.
  - hasReadKey
```
boolean hasReadKey(K key)
```
    Parameters:
    key - Key to check.
    
    Returns:
    True if key is present.
  - hasWriteKey
```
boolean hasWriteKey(K key)
```
    Parameters:
    key - Key to check.
    
    Returns:
    True if key is present.
  - readSet
```
Set<K> readSet()
```
    Returns:
    Read set.
  - writeSet
```
Set<K> writeSet()
```
    Returns:
    Write set.
  - allEntries
```
Collection<GridCacheTxEntry<K,V>> allEntries()
```
    Returns:
    All transaction entries.
  - writeEntries
```
Collection<GridCacheTxEntry<K,V>> writeEntries()
```
    Returns:
    Write entries.
  - readEntries
```
Collection<GridCacheTxEntry<K,V>> readEntries()
```
    Returns:
    Read entries.
  - writeMap
```
Map<K,GridCacheTxEntry<K,V>> writeMap()
```
    Returns:
    Transaction write map.
  - readMap
```
Map<K,GridCacheTxEntry<K,V>> readMap()
```
    Returns:
    Transaction read map.
  - recoveryWrites
```
Collection<GridCacheTxEntry<K,V>> recoveryWrites()
```
    Gets pessimistic recovery writes, i.e. values that have never been sent to remote nodes with lock requests.
    
    Returns:
    Collection of recovery writes.
  - optimisticLockEntries
```
Collection<GridCacheTxEntry<K,V>> optimisticLockEntries()
```
    Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
    
    Returns:
    List of tx entries for optimistic locking.
  - seal
```
void seal()
```
    Seals transaction for updates.
  - entry
```
@Nullable
GridCacheTxEntry<K,V> entry(K key)
```
    Parameters:
    key - Key for the entry.
    
    Returns:
    Entry for the key (either from write set or read set).
  - peek
```
@Nullable
GridTuple<V> peek(boolean failFast,
                         K key,
                         @Nullable
                         GridPredicate<GridCacheEntry<K,V>>[] filter)
                  throws GridCacheFilterFailedException
```
    Parameters:
    failFast - Fail-fast flag.
    key - Key to look up.
    filter - Filter to check.
    
    Returns:
    Current value for the key within transaction.
    
    Throws:
    
    GridCacheFilterFailedException - If filter failed and failFast is true.
  - startVersion
```
GridCacheVersion startVersion()
```
    Returns:
    Start version.
  - xidVersion
```
GridCacheVersion xidVersion()
```
    Returns:
    Transaction version.
  - commitVersion
```
GridCacheVersion commitVersion()
```
    Returns:
    Version created at commit time.
  - commitVersion
```
boolean commitVersion(GridCacheVersion commitVer)
```
    Parameters:
    commitVer - Commit version.
    
    Returns:
    True if version was set.
  - endVersion
```
GridCacheVersion endVersion()
```
    Returns:
    End version (a.k.a. 'tnc' or 'transaction number counter') assigned to this transaction at the end of write phase.
  - prepare
```
void prepare()
             throws GridException
```
    Prepare state.
    
    Throws:
    
    GridException - If failed.
  - prepareAsync
```
GridFuture<GridCacheTxEx<K,V>> prepareAsync()
```
    Prepare stage.
    
    Returns:
    Future for prepare step.
  - endVersion
```
void endVersion(GridCacheVersion endVer)
```
    Parameters:
    endVer - End version (a.k.a. 'tnc' or 'transaction number counter') assigned to this transaction at the end of write phase.
  - writeVersion
```
GridCacheVersion writeVersion()
```
    Returns:
    Transaction write version. For all transactions except DHT transactions, will be equal to xidVersion().
  - writeVersion
```
void writeVersion(GridCacheVersion ver)
```
    Sets write version.
    
    Parameters:
    ver - Write version.
  - finishFuture
```
GridFuture<GridCacheTx> finishFuture()
```
    Returns:
    Future for transaction completion.
  - state
```
boolean state(GridCacheTxState state)
```
    Parameters:
    state - Transaction state.
    
    Returns:
    True if transition was valid, false otherwise.
  - invalidate
```
void invalidate(boolean invalidate)
```
    Parameters:
    invalidate - Invalidate flag.
  - systemInvalidate
```
void systemInvalidate(boolean sysInvalidate)
```
    Parameters:
    sysInvalidate - System invalidate flag.
  - isSystemInvalidate
```
boolean isSystemInvalidate()
```
    Returns:
    System invalidate flag.
  - rollbackAsync
```
GridFuture<GridCacheTx> rollbackAsync()
```
    TODO-gg-4004 Put rollback async on public API? Asynchronously rollback this transaction.
    
    Returns:
    Rollback future.
  - addLocalCandidates
```
void addLocalCandidates(K key,
                      Collection<GridCacheMvccCandidate<K>> cands)
```
    Parameters:
    key - Cache key.
    cands - Collection of lock candidates for that key.
  - localCandidates
```
Map<K,Collection<GridCacheMvccCandidate<K>>> localCandidates()
```
    Returns:
    All lock candidates.
  - onOwnerChanged
```
boolean onOwnerChanged(GridCacheEntryEx<K,V> entry,
                     GridCacheMvccCandidate<K> owner)
```
    Callback invoked whenever there is a lock that has been acquired by this transaction for any of the participating entries.
    
    Parameters:
    entry - Cache entry.
    owner - Lock candidate that won ownership of the lock.
    
    Returns:
    True if transaction cared about notification.
  - timedOut
```
boolean timedOut()
```
    Returns:
    True if transaction timed out.
  - done
```
boolean done()
```
    Returns:
    True if transaction had completed successfully or unsuccessfully.
  - optimistic
```
boolean optimistic()
```
    Returns:
    True for OPTIMISTIC transactions.
  - pessimistic
```
boolean pessimistic()
```
    Returns:
    True for PESSIMISTIC transactions.
  - readCommitted
```
boolean readCommitted()
```
    Returns:
    True if read-committed.
  - repeatableRead
```
boolean repeatableRead()
```
    Returns:
    True if repeatable-read.
  - serializable
```
boolean serializable()
```
    Returns:
    True if serializable.
  - removed
```
boolean removed(K key)
```
    Checks whether given key has been removed within transaction.
    
    Parameters:
    key - Key to check.
    
    Returns:
    True if key has been removed.
  - remainingTime
```
long remainingTime()
                   throws GridCacheTxTimeoutException
```
    Gets allowed remaining time for this transaction.
    
    Returns:
    Remaining time.
    
    Throws:
    
    GridCacheTxTimeoutException - If transaction timed out.
  - alternateVersions
```
Collection<GridCacheVersion> alternateVersions()
```
    Returns:
    Alternate transaction versions.
  - needsCompletedVersions
```
boolean needsCompletedVersions()
```
    Returns:
    True if transaction needs completed versions for processing.
  - completedVersions
```
void completedVersions(GridCacheVersion base,
                     Collection<GridCacheVersion> committed,
                     Collection<GridCacheVersion> rolledback)
```
    Parameters:
    base - Base for committed versions.
    committed - Committed transactions relative to base.
    rolledback - Rolled back transactions relative to base.
  - internal
```
boolean internal()
```
    Returns:
    True if transaction has at least one internal entry.
  - onePhaseCommit
```
boolean onePhaseCommit()
```
    Returns:
    True if transaction is a one-phase-commit transaction.

Interface GridCacheTxEx<K,V>

Nested Class Summary

Method Summary

Methods inherited from interface org.gridgain.grid.cache.GridCacheTx

Methods inherited from interface org.gridgain.grid.GridMetadataAware

Methods inherited from interface org.gridgain.grid.kernal.processors.timeout.GridTimeoutObject

Method Detail

size

topologyVersion

implicitSingle

topologyVersion

empty

groupLock

groupLockKey

markPreparing

markFinalizing

addInvalidPartition

invalidPartitions

ownedVersion

otherNodeId

eventNodeId

originatingNodeId

masterNodeIds

nearXidVersion

transactionNodes

ownsLock

ownsLockUnsafe

enforceSerializable

near

dht

colocated

local

replicated

subjectId

user

syncCommit

syncRollback

hasReadKey

hasWriteKey

readSet

writeSet

allEntries

writeEntries

readEntries

writeMap

readMap

recoveryWrites

optimisticLockEntries

seal

entry

peek

startVersion

xidVersion

commitVersion

commitVersion

endVersion

prepare

prepareAsync

endVersion

writeVersion

writeVersion

finishFuture

state

invalidate

systemInvalidate

isSystemInvalidate

rollbackAsync

addLocalCandidates

localCandidates

onOwnerChanged

timedOut

done

optimistic

pessimistic

readCommitted

repeatableRead

serializable

removed

remainingTime

alternateVersions