plan

type CachedTable interface {
	Hits() int64
	Misses() int64
	Bytes() int64
}

type Client struct {
	// Pipe is the connection to the
	// remote query environment.
	Pipe io.ReadWriteCloser
	// contains filtered or unexported fields
}

type CountStar struct {
	Nonterminal
	As       string // output count name
	NonEmpty bool   // don't output count=0
}

type Descriptor struct {
	// Descriptor is the input object descriptor.
	//
	// The query planner uses the contents of Descriptor.Trailer
	// for the purposes of query planning, but otherwise leaves
	// the semantics of Descriptor.{Path,ETag,...} up to the
	// [Runner] used to execute the query.
	blockfmt.Descriptor

	// Blocks indicates the list of blocks within
	// the object that are actually referenced.
	Blocks ints.Intervals
}

type Distinct struct {
	Nonterminal
	Fields []expr.Node
	Limit  int64
}

type DummyOutput struct{}

type Env interface {
	// Stat returns a *Input
	// associated with the given PartiQL expression.
	// The Hints provided in the second
	// argument can be used to constrain the set of
	// rows and columns that are present in the returned *Input.
	// The information provided by the *Input
	// is used by the query planner to make query-splitting
	// decisions.
	Stat(tbl expr.Node, h *Hints) (*Input, error)
}

type ExecParams struct {
	// Plan is the query plan being executed.
	Plan *Tree
	// Output is the destination of the query output.
	Output io.Writer
	// Stats are stats that are collected
	// during query execution.
	Stats ExecStats
	// Parallel determines the (local) parallelism
	// of plan execution. If Parallel is unset, then
	// runtime.GOMAXPROCS(0) is used instead.
	Parallel int
	// Rewriter is a rewrite that should be applied
	// to each expression in the query plan before
	// the query begins execution.
	Rewriter expr.Rewriter
	// Context indicates the cancellation scope
	// of the query. Transports are expected to
	// stop processing queries after Context is canceled.
	Context context.Context
	// Runner is the local execution environment
	// for the query. If Runner is nil, then query
	// execution will fail.
	Runner Runner
	// FS is the file system to read inputs from.
	// This may implement UploadFS, which is
	// required to enable support for SELECT INTO.
	FS fs.FS
	// contains filtered or unexported fields
}

type ExecStats struct {
	// CacheHits and CacheMisses
	// are the sum of the results
	// of CachedTable.Hits() and CachedTable.Misses(),
	// respectively.
	//
	// NOTE: see tenant/dcache.Stats
	// for a detailed description of how
	// we do bookkeeping for cache statistics.
	CacheHits, CacheMisses int64
	// BytesScanned is the number
	// of bytes scanned.
	BytesScanned int64
}

type Explain struct {
	Format expr.ExplainFormat
	Query  *expr.Query
	Tree   *Tree
}

type FSRunner struct {
	fs.FS
}

type Filter struct {
	Nonterminal
	Expr expr.Node
}

type Geometry struct {
	Peers []Transport
}

type HashAggregate struct {
	Nonterminal
	Agg      vm.Aggregation
	By       vm.Selection
	Windows  vm.Aggregation
	Limit    int
	OrderBy  []HashOrder
	NonEmpty bool
}

type HashOrder struct {
	Column   int
	Ordering vm.SortOrdering
}

type Hints struct {
	// Filter, if non-nil, is a predicate
	// that is applied to every row of the table.
	// (Env.Stat may use this to produce a *Input
	// that produces fewer rows than it otherwise would
	// due to the presence of some secondary indexing information.)
	Filter expr.Node
	// Fields is a list of top-level record fields explicitly
	// referenced by the query. The list of fields will always
	// be in lexicographical order.
	Fields []string
	// AllFields is set to true if all of the fields
	// are implicitly referenced in the query (i.e. via "*");
	// otherwise it is set to false.
	AllFields bool
}

type IfMatcher interface {
	// IfMatch is called to specify that the file
	// should be checked against the given ETag
	// and return an error if it doesn't match.
	//
	// If the ETag does not match, the error may
	// be returned at the time IfMatch is called,
	// on read, or at close time.
	IfMatch(etag string) error
}

type Index = pir.Index

type Indexer interface {
	// 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 Input struct {
	// Descs is the list of referenced descriptors
	// in the input.
	Descs []Descriptor

	// Fields are the fields in the input that are
	// needed by the query. If nil, all fields are
	// assumed to be needed. To specify zero
	// fields, use a non-nil slice of length 0.
	Fields []string
	// contains filtered or unexported fields
}

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

type Leaf struct {
	// Orig is the original table expression;
	// this exists mostly for presentation purposes.
	Orig *expr.Table
	// Filter is pushed down before exec if the
	// parent node supports filter pushdown.
	Filter expr.Node
	// OnEqual is a filtering operation that applies
	// specifically to partitions. The table will
	// only be iterated for partitions where
	//
	//   OnEqual[i] = PARTITION_VALUE(i)
	//
	// Since OnEqual depends on PARTITION_VALUE(i) being rewritten,
	// OnEqual is only present when Leaf is part of a sub-query
	// for a partitioned query.
	OnEqual   []string
	EqualExpr []expr.Node
}

type Limit struct {
	Nonterminal
	Num int64
}

type LocalTransport struct {
	// Threads is the number of threads
	// used for query evaluation.
	// If Threads is <= 0, then runtime.GOMAXPROCS
	// is used.
	Threads int
}

type NoOutput struct{}

type Node struct {
	// OutputType is the type of
	// the output column(s) of the
	// sub-query produced by this tree.
	// Note that we cannot always infer
	// the output types of every query.
	// For example, 'SELECT * ...' on data
	// without a schema does not produce
	// a known ResultSet.
	OutputType ResultSet
	// Input is the original input associated with this Op.
	Input int
	// Op is the first element of a linked list
	// of query execution steps. The linked list
	// is encoded in reverse-execution-order, so
	// Op is the last step in execution order,
	// and the terminal element of the list
	// is the first in execution order.
	Op Op
}

type Nonterminal struct {
	From Op
}

type Op interface {
	fmt.Stringer
	ion.FieldSetter
	// contains filtered or unexported methods
}

type OrderBy struct {
	Nonterminal
	Columns []vm.SortColumn
	Limit   int
	Offset  int
}

type OutputIndex struct {
	Nonterminal
	DB, Table string
	Basename  string
	Key       *blockfmt.Key
}

type OutputPart struct {
	Nonterminal
	Basename string
}

type PartGroups[T any] struct {
	// contains filtered or unexported fields
}

type Project struct {
	Nonterminal
	Using []expr.Binding
}

type Result struct {
	Name string
	Type expr.TypeSet
}

type ResultSet []Result

type Runner interface {
	// Run should write the contents of src into dst
	// and update ep.Stats as it does so.
	Run(dst vm.QuerySink, src *Input, ep *ExecParams) error
}

type Schemer 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
}

type Server struct {
	// Runner is the local execution environment
	// for the query. If Runner is nil, then query
	// execution will fail.
	Runner Runner
	// InitFS is used to initialize a file system
	// which will be used by the Runner to access
	// input objects. The datum passed to InitFS
	// is provided by the client to pass
	// appropriate information necessary to access
	// file system (e.g., credentials).
	InitFS func(ion.Datum) (fs.FS, error)
}

type SimpleAggregate struct {
	Nonterminal
	Outputs  vm.Aggregation
	NonEmpty bool
}

type SplitEnv interface {
	Env
	Geometry() *Geometry
}

type Substitute struct {
	Nonterminal

	// Inner is the list of sub-queries that need
	// their results substituted into the input
	// of this Substitute Op. The order of Inner elements
	// is important, as each Inner node i is used to substitute
	// results into the *REPLACEMENT(i) expressions.
	Inner []*Node
}

type Table struct {
	// TODO: we should encode the underlying table
	// expr only so different bindings don't cause
	// the same table to be scanned multiple times
	Table    *expr.Table
	Contents *Input
}

type TableLister interface {
	// ListTables returns the names of tables in
	// the given db. Callers must not modify the
	// returned list.
	ListTables(db string) ([]string, error)
}

type Transport interface {
	// Exec executes the provided query plan,
	// streaming the output of the query to ep.Output
	// (ep.Output may not be nil).
	// Each call to ep.Output.Write should contain exactly
	// one "chunk" of ion-encoded data, which will
	// begin with an ion BVM and be followed by zero
	// or more ion structures.
	//
	// The ep.Rewrite provided via ExecParams, if non-nil,
	// determines how table expressions are re-written
	// before they are provided to Transport.
	Exec(ep *ExecParams) error
}

type TransportDecoder interface {
	ion.FieldSetter
	Transport
}

type Tree struct {
	// ID is an opaque ID assigned to this query by the caller.
	ID string
	// Inputs is the global list of inputs for the tree.
	// Each [Node.Input] references an element of this array.
	//
	// (These are stored globally so that the same table
	// referenced multiple times does not consume extra space.)
	Inputs []*Input
	// Data is arbitrary data that can be included
	// along with the tree during serialization.
	Data ion.Datum
	// Root is the root node of the plan tree.
	Root Node

	Results     []expr.Binding
	ResultTypes []expr.TypeSet
}

type UnionMap struct {
	Nonterminal

	// Geometry determines how table handle inputs
	// are distributed onto the constituent partials
	Geometry *Geometry
}

type UnionPartition struct {
	Nonterminal
	By []string
}

type Unnest struct {
	Nonterminal // source op
	Expr        expr.Node
	Result      string
}

type Unpivot struct {
	Nonterminal
	As *string
	At *string
}

type UnpivotAtDistinct struct {
	Nonterminal
	At string
}

type UploadEnv interface {
	// Key returns the key that should be used to
	// sign the index.
	Key() *blockfmt.Key
}

type UploadFS interface {
	blockfmt.UploadFS
}