Upgrade versions of vendored libs

vendor/github.com/cockroachdb/pebble/internal/arenaskl/flush_iterator.go

@@ -34,17 +34,21 @@ func (it *flushIterator) String() string {
 	return "memtable"
 }
 
-func (it *flushIterator) SeekGE(key []byte, flags base.SeekGEFlags) (*base.InternalKey, []byte) {
+func (it *flushIterator) SeekGE(
+	key []byte, flags base.SeekGEFlags,
+) (*base.InternalKey, base.LazyValue) {
 	panic("pebble: SeekGE unimplemented")
 }
 
 func (it *flushIterator) SeekPrefixGE(
 	prefix, key []byte, flags base.SeekGEFlags,
-) (*base.InternalKey, []byte) {
+) (*base.InternalKey, base.LazyValue) {
 	panic("pebble: SeekPrefixGE unimplemented")
 }
 
-func (it *flushIterator) SeekLT(key []byte, flags base.SeekLTFlags) (*base.InternalKey, []byte) {
+func (it *flushIterator) SeekLT(
+	key []byte, flags base.SeekLTFlags,
+) (*base.InternalKey, base.LazyValue) {
 	panic("pebble: SeekLT unimplemented")
 }
 
@@ -52,10 +56,10 @@ func (it *flushIterator) SeekLT(key []byte, flags base.SeekLTFlags) (*base.Inter
 // if the iterator is pointing at a valid entry, and (nil, nil) otherwise. Note
 // that First only checks the upper bound. It is up to the caller to ensure
 // that key is greater than or equal to the lower bound.
-func (it *flushIterator) First() (*base.InternalKey, []byte) {
+func (it *flushIterator) First() (*base.InternalKey, base.LazyValue) {
 	key, val := it.Iterator.First()
 	if key == nil {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	*it.bytesIterated += uint64(it.nd.allocSize)
 	return key, val
@@ -65,16 +69,16 @@ func (it *flushIterator) First() (*base.InternalKey, []byte) {
 // iterator is pointing at a valid entry, and (nil, nil) otherwise.
 // Note: flushIterator.Next mirrors the implementation of Iterator.Next
 // due to performance. Keep the two in sync.
-func (it *flushIterator) Next() (*base.InternalKey, []byte) {
+func (it *flushIterator) Next() (*base.InternalKey, base.LazyValue) {
 	it.nd = it.list.getNext(it.nd, 0)
 	if it.nd == it.list.tail {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	*it.bytesIterated += uint64(it.nd.allocSize)
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
-func (it *flushIterator) Prev() (*base.InternalKey, []byte) {
+func (it *flushIterator) Prev() (*base.InternalKey, base.LazyValue) {
 	panic("pebble: Prev unimplemented")
 }

vendor/github.com/cockroachdb/pebble/internal/arenaskl/iterator.go

@@ -78,11 +78,11 @@ func (it *Iterator) Error() error {
 // pointing at a valid entry, and (nil, nil) otherwise. Note that SeekGE only
 // checks the upper bound. It is up to the caller to ensure that key is greater
 // than or equal to the lower bound.
-func (it *Iterator) SeekGE(key []byte, flags base.SeekGEFlags) (*base.InternalKey, []byte) {
+func (it *Iterator) SeekGE(key []byte, flags base.SeekGEFlags) (*base.InternalKey, base.LazyValue) {
 	if flags.TrySeekUsingNext() {
 		if it.nd == it.list.tail {
 			// Iterator is done.
-			return nil, nil
+			return nil, base.LazyValue{}
 		}
 		less := it.list.cmp(it.key.UserKey, key) < 0
 		// Arbitrary constant. By measuring the seek cost as a function of the
@@ -94,24 +94,24 @@ func (it *Iterator) SeekGE(key []byte, flags base.SeekGEFlags) (*base.InternalKe
 			k, _ := it.Next()
 			if k == nil {
 				// Iterator is done.
-				return nil, nil
+				return nil, base.LazyValue{}
 			}
 			less = it.list.cmp(it.key.UserKey, key) < 0
 		}
 		if !less {
-			return &it.key, it.value()
+			return &it.key, base.MakeInPlaceValue(it.value())
 		}
 	}
 	_, it.nd, _ = it.seekForBaseSplice(key)
 	if it.nd == it.list.tail {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.upper != nil && it.list.cmp(it.upper, it.key.UserKey) <= 0 {
 		it.nd = it.list.tail
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // SeekPrefixGE moves the iterator to the first entry whose key is greater than
@@ -120,7 +120,7 @@ func (it *Iterator) SeekGE(key []byte, flags base.SeekGEFlags) (*base.InternalKe
 // internal/base.InternalIterator interface.
 func (it *Iterator) SeekPrefixGE(
 	prefix, key []byte, flags base.SeekGEFlags,
-) (*base.InternalKey, []byte) {
+) (*base.InternalKey, base.LazyValue) {
 	return it.SeekGE(key, flags)
 }
 
@@ -128,85 +128,85 @@ func (it *Iterator) SeekPrefixGE(
 // key. Returns the key and value if the iterator is pointing at a valid entry,
 // and (nil, nil) otherwise. Note that SeekLT only checks the lower bound. It
 // is up to the caller to ensure that key is less than the upper bound.
-func (it *Iterator) SeekLT(key []byte, flags base.SeekLTFlags) (*base.InternalKey, []byte) {
+func (it *Iterator) SeekLT(key []byte, flags base.SeekLTFlags) (*base.InternalKey, base.LazyValue) {
 	// NB: the top-level Iterator has already adjusted key based on
 	// the upper-bound.
 	it.nd, _, _ = it.seekForBaseSplice(key)
 	if it.nd == it.list.head {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.lower != nil && it.list.cmp(it.lower, it.key.UserKey) > 0 {
 		it.nd = it.list.head
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // First seeks position at the first entry in list. Returns the key and value
 // if the iterator is pointing at a valid entry, and (nil, nil) otherwise. Note
 // that First only checks the upper bound. It is up to the caller to ensure
 // that key is greater than or equal to the lower bound (e.g. via a call to SeekGE(lower)).
-func (it *Iterator) First() (*base.InternalKey, []byte) {
+func (it *Iterator) First() (*base.InternalKey, base.LazyValue) {
 	it.nd = it.list.getNext(it.list.head, 0)
 	if it.nd == it.list.tail {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.upper != nil && it.list.cmp(it.upper, it.key.UserKey) <= 0 {
 		it.nd = it.list.tail
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // Last seeks position at the last entry in list. Returns the key and value if
 // the iterator is pointing at a valid entry, and (nil, nil) otherwise. Note
 // that Last only checks the lower bound. It is up to the caller to ensure that
 // key is less than the upper bound (e.g. via a call to SeekLT(upper)).
-func (it *Iterator) Last() (*base.InternalKey, []byte) {
+func (it *Iterator) Last() (*base.InternalKey, base.LazyValue) {
 	it.nd = it.list.getPrev(it.list.tail, 0)
 	if it.nd == it.list.head {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.lower != nil && it.list.cmp(it.lower, it.key.UserKey) > 0 {
 		it.nd = it.list.head
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // Next advances to the next position. Returns the key and value if the
 // iterator is pointing at a valid entry, and (nil, nil) otherwise.
 // Note: flushIterator.Next mirrors the implementation of Iterator.Next
 // due to performance. Keep the two in sync.
-func (it *Iterator) Next() (*base.InternalKey, []byte) {
+func (it *Iterator) Next() (*base.InternalKey, base.LazyValue) {
 	it.nd = it.list.getNext(it.nd, 0)
 	if it.nd == it.list.tail {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.upper != nil && it.list.cmp(it.upper, it.key.UserKey) <= 0 {
 		it.nd = it.list.tail
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // Prev moves to the previous position. Returns the key and value if the
 // iterator is pointing at a valid entry, and (nil, nil) otherwise.
-func (it *Iterator) Prev() (*base.InternalKey, []byte) {
+func (it *Iterator) Prev() (*base.InternalKey, base.LazyValue) {
 	it.nd = it.list.getPrev(it.nd, 0)
 	if it.nd == it.list.head {
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
 	it.decodeKey()
 	if it.lower != nil && it.list.cmp(it.lower, it.key.UserKey) > 0 {
 		it.nd = it.list.head
-		return nil, nil
+		return nil, base.LazyValue{}
 	}
-	return &it.key, it.value()
+	return &it.key, base.MakeInPlaceValue(it.value())
 }
 
 // value returns the value at the current position.