org.corfudb.runtime.collections

Class CorfuTable<K,V>

java.lang.Object

org.corfudb.runtime.collections.CorfuTable<K,V>

Type Parameters:

K - The type of the primary key.

V - The type of the values to be mapped.

All Implemented Interfaces:

Map<K,V>, ICorfuMap<K,V>

public class CorfuTable<K,V>
extends Object
implements ICorfuMap<K,V>

The CorfuTable implements a simple key-value store.

The primary interface to the CorfuTable is a Map, where the keys must be unique and each key is mapped to exactly one value. Null values are not permitted.

The CorfuTable also supports an unlimited number of secondary indexes, which the user provides at construction time as an enum which implements the IndexSpecification interface. An index specification consists of a IndexFunction, which returns a set of secondary keys (indexes) the value should be mapped to. Secondary indexes are many-to-many: values can be mapped to multiple indexes, and indexes can be mapped to multiples values. Each IndexSpecification also specifies a projection function, which specifies a transformation that can be done on a retrieval on the index. A common projection is to emit only the values.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CorfuTable.Index<K,V,I extends Comparable<?>> Descriptor of named indexing function entry.
static interface	CorfuTable.IndexFunction<K,V,I extends Comparable<?>> Denotes a function that takes as input the key and value of an CorfuTable record, and computes the associated index value for the record.
static interface	CorfuTable.IndexName Denotes a function that supplies the unique name of an index registered to CorfuTable.
static interface	CorfuTable.IndexRegistry<K,V> Registry hosting of a collection of CorfuTable.Index.
static interface	CorfuTable.IndexSpecification<K,V,I extends Comparable<?>,P> The interface for a index specification, which consists of a indexing function and a projection function.
static interface	CorfuTable.MultiValueIndexFunction<K,V,I extends Comparable<?>>
static interface	CorfuTable.ProjectionFunction<K,V,I,P> The interface for a projection function.

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

Map.Entry<K,V>

Constructor Summary

Constructors

Constructor and Description
CorfuTable() Default constructor.
CorfuTable(CorfuTable.IndexRegistry<K,V> indices) Generate a table with the given set of indexes.

Method Summary

Modifier and Type	Method and Description
void	clear()
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
boolean	containsKey(Object key)
boolean	containsValue(Object value)
void	delete(K key) Delete a key from a map.
Set<Map.Entry<K,V>>	entrySet() Makes a shallow copy of the map (i.e.
void	forEach(BiConsumer<? super K,? super V> action)
V	get(Object key)
<I extends Comparable<I>> Collection<Map.Entry<K,V>>	getByIndex(CorfuTable.IndexName indexName, I indexKey) Get a mapping using the specified index function.
<I extends Comparable<I>> Collection<Map.Entry<K,V>>	getByIndexAndFilter(CorfuTable.IndexName indexName, Predicate<? super Map.Entry<K,V>> entryPredicate, I indexKey) Scan and filter using the specified index function and projection.
V	getOrDefault(Object key, V defaultValue)
boolean	hasSecondaryIndices() Return whether this table has secondary indexes or not.
void	insert(K key, V value) Insert a key-value pair into a map, overwriting any previous mapping.
boolean	isEmpty()
Set<K>	keySet()
protected void	mapSecondaryIndexes(K key, V value) Maps the secondary indexes for a given key value pair.
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
V	put(K key, V value)
void	putAll(Map<? extends K,? extends V> m)
V	putIfAbsent(K key, V value)
V	remove(Object key)
boolean	remove(Object key, Object value)
V	replace(K key, V value)
void	replaceAll(BiFunction<? super K,? super V,? extends V> function)
List<V>	scanAndFilter(Predicate<? super V> p) Returns a filtered List view of the values contained in this map.
Collection<Map.Entry<K,V>>	scanAndFilterByEntry(Predicate<? super Map.Entry<K,V>> entryPredicate) Returns a Collection filtered by entries (keys and/or values).
int	size()
protected void	undoPut(CorfuTable<K,V> table, V undoRecord, K key, V value)
protected V	undoPutRecord(CorfuTable<K,V> table, K key, V value)
protected void	undoRemove(CorfuTable<K,V> table, V undoRecord, K key)
protected V	undoRemoveRecord(CorfuTable<K,V> table, K key)
protected void	unmapSecondaryIndexes(K key, V value) Unmaps the secondary indexes for a given key value pair.
Collection<V>	values()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Map

compute, equals, hashCode, replace

Constructor Detail

CorfuTable

public CorfuTable(CorfuTable.IndexRegistry<K,V> indices)

Generate a table with the given set of indexes.

CorfuTable

public CorfuTable()

Default constructor. Generates a table without any secondary indexes.

Method Detail

size

public int size()

Specified by:

size in interface Map<K,V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

hasSecondaryIndices

public boolean hasSecondaryIndices()

Return whether this table has secondary indexes or not.

Returns:

True, if secondary indexes are present. False otherwise.

containsKey

public boolean containsKey(Object key)

Specified by:

containsKey in interface Map<K,V>

containsValue

public boolean containsValue(Object value)

Specified by:

containsValue in interface Map<K,V>

get

public V get(Object key)

Specified by:

get in interface Map<K,V>

getByIndex

@Nonnull
public <I extends Comparable<I>> Collection<Map.Entry<K,V>> getByIndex(@Nonnull
                                                                                CorfuTable.IndexName indexName,
                                                                                I indexKey)

Get a mapping using the specified index function.

Parameters:

indexName - Name of the the secondary index to query.

indexKey - The index key used to query the secondary index

Returns:

A collection of Map.Entry

getByIndexAndFilter

@Nonnull
public <I extends Comparable<I>> Collection<Map.Entry<K,V>> getByIndexAndFilter(@Nonnull
                                                                                         CorfuTable.IndexName indexName,
                                                                                         @Nonnull
                                                                                         Predicate<? super Map.Entry<K,V>> entryPredicate,
                                                                                         I indexKey)

Scan and filter using the specified index function and projection.

Parameters:

indexName - Name of the the secondary index to query.

entryPredicate - The predicate to scan and filter with.

indexKey - A collection of Map.Entry

Returns:

put

public V put(K key,
             V value)

Specified by:

put in interface Map<K,V>

undoPutRecord

protected V undoPutRecord(CorfuTable<K,V> table,
                          K key,
                          V value)

undoPut

protected void undoPut(CorfuTable<K,V> table,
                       V undoRecord,
                       K key,
                       V value)

insert

public void insert(K key,
                   V value)

Insert a key-value pair into a map, overwriting any previous mapping. This function performs better than put, because no value is returned (and is therefore a write rather than a read-modify-write).

Specified by:

insert in interface ICorfuMap<K,V>

Parameters:

key - The key to insert

value - The value to insert

scanAndFilter

public List<V> scanAndFilter(Predicate<? super V> p)

Returns a filtered List view of the values contained in this map. This method has a memory/CPU advantage over the map iterators as no deep copy is actually performed.

Parameters:

p - java predicate (function to evaluate)

Returns:

a view of the values contained in this map meeting the predicate condition.

scanAndFilterByEntry

public Collection<Map.Entry<K,V>> scanAndFilterByEntry(Predicate<? super Map.Entry<K,V>> entryPredicate)

Returns a Collection filtered by entries (keys and/or values). This method has a memory/CPU advantage over the map iterators as no deep copy is actually performed.

Specified by:

scanAndFilterByEntry in interface ICorfuMap<K,V>

Parameters:

entryPredicate - java predicate (function to evaluate)

Returns:

a view of the entries contained in this map meeting the predicate condition.

remove

public V remove(Object key)

Specified by:

remove in interface Map<K,V>

undoRemoveRecord

protected V undoRemoveRecord(CorfuTable<K,V> table,
                             K key)

undoRemove

protected void undoRemove(CorfuTable<K,V> table,
                          V undoRecord,
                          K key)

delete

public void delete(K key)

Delete a key from a map. This function performs better than a remove, because no value is returned (and is therefore a write rather than a read-modify-write).

Specified by:

delete in interface ICorfuMap<K,V>

Parameters:

key - The key to delete

putAll

public void putAll(@Nonnull
                   Map<? extends K,? extends V> m)

Specified by:

putAll in interface Map<K,V>

clear

public void clear()

Specified by:

clear in interface Map<K,V>

keySet

@Nonnull
public Set<K> keySet()

Specified by:

keySet in interface Map<K,V>

values

@Nonnull
public Collection<V> values()

Specified by:

values in interface Map<K,V>

entrySet

@Nonnull
public Set<Map.Entry<K,V>> entrySet()

Makes a shallow copy of the map (i.e. all map entries), but not the key/values (i.e only the mappings are copied).

Specified by:

entrySet in interface Map<K,V>

getOrDefault

public V getOrDefault(Object key,
                      V defaultValue)

Specified by:

getOrDefault in interface Map<K,V>

forEach

public void forEach(BiConsumer<? super K,? super V> action)

Specified by:

forEach in interface Map<K,V>

replaceAll

public void replaceAll(BiFunction<? super K,? super V,? extends V> function)

Specified by:

replaceAll in interface Map<K,V>

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Specified by:

putIfAbsent in interface Map<K,V>

remove

public boolean remove(Object key,
                      Object value)

Specified by:

remove in interface Map<K,V>

replace

public V replace(K key,
                 V value)

Specified by:

replace in interface Map<K,V>

computeIfAbsent

public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)

Specified by:

computeIfAbsent in interface Map<K,V>

computeIfPresent

public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

computeIfPresent in interface Map<K,V>

merge

public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)

Specified by:

merge in interface Map<K,V>

unmapSecondaryIndexes

protected void unmapSecondaryIndexes(K key,
                                     V value)

Unmaps the secondary indexes for a given key value pair.

Parameters:

key - The primary key (index) for the mapping.

value - The value to unmap.

mapSecondaryIndexes

protected void mapSecondaryIndexes(K key,
                                   V value)

Maps the secondary indexes for a given key value pair.

Parameters:

key - the primary key associated with the indexing.

value - the value to map.