ethdb: remove snapshot (#30189)

core/rawdb/table.go

@@ -200,13 +200,6 @@ func (t *table) NewBatchWithSize(size int) ethdb.Batch {
 	return &tableBatch{t.db.NewBatchWithSize(size), t.prefix}
 }
 
-// NewSnapshot creates a database snapshot based on the current state.
-// The created snapshot will not be affected by all following mutations
-// happened on the database.
-func (t *table) NewSnapshot() (ethdb.Snapshot, error) {
-	return t.db.NewSnapshot()
-}
-
 // tableBatch is a wrapper around a database batch that prefixes each key access
 // with a pre-configured string.
 type tableBatch struct {

ethdb/database.go

@@ -64,7 +64,6 @@ type KeyValueStore interface {
 	Batcher
 	Iteratee
 	Compacter
-	Snapshotter
 	io.Closer
 }
 
@@ -199,6 +198,5 @@ type Database interface {
 	Iteratee
 	Stater
 	Compacter
-	Snapshotter
 	io.Closer
 }

ethdb/dbtest/testsuite.go

@@ -318,69 +318,6 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
 		}
 	})
 
-	t.Run("Snapshot", func(t *testing.T) {
-		db := New()
-		defer db.Close()
-
-		initial := map[string]string{
-			"k1": "v1", "k2": "v2", "k3": "", "k4": "",
-		}
-		for k, v := range initial {
-			db.Put([]byte(k), []byte(v))
-		}
-		snapshot, err := db.NewSnapshot()
-		if err != nil {
-			t.Fatal(err)
-		}
-		for k, v := range initial {
-			got, err := snapshot.Get([]byte(k))
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !bytes.Equal(got, []byte(v)) {
-				t.Fatalf("Unexpected value want: %v, got %v", v, got)
-			}
-		}
-
-		// Flush more modifications into the database, ensure the snapshot
-		// isn't affected.
-		var (
-			update = map[string]string{"k1": "v1-b", "k3": "v3-b"}
-			insert = map[string]string{"k5": "v5-b"}
-			delete = map[string]string{"k2": ""}
-		)
-		for k, v := range update {
-			db.Put([]byte(k), []byte(v))
-		}
-		for k, v := range insert {
-			db.Put([]byte(k), []byte(v))
-		}
-		for k := range delete {
-			db.Delete([]byte(k))
-		}
-		for k, v := range initial {
-			got, err := snapshot.Get([]byte(k))
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !bytes.Equal(got, []byte(v)) {
-				t.Fatalf("Unexpected value want: %v, got %v", v, got)
-			}
-		}
-		for k := range insert {
-			got, err := snapshot.Get([]byte(k))
-			if err == nil || len(got) != 0 {
-				t.Fatal("Unexpected value")
-			}
-		}
-		for k := range delete {
-			got, err := snapshot.Get([]byte(k))
-			if err != nil || len(got) == 0 {
-				t.Fatal("Unexpected deletion")
-			}
-		}
-	})
-
 	t.Run("OperationsAfterClose", func(t *testing.T) {
 		db := New()
 		db.Put([]byte("key"), []byte("value"))

ethdb/leveldb/leveldb.go

@@ -230,19 +230,6 @@ func (db *Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
 	return db.db.NewIterator(bytesPrefixRange(prefix, start), nil)
 }
 
-// NewSnapshot creates a database snapshot based on the current state.
-// The created snapshot will not be affected by all following mutations
-// happened on the database.
-// Note don't forget to release the snapshot once it's used up, otherwise
-// the stale data will never be cleaned up by the underlying compactor.
-func (db *Database) NewSnapshot() (ethdb.Snapshot, error) {
-	snap, err := db.db.GetSnapshot()
-	if err != nil {
-		return nil, err
-	}
-	return &snapshot{db: snap}, nil
-}
-
 // Stat returns the statistic data of the database.
 func (db *Database) Stat() (string, error) {
 	var stats leveldb.DBStats
@@ -498,26 +485,3 @@ func bytesPrefixRange(prefix, start []byte) *util.Range {
 	r.Start = append(r.Start, start...)
 	return r
 }
-
-// snapshot wraps a leveldb snapshot for implementing the Snapshot interface.
-type snapshot struct {
-	db *leveldb.Snapshot
-}
-
-// Has retrieves if a key is present in the snapshot backing by a key-value
-// data store.
-func (snap *snapshot) Has(key []byte) (bool, error) {
-	return snap.db.Has(key, nil)
-}
-
-// Get retrieves the given key if it's present in the snapshot backing by
-// key-value data store.
-func (snap *snapshot) Get(key []byte) ([]byte, error) {
-	return snap.db.Get(key, nil)
-}
-
-// Release releases associated resources. Release should always succeed and can
-// be called multiple times without causing error.
-func (snap *snapshot) Release() {
-	snap.db.Release()
-}

ethdb/memorydb/memorydb.go

@@ -35,10 +35,6 @@ var (
 	// errMemorydbNotFound is returned if a key is requested that is not found in
 	// the provided memory database.
 	errMemorydbNotFound = errors.New("not found")
-
-	// errSnapshotReleased is returned if callers want to retrieve data from a
-	// released snapshot.
-	errSnapshotReleased = errors.New("snapshot released")
 )
 
 // Database is an ephemeral key-value store. Apart from basic data storage
@@ -175,13 +171,6 @@ func (db *Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
 	}
 }
 
-// NewSnapshot creates a database snapshot based on the current state.
-// The created snapshot will not be affected by all following mutations
-// happened on the database.
-func (db *Database) NewSnapshot() (ethdb.Snapshot, error) {
-	return newSnapshot(db), nil
-}
-
 // Stat returns the statistic data of the database.
 func (db *Database) Stat() (string, error) {
 	return "", nil
@@ -332,59 +321,3 @@ func (it *iterator) Value() []byte {
 func (it *iterator) Release() {
 	it.index, it.keys, it.values = -1, nil, nil
 }
-
-// snapshot wraps a batch of key-value entries deep copied from the in-memory
-// database for implementing the Snapshot interface.
-type snapshot struct {
-	db   map[string][]byte
-	lock sync.RWMutex
-}
-
-// newSnapshot initializes the snapshot with the given database instance.
-func newSnapshot(db *Database) *snapshot {
-	db.lock.RLock()
-	defer db.lock.RUnlock()
-
-	copied := make(map[string][]byte, len(db.db))
-	for key, val := range db.db {
-		copied[key] = common.CopyBytes(val)
-	}
-	return &snapshot{db: copied}
-}
-
-// Has retrieves if a key is present in the snapshot backing by a key-value
-// data store.
-func (snap *snapshot) Has(key []byte) (bool, error) {
-	snap.lock.RLock()
-	defer snap.lock.RUnlock()
-
-	if snap.db == nil {
-		return false, errSnapshotReleased
-	}
-	_, ok := snap.db[string(key)]
-	return ok, nil
-}
-
-// Get retrieves the given key if it's present in the snapshot backing by
-// key-value data store.
-func (snap *snapshot) Get(key []byte) ([]byte, error) {
-	snap.lock.RLock()
-	defer snap.lock.RUnlock()
-
-	if snap.db == nil {
-		return nil, errSnapshotReleased
-	}
-	if entry, ok := snap.db[string(key)]; ok {
-		return common.CopyBytes(entry), nil
-	}
-	return nil, errMemorydbNotFound
-}
-
-// Release releases associated resources. Release should always succeed and can
-// be called multiple times without causing error.
-func (snap *snapshot) Release() {
-	snap.lock.Lock()
-	defer snap.lock.Unlock()
-
-	snap.db = nil
-}

ethdb/pebble/pebble.go

@@ -351,55 +351,6 @@ func (d *Database) NewBatchWithSize(size int) ethdb.Batch {
 	}
 }
 
-// snapshot wraps a pebble snapshot for implementing the Snapshot interface.
-type snapshot struct {
-	db *pebble.Snapshot
-}
-
-// NewSnapshot creates a database snapshot based on the current state.
-// The created snapshot will not be affected by all following mutations
-// happened on the database.
-// Note don't forget to release the snapshot once it's used up, otherwise
-// the stale data will never be cleaned up by the underlying compactor.
-func (d *Database) NewSnapshot() (ethdb.Snapshot, error) {
-	snap := d.db.NewSnapshot()
-	return &snapshot{db: snap}, nil
-}
-
-// Has retrieves if a key is present in the snapshot backing by a key-value
-// data store.
-func (snap *snapshot) Has(key []byte) (bool, error) {
-	_, closer, err := snap.db.Get(key)
-	if err != nil {
-		if err != pebble.ErrNotFound {
-			return false, err
-		} else {
-			return false, nil
-		}
-	}
-	closer.Close()
-	return true, nil
-}
-
-// Get retrieves the given key if it's present in the snapshot backing by
-// key-value data store.
-func (snap *snapshot) Get(key []byte) ([]byte, error) {
-	dat, closer, err := snap.db.Get(key)
-	if err != nil {
-		return nil, err
-	}
-	ret := make([]byte, len(dat))
-	copy(ret, dat)
-	closer.Close()
-	return ret, nil
-}
-
-// Release releases associated resources. Release should always succeed and can
-// be called multiple times without causing error.
-func (snap *snapshot) Release() {
-	snap.db.Close()
-}
-
 // upperBound returns the upper bound for the given prefix
 func upperBound(prefix []byte) (limit []byte) {
 	for i := len(prefix) - 1; i >= 0; i-- {

ethdb/remotedb/remotedb.go

@@ -138,10 +138,6 @@ func (db *Database) Compact(start []byte, limit []byte) error {
 	return nil
 }
 
-func (db *Database) NewSnapshot() (ethdb.Snapshot, error) {
-	panic("not supported")
-}
-
 func (db *Database) Close() error {
 	db.remote.Close()
 	return nil

trie/trie_test.go

@@ -819,7 +819,6 @@ func (s *spongeDb) Get(key []byte) ([]byte, error)           { return nil, error
 func (s *spongeDb) Delete(key []byte) error                  { panic("implement me") }
 func (s *spongeDb) NewBatch() ethdb.Batch                    { return &spongeBatch{s} }
 func (s *spongeDb) NewBatchWithSize(size int) ethdb.Batch    { return &spongeBatch{s} }
-func (s *spongeDb) NewSnapshot() (ethdb.Snapshot, error)     { panic("implement me") }
 func (s *spongeDb) Stat() (string, error)                    { panic("implement me") }
 func (s *spongeDb) Compact(start []byte, limit []byte) error { panic("implement me") }
 func (s *spongeDb) Close() error                             { return nil }