TransactionMap

java.lang.Object
- java.util.AbstractMap<K,V>
- - org.h2.mvstore.tx.TransactionMap<K,V>

Type Parameters:
K - the key type
V - the value type

All Implemented Interfaces:

java.util.Map<K,V>
```
public class TransactionMap<K,V>
extends java.util.AbstractMap<K,V>
```
A map that supports transactions.
Methods of this class may be changed at any time without notice. If you use this class directly make sure that your application or library requires exactly the same version of MVStore or H2 jar as the version that you use during its development and build.

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.AbstractMap
  java.util.AbstractMap.SimpleEntry<K,V>, java.util.AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  java.util.Map.Entry<K,V>

Field Summary

Fields
Modifier and Type Field and Description

MVMap<K,VersionedValue> map
The map used for writing (the latest version).

Fields
Modifier and Type	Field and Description
`MVMap<K,VersionedValue>`	`map` The map used for writing (the latest version).

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`append(K key, V value)` Appends entry to underlying map.
`K`	`ceilingKey(K key)` Get the smallest key that is larger than or equal to this key, or null if no such key exists.
`void`	`clear()` Clear the map.
`boolean`	`containsKey(java.lang.Object key)` Whether the map contains the key.
`java.util.Iterator<java.util.Map.Entry<K,V>>`	`entryIterator(K from, K to)` Iterate over entries.
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()`
`K`	`firstKey()` Get the first key.
`K`	`floorKey(K key)` Get the largest key that is smaller than or equal to this key, or null if no such key exists.
`V`	`get(java.lang.Object key)` Get the effective value for the given key.
`TransactionMap<K,V>`	`getInstance(Transaction transaction)` Get a clone of this map for the given transaction.
`DataType`	`getKeyType()`
`Transaction`	`getTransaction()`
`K`	`higherKey(K key)` Get the smallest key that is larger than the given key, or null if no such key exists.
`boolean`	`isClosed()` Check whether this map is closed.
`boolean`	`isSameTransaction(K key)` Whether the entry for this key was added or removed from this session.
`java.util.Iterator<K>`	`keyIterator(K from)` Iterate over keys.
`java.util.Iterator<K>`	`keyIterator(K from, K to, boolean includeUncommitted)` Iterate over keys.
`K`	`lastKey()` Get the last key.
`V`	`lock(K key)` Lock row for the given key.
`K`	`lowerKey(K key)` Get the largest key that is smaller than the given key, or null if no such key exists.
`V`	`put(K key, V value)` Update the value for the given key.
`V`	`putCommitted(K key, V value)` Update the value for the given key, without adding an undo log entry.
`V`	`putIfAbsent(K key, V value)` Put the value for the given key if entry for this key does not exist.
`V`	`remove(java.lang.Object key)` Remove an entry.
`int`	`size()` Get the number of entries, as a integer.
`long`	`sizeAsLong()` Get the size of the map as seen by this transaction.
`long`	`sizeAsLongMax()` Get the size of the raw map.
`boolean`	`tryPut(K key, V value)` Try to update the value for the given key.
`boolean`	`tryRemove(K key)` Try to remove the value for the given key.
`boolean`	`trySet(K key, V value)` Try to set or remove the value.
`java.util.Iterator<K>`	`wrapIterator(java.util.Iterator<K> iterator, boolean includeUncommitted)` Iterate over keys.

Methods inherited from class java.util.AbstractMap
clone, containsValue, equals, hashCode, isEmpty, keySet, putAll, toString, values

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

- Field Detail
  - map
```
public final MVMap<K,VersionedValue> map
```
    The map used for writing (the latest version).
    Key: key the key of the data. Value: { transactionId, oldVersion, value }
- Method Detail
  - getInstance
```
public TransactionMap<K,V> getInstance(Transaction transaction)
```
    Get a clone of this map for the given transaction.
    
    Parameters:
    transaction - the transaction
    
    Returns:
    the map
  - size
```
public final int size()
```
    Get the number of entries, as a integer. Integer.MAX_VALUE is returned if there are more than this entries.
    
    Specified by:
    
    size in interface java.util.Map<K,V>
    
    Overrides:
    
    size in class java.util.AbstractMap<K,V>
    
    Returns:
    the number of entries, as an integer
    See Also:
    sizeAsLong()
  - sizeAsLongMax
```
public long sizeAsLongMax()
```
    Get the size of the raw map. This includes uncommitted entries, and transiently removed entries, so it is the maximum number of entries.
    
    Returns:
    the maximum size
  - sizeAsLong
```
public long sizeAsLong()
```
    Get the size of the map as seen by this transaction.
    
    Returns:
    the size
  - remove
```
public V remove(java.lang.Object key)
```
    Remove an entry.
    If the row is locked, this method will retry until the row could be updated or until a lock timeout.
    
    Specified by:
    
    remove in interface java.util.Map<K,V>
    
    Overrides:
    
    remove in class java.util.AbstractMap<K,V>
    
    Parameters:
    key - the key
    
    Throws:
    
    java.lang.IllegalStateException - if a lock timeout occurs
    
    java.lang.ClassCastException - if type of the specified key is not compatible with this map
  - put
```
public V put(K key,
    V value)
```
    Update the value for the given key.
    If the row is locked, this method will retry until the row could be updated or until a lock timeout.
    
    Specified by:
    
    put in interface java.util.Map<K,V>
    
    Overrides:
    
    put in class java.util.AbstractMap<K,V>
    
    Parameters:
    key - the key
    value - the new value (not null)
    
    Returns:
    the old value
    
    Throws:
    
    java.lang.IllegalStateException - if a lock timeout occurs
  - putIfAbsent
```
public V putIfAbsent(K key,
            V value)
```
    Put the value for the given key if entry for this key does not exist. It is atomic equivalent of the following expression: contains(key) ? get(k) : put(key, value);
    
    Parameters:
    key - the key
    value - the new value (not null)
    
    Returns:
    the old value
  - append
```
public void append(K key,
          V value)
```
    Appends entry to underlying map. This method may be used concurrently, but latest appended values are not guaranteed to be visible.
    
    Parameters:
    key - should be higher in map's order than any existing key
    value - to be appended
  - lock
```
public V lock(K key)
```
    Lock row for the given key.
    If the row is locked, this method will retry until the row could be updated or until a lock timeout.
    
    Parameters:
    key - the key
    
    Returns:
    the locked value
    
    Throws:
    
    java.lang.IllegalStateException - if a lock timeout occurs
  - putCommitted
```
public V putCommitted(K key,
             V value)
```
    Update the value for the given key, without adding an undo log entry.
    
    Parameters:
    key - the key
    value - the value
    
    Returns:
    the old value
  - tryRemove
```
public boolean tryRemove(K key)
```
    Try to remove the value for the given key.
    This will fail if the row is locked by another transaction (that means, if another open transaction changed the row).
    
    Parameters:
    key - the key
    
    Returns:
    whether the entry could be removed
  - tryPut
```
public boolean tryPut(K key,
             V value)
```
    Try to update the value for the given key.
    This will fail if the row is locked by another transaction (that means, if another open transaction changed the row).
    
    Parameters:
    key - the key
    value - the new value
    
    Returns:
    whether the entry could be updated
  - trySet
```
public boolean trySet(K key,
             V value)
```
    Try to set or remove the value. When updating only unchanged entries, then the value is only changed if it was not changed after opening the map.
    
    Parameters:
    key - the key
    value - the new value (null to remove the value)
    
    Returns:
    true if the value was set, false if there was a concurrent update
  - get
```
public V get(java.lang.Object key)
```
    Get the effective value for the given key.
    
    Specified by:
    
    get in interface java.util.Map<K,V>
    
    Overrides:
    
    get in class java.util.AbstractMap<K,V>
    
    Parameters:
    key - the key
    
    Returns:
    the value or null
    
    Throws:
    
    java.lang.ClassCastException - if type of the specified key is not compatible with this map
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Whether the map contains the key.
    
    Specified by:
    
    containsKey in interface java.util.Map<K,V>
    
    Overrides:
    
    containsKey in class java.util.AbstractMap<K,V>
    
    Parameters:
    key - the key
    
    Returns:
    true if the map contains an entry for this key
    
    Throws:
    
    java.lang.ClassCastException - if type of the specified key is not compatible with this map
  - isSameTransaction
```
public boolean isSameTransaction(K key)
```
    Whether the entry for this key was added or removed from this session.
    
    Parameters:
    key - the key
    
    Returns:
    true if yes
  - isClosed
```
public boolean isClosed()
```
    Check whether this map is closed.
    
    Returns:
    true if closed
  - clear
```
public void clear()
```
    Clear the map.
    
    Specified by:
    
    clear in interface java.util.Map<K,V>
    
    Overrides:
    
    clear in class java.util.AbstractMap<K,V>
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<K,V>
    
    Specified by:
    
    entrySet in class java.util.AbstractMap<K,V>
  - firstKey
```
public K firstKey()
```
    Get the first key.
    
    Returns:
    the first key, or null if empty
  - lastKey
```
public K lastKey()
```
    Get the last key.
    
    Returns:
    the last key, or null if empty
  - higherKey
```
public K higherKey(K key)
```
    Get the smallest key that is larger than the given key, or null if no such key exists.
    
    Parameters:
    key - the key (may not be null)
    
    Returns:
    the result
  - ceilingKey
```
public K ceilingKey(K key)
```
    Get the smallest key that is larger than or equal to this key, or null if no such key exists.
    
    Parameters:
    key - the key (may not be null)
    
    Returns:
    the result
  - floorKey
```
public K floorKey(K key)
```
    Get the largest key that is smaller than or equal to this key, or null if no such key exists.
    
    Parameters:
    key - the key (may not be null)
    
    Returns:
    the result
  - lowerKey
```
public K lowerKey(K key)
```
    Get the largest key that is smaller than the given key, or null if no such key exists.
    
    Parameters:
    key - the key (may not be null)
    
    Returns:
    the result
  - keyIterator
```
public java.util.Iterator<K> keyIterator(K from)
```
    Iterate over keys.
    
    Parameters:
    from - the first key to return
    
    Returns:
    the iterator
  - keyIterator
```
public java.util.Iterator<K> keyIterator(K from,
                                K to,
                                boolean includeUncommitted)
```
    Iterate over keys.
    
    Parameters:
    from - the first key to return
    to - the last key to return or null if there is no limit
    includeUncommitted - whether uncommitted entries should be included
    
    Returns:
    the iterator
  - entryIterator
```
public java.util.Iterator<java.util.Map.Entry<K,V>> entryIterator(K from,
                                                         K to)
```
    Iterate over entries.
    
    Parameters:
    from - the first key to return
    to - the last key to return
    
    Returns:
    the iterator
  - wrapIterator
```
public java.util.Iterator<K> wrapIterator(java.util.Iterator<K> iterator,
                                 boolean includeUncommitted)
```
    Iterate over keys.
    
    Parameters:
    iterator - the iterator to wrap
    includeUncommitted - whether uncommitted entries should be included
    
    Returns:
    the iterator
  - getTransaction
```
public Transaction getTransaction()
```
  - getKeyType
```
public DataType getKeyType()
```

Class TransactionMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Field Detail

map

Method Detail

getInstance

size

sizeAsLongMax

sizeAsLong

remove

put

putIfAbsent

append

lock

putCommitted

tryRemove

tryPut

trySet

get

containsKey

isSameTransaction

isClosed

clear

entrySet

firstKey

lastKey

higherKey

ceilingKey

floorKey

lowerKey

keyIterator

keyIterator

entryIterator

wrapIterator

getTransaction

getKeyType