Uses of Class
org.apache.ignite.transactions.TransactionException

Packages that use TransactionException

Package	Description
org.apache.ignite	Contains entry-point Ignite & HPC APIs.
org.apache.ignite.transactions	Contains transaction-related classes.

Uses of TransactionException in org.apache.ignite

Methods in org.apache.ignite that throw TransactionException

Modifier and Type	Method and Description
boolean	IgniteCache.containsKey(K key)
IgniteFuture<Boolean>	IgniteCache.containsKeyAsync(K key) Asynchronously determines if the Cache contains an entry for the specified key.
boolean	IgniteCache.containsKeys(Set<? extends K> keys) Determines if the Cache contains entries for the specified keys.
IgniteFuture<Boolean>	IgniteCache.containsKeysAsync(Set<? extends K> keys) Asynchronously determines if the Cache contains entries for the specified keys.
V	IgniteCache.get(K key)
Map<K,V>	IgniteCache.getAll(Set<? extends K> keys)
IgniteFuture<Map<K,V>>	IgniteCache.getAllAsync(Set<? extends K> keys) Asynchronously gets a collection of entries from the Cache, returning them as Map of the values associated with the set of keys requested.
V	IgniteCache.getAndPut(K key, V val)
IgniteFuture<V>	IgniteCache.getAndPutAsync(K key, V val) Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed as the future result.
V	IgniteCache.getAndPutIfAbsent(K key, V val) Stores given key-value pair in cache only if cache had no previous mapping for it.
IgniteFuture<V>	IgniteCache.getAndPutIfAbsentAsync(K key, V val) Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
V	IgniteCache.getAndRemove(K key)
IgniteFuture<V>	IgniteCache.getAndRemoveAsync(K key) Asynchronously removes the entry for a key only if currently mapped to some value.
V	IgniteCache.getAndReplace(K key, V val)
Collection<CacheEntry<K,V>>	IgniteCache.getEntries(Set<? extends K> keys) Gets a collection of entries from the Cache.
IgniteFuture<Collection<CacheEntry<K,V>>>	IgniteCache.getEntriesAsync(Set<? extends K> keys) Asynchronously gets a collection of entries from the Cache.
CacheEntry<K,V>	IgniteCache.getEntry(K key) Gets an entry from the cache.
IgniteFuture<CacheEntry<K,V>>	IgniteCache.getEntryAsync(K key) Asynchronously gets an entry from the cache.
<T> T	IgniteCache.invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments) Invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key.
<T> T	IgniteCache.invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments) Please refer to documentation for CacheAtomicityMode.ATOMIC for information on system behavior in crash scenarios for atomic caches.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) Asynchronously invokes each EntryProcessor from map's values against the correspondent Cache.Entry specified by map's key set.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args) Invokes an CacheEntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	IgniteCache.invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) Please refer to documentation for CacheAtomicityMode.ATOMIC for information on system behavior in crash scenarios for atomic caches.
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	IgniteCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) Asynchronous version of the IgniteCache.invokeAll(Map, Object...) method.
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	IgniteCache.invokeAllAsync(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args) Asynchronously invokes an CacheEntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	IgniteCache.invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) Asynchronously invokes an EntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteFuture<T>	IgniteCache.invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments) Asynchronously invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key.
<T> IgniteFuture<T>	IgniteCache.invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments) Asynchronously invokes an EntryProcessor against the Cache.Entry specified by the provided key.
void	IgniteCache.put(K key, V val)
void	IgniteCache.putAll(Map<? extends K,? extends V> map) Keys are locked in the order in which they appear in map.
IgniteFuture<Void>	IgniteCache.putAllAsync(Map<? extends K,? extends V> map) Asynchronously copies all of the entries from the specified map to the Cache.
IgniteFuture<Void>	IgniteCache.putAsync(K key, V val) Asynchronously associates the specified value with the specified key in the cache.
boolean	IgniteCache.putIfAbsent(K key, V val) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
boolean	IgniteCache.remove(K key)
boolean	IgniteCache.remove(K key, V oldVal) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
void	IgniteCache.removeAll(Set<? extends K> keys) Keys are locked in the order in which they appear in key set.
IgniteFuture<Void>	IgniteCache.removeAllAsync(Set<? extends K> keys) Asynchronously removes entries for the specified keys.
IgniteFuture<Boolean>	IgniteCache.removeAsync(K key) Asynchronously removes the mapping for a key from this cache if it is present.
IgniteFuture<Boolean>	IgniteCache.removeAsync(K key, V oldVal) Asynchronously removes the mapping for a key only if currently mapped to the given value.
boolean	IgniteCache.replace(K key, V val)
boolean	IgniteCache.replace(K key, V oldVal, V newVal) For CacheAtomicityMode.ATOMIC return value on primary node crash may be incorrect because of the automatic retries.
IgniteFuture<Boolean>	IgniteCache.replaceAsync(K key, V val) Asynchronously replaces the entry for a key only if currently mapped to a given value.
IgniteFuture<Boolean>	IgniteCache.replaceAsync(K key, V oldVal, V newVal) Asynchronous version of the IgniteCache.replace(Object, Object, Object).

Uses of TransactionException in org.apache.ignite.transactions

Subclasses of TransactionException in org.apache.ignite.transactions

Modifier and Type	Class and Description
class	TransactionAlreadyCompletedException Exception thrown whenever Mvcc transaction has been finished before operation finished.
class	TransactionDeadlockException Transaction deadlock exception.
class	TransactionDuplicateKeyException Exception thrown whenever transaction tries to inserts entry with same mvcc version more than once.
class	TransactionHeuristicException Exception thrown whenever grid transaction enters an unknown state.
class	TransactionMixedModeException Exception thrown whenever transaction spans over MVCC and non-MVCC caches.
class	TransactionOptimisticException Exception thrown whenever grid transactions fail optimistically.
class	TransactionRollbackException Exception thrown whenever grid transactions has been automatically rolled back.
class	TransactionSerializationException Exception thrown whenever transaction can't be serialized due to write conflict.
class	TransactionTimeoutException Exception thrown whenever transactions time out.
class	TransactionUnsupportedConcurrencyException Exception thrown whenever transaction concurrency level is not supported.