[occ] Implement basic multiversion store (#322)

## Describe your changes and provide context
This implements the multiversion with basic functionality, but still
needs additional work to implement the iterator functionality and/or
persisting readsets for validation

## Testing performed to validate your change
Added unit tests for basic multiversion store

store/multiversion/store.go

@@ -0,0 +1,120 @@
+package multiversion
+
+import (
+ "sync"
+)
+
+type MultiVersionStore interface {
+ GetLatest(key []byte) (value MultiVersionValueItem)
+ GetLatestBeforeIndex(index int, key []byte) (value MultiVersionValueItem)
+ Set(index int, incarnation int, key []byte, value []byte)
+ SetEstimate(index int, incarnation int, key []byte)
+ Delete(index int, incarnation int, key []byte)
+ Has(index int, key []byte) bool
+ // TODO: do we want to add helper functions for validations with readsets / applying writesets ?
+}
+
+type Store struct {
+ mtx sync.RWMutex
+ // map that stores the key -> MultiVersionValue mapping for accessing from a given key
+ multiVersionMap map[string]MultiVersionValue
+ // TODO: do we need to add something here to persist readsets for later validation
+ // TODO: we need to support iterators as well similar to how cachekv does it
+ // TODO: do we need secondary indexing on index -> keys - this way if we need to abort we can replace those keys with ESTIMATE values? - maybe this just means storing writeset
+}
+
+func NewMultiVersionStore() *Store {
+ return &Store{
+ multiVersionMap: make(map[string]MultiVersionValue),
+ }
+}
+
+// GetLatest implements MultiVersionStore.
+func (s *Store) GetLatest(key []byte) (value MultiVersionValueItem) {
+ s.mtx.RLock()
+ defer s.mtx.RUnlock()
+
+ keyString := string(key)
+ // if the key doesn't exist in the overall map, return nil
+ if _, ok := s.multiVersionMap[keyString]; !ok {
+ return nil
+ }
+ val, found := s.multiVersionMap[keyString].GetLatest()
+ if !found {
+ return nil // this shouldn't be possible
+ }
+ return val
+}
+
+// GetLatestBeforeIndex implements MultiVersionStore.
+func (s *Store) GetLatestBeforeIndex(index int, key []byte) (value MultiVersionValueItem) {
+ s.mtx.RLock()
+ defer s.mtx.RUnlock()
+
+ keyString := string(key)
+ // if the key doesn't exist in the overall map, return nil
+ if _, ok := s.multiVersionMap[keyString]; !ok {
+ return nil
+ }
+ val, found := s.multiVersionMap[keyString].GetLatestBeforeIndex(index)
+ // otherwise, we may have found a value for that key, but its not written before the index passed in
+ if !found {
+ return nil
+ }
+ // found a value prior to the passed in index, return that value (could be estimate OR deleted, but it is a definitive value)
+ return val
+}
+
+// Has implements MultiVersionStore. It checks if the key exists in the multiversion store at or before the specified index.
+func (s *Store) Has(index int, key []byte) bool {
+ s.mtx.RLock()
+ defer s.mtx.RUnlock()
+
+ keyString := string(key)
+ if _, ok := s.multiVersionMap[keyString]; !ok {
+ return false // this is okay because the caller of this will THEN need to access the parent store to verify that the key doesnt exist there
+ }
+ _, found := s.multiVersionMap[keyString].GetLatestBeforeIndex(index)
+ return found
+}
+
+// This function will try to intialize the multiversion item if it doesn't exist for a key specified by byte array
+// NOTE: this should be used within an acquired mutex lock
+func (s *Store) tryInitMultiVersionItem(keyString string) {
+ if _, ok := s.multiVersionMap[keyString]; !ok {
+ multiVersionValue := NewMultiVersionItem()
+ s.multiVersionMap[keyString] = multiVersionValue
+ }
+}
+
+// Set implements MultiVersionStore.
+func (s *Store) Set(index int, incarnation int, key []byte, value []byte) {
+ s.mtx.Lock()
+ defer s.mtx.Unlock()
+
+ keyString := string(key)
+ s.tryInitMultiVersionItem(keyString)
+ s.multiVersionMap[keyString].Set(index, incarnation, value)
+}
+
+// SetEstimate implements MultiVersionStore.
+func (s *Store) SetEstimate(index int, incarnation int, key []byte) {
+ s.mtx.Lock()
+ defer s.mtx.Unlock()
+
+ keyString := string(key)
+ s.tryInitMultiVersionItem(keyString)
+ s.multiVersionMap[keyString].SetEstimate(index, incarnation)
+}
+
+// Delete implements MultiVersionStore.
+func (s *Store) Delete(index int, incarnation int, key []byte) {
+ s.mtx.Lock()
+ defer s.mtx.Unlock()
+
+ keyString := string(key)
+ s.tryInitMultiVersionItem(keyString)
+ s.multiVersionMap[keyString].Delete(index, incarnation)
+}
+
+var _ MultiVersionStore = (*Store)(nil)

store/multiversion/store_test.go

@@ -0,0 +1,54 @@
+package multiversion_test
+
+import (
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/store/multiversion"
+ "github.com/stretchr/testify/require"
+)
+
+func TestMultiVersionStore(t *testing.T) {
+ store := multiversion.NewMultiVersionStore()
+
+ // Test Set and GetLatest
+ store.Set(1, 1, []byte("key1"), []byte("value1"))
+ store.Set(2, 1, []byte("key1"), []byte("value2"))
+ store.Set(3, 1, []byte("key2"), []byte("value3"))
+ require.Equal(t, []byte("value2"), store.GetLatest([]byte("key1")).Value())
+ require.Equal(t, []byte("value3"), store.GetLatest([]byte("key2")).Value())
+
+ // Test SetEstimate
+ store.SetEstimate(4, 1, []byte("key1"))
+ require.True(t, store.GetLatest([]byte("key1")).IsEstimate())
+
+ // Test Delete
+ store.Delete(5, 1, []byte("key1"))
+ require.True(t, store.GetLatest([]byte("key1")).IsDeleted())
+
+ // Test GetLatestBeforeIndex
+ store.Set(6, 1, []byte("key1"), []byte("value4"))
+ require.True(t, store.GetLatestBeforeIndex(5, []byte("key1")).IsEstimate())
+ require.Equal(t, []byte("value4"), store.GetLatestBeforeIndex(7, []byte("key1")).Value())
+
+ // Test Has
+ require.True(t, store.Has(2, []byte("key1")))
+ require.False(t, store.Has(0, []byte("key1")))
+ require.False(t, store.Has(5, []byte("key4")))
+}
+
+func TestMultiVersionStoreHasLaterValue(t *testing.T) {
+ store := multiversion.NewMultiVersionStore()
+
+ store.Set(5, 1, []byte("key1"), []byte("value2"))
+
+ require.Nil(t, store.GetLatestBeforeIndex(4, []byte("key1")))
+ require.Equal(t, []byte("value2"), store.GetLatestBeforeIndex(6, []byte("key1")).Value())
+}
+
+func TestMultiVersionStoreKeyDNE(t *testing.T) {
+ store := multiversion.NewMultiVersionStore()
+
+ require.Nil(t, store.GetLatest([]byte("key1")))
+ require.Nil(t, store.GetLatestBeforeIndex(0, []byte("key1")))
+ require.False(t, store.Has(0, []byte("key1")))
+}