java.lang.Object
- org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter
- - org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter

All Implemented Interfaces:

IgniteInternalTx

Direct Known Subclasses:

GridDistributedTxRemoteAdapter, IgniteTxLocalAdapter
```
public abstract class IgniteTxAdapter
extends GridMetadataAwareAdapter
implements IgniteInternalTx
```
Managed transaction adapter.

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter
  GridMetadataAwareAdapter.EntryKey
- Nested classes/interfaces inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx
  IgniteInternalTx.FinalizationStatus

Field Summary

Fields
Modifier and Type	Field	Description
`protected GridCacheSharedContext<?,?>`	`cctx`	Cache registry.
`protected TransactionConcurrency`	`concurrency`	Concurrency.
`protected ConsistentIdMapper`	`consistentIdMapper`	UUID to consistent id mapper.
`protected IgniteUuid`	`deploymentLdrId`	Deployment class loader id which will be used for deserialization of entries on a distributed task.
`protected boolean`	`implicit`	Implicit flag.
`protected boolean`	`invalidate`	Invalidate flag.
`protected boolean`	`isDone`	Done marker.
`protected TransactionIsolation`	`isolation`	Isolation.
`protected static IgniteLogger`	`log`	Logger.
`protected UUID`	`nodeId`	Node ID.
`protected boolean`	`onePhaseCommit`	One phase commit flag.
`protected long`	`startTime`	Transaction start time.
`protected String`	`taskName`	Task name.
`protected long`	`threadId`	Thread ID.
`protected AffinityTopologyVersion`	`topVer`	Topology version.
`protected Map<UUID,Collection<UUID>>`	`txNodes`
`protected int`	`txSize`
`protected GridCacheVersion`	`xidVer`	Transaction ID.

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`IgniteTxAdapter(GridCacheSharedContext<?,?> cctx, UUID nodeId, GridCacheVersion xidVer, long threadId, boolean sys, byte plc, TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, int txSize, @Nullable UUID subjId, int taskNameHash)`
`protected`	`IgniteTxAdapter(GridCacheSharedContext<?,?> cctx, GridCacheVersion xidVer, boolean implicit, boolean loc, boolean sys, byte plc, TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout, boolean invalidate, boolean storeEnabled, boolean onePhaseCommit, int txSize, @Nullable UUID subjId, int taskNameHash)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`abstract void`	`addActiveCache(GridCacheContext<?,?> cacheCtx, boolean recovery)`	Adds cache to the list of active caches in transaction.
`void`	`addInvalidPartition(int cacheId, int part)`
`protected IgniteBiTuple<GridCacheOperation,CacheObject>`	`applyTransformClosures(IgniteTxEntry txEntry, boolean metrics, @Nullable GridCacheReturn ret)`
`protected void`	`applyTxSizes()`	Makes cache sizes changes accumulated during transaction visible outside of transaction.
`protected void`	`batchStoreCommit(Iterable<IgniteTxEntry> writeEntries)`	Performs batch database operations.
`boolean`	`chainState(TransactionState state)`	Changing state for this transaction as well as chained(parent) transactions.
`protected boolean`	`checkInternal(IgniteTxKey key)`
`boolean`	`colocated()`
`GridCacheVersion`	`commitVersion()`
`void`	`commitVersion(GridCacheVersion commitVer)`
`void`	`completedVersions(GridCacheVersion base, Collection<GridCacheVersion> committed, Collection<GridCacheVersion> txs)`
`TransactionConcurrency`	`concurrency()`	Cache transaction concurrency mode.
`protected IgniteBiTuple<GridCacheOperation,GridCacheVersionConflictContext>`	`conflictResolve(GridCacheOperation op, IgniteTxEntry txEntry, CacheObject newVal, GridCacheVersion newVer, GridCacheEntryEx old)`	Resolve DR conflict.
`GridCacheSharedContext<?,?>`	`context()`
`@Nullable IgniteInternalFuture<?>`	`currentPrepareFuture()`
`boolean`	`dht()`
`boolean`	`done()`
`boolean`	`equals(Object o)`
`void`	`errorWhenCommitting()`	Changes transaction state from COMMITTING to MARKED_ROLLBACK.
`protected boolean`	`evictNearEntry(IgniteTxEntry e, boolean primaryOnly)`
`@Nullable IgniteInternalTx.FinalizationStatus`	`finalizationStatus()`
`IgniteInternalFuture<IgniteInternalTx>`	`finishFuture()`
`int`	`hashCode()`
`IgniteCheckedException`	`heuristicException(Throwable ex)`
`boolean`	`implicit()`	Flag indicating whether transaction was started automatically by the system or not.
`boolean`	`implicitSingle()`
`UUID`	`incrementalSnapshotId()`
`void`	`incrementalSnapshotId(UUID id)`
`boolean`	`internal()`
`void`	`invalidate(boolean invalidate)`
`Map<Integer,Set<Integer>>`	`invalidPartitions()`
`byte`	`ioPolicy()`
`boolean`	`isInvalidate()`	Get invalidation flag for this transaction.
`protected boolean`	`isNearLocallyMapped(IgniteTxEntry e, boolean primaryOnly)`
`TransactionIsolation`	`isolation()`	Cache transaction isolation level.
`boolean`	`isRollbackOnly()`	If transaction was marked as rollback-only.
`abstract boolean`	`isStarted()`
`boolean`	`isSystemInvalidate()`
`protected boolean`	`isWriteToStoreFromDhtValid(Collection<CacheStoreManager> stores)`
`boolean`	`local()`
`boolean`	`localResult()`
`protected IgniteLogger`	`log()`
`void`	`logTxFinishErrorSafe(@Nullable IgniteLogger log, boolean commit, Throwable e)`
`boolean`	`markFinalizing(IgniteInternalTx.FinalizationStatus status)`
`boolean`	`near()`
`@Nullable GridCacheVersion`	`nearXidVersion()`
`boolean`	`needReturnValue()`
`void`	`needReturnValue(boolean needRetVal)`
`boolean`	`needsCompletedVersions()`
`UUID`	`nodeId()`	ID of the node on which this transaction started.
`boolean`	`onePhaseCommit()`
`void`	`onePhaseCommit(boolean onePhaseCommit)`
`boolean`	`optimistic()`
`Collection<IgniteTxEntry>`	`optimisticLockEntries()`	Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
`UUID`	`otherNodeId()`	Gets ID of additional node involved.
`GridCacheVersion`	`ownedVersion(IgniteTxKey key)`	Gets owned version for near remote transaction.
`boolean`	`ownsLock(GridCacheEntryEx entry)`
`boolean`	`ownsLockUnsafe(GridCacheEntryEx entry)`
`boolean`	`pessimistic()`
`boolean`	`readCommitted()`
`protected void`	`recordStateChangedEvent(int type)`
`long`	`remainingTime()`	Gets remaining allowed transaction time.
`boolean`	`remote()`
`boolean`	`repeatableRead()`
`String`	`resolveTaskName()`
`IgniteCheckedException`	`rollbackException()`
`boolean`	`serializable()`
`protected void`	`sessionEnd(Collection<CacheStoreManager> stores, boolean commit)`
`void`	`setParentTx(GridNearTxLocal parentTx)`
`boolean`	`setRollbackOnly()`	Modify the transaction associated with the current thread such that the only possible outcome of the transaction is to roll back the transaction.
`int`	`size()`
`boolean`	`skipCompletedVersions()`
`void`	`skipCompletedVersions(boolean skipCompletedVers)`
`long`	`startTime()`	Start time of this transaction.
`long`	`startTimeNanos()`	Start time of this transaction in nanoseconds to measure duration.
`TransactionState`	`state()`	Gets current transaction state value.
`boolean`	`state(TransactionState state)`
`protected boolean`	`state(TransactionState state, boolean timedOut)`
`boolean`	`storeEnabled()`
`void`	`storeEnabled(boolean storeEnabled)`
`boolean`	`storeWriteThrough()`
`UUID`	`subjectId()`
`boolean`	`system()`	Checks if this is system cache transaction.
`void`	`systemInvalidate(boolean sysInvalidate)`
`int`	`taskNameHash()`	Task name hash in case if transaction was initiated within task execution.
`long`	`threadId()`	ID of the thread in which this transaction started.
`boolean`	`timedOut()`
`long`	`timeout()`	Gets timeout value in milliseconds for this transaction.
`long`	`timeout(long timeout)`	Sets transaction timeout value.
`IgniteCheckedException`	`timeoutException()`
`IgniteCheckedException`	`timeoutException(String msg)`
`AffinityTopologyVersion`	`topologyVersion()`
`AffinityTopologyVersion`	`topologyVersion(AffinityTopologyVersion topVer)`	Attempts to set topology version and returns the current value.
`AffinityTopologyVersion`	`topologyVersionSnapshot()`
`String`	`toString()`
`@Nullable Map<UUID,Collection<UUID>>`	`transactionNodes()`
`void`	`transactionNodes(Map<UUID,Collection<UUID>> txNodes)`
`TxCounters`	`txCounters(boolean createIfAbsent)`
`protected void`	`uncommit()`	Uncommits transaction by invalidating all of its entries.
`protected boolean`	`updateNearCache(GridCacheContext<?,?> cacheCtx, KeyCacheObject key, AffinityTopologyVersion topVer)`	Checks whether near cache should be updated.
`boolean`	`user()`
`GridCacheVersion`	`writeVersion()`
`void`	`writeVersion(GridCacheVersion writeVer)`	Sets write version.
`IgniteUuid`	`xid()`	Gets unique identifier for this transaction.
`GridCacheVersion`	`xidVersion()`

Methods inherited from class org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter
addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, clone, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, removeAllMeta, removeMeta, removeMeta, replaceMeta

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx
activeCachesDeploymentEnabled, activeCachesDeploymentEnabled, addMeta, allEntries, alternateVersions, commitAsync, commitError, empty, entry, eventNodeId, hasWriteKey, label, masterNodeIds, meta, onOwnerChanged, originatingNodeId, peek, readEntries, readMap, readSet, removeMeta, rollbackAsync, salvageTx, seal, txState, writeEntries, writeMap, writeSet

- Field Detail
  - log
```
protected static IgniteLogger log
```
    Logger.
  - xidVer
```
@GridToStringInclude
protected final GridCacheVersion xidVer
```
    Transaction ID.
  - implicit
```
@GridToStringInclude
protected final boolean implicit
```
    Implicit flag.
  - threadId
```
@GridToStringInclude
protected long threadId
```
    Thread ID.
  - startTime
```
@GridToStringInclude
protected final long startTime
```
    Transaction start time.
  - nodeId
```
@GridToStringInclude
protected final UUID nodeId
```
    Node ID.
  - cctx
```
@GridToStringExclude
protected final GridCacheSharedContext<?,?> cctx
```
    Cache registry.
  - isolation
```
@GridToStringInclude
protected final TransactionIsolation isolation
```
    Isolation.
  - concurrency
```
@GridToStringInclude
protected final TransactionConcurrency concurrency
```
    Concurrency.
  - deploymentLdrId
```
@GridToStringExclude
protected final IgniteUuid deploymentLdrId
```
    Deployment class loader id which will be used for deserialization of entries on a distributed task.
  - invalidate
```
protected volatile boolean invalidate
```
    Invalidate flag.
  - onePhaseCommit
```
protected boolean onePhaseCommit
```
    One phase commit flag.
  - isDone
```
protected volatile boolean isDone
```
    Done marker.
  - txSize
```
protected final int txSize
```
  - topVer
```
@GridToStringInclude
protected volatile AffinityTopologyVersion topVer
```
    Topology version.
  - txNodes
```
protected Map<UUID,Collection<UUID>> txNodes
```
  - taskName
```
protected final String taskName
```
    Task name.
  - consistentIdMapper
```
protected final ConsistentIdMapper consistentIdMapper
```
    UUID to consistent id mapper.
- Constructor Detail
  - IgniteTxAdapter
```
protected IgniteTxAdapter(GridCacheSharedContext<?,?> cctx,
                          GridCacheVersion xidVer,
                          boolean implicit,
                          boolean loc,
                          boolean sys,
                          byte plc,
                          TransactionConcurrency concurrency,
                          TransactionIsolation isolation,
                          long timeout,
                          boolean invalidate,
                          boolean storeEnabled,
                          boolean onePhaseCommit,
                          int txSize,
                          @Nullable
                          @Nullable UUID subjId,
                          int taskNameHash)
```
    Parameters:
    
    cctx - Cache registry.
    
    xidVer - Transaction ID.
    
    implicit - Implicit flag.
    
    loc - Local flag.
    
    sys - System transaction flag.
    
    plc - IO policy.
    
    concurrency - Concurrency.
    
    isolation - Isolation.
    
    timeout - Timeout.
    
    txSize - Transaction size.
  - IgniteTxAdapter
```
protected IgniteTxAdapter(GridCacheSharedContext<?,?> cctx,
                          UUID nodeId,
                          GridCacheVersion xidVer,
                          long threadId,
                          boolean sys,
                          byte plc,
                          TransactionConcurrency concurrency,
                          TransactionIsolation isolation,
                          long timeout,
                          int txSize,
                          @Nullable
                          @Nullable UUID subjId,
                          int taskNameHash)
```
    Parameters:
    
    cctx - Cache registry.
    
    nodeId - Node ID.
    
    xidVer - Transaction ID.
    
    threadId - Thread ID.
    
    sys - System transaction flag.
    
    plc - IO policy.
    
    concurrency - Concurrency.
    
    isolation - Isolation.
    
    timeout - Timeout.
    
    txSize - Transaction size.
- Method Detail
  - incrementalSnapshotId
```
public UUID incrementalSnapshotId()
```
    Specified by:
    
    incrementalSnapshotId in interface IgniteInternalTx
    
    Returns:
    
    ID of incremental snapshot after which this transaction commits, null if snapshot isn't running.
  - incrementalSnapshotId
```
public void incrementalSnapshotId(UUID id)
```
    Specified by:
    
    incrementalSnapshotId in interface IgniteInternalTx
    
    Parameters:
    
    id - ID of incremental snapshot after which this transaction commits, null if snapshot isn't running.
  - setParentTx
```
public void setParentTx(GridNearTxLocal parentTx)
```
    Parameters:
    
    parentTx - Transaction from which this transaction was copied by.
  - skipCompletedVersions
```
public boolean skipCompletedVersions()
```
    Returns:
    
    True if tx should skip adding itself to completed version map on finish.
  - skipCompletedVersions
```
public void skipCompletedVersions(boolean skipCompletedVers)
```
    Parameters:
    
    skipCompletedVers - True if tx should skip adding itself to completed version map on finish.
  - context
```
public GridCacheSharedContext<?,?> context()
```
    Returns:
    
    Shared cache context.
  - localResult
```
public boolean localResult()
```
    Specified by:
    
    localResult in interface IgniteInternalTx
    
    Returns:
    
    True if transaction started on the node initiated cache operation.
  - updateNearCache
```
protected boolean updateNearCache(GridCacheContext<?,?> cacheCtx,
                                  KeyCacheObject key,
                                  AffinityTopologyVersion topVer)
```
    Checks whether near cache should be updated.
    
    Returns:
    
    Flag indicating whether near cache should be updated.
  - optimisticLockEntries
```
public Collection<IgniteTxEntry> optimisticLockEntries()
```
    Gets a list of entries that needs to be locked on the next step of prepare stage of optimistic transaction.
    
    Specified by:
    
    optimisticLockEntries in interface IgniteInternalTx
    
    Returns:
    
    List of tx entries for optimistic locking.
  - storeEnabled
```
public boolean storeEnabled()
```
    Specified by:
    
    storeEnabled in interface IgniteInternalTx
    
    Returns:
    
    True if transaction is allowed to use store.
  - storeEnabled
```
public void storeEnabled(boolean storeEnabled)
```
    Parameters:
    
    storeEnabled - Store enabled flag.
  - system
```
public boolean system()
```
    Checks if this is system cache transaction. System transactions are isolated from user transactions because some of the public API methods may be invoked inside user transactions and internally start system cache transactions.
    
    Specified by:
    
    system in interface IgniteInternalTx
    
    Returns:
    
    True if transaction is started for system cache.
  - ioPolicy
```
public byte ioPolicy()
```
    Specified by:
    
    ioPolicy in interface IgniteInternalTx
    
    Returns:
    
    Pool where message for the given transaction must be processed.
  - storeWriteThrough
```
public boolean storeWriteThrough()
```
    Specified by:
    
    storeWriteThrough in interface IgniteInternalTx
    
    Returns:
    
    True if transaction is allowed to use store and transactions spans one or more caches with store enabled.
  - uncommit
```
protected void uncommit()
```
    Uncommits transaction by invalidating all of its entries. Courtesy to minimize inconsistency.
  - otherNodeId
```
public UUID otherNodeId()
```
    Gets ID of additional node involved. For example, in DHT case, other node is near node ID.
    
    Specified by:
    
    otherNodeId in interface IgniteInternalTx
    
    Returns:
    
    Parent node IDs.
  - subjectId
```
public UUID subjectId()
```
    Specified by:
    
    subjectId in interface IgniteInternalTx
    
    Returns:
    
    Subject ID initiated this transaction.
  - taskNameHash
```
public int taskNameHash()
```
    Task name hash in case if transaction was initiated within task execution.
    
    Specified by:
    
    taskNameHash in interface IgniteInternalTx
    
    Returns:
    
    Task name hash.
  - topologyVersion
```
public AffinityTopologyVersion topologyVersion()
```
    Specified by:
    
    topologyVersion in interface IgniteInternalTx
    
    Returns:
    
    Last recorded topology version.
  - topologyVersionSnapshot
```
public final AffinityTopologyVersion topologyVersionSnapshot()
```
    Specified by:
    
    topologyVersionSnapshot in interface IgniteInternalTx
    
    Returns:
    
    Topology version snapshot.
  - topologyVersion
```
public final AffinityTopologyVersion topologyVersion(AffinityTopologyVersion 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).
    
    Specified by:
    
    topologyVersion in interface IgniteInternalTx
    
    Parameters:
    
    topVer - Topology version.
    
    Returns:
    
    Recorded topology version.
  - markFinalizing
```
public final boolean markFinalizing(IgniteInternalTx.FinalizationStatus status)
```
    Specified by:
    
    markFinalizing in interface IgniteInternalTx
    
    Parameters:
    
    status - Finalization status to set.
    
    Returns:
    
    True if marked.
  - finalizationStatus
```
@Nullable
public @Nullable IgniteInternalTx.FinalizationStatus finalizationStatus()
```
    Specified by:
    
    finalizationStatus in interface IgniteInternalTx
    
    Returns:
    
    Finalization status.
  - isStarted
```
public abstract boolean isStarted()
```
    Returns:
    
    True if transaction has at least one key enlisted.
  - size
```
public int size()
```
    Specified by:
    
    size in interface IgniteInternalTx
    
    Returns:
    
    Size of the transaction.
  - log
```
protected IgniteLogger log()
```
    Returns:
    
    Logger.
  - remote
```
public boolean remote()
```
    Returns:
    
    True if transaction reflects changes in primary -> backup direction.
  - near
```
public boolean near()
```
    Specified by:
    
    near in interface IgniteInternalTx
    
    Returns:
    
    True if near transaction.
  - implicit
```
public boolean implicit()
```
    Flag indicating whether transaction was started automatically by the system or not. System will start transactions implicitly whenever any cache put(..) or remove(..) operation is invoked outside of transaction.
    
    Specified by:
    
    implicit in interface IgniteInternalTx
    
    Returns:
    
    True if transaction was started implicitly.
  - implicitSingle
```
public boolean implicitSingle()
```
    Specified by:
    
    implicitSingle in interface IgniteInternalTx
    
    Returns:
    
    Flag indicating whether transaction is implicit with only one key.
  - local
```
public boolean local()
```
    Specified by:
    
    local in interface IgniteInternalTx
    
    Returns:
    
    True if transaction is local, false if it's remote.
  - user
```
public final boolean user()
```
    Specified by:
    
    user in interface IgniteInternalTx
    
    Returns:
    
    True if transaction is user transaction, which means:
    
    Explicit
    
    Local
    
    Not DHT
  - dht
```
public boolean dht()
```
    Specified by:
    
    dht in interface IgniteInternalTx
    
    Returns:
    
    True if DHT transaction.
  - colocated
```
public boolean colocated()
```
    Specified by:
    
    colocated in interface IgniteInternalTx
    
    Returns:
    
    True if dht colocated transaction.
  - xid
```
public IgniteUuid xid()
```
    Gets unique identifier for this transaction.
    
    Specified by:
    
    xid in interface IgniteInternalTx
    
    Returns:
    
    Transaction UID.
  - invalidPartitions
```
public Map<Integer,Set<Integer>> invalidPartitions()
```
    Specified by:
    
    invalidPartitions in interface IgniteInternalTx
    
    Returns:
    
    Invalid partitions.
  - addInvalidPartition
```
public void addInvalidPartition(int cacheId,
                                int part)
```
    Specified by:
    
    addInvalidPartition in interface IgniteInternalTx
    
    Parameters:
    
    cacheId - Cache id.
    
    part - Invalid partition.
  - ownedVersion
```
public GridCacheVersion ownedVersion(IgniteTxKey key)
```
    Gets owned version for near remote transaction.
    
    Specified by:
    
    ownedVersion in interface IgniteInternalTx
    
    Parameters:
    
    key - Key to get version for.
    
    Returns:
    
    Owned version, if any.
  - startTime
```
public long startTime()
```
    Start time of this transaction.
    
    Specified by:
    
    startTime in interface IgniteInternalTx
    
    Returns:
    
    Start time of this transaction on this node.
  - startTimeNanos
```
public long startTimeNanos()
```
    Start time of this transaction in nanoseconds to measure duration.
    
    Specified by:
    
    startTimeNanos in interface IgniteInternalTx
    
    Returns:
    
    Start time of this transaction in nanoseconds.
  - needReturnValue
```
public boolean needReturnValue()
```
    Returns:
    
    Flag indicating whether transaction needs return value.
  - needReturnValue
```
public void needReturnValue(boolean needRetVal)
```
    Parameters:
    
    needRetVal - Need return value flag.
  - remainingTime
```
public long remainingTime()
```
    Gets remaining allowed transaction time.
    
    Specified by:
    
    remainingTime in interface IgniteInternalTx
    
    Returns:
    
    Remaining transaction time. 0 if timeout isn't specified. -1 if time is out.
  - timeoutException
```
public final IgniteCheckedException timeoutException()
```
    Returns:
    
    Transaction timeout exception with the message of lock acquire failure.
  - timeoutException
```
public final IgniteCheckedException timeoutException(String msg)
```
    Parameters:
    
    msg - Message text to put to the timeout exception.
    
    Returns:
    
    Transaction timeout exception with the provided message.
  - rollbackException
```
public final IgniteCheckedException rollbackException()
```
    Returns:
    
    Rollback exception.
  - heuristicException
```
public final IgniteCheckedException heuristicException(Throwable ex)
```
    Parameters:
    
    ex - Root cause.
  - logTxFinishErrorSafe
```
public void logTxFinishErrorSafe(@Nullable
                                 @Nullable IgniteLogger log,
                                 boolean commit,
                                 Throwable e)
```
    Parameters:
    
    log - Log.
    
    commit - Commit.
    
    e - Exception.
  - xidVersion
```
public GridCacheVersion xidVersion()
```
    Specified by:
    
    xidVersion in interface IgniteInternalTx
    
    Returns:
    
    Transaction version.
  - threadId
```
public long threadId()
```
    ID of the thread in which this transaction started.
    
    Specified by:
    
    threadId in interface IgniteInternalTx
    
    Returns:
    
    Thread ID.
  - nodeId
```
public UUID nodeId()
```
    ID of the node on which this transaction started.
    
    Specified by:
    
    nodeId in interface IgniteInternalTx
    
    Returns:
    
    Originating node ID.
  - isolation
```
public TransactionIsolation isolation()
```
    Cache transaction isolation level.
    
    Specified by:
    
    isolation in interface IgniteInternalTx
    
    Returns:
    
    Isolation level.
  - concurrency
```
public TransactionConcurrency concurrency()
```
    Cache transaction concurrency mode.
    
    Specified by:
    
    concurrency in interface IgniteInternalTx
    
    Returns:
    
    Concurrency mode.
  - timeout
```
public long timeout()
```
    Gets timeout value in milliseconds for this transaction. If transaction times out prior to it's completion, IgniteTxTimeoutCheckedException will be thrown.
    
    Specified by:
    
    timeout in interface IgniteInternalTx
    
    Returns:
    
    Transaction timeout value.
  - timeout
```
public long timeout(long timeout)
```
    Sets transaction timeout value. This value can be set only before a first operation on transaction has been performed.
    
    Specified by:
    
    timeout in interface IgniteInternalTx
    
    Parameters:
    
    timeout - Transaction timeout value.
    
    Returns:
    
    Previous timeout.
  - ownsLock
```
public boolean ownsLock(GridCacheEntryEx entry)
                 throws GridCacheEntryRemovedException
```
    Specified by:
    
    ownsLock in interface IgniteInternalTx
    
    Parameters:
    
    entry - Entry to check.
    
    Returns:
    
    True if lock is owned.
    
    Throws:
    
    GridCacheEntryRemovedException - If entry has been removed.
  - ownsLockUnsafe
```
public boolean ownsLockUnsafe(GridCacheEntryEx entry)
```
    Specified by:
    
    ownsLockUnsafe in interface IgniteInternalTx
    
    Parameters:
    
    entry - Entry to check.
    
    Returns:
    
    True if lock is owned.
  - state
```
public TransactionState state()
```
    Gets current transaction state value.
    
    Specified by:
    
    state in interface IgniteInternalTx
    
    Returns:
    
    Current transaction state.
  - errorWhenCommitting
```
public final void errorWhenCommitting()
```
    Changes transaction state from COMMITTING to MARKED_ROLLBACK. Must be called only from thread committing transaction.
    
    Specified by:
    
    errorWhenCommitting in interface IgniteInternalTx
  - setRollbackOnly
```
public boolean setRollbackOnly()
```
    Modify the transaction associated with the current thread such that the only possible outcome of the transaction is to roll back the transaction.
    
    Specified by:
    
    setRollbackOnly in interface IgniteInternalTx
    
    Returns:
    
    True if rollback-only flag was set as a result of this operation, false if it was already set prior to this call or could not be set because transaction is already finishing up committing or rolling back.
  - isRollbackOnly
```
public boolean isRollbackOnly()
```
    Description copied from interface: IgniteInternalTx
    
    If transaction was marked as rollback-only.
    
    Specified by:
    
    isRollbackOnly in interface IgniteInternalTx
    
    Returns:
    
    True if rollback only flag is set.
  - done
```
public boolean done()
```
    Specified by:
    
    done in interface IgniteInternalTx
    
    Returns:
    
    True if transaction had completed successfully or unsuccessfully.
  - commitVersion
```
public GridCacheVersion commitVersion()
```
    Specified by:
    
    commitVersion in interface IgniteInternalTx
    
    Returns:
    
    Commit version.
  - commitVersion
```
public void commitVersion(GridCacheVersion commitVer)
```
    Specified by:
    
    commitVersion in interface IgniteInternalTx
    
    Parameters:
    
    commitVer - Commit version.
  - needsCompletedVersions
```
public boolean needsCompletedVersions()
```
    Specified by:
    
    needsCompletedVersions in interface IgniteInternalTx
    
    Returns:
    
    True if transaction needs completed versions for processing.
  - completedVersions
```
public void completedVersions(GridCacheVersion base,
                              Collection<GridCacheVersion> committed,
                              Collection<GridCacheVersion> txs)
```
    Specified by:
    
    completedVersions in interface IgniteInternalTx
    
    Parameters:
    
    base - Base for committed versions.
    
    committed - Committed transactions relative to base.
    
    txs - Rolled back transactions relative to base.
  - internal
```
public boolean internal()
```
    Specified by:
    
    internal in interface IgniteInternalTx
    
    Returns:
    
    True if transaction has at least one internal entry.
  - checkInternal
```
protected boolean checkInternal(IgniteTxKey key)
```
    Parameters:
    
    key - Key.
    
    Returns:
    
    True if key is internal.
  - onePhaseCommit
```
public void onePhaseCommit(boolean onePhaseCommit)
```
    Parameters:
    
    onePhaseCommit - True if transaction commit should be performed in short-path way.
  - onePhaseCommit
```
public boolean onePhaseCommit()
```
    Specified by:
    
    onePhaseCommit in interface IgniteInternalTx
    
    Returns:
    
    Fast commit flag.
  - optimistic
```
public boolean optimistic()
```
    Specified by:
    
    optimistic in interface IgniteInternalTx
    
    Returns:
    
    True for OPTIMISTIC transactions.
  - pessimistic
```
public boolean pessimistic()
```
    Specified by:
    
    pessimistic in interface IgniteInternalTx
    
    Returns:
    
    True for PESSIMISTIC transactions.
  - serializable
```
public boolean serializable()
```
    Specified by:
    
    serializable in interface IgniteInternalTx
    
    Returns:
    
    True if serializable.
  - repeatableRead
```
public boolean repeatableRead()
```
    Specified by:
    
    repeatableRead in interface IgniteInternalTx
    
    Returns:
    
    True if repeatable-read.
  - readCommitted
```
public boolean readCommitted()
```
    Specified by:
    
    readCommitted in interface IgniteInternalTx
    
    Returns:
    
    True if read-committed.
  - state
```
public boolean state(TransactionState state)
```
    Specified by:
    
    state in interface IgniteInternalTx
    
    Parameters:
    
    state - Transaction state.
    
    Returns:
    
    True if transition was valid, false otherwise.
  - chainState
```
public boolean chainState(TransactionState state)
```
    Changing state for this transaction as well as chained(parent) transactions.
    
    Parameters:
    
    state - Transaction state.
    
    Returns:
    
    True if transition was valid, false otherwise.
  - finishFuture
```
public IgniteInternalFuture<IgniteInternalTx> finishFuture()
```
    Specified by:
    
    finishFuture in interface IgniteInternalTx
    
    Returns:
    
    Future for transaction completion.
  - currentPrepareFuture
```
@Nullable
public @Nullable IgniteInternalFuture<?> currentPrepareFuture()
```
    Specified by:
    
    currentPrepareFuture in interface IgniteInternalTx
    
    Returns:
    
    Future for transaction prepare if prepare is in progress.
  - state
```
protected final boolean state(TransactionState state,
                              boolean timedOut)
```
    Parameters:
    
    state - State to set.
    
    timedOut - Timeout flag.
    
    Returns:
    
    True if state changed.
  - recordStateChangedEvent
```
protected void recordStateChangedEvent(int type)
```
    Parameters:
    
    type - Event type.
  - writeVersion
```
public GridCacheVersion writeVersion()
```
    Specified by:
    
    writeVersion in interface IgniteInternalTx
    
    Returns:
    
    Transaction write version. For all transactions except DHT transactions, will be equal to IgniteInternalTx.xidVersion().
  - writeVersion
```
public void writeVersion(GridCacheVersion writeVer)
```
    Sets write version.
    
    Specified by:
    
    writeVersion in interface IgniteInternalTx
    
    Parameters:
    
    writeVer - Write version.
  - timedOut
```
public boolean timedOut()
```
    Specified by:
    
    timedOut in interface IgniteInternalTx
    
    Returns:
    
    True if transaction timed out.
  - invalidate
```
public void invalidate(boolean invalidate)
```
    Specified by:
    
    invalidate in interface IgniteInternalTx
    
    Parameters:
    
    invalidate - Invalidate flag.
  - isInvalidate
```
public boolean isInvalidate()
```
    Get invalidation flag for this transaction. If set to true, then remote values will be invalidated (set to null) instead of updated.
    Invalidation messages don't carry new values, so they are a lot lighter than update messages. However, when a value is accessed on a node after it's been invalidated, it must be loaded from persistent store.
    
    Specified by:
    
    isInvalidate in interface IgniteInternalTx
    
    Returns:
    
    Invalidation flag.
  - isSystemInvalidate
```
public final boolean isSystemInvalidate()
```
    Specified by:
    
    isSystemInvalidate in interface IgniteInternalTx
    
    Returns:
    
    System invalidate flag.
  - systemInvalidate
```
public final void systemInvalidate(boolean sysInvalidate)
```
    Specified by:
    
    systemInvalidate in interface IgniteInternalTx
    
    Parameters:
    
    sysInvalidate - System invalidate flag.
  - transactionNodes
```
@Nullable
public @Nullable Map<UUID,Collection<UUID>> transactionNodes()
```
    Specified by:
    
    transactionNodes in interface IgniteInternalTx
    
    Returns:
    
    Transaction nodes mapping (primary node -> related backup nodes).
  - transactionNodes
```
public void transactionNodes(Map<UUID,Collection<UUID>> txNodes)
```
    Parameters:
    
    txNodes - Transaction nodes.
  - nearXidVersion
```
@Nullable
public @Nullable GridCacheVersion nearXidVersion()
```
    Specified by:
    
    nearXidVersion in interface IgniteInternalTx
    
    Returns:
    
    Near transaction ID.
  - isWriteToStoreFromDhtValid
```
protected boolean isWriteToStoreFromDhtValid(Collection<CacheStoreManager> stores)
```
    Parameters:
    
    stores - Store managers.
    
    Returns:
    
    If isWriteToStoreFromDht value same for all stores.
  - sessionEnd
```
protected void sessionEnd(Collection<CacheStoreManager> stores,
                          boolean commit)
                   throws IgniteCheckedException
```
    Parameters:
    
    stores - Store managers.
    
    commit - Commit flag.
    
    Throws:
    
    IgniteCheckedException - In case of error.
  - batchStoreCommit
```
protected final void batchStoreCommit(Iterable<IgniteTxEntry> writeEntries)
                               throws IgniteCheckedException
```
    Performs batch database operations. This commit must be called before cache update. This way if there is a DB failure, cache transaction can still be rolled back.
    
    Parameters:
    
    writeEntries - Transaction write set.
    
    Throws:
    
    IgniteCheckedException - If batch update failed.
  - applyTransformClosures
```
protected IgniteBiTuple<GridCacheOperation,CacheObject> applyTransformClosures(IgniteTxEntry txEntry,
                                                                                     boolean metrics,
                                                                                     @Nullable
                                                                                     @Nullable GridCacheReturn ret)
                                                                              throws GridCacheEntryRemovedException,
                                                                                     IgniteCheckedException
```
    Parameters:
    
    txEntry - Entry to process.
    
    metrics - True if metrics should be updated.
    
    ret - Optional return value to initialize.
    
    Returns:
    
    Tuple containing transformation results.
    
    Throws:
    
    IgniteCheckedException - If failed to get previous value for transform.
    
    GridCacheEntryRemovedException - If entry was concurrently deleted.
  - resolveTaskName
```
public String resolveTaskName()
```
    Returns:
    
    Resolves task name.
  - conflictResolve
```
protected IgniteBiTuple<GridCacheOperation,GridCacheVersionConflictContext> conflictResolve(GridCacheOperation op,
                                                                                                  IgniteTxEntry txEntry,
                                                                                                  CacheObject newVal,
                                                                                                  GridCacheVersion newVer,
                                                                                                  GridCacheEntryEx old)
                                                                                           throws IgniteCheckedException,
                                                                                                  GridCacheEntryRemovedException
```
    Resolve DR conflict.
    
    Parameters:
    
    op - Initially proposed operation.
    
    txEntry - TX entry being updated.
    
    newVal - New value.
    
    newVer - New version.
    
    old - Old entry.
    
    Returns:
    
    Tuple with adjusted operation type and conflict context.
    
    Throws:
    
    IgniteCheckedException - In case of eny exception.
    
    GridCacheEntryRemovedException - If entry got removed.
  - isNearLocallyMapped
```
protected boolean isNearLocallyMapped(IgniteTxEntry e,
                                      boolean primaryOnly)
```
    Parameters:
    
    e - Transaction entry.
    
    primaryOnly - Flag to include backups into check or not.
    
    Returns:
    
    True if entry is locally mapped as a primary or back up node.
  - evictNearEntry
```
protected boolean evictNearEntry(IgniteTxEntry e,
                                 boolean primaryOnly)
```
    Parameters:
    
    e - Entry to evict if it qualifies for eviction.
    
    primaryOnly - Flag to try to evict only on primary node.
    
    Returns:
    
    True if attempt was made to evict the entry.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - addActiveCache
```
public abstract void addActiveCache(GridCacheContext<?,?> cacheCtx,
                                    boolean recovery)
                             throws IgniteCheckedException
```
    Adds cache to the list of active caches in transaction.
    
    Parameters:
    
    cacheCtx - Cache context to add.
    
    recovery - Recovery flag. See CacheOperationContext.setRecovery(boolean).
    
    Throws:
    
    IgniteCheckedException - If caches already enlisted in this transaction are not compatible with given cache (e.g. they have different stores).
  - txCounters
```
public TxCounters txCounters(boolean createIfAbsent)
```
    Specified by:
    
    txCounters in interface IgniteInternalTx
    
    Parameters:
    
    createIfAbsent - True if non-null instance is needed.
    
    Returns:
    
    Transaction counters.
  - applyTxSizes
```
protected void applyTxSizes()
```
    Makes cache sizes changes accumulated during transaction visible outside of transaction.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class IgniteTxAdapter

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter

Nested classes/interfaces inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.apache.ignite.internal.util.lang.GridMetadataAwareAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx

Field Detail

log

xidVer

implicit

threadId

startTime

nodeId

cctx

isolation

concurrency

deploymentLdrId

invalidate

onePhaseCommit

isDone

txSize

topVer

txNodes

taskName

consistentIdMapper

Constructor Detail

IgniteTxAdapter

IgniteTxAdapter

Method Detail

incrementalSnapshotId

incrementalSnapshotId

setParentTx

skipCompletedVersions

skipCompletedVersions

context

localResult

updateNearCache

optimisticLockEntries

storeEnabled

storeEnabled

system

ioPolicy

storeWriteThrough

uncommit

otherNodeId

subjectId

taskNameHash

topologyVersion

topologyVersionSnapshot

topologyVersion

markFinalizing

finalizationStatus

isStarted

size

log

remote

near

implicit

implicitSingle

local

user

dht

colocated

xid

invalidPartitions

addInvalidPartition

ownedVersion

startTime

startTimeNanos

needReturnValue

needReturnValue

remainingTime

timeoutException

timeoutException

rollbackException

heuristicException