refactor StartEndPrefixToLowerUpperBound

Author: zhangchiqing

storage/operation/badgerimpl/iterator.go

@@ -9,9 +9,10 @@ import (
 )
 
 type badgerIterator struct {
-	iter       *badger.Iterator
-	lowerBound []byte
-	upperBound []byte
+	iter          *badger.Iterator
+	lowerBound    []byte
+	upperBound    []byte
+	hasUpperBound bool // whether there's an upper bound
 }
 
 var _ storage.Iterator = (*badgerIterator)(nil)
@@ -25,12 +26,13 @@ func newBadgerIterator(db *badger.DB, startPrefix, endPrefix []byte, ops storage
 	tx := db.NewTransaction(false)
 	iter := tx.NewIterator(options)
 
-	lowerBound, upperBound := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
+	lowerBound, upperBound, hasUpperBound := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
 
 	return &badgerIterator{
-		iter:       iter,
-		lowerBound: lowerBound,
-		upperBound: upperBound,
+		iter:          iter,
+		lowerBound:    lowerBound,
+		upperBound:    upperBound,
+		hasUpperBound: hasUpperBound,
 	}
 }
 
@@ -54,7 +56,7 @@ func (i *badgerIterator) Valid() bool {
 	}
 
 	// if upper bound is nil, then there's no upper bound, so it's always valid
-	if i.upperBound == nil {
+	if !i.hasUpperBound {
 		return true
 	}
 

storage/operation/pebbleimpl/iterator.go

@@ -15,13 +15,18 @@ type pebbleIterator struct {
 var _ storage.Iterator = (*pebbleIterator)(nil)
 
 func newPebbleIterator(reader pebble.Reader, startPrefix, endPrefix []byte, ops storage.IteratorOption) (*pebbleIterator, error) {
-	lowerBound, upperBound := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
+	lowerBound, upperBound, hasUpperBound := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
 
 	options := pebble.IterOptions{
 		LowerBound: lowerBound,
 		UpperBound: upperBound,
 	}
 
+	// setting UpperBound to nil if there is no upper bound
+	if !hasUpperBound {
+		options.UpperBound = nil
+	}
+
 	iter, err := reader.NewIter(&options)
 	if err != nil {
 		return nil, fmt.Errorf("can not create iterator: %w", err)

storage/operation/pebbleimpl/writer.go

@@ -106,8 +106,8 @@ func (b *ReaderBatchWriter) Delete(key []byte) error {
 func (b *ReaderBatchWriter) DeleteByRange(globalReader storage.Reader, startPrefix, endPrefix []byte) error {
 	// DeleteRange takes the prefix range with start (inclusive) and end (exclusive, note: not inclusive).
 	// therefore, we need to increment the endPrefix to make it inclusive.
-	start, end := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
-	if len(end) > 0 {
+	start, end, hasUpperBound := storage.StartEndPrefixToLowerUpperBound(startPrefix, endPrefix)
+	if hasUpperBound {
 		return b.batch.DeleteRange(start, end, pebble.Sync)
 	}
 

storage/operations.go

@@ -135,19 +135,29 @@ func OnCommitSucceed(b ReaderBatchWriter, onSuccessFn func()) {
 // the lower and upper bounds are used for the key iteration.
 // The return value lowerBound specifies the smallest key to iterate and it's inclusive.
 // The return value upperBound specifies the largest key to iterate and it's exclusive (not inclusive)
+// The return value hasUpperBound specifies whether there is upperBound
 // in order to match all keys prefixed with `endPrefix`, we increment the bytes of `endPrefix` by 1,
 // for instance, to iterate keys between "hello" and "world",
 // we use "hello" as LowerBound, "worle" as UpperBound, so that "world", "world1", "worldffff...ffff"
 // will all be included.
-func StartEndPrefixToLowerUpperBound(startPrefix, endPrefix []byte) (lowerBound, upperBound []byte) {
-	return startPrefix, PrefixUpperBound(endPrefix)
+func StartEndPrefixToLowerUpperBound(startPrefix, endPrefix []byte) (lowerBound, upperBound []byte, hasUpperBound bool) {
+	// if the endPrefix is all 1s, such as []byte{0xff, 0xff, ...}, there is no upper-bound
+	// so we return the startPrefix as the lower-bound, and nil as the upper-bound, and false for hasUpperBound
+	upperBound = PrefixUpperBound(endPrefix)
+	if upperBound == nil {
+		return startPrefix, nil, false
+	}
+
+	return startPrefix, upperBound, true
 }
 
 // PrefixUpperBound returns a key K such that all possible keys beginning with the input prefix
 // sort lower than K according to the byte-wise lexicographic key ordering.
 // This is used to define an upper bound for iteration, when we want to iterate over
 // all keys beginning with a given prefix.
 // referred to https://pkg.go.dev/github.com/cockroachdb/pebble#example-Iterator-PrefixIteration
+// when the prefix is all 1s, such as []byte{0xff}, or []byte(0xff, 0xff} etc, there is no upper-bound
+// It returns nil in this case.
 func PrefixUpperBound(prefix []byte) []byte {
 	end := make([]byte, len(prefix))
 	copy(end, prefix)