plan

type Administration interface {
	ConvertID(query.OperationID) ProcedureID
}

type AggregateProcedureSpec interface {
	// AggregateMethod specifies which aggregate method to push down to the storage layer.
	AggregateMethod() string
	// ReAggregateSpec specifies an aggregate procedure to use when aggregating the individual pushed down results.
	ReAggregateSpec() ProcedureSpec
}

type BoundedProcedureSpec interface {
	TimeBounds() BoundsSpec
}

type BoundsSpec struct {
	Start query.Time
	Stop  query.Time
}

type CreateProcedureSpec func(query.OperationSpec, Administration) (ProcedureSpec, error)

type FormatOption func(*formatter)

type LogicalPlanSpec struct {
	Procedures map[ProcedureID]*Procedure
	Order      []ProcedureID
	Resources  query.ResourceManagement
}

type LogicalPlanner interface {
	Plan(*query.Spec) (*LogicalPlanSpec, error)
}

type ParentAwareProcedureSpec interface {
	ParentChanged(old, new ProcedureID)
}

type PlanReader interface {
	Do(func(*Procedure))
	// contains filtered or unexported methods
}

type PlanRewriter interface {
	IsolatePath(parent, child *Procedure) (*Procedure, error)
	RemoveBranch(pr *Procedure) error
	AddChild(parent *Procedure, childSpec ProcedureSpec)
}

type PlanSpec struct {
	// Now represents the relative currentl time of the plan.
	Now    time.Time
	Bounds BoundsSpec
	// Procedures is a set of all operations
	Procedures map[ProcedureID]*Procedure
	Order      []ProcedureID
	// Results is a list of datasets that are the result of the plan
	Results map[string]YieldSpec

	Resources query.ResourceManagement
}

type Planner interface {
	// Plan create a plan from the logical plan and available storage.
	Plan(p *LogicalPlanSpec, s Storage, now time.Time) (*PlanSpec, error)
}

type Procedure struct {
	ID       ProcedureID
	Parents  []ProcedureID
	Children []ProcedureID
	Spec     ProcedureSpec
	// contains filtered or unexported fields
}

type ProcedureID uuid.UUID

type ProcedureKind string

type ProcedureSpec interface {
	// Kind returns the kind of the procedure.
	Kind() ProcedureKind
	Copy() ProcedureSpec
}

type PushDownProcedureSpec interface {
	PushDownRules() []PushDownRule
	PushDown(root *Procedure, dup func() *Procedure)
}

type PushDownRule struct {
	Root    ProcedureKind
	Through []ProcedureKind
	Match   func(ProcedureSpec) bool
}

type RewriteRule interface {
	Root() ProcedureKind
	Rewrite(*Procedure, PlanRewriter) error
}

type Shard struct {
	Node  string
	Range TimeRange
}

type ShardMap map[string][]Shard

type Storage interface {
	ShardMapping() ShardMap
}

type TimeRange struct {
	Start time.Time
	Stop  time.Time
}

type WindowSpec struct {
	Every  query.Duration
	Period query.Duration
	Round  query.Duration
	Start  query.Time
}

type YieldProcedureSpec interface {
	YieldName() string
}

type YieldSpec struct {
	ID ProcedureID
}