operator

type Aggregation struct {
	Inner    InstantVectorOperator
	Start    time.Time
	End      time.Time
	Interval time.Duration
	Grouping []string
	// contains filtered or unexported fields
}

type BinaryOperation struct {
	Left  InstantVectorOperator
	Right InstantVectorOperator
	Op    parser.ItemType

	VectorMatching parser.VectorMatching
	// contains filtered or unexported fields
}

type InstantVectorOperator interface {
	Operator

	// NextSeries returns the next series from this operator, or EOS if no more series are available.
	// SeriesMetadata must be called exactly once before calling NextSeries.
	// The returned InstantVectorSeriesData can be modified by the caller or returned to a pool.
	// The returned InstantVectorSeriesData can contain no points.
	NextSeries(ctx context.Context) (InstantVectorSeriesData, error)
}

type InstantVectorSelector struct {
	Selector *Selector
	// contains filtered or unexported fields
}

type InstantVectorSeriesData struct {
	// Floats contains floating point samples for this series.
	// Samples must be sorted in timestamp order, earliest timestamps first.
	// Samples must not have duplicate timestamps.
	Floats []promql.FPoint

	// Histograms contains histogram samples for this series.
	// Samples must be sorted in timestamp order, earliest timestamps first.
	// Samples must not have duplicate timestamps.
	Histograms []promql.HPoint
}

type Operator interface {
	// SeriesMetadata returns a list of all series that will be returned by this operator.
	// The returned []SeriesMetadata can be modified by the caller or returned to a pool.
	// SeriesMetadata may return series in any order, but the same order must be used by both SeriesMetadata and NextSeries.
	// SeriesMetadata should be called no more than once.
	SeriesMetadata(ctx context.Context) ([]SeriesMetadata, error)

	// Close frees all resources associated with this operator.
	// Calling SeriesMetadata or NextSeries after calling Close may result in unpredictable behaviour, corruption or crashes.
	// It must be safe to call Close at any time, including if SeriesMetadata or NextSeries have returned an error.
	Close()
}

type RangeVectorFunction struct {
	Inner RangeVectorOperator
	// contains filtered or unexported fields
}

type RangeVectorOperator interface {
	Operator

	// StepCount returns the number of time steps produced for each series by this operator.
	// StepCount must only be called after calling SeriesMetadata.
	StepCount() int

	// Range returns the time range selected by this operator at each time step.
	//
	// For example, if this operator represents the selector "some_metric[5m]", Range returns 5 minutes.
	Range() time.Duration

	// NextSeries advances to the next series produced by this operator, or EOS if no more series are available.
	// SeriesMetadata must be called exactly once before calling NextSeries.
	NextSeries(ctx context.Context) error

	// NextStepSamples populates the provided RingBuffer with the samples for the next time step for the
	// current series and returns the timestamps of the next time step, or returns EOS if no more time
	// steps are available.
	// The provided RingBuffer is expected to only contain points for the current series, and the same
	// RingBuffer should be passed to subsequent NextStepSamples calls for the same series.
	// The provided RingBuffer may be populated with points beyond the end of the expected time range, and
	// callers should compare returned points' timestamps to the returned RangeVectorStepData.RangeEnd.
	// Next must be called at least once before calling NextStepSamples.
	NextStepSamples(floats *RingBuffer) (RangeVectorStepData, error)
}

type RangeVectorSelector struct {
	Selector *Selector
	// contains filtered or unexported fields
}

type RangeVectorStepData struct {
	// StepT is the timestamp of this time step.
	StepT int64

	// RangeStart is the beginning of the time range selected by this time step.
	// RangeStart is inclusive (ie. points with timestamp >= RangeStart are included in the range).
	RangeStart int64

	// RangeEnd is the end of the time range selected by this time step.
	// RangeEnd is the same as StepT except when the @ modifier or offsets are used, in which case
	// RangeEnd reflects the time of the underlying points, and StepT is the timestamp of the point
	// produced by the query.
	// RangeEnd is inclusive (ie. points with timestamp <= RangeEnd are included in the range).
	RangeEnd int64
}

type RingBuffer struct {
	// contains filtered or unexported fields
}

type Selector struct {
	Queryable storage.Queryable
	Start     int64  // Milliseconds since Unix epoch
	End       int64  // Milliseconds since Unix epoch
	Timestamp *int64 // Milliseconds since Unix epoch, only set if selector uses @ modifier (eg. metric{...} @ 123)
	Interval  int64  // In milliseconds
	Matchers  []*labels.Matcher

	// Set for instant vector selectors, otherwise 0.
	LookbackDelta time.Duration

	// Set for range vector selectors, otherwise 0.
	Range time.Duration
	// contains filtered or unexported fields
}

type SeriesMetadata struct {
	Labels labels.Labels
}