physical

type Aggregate struct {
	Name                string
	OutputType          octosql.Type
	AggregateDescriptor AggregateDescriptor
}

type AggregateDescriptor struct {
	ArgumentType octosql.Type
	OutputType   octosql.Type
	TypeFn       func(octosql.Type) (octosql.Type, bool)
	Prototype    func() nodes.Aggregate
}

type AggregateDetails struct {
	Description string
	Descriptors []AggregateDescriptor
}

type And struct {
	Arguments []Expression
}

type Cast struct {
	Expression   Expression
	TargetTypeID octosql.TypeID
}

type Coalesce struct {
	Arguments []Expression
}

type Constant struct {
	Value octosql.Value
}

type CountingTrigger struct {
	TriggerAfter uint
}

type Database interface {
	ListTables(ctx context.Context) ([]string, error)
	GetTable(ctx context.Context, name string, options map[string]string) (DatasourceImplementation, Schema, error)
}

type Datasource struct {
	Name, Alias              string
	DatasourceImplementation DatasourceImplementation
	VariableMapping          map[string]string
	Predicates               []Expression
}

type DatasourceImplementation interface {
	Materialize(ctx context.Context, env Environment, schema Schema, pushedDownPredicates []Expression) (execution.Node, error)
	PushDownPredicates(newPredicates, pushedDownPredicates []Expression) (rejected, pushedDown []Expression, changed bool)
}

type DatasourceRepository struct {
	// TODO: A może jednak ten bardziej dynamiczny interfejs? Że database.<table> i wtedy sie resolvuje
	// Bo inaczej będzie na start strasznie dużo rzeczy ładować niepotrzebnych dla wszystkich
	// skonfigurowanych baz danych.
	Databases    map[string]func() (Database, error)
	FileHandlers map[string]func(name string, options map[string]string) (DatasourceImplementation, Schema, error)
}

type Distinct struct {
	Source Node
}

type EndOfStreamTrigger struct {
}

type Environment struct {
	Aggregates      map[string]AggregateDetails
	Datasources     *DatasourceRepository
	Functions       map[string]FunctionDetails
	PhysicalConfig  map[string]interface{}
	VariableContext *VariableContext
}

type Expression struct {
	Type octosql.Type

	ExpressionType ExpressionType
	// Only one of the below may be non-null.
	Variable          *Variable
	Constant          *Constant
	FunctionCall      *FunctionCall
	And               *And
	Or                *Or
	QueryExpression   *QueryExpression
	Coalesce          *Coalesce
	Tuple             *Tuple
	TypeAssertion     *TypeAssertion
	Cast              *Cast
	ObjectFieldAccess *ObjectFieldAccess
}

type ExpressionType int

type Filter struct {
	Source    Node
	Predicate Expression
}

type FunctionCall struct {
	Name               string
	Arguments          []Expression
	FunctionDescriptor FunctionDescriptor
}

type FunctionDescriptor struct {
	ArgumentTypes []octosql.Type
	OutputType    octosql.Type
	TypeFn        func([]octosql.Type) (octosql.Type, bool) `json:"-"`
	Strict        bool
	Function      func([]octosql.Value) (octosql.Value, error) `json:"-"`
}

type FunctionDetails struct {
	Description string
	Descriptors []FunctionDescriptor
}

type GroupBy struct {
	Source               Node
	Aggregates           []Aggregate
	AggregateExpressions []Expression
	Key                  []Expression
	// Either index to Key, or -1, if none.
	KeyEventTimeIndex int
	Trigger           Trigger
}

type Limit struct {
	Source Node
	Limit  Expression
}

type LookupJoin struct {
	Source, Joined Node
}

type Map struct {
	Source      Node
	Expressions []Expression
}

type MultiTrigger struct {
	Triggers []Trigger
}

type Node struct {
	Schema Schema

	NodeType NodeType
	// Only one of the below may be non-null.
	Datasource          *Datasource
	Distinct            *Distinct
	Filter              *Filter
	GroupBy             *GroupBy
	LookupJoin          *LookupJoin
	StreamJoin          *StreamJoin
	Map                 *Map
	OrderBy             *OrderBy
	Requalifier         *Requalifier
	TableValuedFunction *TableValuedFunction
	Unnest              *Unnest
	Limit               *Limit
}

type NodeType int

type ObjectFieldAccess struct {
	Object Expression
	Field  string
}

type Or struct {
	Arguments []Expression
}

type OrderBy struct {
	Source               Node
	Key                  []Expression
	DirectionMultipliers []int
}

type QueryExpression struct {
	Source Node
}

type Requalifier struct {
	Source    Node
	Qualifier string
}

type Schema struct {
	Fields []SchemaField
	// TimeField is -1 if not present.
	TimeField     int
	NoRetractions bool
}

type SchemaField struct {
	Name string
	Type octosql.Type
}

type SchemaOption func(schema *Schema)

type StreamJoin struct {
	Left, Right       Node
	LeftKey, RightKey []Expression
}

type TableValuedFunction struct {
	Name               string
	Arguments          map[string]TableValuedFunctionArgument
	FunctionDescriptor TableValuedFunctionDescriptor
}

type TableValuedFunctionArgument struct {
	TableValuedFunctionArgumentType TableValuedFunctionArgumentType
	// Only one of the below may be non-null.
	Expression *TableValuedFunctionArgumentExpression
	Table      *TableValuedFunctionArgumentTable
	Descriptor *TableValuedFunctionArgumentDescriptor
}

type TableValuedFunctionArgumentDescriptor struct {
	Descriptor string
}

type TableValuedFunctionArgumentExpression struct {
	Expression Expression
}

type TableValuedFunctionArgumentTable struct {
	Table Node
}

type TableValuedFunctionArgumentType int

type TableValuedFunctionDescriptor struct {
	Materialize func(context.Context, Environment, map[string]TableValuedFunctionArgument) (execution.Node, error)
}

type Transformers struct {
	NodeTransformer       func(node Node) Node
	ExpressionTransformer func(expr Expression) Expression
}

type Trigger struct {
	TriggerType TriggerType
	// Only one of the below may be non-null.
	CountingTrigger    *CountingTrigger
	EndOfStreamTrigger *EndOfStreamTrigger
	WatermarkTrigger   *WatermarkTrigger
	MultiTrigger       *MultiTrigger
}

type TriggerType int

type Tuple struct {
	Arguments []Expression
}

type TypeAssertion struct {
	Expression Expression
	TargetType octosql.Type
}

type Unnest struct {
	Source Node
	Field  string
}

type Variable struct {
	Name     string
	IsLevel0 bool
}

type VariableContext struct {
	Parent *VariableContext
	Fields []SchemaField
}

type WatermarkTrigger struct {
	TimeFieldIndex int
}