pir

type Aggregate struct {
	Agg vm.Aggregation
	// GroupBy is nil for normal
	// aggregations, or non-nil
	// when the aggregation is formed
	// on multiple columns
	//
	// note that the groups form part
	// of the binding set
	GroupBy []expr.Binding

	// NonEmpty, if true, indicates that no results
	// should be produced when zero rows reach this op
	NonEmpty bool
	// contains filtered or unexported fields
}

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

type CompileError struct {
	In  expr.Node
	Err string
}

type Distinct struct {
	Columns []expr.Node
	// contains filtered or unexported fields
}

type DummyOutput struct{}

type Env interface {
	// Schema returns type hints associated
	// with a particular table expression.
	// In the event that there is no available
	// type information, Schema may return nil.
	Schema(expr.Node) expr.Hint
	// Index returns the index for the given table
	// expression. This may return (nil, nil) if
	// the index for the table is not available.
	Index(expr.Node) (Index, error)
}

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

type Filter struct {
	Where expr.Node
	// contains filtered or unexported fields
}

type Index interface {
	// TimeRange returns the inclusive time range
	// for the given path expression across the
	// given table.
	TimeRange(path []string) (min, max date.Time, ok bool)
	// HasPartition returns true if the index
	// can be partitioned on the provided field,
	// or false otherwise.
	HasPartition(field string) bool
}

type IterTable struct {
	Table       *expr.Table
	Schema      expr.Hint
	Index       Index
	Partitioned bool

	// OnEqual, if present, indicates that this table
	// is only iterated for partitions that match
	//
	//   OnEqual[i] = PARTITION_VALUE(i)
	//
	OnEqual []string
	// contains filtered or unexported fields
}

type IterValue struct {
	Value  expr.Node // the expression to be iterated
	Result string    // the binding produced by iteration
	// contains filtered or unexported fields
}

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

type NoOutput struct{}

type Order struct {
	Columns []expr.Order
	// contains filtered or unexported fields
}

type OutputIndex struct {
	Table    expr.Node
	Basename string
	// contains filtered or unexported fields
}

type OutputPart struct {
	Basename string
	// contains filtered or unexported fields
}

type SizeClass int

type Step interface {
	// contains filtered or unexported methods
}

type Trace struct {
	// If this trace is not a root trace,
	// then Parent will be a trace that
	// has this trace as one of its inputs.
	Parent *Trace
	// Replacements are traces that produce
	// results that are necessary in order
	// to execute this trace.
	// The results of input traces
	// are available to this trace
	// through the SCALAR_REPLACEMENT(index)
	// and IN_REPLACEMENT(index) expressions.
	// The traces in Input may be executed
	// in any order.
	Replacements []*Trace
	// contains filtered or unexported fields
}

type UnionMap struct {
	// Inner is the table that needs
	// to be partitioned into the child
	// subquery.
	Inner *IterTable
	// Child is the sub-query that is
	// applied to the partitioned table.
	Child *Trace
	// PartitionBy is a list of fields
	// over which the unioning should be partitioned.
	// PartitionBy[i] corresponds to PARTITION_VALUE(i)
	// within each step within Child.
	PartitionBy []string
	// contains filtered or unexported fields
}

type Unpivot struct {
	Ast *expr.Unpivot // The AST node this node was constructed from
	// contains filtered or unexported fields
}

type UnpivotAtDistinct struct {
	Ast *expr.Unpivot // The AST node this node was constructed from
	// contains filtered or unexported fields
}