db: remove getIterAlloc from Iterator

A call to DB.Get returns a io.Closer that must be called once the caller is
finished with the returned value. Previously the *pebble.Iterator type provided
the io.Closer implementation, so the *pebble.Iterator required a pointer to the
containing getIterAlloc allocation for recycling. This commit inverts the
relationship, adding a Close method to getIterAlloc, returning the
*getIterAlloc as the io.Closer and allowing the removal of the getIterAlloc
field from the Iterator. This new organization is more straightforward.

Author: jbowens

get.go

@@ -35,6 +35,22 @@ type getIterAlloc struct {
 	get    getIter
 }
 
+// Close closes the contained iterator and recycles the alloc.
+//
+// During a successful call to DB.Get, *getIterAlloc is returned to the caller
+// as the io.Closer.
+func (g *getIterAlloc) Close() error {
+	err := g.dbi.Close()
+	keyBuf := g.keyBuf
+	if cap(g.dbi.keyBuf) < maxKeyBufCacheSize && cap(g.dbi.keyBuf) > cap(keyBuf) {
+		keyBuf = g.dbi.keyBuf
+	}
+	*g = getIterAlloc{}
+	g.keyBuf = keyBuf
+	getIterAllocPool.Put(g)
+	return err
+}
+
 var getIterAllocPool = sync.Pool{
 	New: func() interface{} {
 		return &getIterAlloc{}
@@ -95,31 +111,30 @@ func (d *DB) getInternal(key []byte, b *Batch, s *Snapshot) ([]byte, io.Closer,
 	i := &buf.dbi
 	pointIter := get
 	*i = Iterator{
-		ctx:          context.Background(),
-		getIterAlloc: buf,
-		iter:         pointIter,
-		pointIter:    pointIter,
-		merge:        d.merge,
-		comparer:     *d.opts.Comparer,
-		readState:    readState,
-		keyBuf:       buf.keyBuf,
+		ctx:       context.Background(),
+		iter:      pointIter,
+		pointIter: pointIter,
+		merge:     d.merge,
+		comparer:  *d.opts.Comparer,
+		readState: readState,
+		keyBuf:    buf.keyBuf,
 	}
 	// Set up a blob value fetcher to use for retrieving values from blob files.
 	i.blobValueFetcher.Init(&readState.current.BlobFiles, d.fileCache, block.NoReadEnv)
 	get.iiopts.blobValueFetcher = &i.blobValueFetcher
 
 	if !i.First() {
-		err := i.Close()
+		err := buf.Close()
 		if err != nil {
 			return nil, nil, err
 		}
 		return nil, nil, ErrNotFound
 	}
 	val, err := i.ValueAndErr()
 	if err != nil {
-		return nil, nil, errors.CombineErrors(err, i.Close())
+		return nil, nil, errors.CombineErrors(err, buf.Close())
 	}
-	return val, i, nil
+	return val, buf, nil
 }
 
 // getIter is an internal iterator used to perform gets. It iterates through

iterator.go

@@ -241,7 +241,6 @@ type Iterator struct {
 	// called. In that case, it is explicitly set to nil.
 	iterKV              *base.InternalKV
 	alloc               *iterAlloc
-	getIterAlloc        *getIterAlloc
 	prefixOrFullSeekKey []byte
 	readSampling        readSampling
 	stats               IteratorStats
@@ -2452,17 +2451,10 @@ func (i *Iterator) Close() error {
 		alloc.merging.heap.items = mergingIterHeapItems
 
 		iterAllocPool.Put(alloc)
-	} else if alloc := i.getIterAlloc; alloc != nil {
-		if cap(i.keyBuf) >= maxKeyBufCacheSize {
-			alloc.keyBuf = nil
-		} else {
-			alloc.keyBuf = i.keyBuf
-		}
-		*alloc = getIterAlloc{
-			keyBuf: alloc.keyBuf,
-		}
-		getIterAllocPool.Put(alloc)
 	}
+	// NB: When the Iterator is used as a part of a Get(), Close() is called by
+	// getIterAlloc.Close which handles recycling the appropriate structure and
+	// fields.
 	return err
 }