org.h2.mvstore.tx

## Class TransactionMap<K,V>

- 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 final 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
`MVMap<K,VersionedValue<V>>` `map` The map used for writing (the latest version).

### Method Summary

All Methods Instance Methods Concrete Methods
`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.
`V` `getFromSnapshot(K key)` Get the value for the given key from a snapshot, or null if not found.
`V` `getImmediate(K key)` Get the value for the given key, or null if not found.
`TransactionMap<K,V>` `getInstance(Transaction transaction)` Get a clone of this map for the given transaction.
`DataType<K>` `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` `isDeletedByCurrentTransaction(K key)` Check if the row was deleted by this transaction.
`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)` Iterate over keys.
`java.util.Iterator<K>` `keyIteratorUncommitted(K from, K to)` Iterate over keys, including keys from uncommitted entries.
`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.

### 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`

### Methods inherited from interface java.util.Map

`compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, remove, replace, replace, replaceAll`

### Field Detail

#### map

    public final MVMap<K,VersionedValue<V>> 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 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:
  `MVStoreException` - 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:
  `MVStoreException` - 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:
  `MVStoreException` - 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

#### getFromSnapshot

    public V getFromSnapshot(K key)

Get the value for the given key from a snapshot, or null if not found.

Parameters:
  `key` - the key
Returns:
  the value, or null if not found

#### getImmediate

    public V getImmediate(K key)

Get the value for the given key, or null if not found.

Parameters:
  `key` - the key
Returns:
  the value, or null if not found

#### 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

#### isDeletedByCurrentTransaction

    public boolean isDeletedByCurrentTransaction(K key)

Check if the row was deleted by this transaction.

Parameters:
  `key` - the key
Returns:
  `true` if it was

#### 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)

Iterate over keys.

Parameters:
  `from` - the first key to return
  `to` - the last key to return or null if there is no limit
Returns:
  the iterator

#### keyIteratorUncommitted

    public java.util.Iterator<K> keyIteratorUncommitted(K from,
                                                        K to)

Iterate over keys, including keys from uncommitted entries.

Parameters:
  `from` - the first key to return
  `to` - the last key to return or null if there is no limit
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

#### getTransaction

    public Transaction getTransaction()

#### getKeyType

    public DataType<K> getKeyType()