promql/engine.go
func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, maxt int64, out []Point) []Point {
	if len(out) > 0 && out[len(out)-1].T >= mint {
		// There is an overlap between previous and current ranges, retain common
		// points. In most such cases:
		//   (a) the overlap is significantly larger than the eval step; and/or
		//   (b) the number of samples is relatively small.
		// so a linear search will be as fast as a binary search.
		var drop int
		for drop = 0; out[drop].T < mint; drop++ {
		}
		copy(out, out[drop:])
		out = out[:len(out)-drop]
		// Only append points with timestamps after the last timestamp we have.
		mint = out[len(out)-1].T + 1
	} else {
		out = out[:0]
	}

	ok := it.Seek(maxt)
	if !ok {
		if it.Err() != nil {
			ev.error(it.Err())
		}
	}

	buf := it.Buffer()
	for buf.Next() {
		t, v := buf.At()
		if value.IsStaleNaN(v) {
			continue
		}
		// Values in the buffer are guaranteed to be smaller than maxt.
		if t >= mint {
			if ev.currentSamples >= ev.maxSamples {
				ev.error(ErrTooManySamples(env))
			}
			out = append(out, Point{T: t, V: v})
			ev.currentSamples++
		}
	}
	// The seeked sample might also be in the range.
	if ok {
		t, v := it.Values()
		if t == maxt && !value.IsStaleNaN(v) {
			if ev.currentSamples >= ev.maxSamples {
				ev.error(ErrTooManySamples(env))
			}
			out = append(out, Point{T: t, V: v})
			ev.currentSamples++
		}
	}
	return out
}
func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, maxt int64, out []Point) []Point {
	if len(out) > 0 && out[len(out)-1].T >= mint {
		// There is an overlap between previous and current ranges, retain common
		// points. In most such cases:
		//   (a) the overlap is significantly larger than the eval step; and/or
		//   (b) the number of samples is relatively small.
		// so a linear search will be as fast as a binary search.
		var drop int
		for drop = 0; out[drop].T < mint; drop++ {
		}
		copy(out, out[drop:])
		out = out[:len(out)-drop]
		// Only append points with timestamps after the last timestamp we have.
		mint = out[len(out)-1].T + 1
	} else {
		out = out[:0]
	}

	ok := it.Seek(maxt)
	if !ok {
		if it.Err() != nil {
			ev.error(it.Err())
		}
	}

	buf := it.Buffer()
	for buf.Next() {
		t, v := buf.At()
		if value.IsStaleNaN(v) {
			continue
		}
		// Values in the buffer are guaranteed to be smaller than maxt.
		if t >= mint {
			if ev.currentSamples >= ev.maxSamples {
				ev.error(ErrTooManySamples(env))
			}
			out = append(out, Point{T: t, V: v})
			ev.currentSamples++
		}
	}
	// The seeked sample might also be in the range.
	if ok {
		t, v := it.Values()
		if t == maxt && !value.IsStaleNaN(v) {
			if ev.currentSamples >= ev.maxSamples {
				ev.error(ErrTooManySamples(env))
			}
			out = append(out, Point{T: t, V: v})
			ev.currentSamples++
		}
	}
	return out
}
func ( ev * evaluator ) matrixIterSlice ( it * storage . BufferedSeriesIterator , mint , maxt int64 , out [ ] Point ) [ ] Point { if len ( out ) > 0 && out [ len ( out ) - 1 ] . T >= mint { // There is an overlap between previous and current ranges, retain common // points. In most such cases: //   (a) the overlap is significantly larger than the eval step; and/or //   (b) the number of samples is relatively small. // so a linear search will be as fast as a binary search. var drop int for drop = 0 ; out [ drop ] . T < mint ; drop ++ { } copy ( out , out [ drop : ] ) out = out [ : len ( out ) - drop ] // Only append points with timestamps after the last timestamp we have. mint = out [ len ( out ) - 1 ] . T + 1 } else { out = out [ : 0 ] } ok := it . Seek ( maxt ) if ! ok { if it . Err ( ) != nil { ev . error ( it . Err ( ) ) } } buf := it . Buffer ( ) for buf . Next ( ) { t , v := buf . At ( ) if value . IsStaleNaN ( v ) { continue } // Values in the buffer are guaranteed to be smaller than maxt. if t >= mint { if ev . currentSamples >= ev . maxSamples { ev . error ( ErrTooManySamples ( env ) ) } out = append ( out , Point { T : t , V : v } ) ev . currentSamples ++ } } // The seeked sample might also be in the range. if ok { t , v := it . Values ( ) if t == maxt && ! value . IsStaleNaN ( v ) { if ev . currentSamples >= ev . maxSamples { ev . error ( ErrTooManySamples ( env ) ) } out = append ( out , Point { T : t , V : v } ) ev . currentSamples ++ } } return out }
// matrixIterSlice populates a matrix vector covering the requested range for a
// single time series, with points retrieved from an iterator.
//
// As an optimization, the matrix vector may already contain points of the same
// time series from the evaluation of an earlier step (with lower mint and maxt
// values). Any such points falling before mint are discarded; points that fall
// into the [mint, maxt] range are retained; only points with later timestamps
// are populated from the iterator.
matrixIterSlice populates a matrix vector covering the requested range for a single time series with points retrieved from an iterator . As an optimization the matrix vector may already contain points of the same time series from the evaluation of an earlier step ( with lower mint and maxt values ) . Any such points falling before mint are discarded ; points that fall into the [ mint maxt ] range are retained ; only points with later timestamps are populated from the iterator .