execute

type AccumulationMode int

type Administration interface {
	ResolveTime(qt query.Time) Time
	Bounds() Bounds
	Allocator() *Allocator
	Parents() []DatasetID
	ConvertID(plan.ProcedureID) DatasetID
}

type Aggregate interface {
	NewBoolAgg() DoBoolAgg
	NewIntAgg() DoIntAgg
	NewUIntAgg() DoUIntAgg
	NewFloatAgg() DoFloatAgg
	NewStringAgg() DoStringAgg
}

type AllocError struct {
	Limit     int64
	Allocated int64
	Wanted    int64
}

type Allocator struct {
	Limit int64
	// contains filtered or unexported fields
}

type Block interface {
	BlockMetadata

	Cols() []ColMeta
	// Col returns an iterator to consume the values for a given column.
	Col(c int) ValueIterator

	// Times returns an iterator to consume the values for the "_time" column.
	Times() ValueIterator
	// Values returns an iterator to consume the values for the "_value" column.
	// If no column exists and error is returned
	Values() (ValueIterator, error)

	// RefCount modifies the reference count on the block by n.
	// When the RefCount goes to zero, the block is freed.
	RefCount(n int)
}

type BlockBuilder interface {
	SetBounds(Bounds)

	BlockMetadata

	NRows() int
	NCols() int
	Cols() []ColMeta

	// AddCol increases the size of the block by one column.
	// The index of the column is returned.
	AddCol(ColMeta) int

	// Set sets the value at the specified coordinates
	// The rows and columns must exist before calling set, otherwise Set panics.
	SetBool(i, j int, value bool)
	SetInt(i, j int, value int64)
	SetUInt(i, j int, value uint64)
	SetFloat(i, j int, value float64)
	SetString(i, j int, value string)
	SetTime(i, j int, value Time)

	// SetCommonString sets a single value for the entire column.
	SetCommonString(j int, value string)

	AppendBool(j int, value bool)
	AppendInt(j int, value int64)
	AppendUInt(j int, value uint64)
	AppendFloat(j int, value float64)
	AppendString(j int, value string)
	AppendTime(j int, value Time)

	AppendFloats(j int, values []float64)
	AppendStrings(j int, values []string)
	AppendTimes(j int, values []Time)

	// Sort the rows of the by the values of the columns in the order listed.
	Sort(cols []string, desc bool)

	// Clear removes all rows, while preserving the column meta data.
	ClearData()

	// Block returns the block that has been built.
	// Further modifications of the builder will not effect the returned block.
	Block() (Block, error)
}

type BlockBuilderCache interface {
	// BlockBuilder returns an existing or new BlockBuilder for the given meta data.
	// The boolean return value indicates if BlockBuilder is new.
	BlockBuilder(meta BlockMetadata) (BlockBuilder, bool)
	ForEachBuilder(f func(BlockKey, BlockBuilder))
}

type BlockContext struct {
	Bounds Bounds
	Count  int
}

type BlockIterator interface {
	Do(f func(Block) error) error
}

type BlockKey string

type BlockMetadata interface {
	Bounds() Bounds
	Tags() Tags
}

type BoolValueFunc interface {
	ValueBool() bool
}

type Bounds struct {
	Start Time
	Stop  Time
}

type ColKind int

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

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

type ColMeta struct {
	Label string
	Type  DataType
	Kind  ColKind
	// Common indicates that the value for the column is shared by all rows.
	Common bool
}

type Config struct {
	StorageReader StorageReader
}

type CreateSource func(spec plan.ProcedureSpec, id DatasetID, sr StorageReader, ctx Administration) Source

type CreateTransformation func(id DatasetID, mode AccumulationMode, spec plan.ProcedureSpec, a Administration) (Transformation, Dataset, error)

type DataCache interface {
	BlockMetadata(BlockKey) BlockMetadata
	Block(BlockKey) (Block, error)

	ForEach(func(BlockKey))
	ForEachWithContext(func(BlockKey, Trigger, BlockContext))

	DiscardBlock(BlockKey)
	ExpireBlock(BlockKey)

	SetTriggerSpec(t query.TriggerSpec)
}

type DataType int

type Dataset interface {
	Node

	RetractBlock(key BlockKey) error
	UpdateProcessingTime(t Time) error
	UpdateWatermark(mark Time) error
	Finish(error)

	SetTriggerSpec(t query.TriggerSpec)
}

type DatasetID uuid.UUID

type Dispatcher interface {
	// Schedule fn to be executed
	Schedule(fn ScheduleFunc)
}

type DoBoolAgg interface {
	ValueFunc
	DoBool([]bool)
}

type DoBoolIndexSelector interface {
	DoBool([]bool) []int
}

type DoBoolRowSelector interface {
	Rower
	// What if the selector doesn't know yet and needs to wait all is finalized?
	DoBool(vs []bool, rr RowReader)
}

type DoFloatAgg interface {
	ValueFunc
	DoFloat([]float64)
}

type DoFloatIndexSelector interface {
	DoFloat([]float64) []int
}

type DoFloatRowSelector interface {
	Rower
	DoFloat(vs []float64, rr RowReader)
}

type DoIntAgg interface {
	ValueFunc
	DoInt([]int64)
}

type DoIntIndexSelector interface {
	DoInt([]int64) []int
}

type DoIntRowSelector interface {
	Rower
	DoInt(vs []int64, rr RowReader)
}

type DoStringAgg interface {
	ValueFunc
	DoString([]string)
}

type DoStringIndexSelector interface {
	DoString([]string) []int
}

type DoStringRowSelector interface {
	Rower
	DoString(vs []string, rr RowReader)
}

type DoUIntAgg interface {
	ValueFunc
	DoUInt([]uint64)
}

type DoUIntIndexSelector interface {
	DoUInt([]uint64) []int
}

type DoUIntRowSelector interface {
	Rower
	DoUInt(vs []uint64, rr RowReader)
}

type Duration int64

type Executor interface {
	Execute(context.Context, *plan.PlanSpec) (map[string]Result, error)
}

type FinishMsg interface {
	Message
	Error() error
}

type FloatValueFunc interface {
	ValueFloat() float64
}

type FormatOptions struct {
	// RepeatHeaderCount is the number of rows to print before printing the header again.
	// If zero then the headers are not repeated.
	RepeatHeaderCount int
}

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

type IndexSelector interface {
	NewBoolSelector() DoBoolIndexSelector
	NewIntSelector() DoIntIndexSelector
	NewUIntSelector() DoUIntIndexSelector
	NewFloatSelector() DoFloatIndexSelector
	NewStringSelector() DoStringIndexSelector
}

type IntValueFunc interface {
	ValueInt() int64
}

type Message interface {
	Type() MessageType
	SrcDatasetID() DatasetID
}

type MessageQueue interface {
	Push(Message)
	Pop() Message
}

type MessageType int

type Node interface {
	AddTransformation(t Transformation)
}

type OneTimeBlock interface {
	Block
	// contains filtered or unexported methods
}

type ProcessMsg interface {
	Message
	Block() Block
}

type ReadSpec struct {
	RAMLimit     uint64
	Database     string
	Hosts        []string
	Predicate    *semantic.FunctionExpression
	PointsLimit  int64
	SeriesLimit  int64
	SeriesOffset int64
	Descending   bool

	AggregateMethod string

	// OrderByTime indicates that series reads should produce all
	// series for a time before producing any series for a larger time.
	// By default this is false meaning all values of time are produced for a given series,
	// before any values are produced from the next series.
	OrderByTime bool
	// MergeAll indicates that all series should be merged into a single group
	MergeAll bool
	// GroupKeys is the list of dimensions along which to group
	GroupKeys []string
	// GroupExcept is the list of dimensions along which to not group
	GroupExcept []string
	// GroupKeep is the list of tags to keep but not group by.
	GroupKeep []string
}

type Result interface {
	Blocks() BlockIterator
	// contains filtered or unexported methods
}

type RetractBlockMsg interface {
	Message
	BlockMetadata() BlockMetadata
}

type Row struct {
	Values []interface{}
}

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

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

type RowReader interface {
	Cols() []ColMeta
	// AtBool returns the bool value of another column and given index.
	AtBool(i, j int) bool
	// AtInt returns the int value of another column and given index.
	AtInt(i, j int) int64
	// AtUInt returns the uint value of another column and given index.
	AtUInt(i, j int) uint64
	// AtFloat returns the float value of another column and given index.
	AtFloat(i, j int) float64
	// AtString returns the string value of another column and given index.
	AtString(i, j int) string
	// AtTime returns the time value of another column and given index.
	AtTime(i, j int) Time
}

type RowSelector interface {
	NewBoolSelector() DoBoolRowSelector
	NewIntSelector() DoIntRowSelector
	NewUIntSelector() DoUIntRowSelector
	NewFloatSelector() DoFloatRowSelector
	NewStringSelector() DoStringRowSelector
}

type Rower interface {
	Rows() []Row
}

type ScheduleFunc func(throughput int)

type Source interface {
	Node
	Run(ctx context.Context)
}

type StorageReader interface {
	Read(ctx context.Context, trace map[string]string, rs ReadSpec, start, stop Time) (BlockIterator, error)
	Close()
}

type StringValueFunc interface {
	ValueString() string
}

type Tags map[string]string

type TagsKey string

type Time int64

type Transformation interface {
	RetractBlock(id DatasetID, meta BlockMetadata) error
	Process(id DatasetID, b Block) error
	UpdateWatermark(id DatasetID, t Time) error
	UpdateProcessingTime(id DatasetID, t Time) error
	Finish(id DatasetID, err error)
}

type Transport interface {
	Transformation
	// Finished reports when the Transport has completed and there is no more work to do.
	Finished() <-chan struct{}
}

type Trigger interface {
	Triggered(TriggerContext) bool
	Finished() bool
	Reset()
}

type TriggerContext struct {
	Block                 BlockContext
	Watermark             Time
	CurrentProcessingTime Time
}

type UIntValueFunc interface {
	ValueUInt() uint64
}

type UpdateProcessingTimeMsg interface {
	Message
	ProcessingTime() Time
}

type UpdateWatermarkMsg interface {
	Message
	WatermarkTime() Time
}

type ValueFunc interface {
	Type() DataType
}

type ValueIterator interface {
	DoBool(f func([]bool, RowReader))
	DoInt(f func([]int64, RowReader))
	DoUInt(f func([]uint64, RowReader))
	DoFloat(f func([]float64, RowReader))
	DoString(f func([]string, RowReader))
	DoTime(f func([]Time, RowReader))
}

type Window struct {
	Every  Duration
	Period Duration
	Round  Duration
	Start  Time
}