Method startIterator

iterator.go:98–203

startIterator() returns a new iterator on the given segmentStack. On success, the returned Iterator will be positioned so that Iterator.Current() will either provide the first entry in the iteration range or ErrIteratorDone. A startKeyInclusive of nil means the logical "bottom-most" possible key a

(
	startKeyInclusive, endKeyExclusive []byte,
	iteratorOptions IteratorOptions)

// IteratorOptions.MinSegmentLevel parameter.  For example, to ignore
// the lowest, 0th segment, use MinSegmentLevel of 1.
func (ss *segmentStack) startIterator(
	startKeyInclusive, endKeyExclusive []byte,
	iteratorOptions IteratorOptions) (*iterator, error) {
	if iteratorOptions.MaxSegmentHeight <= 0 {
		iteratorOptions.MaxSegmentHeight = len(ss.a)
	}

	prefixLen := 0
	if len(startKeyInclusive) > 0 &&
		len(endKeyExclusive) > 0 {
		prefixLen = sharedPrefixLen(startKeyInclusive, endKeyExclusive)
	}

	iter := &iterator{
		ss:      ss,
		cursors: make([]*cursor, 0, len(ss.a)+1),

		startKeyInclusive: startKeyInclusive,
		endKeyExclusive:   endKeyExclusive,

		prefixLen: prefixLen,

		iteratorOptions: iteratorOptions,
	}

	// ----------------------------------------------
	// Add cursors for our allowed segments.

	minSegmentLevel := iteratorOptions.MinSegmentLevel
	maxSegmentLevel := iteratorOptions.MaxSegmentHeight - 1

	ss.ensureSorted(minSegmentLevel, maxSegmentLevel)

	for ssIndex := minSegmentLevel; ssIndex <= maxSegmentLevel; ssIndex++ {
		b := ss.a[ssIndex]

		sc, err := b.Cursor(startKeyInclusive, endKeyExclusive)
		if err != nil {
			return nil, err
		}
		op, k, v := sc.Current()
		if op == 0 && k == nil && v == nil {
			continue
		}

		iter.cursors = append(iter.cursors, &cursor{
			ssIndex: ssIndex,
			sc:      sc,
			op:      op,
			k:       k,
			v:       v,
		})
	}

	// ----------------------------------------------
	// Add cursor for the lower level, if wanted.

	if !iteratorOptions.SkipLowerLevel &&