types

type Aggregable interface {
	fmt.Stringer

	// creates a new aggregation buffer for this aggregate
	NewBuffer() (AggregationBuffer, error)

	// convenience to get the first argument of the aggregate
	FirstChildExpr() PlanExpression

	// returns all the child expressions for this aggregate
	Children() []PlanExpression

	// returns the type of the aggregate
	Type() parser.ExprDataType
}

type AggregationBuffer interface {
	Eval(ctx context.Context) (interface{}, error)
	Update(ctx context.Context, row Row) error
}

type CompilePlanner interface {
	CompilePlan(context.Context, parser.Statement) (PlanOperator, error)
}

type ContainsExpressions interface {
	// returns the list of expressions contained by the plan operator
	Expressions() []PlanExpression

	// WithUpdatedExpressions returns a the operator with expressions updated
	WithUpdatedExpressions(exprs ...PlanExpression) (PlanOperator, error)
}

type FilteredRelation interface {
	Relation
	IsFilterable() bool
	UpdateFilters(filterCondition PlanExpression) (PlanOperator, error)
	UpdateTimeQuantumFilters(filters ...PlanExpression) (PlanOperator, error)
}

type IdentifiableByName interface {
	Name() string
}

type PlanExpression interface {
	fmt.Stringer

	// evaluates expression based on current row
	Evaluate(currentRow []interface{}) (interface{}, error)

	// returns the type of the expression
	Type() parser.ExprDataType

	// returns the child expressions for this expression
	Children() []PlanExpression

	// creates a new expression node with the children replaced
	WithChildren(children ...PlanExpression) (PlanExpression, error)

	// returns a map containing a rich description of this expression; intended to be
	// marshalled into json
	Plan() map[string]interface{}
}

type PlanOperator interface {
	fmt.Stringer

	// Children of this operator.
	Children() []PlanOperator

	// Schema of this operator.
	Schema() Schema

	// Iterator produces an iterator from this node. The current row being
	// evaluated is provided, as well as the context of the query.
	Iterator(ctx context.Context, row Row) (RowIterator, error)

	// WithChildren creates a new node with the children passed
	WithChildren(children ...PlanOperator) (PlanOperator, error)

	// Plan returns a map containing a rich description of this operator;
	// intended to be marshalled into json.
	Plan() map[string]interface{}

	// AddWarning adds a warning to the plan.
	AddWarning(warning string)

	// Warnings returns a list of warnings as strings.
	Warnings() []string
}

type PlannerColumn struct {
	ColumnName   string
	RelationName string
	AliasName    string
	Type         parser.ExprDataType
}

type Relation interface {
	Name() string
}

type Row []interface{}

type RowIterable interface {
	Iterator(ctx context.Context, row Row) (RowIterator, error)
}

type RowIterator interface {
	Next(ctx context.Context) (Row, error)
}

type Rows []Row

type Schema []*PlannerColumn