plan

type AggregateNode struct {
	Input     LogicalNode
	GroupKeys []string
	Aggs      []expr.AggNode
	// contains filtered or unexported fields
}

type Executor interface {
	// Scan materializes the source handle into a DataFrame, optionally honoring
	// scan-level pushdown annotations (columns, limit, filters). source is the
	// ScanNode handle (e.g. a *dataframe.DataFrame).
	Scan(ctx context.Context, node *ScanNode) (any, error)
	Filter(ctx context.Context, df any, predicate expr.Expr) (any, error)
	Project(df any, cols []string) (any, error)
	Limit(df any, n int64) (any, error)
	Sort(ctx context.Context, df any, keys []expr.SortKey) (any, error)
	Aggregate(ctx context.Context, df any, groupKeys []string, aggs []expr.AggNode) (any, error)
	Join(ctx context.Context, left, right any, on string, how string) (any, error)
	WithColumn(df any, e expr.Expr) (any, error)

	// ScanStream opens a file-backed ScanNode as a streaming RecordReader,
	// honoring pushed column/limit annotations where the source supports them.
	ScanStream(ctx context.Context, node *ScanNode) (any, error)
	// FilterStream applies predicate to each batch of reader, yielding a reader
	// over the surviving rows.
	FilterStream(ctx context.Context, reader any, predicate expr.Expr) (any, error)
	// ProjectStream narrows each batch of reader to cols.
	ProjectStream(reader any, cols []string) (any, error)
	// LimitStream stops the stream once n rows have been emitted across batches.
	LimitStream(reader any, n int64) any
	// StreamFromDataFrame adapts a materialized DataFrame handle into a
	// RecordReader so a pipeline-breaking operator's output can be streamed.
	StreamFromDataFrame(df any) (any, error)
}

type FilterNode struct {
	Input     LogicalNode
	Predicate expr.Expr
	// contains filtered or unexported fields
}

type JoinNode struct {
	Left  LogicalNode
	Right LogicalNode
	On    string
	How   string
	// contains filtered or unexported fields
}

type LimitNode struct {
	Input LogicalNode
	N     int64
	// contains filtered or unexported fields
}

type LogicalNode interface {
	Name() string
	Schema() *schema.Schema
	Children() []LogicalNode
}

type LogicalPlan struct {
	Root LogicalNode
}

type PhysAggregate struct {
	Input     PhysicalNode
	GroupKeys []string
	Aggs      []expr.AggNode
	// contains filtered or unexported fields
}

type PhysFilter struct {
	Input     PhysicalNode
	Predicate expr.Expr
	// contains filtered or unexported fields
}

type PhysJoin struct {
	Left  PhysicalNode
	Right PhysicalNode
	On    string
	How   string
	// contains filtered or unexported fields
}

type PhysLimit struct {
	Input PhysicalNode
	N     int64
	// contains filtered or unexported fields
}

type PhysProject struct {
	Input   PhysicalNode
	Columns []string
	// contains filtered or unexported fields
}

type PhysScan struct {
	Node *ScanNode
	// contains filtered or unexported fields
}

type PhysSort struct {
	Input PhysicalNode
	Keys  []expr.SortKey
	// contains filtered or unexported fields
}

type PhysWithColumn struct {
	Input PhysicalNode
	Expr  expr.Expr
	// contains filtered or unexported fields
}

type PhysicalNode interface {
	Name() string
	Schema() *arrow.Schema
	Children() []PhysicalNode
	Execute(ctx context.Context, exec Executor) (any, error)
}

type PhysicalPlan struct {
	Root PhysicalNode
}

type ProjectNode struct {
	Input   LogicalNode
	Columns []string
	// contains filtered or unexported fields
}

type ScanNode struct {

	// Handle is the opaque source object the executor scans (e.g. a
	// *dataframe.DataFrame). It is typed as any to keep plan free of a
	// dataframe import.
	Handle any

	// Pushdown annotations produced by Optimize. They are advisory: the
	// executor honors whichever it understands and the surviving logical
	// nodes above the scan still produce a correct result if it does not.
	PushedFilters []expr.Expr
	PushedColumns []string
	PushedLimit   int64 // <0 means "no limit pushed"
	// contains filtered or unexported fields
}

type SortNode struct {
	Input LogicalNode
	Keys  []expr.SortKey
	// contains filtered or unexported fields
}

type StreamingNode interface {
	PhysicalNode
	// ExecuteStream runs the node and returns a streaming reader handle.
	ExecuteStream(ctx context.Context, exec Executor) (any, error)
}

type WithColumnNode struct {
	Input LogicalNode
	Expr  expr.Expr
	// contains filtered or unexported fields
}