Add Err API to DocIDSetIterator and PositionIterator (#100)

index/at_position_doc_id_set_iterator.go

@@ -48,6 +48,7 @@ func (it *AtPositionDocIDSetIterator) Next() bool {
 	}
 	if !it.positionIt.Next() {
 		it.done = true
+		it.err = it.positionIt.Err()
 		return false
 	}
 	nextPos := it.positionIt.Position()

index/at_position_doc_id_set_iterator_test.go

@@ -34,6 +34,7 @@ func TestAtPositionDocIDSetIteratorForwardOnly(t *testing.T) {
 		mockPositionIt.EXPECT().Next().Return(true),
 		mockPositionIt.EXPECT().Position().Return(7),
 		mockPositionIt.EXPECT().Next().Return(false),
+		mockPositionIt.EXPECT().Err().Return(nil),
 	)
 	atPositionIt := NewAtPositionDocIDSetIterator(docIDSetIter, mockPositionIt)
 	defer atPositionIt.Close()
@@ -43,6 +44,7 @@ func TestAtPositionDocIDSetIteratorForwardOnly(t *testing.T) {
 	for atPositionIt.Next() {
 		actual = append(actual, atPositionIt.DocID())
 	}
+	require.NoError(t, atPositionIt.Err())
 	require.Equal(t, expected, actual)
 }
 
@@ -71,6 +73,7 @@ func TestAtPositionDocIDSetIteratorSeekable(t *testing.T) {
 		mockPositionIt.EXPECT().Next().Return(true),
 		mockPositionIt.EXPECT().Position().Return(7),
 		mockPositionIt.EXPECT().Next().Return(false),
+		mockPositionIt.EXPECT().Err().Return(nil),
 	)
 	atPositionIt := NewAtPositionDocIDSetIterator(docIDSetIter, mockPositionIt)
 	defer atPositionIt.Close()

index/bitmap_based_doc_id_position_iterator.go

@@ -10,6 +10,7 @@ type bitmapBasedDocIDPositionIterator struct {
 	currDocID       int32
 	backingPosition int
 	maskingPosition int
+	err             error
 }
 
 // nolint: deadcode
@@ -27,11 +28,12 @@ func newBitmapBasedDocIDPositionIterator(
 }
 
 func (it *bitmapBasedDocIDPositionIterator) Next() bool {
-	if it.done {
+	if it.done || it.err != nil {
 		return false
 	}
 	if !it.maskingIt.Next() {
 		it.done = true
+		it.err = it.maskingIt.Err()
 		return false
 	}
 	it.maskingPosition++
@@ -53,8 +55,11 @@ func (it *bitmapBasedDocIDPositionIterator) Position() int { return it.backingPo
 
 func (it *bitmapBasedDocIDPositionIterator) MaskingPosition() int { return it.maskingPosition }
 
+func (it *bitmapBasedDocIDPositionIterator) Err() error { return it.err }
+
 func (it *bitmapBasedDocIDPositionIterator) Close() {
 	it.bm = nil
 	it.maskingIt.Close()
 	it.maskingIt = nil
+	it.err = nil
 }

index/bitmap_based_doc_id_position_iterator_test.go

@@ -23,6 +23,8 @@ func TestBitmapBasedDocIDPositionIterator(t *testing.T) {
 		maskingIt.EXPECT().Next().Return(true),
 		maskingIt.EXPECT().DocID().Return(int32(12)).MinTimes(1),
 		maskingIt.EXPECT().Next().Return(false).AnyTimes(),
+		maskingIt.EXPECT().Err().Return(nil),
+		maskingIt.EXPECT().Close(),
 	)
 
 	var (
@@ -34,11 +36,14 @@ func TestBitmapBasedDocIDPositionIterator(t *testing.T) {
 		expectedMaskingPositions = []int{0, 2}
 	)
 	it := newBitmapBasedDocIDPositionIterator(bm, maskingIt)
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 		backingPositions = append(backingPositions, it.Position())
 		maskingPositions = append(maskingPositions, it.MaskingPosition())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, expectedDocIDs, docIDs)
 	require.Equal(t, expectedBackingPositions, backingPositions)
 	require.Equal(t, expectedMaskingPositions, maskingPositions)

index/bitmap_based_doc_id_set_iterator.go

@@ -29,6 +29,8 @@ func (it *bitmapBasedDocIDIterator) Next() bool {
 
 func (it *bitmapBasedDocIDIterator) DocID() int32 { return it.curr }
 
+func (it *bitmapBasedDocIDIterator) Err() error { return nil }
+
 func (it *bitmapBasedDocIDIterator) Close() {
 	if it.closed {
 		return

index/doc_id_position_iterator.go

@@ -24,6 +24,7 @@ type docIDPositionIterator struct {
 	maskingDocID    int32
 	backingPosition int
 	maskingPosition int
+	err             error
 }
 
 // NewDocIDPositionIterator creates a new doc ID position iterator.
@@ -45,15 +46,15 @@ func NewDocIDPositionIterator(
 
 // Next returns true if there are more items to be iterated over.
 func (it *docIDPositionIterator) Next() bool {
-	if it.backingDone || it.maskingDone {
+	if it.err != nil || it.backingDone || it.maskingDone {
 		return false
 	}
 	it.advanceBackingIter()
-	if it.backingDone {
+	if it.err != nil || it.backingDone {
 		return false
 	}
 	for {
-		if it.maskingDone {
+		if it.err != nil || it.maskingDone {
 			return false
 		}
 		if it.backingDocID == it.maskingDocID {
@@ -75,10 +76,14 @@ func (it *docIDPositionIterator) Position() int { return it.backingPosition }
 // MaskingPosition returns the current doc ID position in the masking doc ID set.
 func (it *docIDPositionIterator) MaskingPosition() int { return it.maskingPosition }
 
+// Err returns any error encountered during iteration.
+func (it *docIDPositionIterator) Err() error { return it.err }
+
 // Close closes the iterator.
 func (it *docIDPositionIterator) Close() {
 	it.backingIt.Close()
 	it.maskingIt.Close()
+	it.err = nil
 }
 
 func (it *docIDPositionIterator) advanceBackingIter() {
@@ -87,6 +92,7 @@ func (it *docIDPositionIterator) advanceBackingIter() {
 		it.backingPosition++
 	} else {
 		it.backingDone = true
+		it.err = it.backingIt.Err()
 	}
 }
 
@@ -96,5 +102,6 @@ func (it *docIDPositionIterator) advanceMaskingIter() {
 		it.maskingPosition++
 	} else {
 		it.maskingDone = true
+		it.err = it.maskingIt.Err()
 	}
 }

index/doc_id_position_iterator_test.go

@@ -25,6 +25,7 @@ func TestDocIDPositionIteratorNoOverlap(t *testing.T) {
 		backingIt.EXPECT().Next().Return(true),
 		backingIt.EXPECT().DocID().Return(int32(15)).MinTimes(1),
 		backingIt.EXPECT().Next().Return(false).AnyTimes(),
+		backingIt.EXPECT().Close(),
 	)
 
 	maskingIt := NewMockDocIDSetIterator(ctrl)
@@ -36,6 +37,8 @@ func TestDocIDPositionIteratorNoOverlap(t *testing.T) {
 		maskingIt.EXPECT().Next().Return(true),
 		maskingIt.EXPECT().DocID().Return(int32(13)).MinTimes(1),
 		maskingIt.EXPECT().Next().Return(false).AnyTimes(),
+		maskingIt.EXPECT().Err().Return(nil),
+		maskingIt.EXPECT().Close(),
 	)
 
 	var (
@@ -44,11 +47,14 @@ func TestDocIDPositionIteratorNoOverlap(t *testing.T) {
 		maskingPositions []int
 	)
 	it := NewDocIDPositionIterator(backingIt, maskingIt)
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 		backingPositions = append(backingPositions, it.Position())
 		maskingPositions = append(maskingPositions, it.MaskingPosition())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, 0, len(docIDs))
 	require.Equal(t, 0, len(backingPositions))
 	require.Equal(t, 0, len(maskingPositions))
@@ -71,6 +77,8 @@ func TestDocIDPositionIteratorAllOverlap(t *testing.T) {
 		backingIt.EXPECT().Next().Return(true),
 		backingIt.EXPECT().DocID().Return(int32(15)).MinTimes(1),
 		backingIt.EXPECT().Next().Return(false).AnyTimes(),
+		backingIt.EXPECT().Err().Return(nil),
+		backingIt.EXPECT().Close(),
 	)
 
 	maskingIt := NewMockDocIDSetIterator(ctrl)
@@ -86,6 +94,7 @@ func TestDocIDPositionIteratorAllOverlap(t *testing.T) {
 		maskingIt.EXPECT().Next().Return(true),
 		maskingIt.EXPECT().DocID().Return(int32(15)).MinTimes(1),
 		maskingIt.EXPECT().Next().Return(false).AnyTimes(),
+		maskingIt.EXPECT().Close(),
 	)
 
 	var (
@@ -97,11 +106,14 @@ func TestDocIDPositionIteratorAllOverlap(t *testing.T) {
 		expectedMaskingPositions = []int{0, 1, 2, 3, 4}
 	)
 	it := NewDocIDPositionIterator(backingIt, maskingIt)
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 		backingPositions = append(backingPositions, it.Position())
 		maskingPositions = append(maskingPositions, it.MaskingPosition())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, expectedDocIDs, docIDs)
 	require.Equal(t, expectedBackingPositions, backingPositions)
 	require.Equal(t, expectedMaskingPositions, maskingPositions)
@@ -124,6 +136,7 @@ func TestDocIDPositionIteratorPartialOverlap(t *testing.T) {
 		backingIt.EXPECT().Next().Return(true),
 		backingIt.EXPECT().DocID().Return(int32(15)).MinTimes(1),
 		backingIt.EXPECT().Next().Return(false).AnyTimes(),
+		backingIt.EXPECT().Close(),
 	)
 
 	maskingIt := NewMockDocIDSetIterator(ctrl)
@@ -137,6 +150,8 @@ func TestDocIDPositionIteratorPartialOverlap(t *testing.T) {
 		maskingIt.EXPECT().Next().Return(true),
 		maskingIt.EXPECT().DocID().Return(int32(12)).MinTimes(1),
 		maskingIt.EXPECT().Next().Return(false).AnyTimes(),
+		maskingIt.EXPECT().Err().Return(nil),
+		maskingIt.EXPECT().Close(),
 	)
 
 	var (
@@ -148,11 +163,14 @@ func TestDocIDPositionIteratorPartialOverlap(t *testing.T) {
 		expectedMaskingPositions = []int{0, 2}
 	)
 	it := NewDocIDPositionIterator(backingIt, maskingIt)
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 		backingPositions = append(backingPositions, it.Position())
 		maskingPositions = append(maskingPositions, it.MaskingPosition())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, expectedDocIDs, docIDs)
 	require.Equal(t, expectedBackingPositions, backingPositions)
 	require.Equal(t, expectedMaskingPositions, maskingPositions)

index/doc_id_set_iterator.go

@@ -1,7 +1,6 @@
 package index
 
 // DocIDSetIterator is the document ID set iterator.
-// TODO(xichen): Add `Err` API.
 type DocIDSetIterator interface {
 	// Next returns true if there are more document IDs to be iterated over.
 	Next() bool
@@ -12,6 +11,9 @@ type DocIDSetIterator interface {
 	// more specific w.r.t. what value this is referring to.
 	DocID() int32
 
+	// Err returns any error encountered during iteration.
+	Err() error
+
 	// Close closes the iterator.
 	Close()
 }

index/empty_doc_id_set_iterator.go

@@ -14,5 +14,8 @@ func (it EmptyDocIDSetIterator) Next() bool { return false }
 // DocID returns the current doc ID.
 func (it EmptyDocIDSetIterator) DocID() int32 { return invalidDocID }
 
+// Err returns any error encountered during iteration.
+func (it EmptyDocIDSetIterator) Err() error { return nil }
+
 // Close closes the iterator.
 func (it EmptyDocIDSetIterator) Close() {}

index/empty_doc_id_set_iterator_test.go

@@ -9,8 +9,11 @@ import (
 func TestEmptyDocIDSetIterator(t *testing.T) {
 	var docIDs []int32
 	it := NewEmptyDocIDSetIterator()
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, 0, len(docIDs))
 }

index/exclude_doc_id_set_iterator.go

@@ -8,28 +8,34 @@ type ExcludeDocIDSetIterator struct {
 
 	toExcludeDone bool
 	curr          int32
+	err           error
 }
 
 // NewExcludeDocIDSetIterator creates a new iterator.
 func NewExcludeDocIDSetIterator(
 	numTotalDocs int32,
 	toExcludeIt DocIDSetIterator,
 ) *ExcludeDocIDSetIterator {
-	toExcludeDone := false
+	var (
+		toExcludeDone bool
+		err           error
+	)
 	if !toExcludeIt.Next() {
 		toExcludeDone = true
+		err = toExcludeIt.Err()
 	}
 	return &ExcludeDocIDSetIterator{
 		numTotalDocs:  numTotalDocs,
 		toExcludeIt:   toExcludeIt,
 		toExcludeDone: toExcludeDone,
 		curr:          -1,
+		err:           err,
 	}
 }
 
 // Next returns true if there are more doc IDs to be iterated over.
 func (it *ExcludeDocIDSetIterator) Next() bool {
-	if it.curr >= it.numTotalDocs {
+	if it.err != nil || it.curr >= it.numTotalDocs {
 		return false
 	}
 	it.curr++
@@ -43,15 +49,20 @@ func (it *ExcludeDocIDSetIterator) Next() bool {
 	// we advance the exclude iterator.
 	if !it.toExcludeIt.Next() {
 		it.toExcludeDone = true
+		it.err = it.toExcludeIt.Err()
 	}
 	return it.Next()
 }
 
 // DocID returns the current doc ID.
 func (it *ExcludeDocIDSetIterator) DocID() int32 { return it.curr }
 
+// Err returns any error encountered during iteration.
+func (it *ExcludeDocIDSetIterator) Err() error { return it.err }
+
 // Close closes the iterator.
 func (it *ExcludeDocIDSetIterator) Close() {
 	it.toExcludeIt.Close()
 	it.toExcludeIt = nil
+	it.err = nil
 }

index/exclude_doc_id_set_iterator_test.go

@@ -22,12 +22,17 @@ func TestExcludeDocIDSetIterator(t *testing.T) {
 		toExclude.EXPECT().Next().Return(true),
 		toExclude.EXPECT().DocID().Return(int32(10)).MinTimes(1),
 		toExclude.EXPECT().Next().Return(false).AnyTimes(),
+		toExclude.EXPECT().Err().Return(nil),
+		toExclude.EXPECT().Close(),
 	)
 
 	var docIDs []int32
 	it := NewExcludeDocIDSetIterator(11, toExclude)
+	defer it.Close()
+
 	for it.Next() {
 		docIDs = append(docIDs, it.DocID())
 	}
+	require.NoError(t, it.Err())
 	require.Equal(t, []int32{0, 1, 2, 5, 6, 8, 9}, docIDs)
 }

index/field/at_position_bool_field_iterator.gen.go

@@ -56,6 +56,7 @@ func (it *atPositionBoolFieldIterator) Next() bool {
 	}
 	if !it.docIDPosIt.Next() {
 		it.done = true
+		it.err = it.docIDPosIt.Err()
 		return false
 	}
 	nextPos := it.docIDPosIt.Position()

index/field/at_position_double_field_iterator.gen.go

@@ -56,6 +56,7 @@ func (it *atPositionDoubleFieldIterator) Next() bool {
 	}
 	if !it.docIDPosIt.Next() {
 		it.done = true
+		it.err = it.docIDPosIt.Err()
 		return false
 	}
 	nextPos := it.docIDPosIt.Position()

index/field/at_position_int_field_iterator.gen.go

@@ -56,6 +56,7 @@ func (it *atPositionIntFieldIterator) Next() bool {
 	}
 	if !it.docIDPosIt.Next() {
 		it.done = true
+		it.err = it.docIDPosIt.Err()
 		return false
 	}
 	nextPos := it.docIDPosIt.Position()

index/field/at_position_string_field_iterator.gen.go

@@ -56,6 +56,7 @@ func (it *atPositionStringFieldIterator) Next() bool {
 	}
 	if !it.docIDPosIt.Next() {
 		it.done = true
+		it.err = it.docIDPosIt.Err()
 		return false
 	}
 	nextPos := it.docIDPosIt.Position()