## 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.Entry`s 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.Entry`s 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.Entry`s 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.

2020 Copyright © Apache Software Foundation
| Follow @ApacheIgnite
Ignite Database and Caching Platform | : ver. 2.9.1
Release Date | : December 9 2020