From e2d76b3078ec36229e2917af299d8db48ab5474a Mon Sep 17 00:00:00 2001 From: Aleksandr Bezobchuk Date: Tue, 9 Jan 2024 10:38:24 -0500 Subject: [PATCH] feat(store/v2): Modify RootStore to Support Multi StoreKeys (#18968) --- store/changeset.go | 26 ++++-- store/commitment/store_test_suite.go | 2 +- store/kv/branch/store.go | 10 ++- store/kv/branch/store_test.go | 2 +- store/kv/mem/store.go | 2 +- store/pruning/manager_test.go | 2 +- store/root/store.go | 103 +++++++++++++----------- store/root/store_test.go | 114 ++++----------------------- store/storage/storage_bench_test.go | 6 +- store/storage/storage_test_suite.go | 32 ++++---- 10 files changed, 121 insertions(+), 178 deletions(-) diff --git a/store/changeset.go b/store/changeset.go index 6982344375..7c5d88a864 100644 --- a/store/changeset.go +++ b/store/changeset.go @@ -11,13 +11,19 @@ type KVPair struct { type KVPairs []KVPair -// Changeset defines a set of KVPair entries by maintaining a map -// from store key to a slice of KVPair objects. +// Changeset defines a set of KVPair entries by maintaining a map from store key +// to a slice of KVPair objects. type Changeset struct { Pairs map[string]KVPairs } -func NewChangeset(pairs map[string]KVPairs) *Changeset { +func NewChangeset() *Changeset { + return &Changeset{ + Pairs: make(map[string]KVPairs), + } +} + +func NewChangesetWithPairs(pairs map[string]KVPairs) *Changeset { return &Changeset{ Pairs: pairs, } @@ -36,8 +42,9 @@ func (cs *Changeset) Size() int { // Add adds a key-value pair to the ChangeSet. func (cs *Changeset) Add(storeKey string, key, value []byte) { cs.Pairs[storeKey] = append(cs.Pairs[storeKey], KVPair{ - Key: key, - Value: value, + Key: key, + Value: value, + StoreKey: storeKey, }) } @@ -45,3 +52,12 @@ func (cs *Changeset) Add(storeKey string, key, value []byte) { func (cs *Changeset) AddKVPair(storeKey string, pair KVPair) { cs.Pairs[storeKey] = append(cs.Pairs[storeKey], pair) } + +// Merge merges the provided Changeset argument into the receiver. This may be +// useful when you have a Changeset that only pertains to a single store key, +// i.e. a map of size one, and you want to merge it into another. +func (cs *Changeset) Merge(other *Changeset) { + for storeKey, pairs := range other.Pairs { + cs.Pairs[storeKey] = append(cs.Pairs[storeKey], pairs...) + } +} diff --git a/store/commitment/store_test_suite.go b/store/commitment/store_test_suite.go index 370958cb3f..6c0a569148 100644 --- a/store/commitment/store_test_suite.go +++ b/store/commitment/store_test_suite.go @@ -43,7 +43,7 @@ func (s *CommitStoreTestSuite) TestSnapshotter() { kvPairs[storeKey] = append(kvPairs[storeKey], store.KVPair{Key: key, Value: value}) } } - s.Require().NoError(commitStore.WriteBatch(store.NewChangeset(kvPairs))) + s.Require().NoError(commitStore.WriteBatch(store.NewChangesetWithPairs(kvPairs))) _, err = commitStore.Commit() s.Require().NoError(err) diff --git a/store/kv/branch/store.go b/store/kv/branch/store.go index 98416a9655..4322d46a04 100644 --- a/store/kv/branch/store.go +++ b/store/kv/branch/store.go @@ -34,7 +34,8 @@ type Store struct { // parent reflects a parent store if branched (it may be nil) parent store.KVStore - // changeset reflects the uncommitted writes to the store + // changeset reflects the uncommitted writes to the store as it contains a mapping + // from key to a KVPair. changeset map[string]store.KVPair } @@ -77,12 +78,13 @@ func (s *Store) GetChangeset() *store.Changeset { for i, key := range keys { kvPair := s.changeset[key] pairs[i] = store.KVPair{ - Key: []byte(key), - Value: slices.Clone(kvPair.Value), + Key: []byte(key), + Value: slices.Clone(kvPair.Value), + StoreKey: s.storeKey, } } - return store.NewChangeset(map[string]store.KVPairs{s.storeKey: pairs}) + return store.NewChangesetWithPairs(map[string]store.KVPairs{s.storeKey: pairs}) } func (s *Store) Reset(toVersion uint64) error { diff --git a/store/kv/branch/store_test.go b/store/kv/branch/store_test.go index 0d3ffffd3e..ada3b8aa0f 100644 --- a/store/kv/branch/store_test.go +++ b/store/kv/branch/store_test.go @@ -30,7 +30,7 @@ func (s *StoreTestSuite) SetupTest() { ss := storage.NewStorageStore(sqliteDB) s.Require().NoError(err) - cs := store.NewChangeset(map[string]store.KVPairs{storeKey: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey: {}}) for i := 0; i < 100; i++ { key := fmt.Sprintf("key%03d", i) // key000, key001, ..., key099 val := fmt.Sprintf("val%03d", i) // val000, val001, ..., val099 diff --git a/store/kv/mem/store.go b/store/kv/mem/store.go index 4e3a1dbb8e..5db8b90a5b 100644 --- a/store/kv/mem/store.go +++ b/store/kv/mem/store.go @@ -85,7 +85,7 @@ func (s *Store) GetChangeset() *store.Changeset { }) } - return store.NewChangeset(map[string]store.KVPairs{s.storeKey: kvPairs}) + return store.NewChangesetWithPairs(map[string]store.KVPairs{s.storeKey: kvPairs}) } func (s *Store) Reset(_ uint64) error { diff --git a/store/pruning/manager_test.go b/store/pruning/manager_test.go index 65e7fe1b09..b3b4ce9b83 100644 --- a/store/pruning/manager_test.go +++ b/store/pruning/manager_test.go @@ -64,7 +64,7 @@ func (s *PruningTestSuite) TestPruning() { for i := uint64(0); i < latestVersion; i++ { version := i + 1 - cs := store.NewChangeset(map[string]store.KVPairs{defaultStoreKey: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{defaultStoreKey: {}}) cs.AddKVPair(defaultStoreKey, store.KVPair{ Key: []byte("key"), Value: []byte(fmt.Sprintf("value%d", version)), diff --git a/store/root/store.go b/store/root/store.go index 4904184f23..386fd0e1bd 100644 --- a/store/root/store.go +++ b/store/root/store.go @@ -18,11 +18,6 @@ import ( "cosmossdk.io/store/v2/pruning" ) -// defaultStoreKey defines the default store key used for the single SC backend. -// Note, however, this store key is essentially irrelevant as it's not exposed -// to the user and it only needed to fulfill usage of StoreInfo during Commit. -const defaultStoreKey = "default" - var _ store.RootStore = (*Store)(nil) // Store defines the SDK's default RootStore implementation. It contains a single @@ -39,9 +34,10 @@ type Store struct { // stateCommitment reflects the state commitment (SC) backend stateCommitment store.Committer - // rootKVStore reflects the root BranchedKVStore that is used to accumulate writes + // kvStores reflects a mapping of store keys, typically dedicated to modules, + // to a dedicated BranchedKVStore. Each store is used to accumulate writes // and branch off of. - rootKVStore store.BranchedKVStore + kvStores map[string]store.BranchedKVStore // commitHeader reflects the header used when committing state (note, this isn't required and only used for query purposes) commitHeader *coreheader.Info @@ -69,12 +65,18 @@ func New( logger log.Logger, ss store.VersionedDatabase, sc store.Committer, + storeKeys []string, ssOpts, scOpts pruning.Options, m metrics.StoreMetrics, ) (store.RootStore, error) { - rootKVStore, err := branch.New(defaultStoreKey, ss) - if err != nil { - return nil, err + kvStores := make(map[string]store.BranchedKVStore, len(storeKeys)) + for _, storeKey := range storeKeys { + bkv, err := branch.New(storeKey, ss) + if err != nil { + return nil, err + } + + kvStores[storeKey] = bkv } pruningManager := pruning.NewManager(logger, ss, sc) @@ -87,7 +89,7 @@ func New( initialVersion: 1, stateStore: ss, stateCommitment: sc, - rootKVStore: rootKVStore, + kvStores: kvStores, pruningManager: pruningManager, telemetry: m, }, nil @@ -196,24 +198,28 @@ func (s *Store) Query(storeKey string, version uint64, key []byte, prove bool) ( return result, nil } -// GetKVStore returns the store's root KVStore. Any writes to this store without -// branching will be committed to SC and SS upon Commit(). Branching will create +// GetKVStore returns a KVStore for the given store key. Any writes to this store +// without branching will be committed to SC and SS upon Commit(). Branching will create // a branched KVStore that allow writes to be discarded and propagated to the // root KVStore using Write(). -func (s *Store) GetKVStore(_ string) store.KVStore { - if s.TracingEnabled() { - return trace.New(s.rootKVStore, s.traceWriter, s.traceContext) +func (s *Store) GetKVStore(storeKey string) store.KVStore { + bkv, ok := s.kvStores[storeKey] + if !ok { + panic(fmt.Sprintf("unknown store key: %s", storeKey)) } - return s.rootKVStore + if s.TracingEnabled() { + return trace.New(bkv, s.traceWriter, s.traceContext) + } + + return bkv } -func (s *Store) GetBranchedKVStore(_ string) store.BranchedKVStore { - if s.TracingEnabled() { - return trace.New(s.rootKVStore, s.traceWriter, s.traceContext) - } - - return s.rootKVStore +func (s *Store) GetBranchedKVStore(storeKey string) store.BranchedKVStore { + // Branching will soon be removed. + // + // Ref: https://github.com/cosmos/cosmos-sdk/issues/18981 + panic("TODO: WILL BE REMOVED!") } func (s *Store) LoadLatestVersion() error { @@ -242,10 +248,12 @@ func (s *Store) LoadVersion(version uint64) error { func (s *Store) loadVersion(v uint64) error { s.logger.Debug("loading version", "version", v) - // Reset the root KVStore s.t. the latest version is v. Any writes will - // overwrite existing versions. - if err := s.rootKVStore.Reset(v); err != nil { - return err + // Reset each KVStore s.t. the latest version is v. Any writes will overwrite + // existing versions. + for storeKey, kvStore := range s.kvStores { + if err := kvStore.Reset(v); err != nil { + return fmt.Errorf("failed to reset %s KVStore: %w", storeKey, err) + } } if err := s.stateCommitment.LoadVersion(v); err != nil { @@ -277,22 +285,11 @@ func (s *Store) SetCommitHeader(h *coreheader.Info) { s.commitHeader = h } -// Branch a copy of the Store with a branched underlying root KVStore. Any call -// to GetKVStore and GetBranchedKVStore returns the branched KVStore. func (s *Store) Branch() store.BranchedRootStore { - branch := s.rootKVStore.Branch() - - return &Store{ - logger: s.logger, - initialVersion: s.initialVersion, - stateStore: s.stateStore, - stateCommitment: s.stateCommitment, - rootKVStore: branch, - commitHeader: s.commitHeader, - lastCommitInfo: s.lastCommitInfo, - traceWriter: s.traceWriter, - traceContext: s.traceContext, - } + // Branching will soon be removed. + // + // Ref: https://github.com/cosmos/cosmos-sdk/issues/18981 + panic("TODO: WILL BE REMOVED!") } // WorkingHash returns the working hash of the root store. Note, WorkingHash() @@ -320,7 +317,9 @@ func (s *Store) WorkingHash() ([]byte, error) { } func (s *Store) Write() { - s.rootKVStore.Write() + for _, kvStore := range s.kvStores { + kvStore.Write() + } } // Commit commits all state changes to the underlying SS and SC backends. Note, @@ -347,7 +346,10 @@ func (s *Store) Commit() ([]byte, error) { s.logger.Debug("commit header and version mismatch", "header_height", s.commitHeader.Height, "version", version) } - changeset := s.rootKVStore.GetChangeset() + changeset := store.NewChangeset() + for _, kvStore := range s.kvStores { + changeset.Merge(kvStore.GetChangeset()) + } // commit SS if err := s.stateStore.ApplyChangeset(version, changeset); err != nil { @@ -363,8 +365,10 @@ func (s *Store) Commit() ([]byte, error) { s.lastCommitInfo.Timestamp = s.commitHeader.Time } - if err := s.rootKVStore.Reset(version); err != nil { - return nil, fmt.Errorf("failed to reset root KVStore: %w", err) + for storeKey, kvStore := range s.kvStores { + if err := kvStore.Reset(version); err != nil { + return nil, fmt.Errorf("failed to reset %s KVStore: %w", storeKey, err) + } } s.workingHash = nil @@ -380,9 +384,12 @@ func (s *Store) Commit() ([]byte, error) { // of the SC tree. Finally, we construct a *CommitInfo and return the hash. // Note, this should only be called once per block! func (s *Store) writeSC() error { - changeSet := s.rootKVStore.GetChangeset() + changeset := store.NewChangeset() + for _, kvStore := range s.kvStores { + changeset.Merge(kvStore.GetChangeset()) + } - if err := s.stateCommitment.WriteBatch(changeSet); err != nil { + if err := s.stateCommitment.WriteBatch(changeset); err != nil { return fmt.Errorf("failed to write batch to SC store: %w", err) } diff --git a/store/root/store_test.go b/store/root/store_test.go index 9bb17dca03..9d5d697718 100644 --- a/store/root/store_test.go +++ b/store/root/store_test.go @@ -17,6 +17,10 @@ import ( "cosmossdk.io/store/v2/storage/sqlite" ) +const ( + testStoreKey = "test" +) + type RootStoreTestSuite struct { suite.Suite @@ -35,10 +39,10 @@ func (s *RootStoreTestSuite) SetupTest() { ss := storage.NewStorageStore(sqliteDB) tree := iavl.NewIavlTree(dbm.NewMemDB(), noopLog, iavl.DefaultConfig()) - sc, err := commitment.NewCommitStore(map[string]commitment.Tree{defaultStoreKey: tree}, noopLog) + sc, err := commitment.NewCommitStore(map[string]commitment.Tree{testStoreKey: tree}, noopLog) s.Require().NoError(err) - rs, err := New(noopLog, ss, sc, pruning.DefaultOptions(), pruning.DefaultOptions(), nil) + rs, err := New(noopLog, ss, sc, []string{testStoreKey}, pruning.DefaultOptions(), pruning.DefaultOptions(), nil) s.Require().NoError(err) rs.SetTracer(io.Discard) @@ -59,22 +63,16 @@ func (s *RootStoreTestSuite) TestGetSCStore() { } func (s *RootStoreTestSuite) TestGetKVStore() { - kvs := s.rootStore.GetKVStore("") + kvs := s.rootStore.GetKVStore(testStoreKey) s.Require().NotNil(kvs) } -func (s *RootStoreTestSuite) TestGetBranchedKVStore() { - bs := s.rootStore.GetBranchedKVStore("") - s.Require().NotNil(bs) - s.Require().Empty(bs.GetChangeset().Size()) -} - func (s *RootStoreTestSuite) TestQuery() { _, err := s.rootStore.Query("", 1, []byte("foo"), true) s.Require().Error(err) // write and commit a changeset - bs := s.rootStore.GetBranchedKVStore("") + bs := s.rootStore.GetKVStore(testStoreKey) bs.Set([]byte("foo"), []byte("bar")) workingHash, err := s.rootStore.WorkingHash() @@ -87,51 +85,17 @@ func (s *RootStoreTestSuite) TestQuery() { s.Require().Equal(workingHash, commitHash) // ensure the proof is non-nil for the corresponding version - result, err := s.rootStore.Query(defaultStoreKey, 1, []byte("foo"), true) + result, err := s.rootStore.Query(testStoreKey, 1, []byte("foo"), true) s.Require().NoError(err) s.Require().NotNil(result.Proof.Proof) s.Require().Equal([]byte("foo"), result.Proof.Proof.GetExist().Key) s.Require().Equal([]byte("bar"), result.Proof.Proof.GetExist().Value) } -func (s *RootStoreTestSuite) TestBranch() { - // write and commit a changeset - bs := s.rootStore.GetKVStore("") - bs.Set([]byte("foo"), []byte("bar")) - - workingHash, err := s.rootStore.WorkingHash() - s.Require().NoError(err) - s.Require().NotNil(workingHash) - - commitHash, err := s.rootStore.Commit() - s.Require().NoError(err) - s.Require().NotNil(commitHash) - s.Require().Equal(workingHash, commitHash) - - // branch the root store - rs2 := s.rootStore.Branch() - - // ensure we can perform reads which pass through to the original root store - bs2 := rs2.GetKVStore("") - s.Require().Equal([]byte("bar"), bs2.Get([]byte("foo"))) - - // make a change to the branched root store - bs2.Set([]byte("foo"), []byte("updated_bar")) - - // ensure the original root store is not modified - s.Require().Equal([]byte("bar"), bs.Get([]byte("foo"))) - - // write changes - rs2.Write() - - // ensure changes are reflected in the original root store - s.Require().Equal([]byte("updated_bar"), bs.Get([]byte("foo"))) -} - func (s *RootStoreTestSuite) TestLoadVersion() { // write and commit a few changesets for v := 1; v <= 5; v++ { - bs := s.rootStore.GetBranchedKVStore("") + bs := s.rootStore.GetKVStore(testStoreKey) val := fmt.Sprintf("val%03d", v) // val001, val002, ..., val005 bs.Set([]byte("key"), []byte(val)) @@ -164,13 +128,13 @@ func (s *RootStoreTestSuite) TestLoadVersion() { s.Require().Equal(uint64(3), latest) // query state and ensure values returned are based on the loaded version - kvStore := s.rootStore.GetKVStore("") + kvStore := s.rootStore.GetKVStore(testStoreKey) val := kvStore.Get([]byte("key")) s.Require().Equal([]byte("val003"), val) // attempt to write and commit a few changesets for v := 4; v <= 5; v++ { - bs := s.rootStore.GetBranchedKVStore("") + bs := s.rootStore.GetKVStore(testStoreKey) val := fmt.Sprintf("overwritten_val%03d", v) // overwritten_val004, overwritten_val005 bs.Set([]byte("key"), []byte(val)) @@ -190,61 +154,18 @@ func (s *RootStoreTestSuite) TestLoadVersion() { s.Require().Equal(uint64(5), latest) // query state and ensure values returned are based on the loaded version - kvStore = s.rootStore.GetKVStore("") + kvStore = s.rootStore.GetKVStore(testStoreKey) val = kvStore.Get([]byte("key")) s.Require().Equal([]byte("overwritten_val005"), val) } -func (s *RootStoreTestSuite) TestMultiBranch() { - // write and commit a changeset - bs := s.rootStore.GetKVStore("") - bs.Set([]byte("foo"), []byte("bar")) - - workingHash, err := s.rootStore.WorkingHash() - s.Require().NoError(err) - s.Require().NotNil(workingHash) - - commitHash, err := s.rootStore.Commit() - s.Require().NoError(err) - s.Require().NotNil(commitHash) - s.Require().Equal(workingHash, commitHash) - - // create multiple branches of the root store - var branchedRootStores []store.BranchedRootStore - for i := 0; i < 5; i++ { - branchedRootStores = append(branchedRootStores, s.rootStore.Branch()) - } - - // get the last branched root store - rs2 := branchedRootStores[4] - - // ensure we can perform reads which pass through to the original root store - bs2 := rs2.GetKVStore("") - s.Require().Equal([]byte("bar"), bs2.Get([]byte("foo"))) - - // make a change to the branched root store - bs2.Set([]byte("foo"), []byte("updated_bar")) - - // ensure the original root store is not modified - s.Require().Equal([]byte("bar"), bs.Get([]byte("foo"))) - - // write changes - rs2.Write() - - // ensure changes are reflected in the original root store - s.Require().Equal([]byte("updated_bar"), bs.Get([]byte("foo"))) -} - func (s *RootStoreTestSuite) TestCommit() { lv, err := s.rootStore.GetLatestVersion() s.Require().NoError(err) s.Require().Zero(lv) - // branch the root store - rs2 := s.rootStore.Branch() - // perform changes - bs2 := rs2.GetKVStore("") + bs2 := s.rootStore.GetKVStore(testStoreKey) for i := 0; i < 100; i++ { key := fmt.Sprintf("key%03d", i) // key000, key001, ..., key099 val := fmt.Sprintf("val%03d", i) // val000, val001, ..., val099 @@ -252,9 +173,6 @@ func (s *RootStoreTestSuite) TestCommit() { bs2.Set([]byte(key), []byte(val)) } - // write to the branched root store, which will flush to the parent root store - rs2.Write() - // committing w/o calling WorkingHash should error _, err = s.rootStore.Commit() s.Require().Error(err) @@ -273,10 +191,10 @@ func (s *RootStoreTestSuite) TestCommit() { s.Require().Equal(uint64(1), lv) // ensure the root KVStore is cleared - s.Require().Empty(s.rootStore.(*Store).rootKVStore.GetChangeset().Size()) + s.Require().Empty(s.rootStore.(*Store).kvStores[testStoreKey].GetChangeset().Size()) // perform reads on the updated root store - bs := s.rootStore.GetKVStore("") + bs := s.rootStore.GetKVStore(testStoreKey) for i := 0; i < 100; i++ { key := fmt.Sprintf("key%03d", i) // key000, key001, ..., key099 val := fmt.Sprintf("val%03d", i) // val000, val001, ..., val099 diff --git a/store/storage/storage_bench_test.go b/store/storage/storage_bench_test.go index 5639d5d4e8..62ea1d6164 100644 --- a/store/storage/storage_bench_test.go +++ b/store/storage/storage_bench_test.go @@ -65,7 +65,7 @@ func BenchmarkGet(b *testing.B) { _ = db.Close() }() - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < numKeyVals; i++ { cs.AddKVPair(storeKey1, store.KVPair{Key: keys[i], Value: vals[i]}) } @@ -101,7 +101,7 @@ func BenchmarkApplyChangeset(b *testing.B) { for i := 0; i < b.N; i++ { b.StopTimer() - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for j := 0; j < 1000; j++ { key := make([]byte, 128) val := make([]byte, 128) @@ -148,7 +148,7 @@ func BenchmarkIterate(b *testing.B) { b.StopTimer() - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < numKeyVals; i++ { cs.AddKVPair(storeKey1, store.KVPair{Key: keys[i], Value: vals[i]}) } diff --git a/store/storage/storage_test_suite.go b/store/storage/storage_test_suite.go index 7c7ea03e0c..303d77bd13 100644 --- a/store/storage/storage_test_suite.go +++ b/store/storage/storage_test_suite.go @@ -56,7 +56,7 @@ func (s *StorageTestSuite) TestDatabase_VersionedKeys() { defer db.Close() for i := uint64(1); i <= 100; i++ { - s.Require().NoError(db.ApplyChangeset(i, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(i, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: {{Key: []byte("key"), Value: []byte(fmt.Sprintf("value%03d", i))}}, }, @@ -76,7 +76,7 @@ func (s *StorageTestSuite) TestDatabase_GetVersionedKey() { defer db.Close() // store a key at version 1 - s.Require().NoError(db.ApplyChangeset(1, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(1, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: {{Key: []byte("key"), Value: []byte("value001")}}, }, @@ -92,7 +92,7 @@ func (s *StorageTestSuite) TestDatabase_GetVersionedKey() { s.Require().True(ok) // chain progresses to version 11 with an update to key - s.Require().NoError(db.ApplyChangeset(11, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(11, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: {{Key: []byte("key"), Value: []byte("value011")}}, }, @@ -117,7 +117,7 @@ func (s *StorageTestSuite) TestDatabase_GetVersionedKey() { } // chain progresses to version 15 with a delete to key - s.Require().NoError(db.ApplyChangeset(15, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(15, store.NewChangesetWithPairs( map[string]store.KVPairs{storeKey1: {{Key: []byte("key")}}}, ))) @@ -149,7 +149,7 @@ func (s *StorageTestSuite) TestDatabase_ApplyChangeset() { s.Require().NoError(err) defer db.Close() - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 100; i++ { cs.AddKVPair(storeKey1, store.KVPair{Key: []byte(fmt.Sprintf("key%03d", i)), Value: []byte("value")}) } @@ -236,7 +236,7 @@ func (s *StorageTestSuite) TestDatabase_Iterator() { s.Require().NoError(err) defer db.Close() - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 100; i++ { key := fmt.Sprintf("key%03d", i) // key000, key001, ..., key099 val := fmt.Sprintf("val%03d", i) // val000, val001, ..., val099 @@ -301,7 +301,7 @@ func (s *StorageTestSuite) TestDatabase_Iterator_RangedDeletes() { s.Require().NoError(err) defer db.Close() - s.Require().NoError(db.ApplyChangeset(1, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(1, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: { {Key: []byte("key001"), Value: []byte("value001")}, @@ -310,13 +310,13 @@ func (s *StorageTestSuite) TestDatabase_Iterator_RangedDeletes() { }, ))) - s.Require().NoError(db.ApplyChangeset(5, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(5, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: {{Key: []byte("key002"), Value: []byte("value002")}}, }, ))) - s.Require().NoError(db.ApplyChangeset(10, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(10, store.NewChangesetWithPairs( map[string]store.KVPairs{ storeKey1: {{Key: []byte("key002")}}, }, @@ -344,7 +344,7 @@ func (s *StorageTestSuite) TestDatabase_IteratorMultiVersion() { // for versions 1-49, set all 10 keys for v := uint64(1); v < 50; v++ { - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 10; i++ { key := fmt.Sprintf("key%03d", i) val := fmt.Sprintf("val%03d-%03d", i, v) @@ -357,7 +357,7 @@ func (s *StorageTestSuite) TestDatabase_IteratorMultiVersion() { // for versions 50-100, only update even keys for v := uint64(50); v <= 100; v++ { - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 10; i++ { if i%2 == 0 { key := fmt.Sprintf("key%03d", i) @@ -402,7 +402,7 @@ func (s *StorageTestSuite) TestDatabase_IteratorNoDomain() { // for versions 1-50, set all 10 keys for v := uint64(1); v <= 50; v++ { - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 10; i++ { key := fmt.Sprintf("key%03d", i) val := fmt.Sprintf("val%03d-%03d", i, v) @@ -442,7 +442,7 @@ func (s *StorageTestSuite) TestDatabase_Prune() { // for versions 1-50, set 10 keys for v := uint64(1); v <= 50; v++ { - cs := store.NewChangeset(map[string]store.KVPairs{storeKey1: {}}) + cs := store.NewChangesetWithPairs(map[string]store.KVPairs{storeKey1: {}}) for i := 0; i < 10; i++ { key := fmt.Sprintf("key%03d", i) val := fmt.Sprintf("val%03d-%03d", i, v) @@ -508,13 +508,13 @@ func (s *StorageTestSuite) TestDatabase_Prune_KeepRecent() { key := []byte("key") // write a key at three different versions - s.Require().NoError(db.ApplyChangeset(1, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(1, store.NewChangesetWithPairs( map[string]store.KVPairs{storeKey1: {{Key: key, Value: []byte("val001")}}}, ))) - s.Require().NoError(db.ApplyChangeset(100, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(100, store.NewChangesetWithPairs( map[string]store.KVPairs{storeKey1: {{Key: key, Value: []byte("val100")}}}, ))) - s.Require().NoError(db.ApplyChangeset(200, store.NewChangeset( + s.Require().NoError(db.ApplyChangeset(200, store.NewChangesetWithPairs( map[string]store.KVPairs{storeKey1: {{Key: key, Value: []byte("val200")}}}, )))