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.internal.processors.cache	This package contain cache-related processors & persistence implementation.
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	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, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)
<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> 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, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
<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> 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, 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<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<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.
<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.
void	IgniteCache.put(K key, V val)
void	IgniteCache.putAll(Map<? extends K,? extends V> 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)
boolean	IgniteCache.remove(K key)
boolean	IgniteCache.remove(K key, V oldVal)
void	IgniteCache.removeAll(Set<? extends K> keys)
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)
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.internal.processors.cache

Methods in org.apache.ignite.internal.processors.cache that throw TransactionException

Modifier and Type	Method	Description
boolean	GatewayProtectedCacheProxy.containsKey(K key)
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.containsKeyAsync(K key)	Asynchronously determines if the Cache contains an entry for the specified key.
boolean	GatewayProtectedCacheProxy.containsKeys(Set<? extends K> keys)	Determines if the Cache contains entries for the specified keys.
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.containsKeysAsync(Set<? extends K> keys)	Asynchronously determines if the Cache contains entries for the specified keys.
V	GatewayProtectedCacheProxy.get(K key)
Map<K,V>	GatewayProtectedCacheProxy.getAll(Set<? extends K> keys)
IgniteFuture<Map<K,V>>	GatewayProtectedCacheProxy.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	GatewayProtectedCacheProxy.getAndPut(K key, V val)
IgniteFuture<V>	GatewayProtectedCacheProxy.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	GatewayProtectedCacheProxy.getAndPutIfAbsent(K key, V val)	Stores given key-value pair in cache only if cache had no previous mapping for it.
IgniteFuture<V>	GatewayProtectedCacheProxy.getAndPutIfAbsentAsync(K key, V val)	Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
V	GatewayProtectedCacheProxy.getAndRemove(K key)
IgniteFuture<V>	GatewayProtectedCacheProxy.getAndRemoveAsync(K key)	Asynchronously removes the entry for a key only if currently mapped to some value.
V	GatewayProtectedCacheProxy.getAndReplace(K key, V val)
Collection<CacheEntry<K,V>>	GatewayProtectedCacheProxy.getEntries(Set<? extends K> keys)	Gets a collection of entries from the Cache.
IgniteFuture<Collection<CacheEntry<K,V>>>	GatewayProtectedCacheProxy.getEntriesAsync(Set<? extends K> keys)	Asynchronously gets a collection of entries from the Cache.
CacheEntry<K,V>	GatewayProtectedCacheProxy.getEntry(K key)	Gets an entry from the cache.
IgniteFuture<CacheEntry<K,V>>	GatewayProtectedCacheProxy.getEntryAsync(K key)	Asynchronously gets an entry from the cache.
<T> T	GatewayProtectedCacheProxy.invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)
<T> T	GatewayProtectedCacheProxy.invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)	Invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	GatewayProtectedCacheProxy.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>>	GatewayProtectedCacheProxy.invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	GatewayProtectedCacheProxy.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> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	GatewayProtectedCacheProxy.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>>>	GatewayProtectedCacheProxy.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<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	GatewayProtectedCacheProxy.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<T>	GatewayProtectedCacheProxy.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.
<T> IgniteFuture<T>	GatewayProtectedCacheProxy.invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)	Asynchronously invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key.
void	GatewayProtectedCacheProxy.put(K key, V val)
void	GatewayProtectedCacheProxy.putAll(Map<? extends K,? extends V> map)
IgniteFuture<Void>	GatewayProtectedCacheProxy.putAllAsync(Map<? extends K,? extends V> map)	Asynchronously copies all of the entries from the specified map to the Cache.
IgniteFuture<Void>	GatewayProtectedCacheProxy.putAsync(K key, V val)	Asynchronously associates the specified value with the specified key in the cache.
boolean	GatewayProtectedCacheProxy.putIfAbsent(K key, V val)
boolean	GatewayProtectedCacheProxy.remove(K key)
boolean	GatewayProtectedCacheProxy.remove(K key, V oldVal)
void	GatewayProtectedCacheProxy.removeAll(Set<? extends K> keys)
IgniteFuture<Void>	GatewayProtectedCacheProxy.removeAllAsync(Set<? extends K> keys)	Asynchronously removes entries for the specified keys.
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.removeAsync(K key)	Asynchronously removes the mapping for a key from this cache if it is present.
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.removeAsync(K key, V oldVal)	Asynchronously removes the mapping for a key only if currently mapped to the given value.
boolean	GatewayProtectedCacheProxy.replace(K key, V val)
boolean	GatewayProtectedCacheProxy.replace(K key, V oldVal, V newVal)
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.replaceAsync(K key, V val)	Asynchronously replaces the entry for a key only if currently mapped to a given value.
IgniteFuture<Boolean>	GatewayProtectedCacheProxy.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	Description
class	TransactionDeadlockException	Transaction deadlock exception.
class	TransactionHeuristicException	Exception thrown whenever grid transaction enters an unknown state.
class	TransactionOptimisticException	Exception thrown whenever grid transactions fail optimistically.
class	TransactionRollbackException	Exception thrown whenever grid transactions has been automatically rolled back.
class	TransactionTimeoutException	Exception thrown whenever transactions time out.