LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

feat(store/v2): Modify RootStore to Support Multi StoreKeys (#18968)

Browse Source
This commit is contained in:
Aleksandr Bezobchuk 2024-01-09 10:38:24 -05:00 committed by GitHub
parent bde7eb1a4d
commit e2d76b3078
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 121 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
store/changeset.go
View File

@ -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...)
}
}

2
store/commitment/store_test_suite.go
View File

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

10
store/kv/branch/store.go
View File

@ -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 {

2
store/kv/branch/store_test.go
View File

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

2
store/kv/mem/store.go
View File

@ -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 {

2
store/pruning/manager_test.go
View File

@ -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)),

103
store/root/store.go
View File

@ -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)
}

114
store/root/store_test.go
View File

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

6
store/storage/storage_bench_test.go
View File

@ -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]})
}

32
store/storage/storage_test_suite.go
View File

@ -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")}}},
)))