lang

type ASTCompiler ¶

type ASTCompiler struct {
	AST *ast.Package `json:"ast"`
	Now time.Time
}

ASTCompiler implements Compiler by producing a Spec from an AST.

func (c ASTCompiler) Compile(ctx context.Context) (flux.Program, error)

func (ASTCompiler) CompilerType() flux.CompilerType

func (c *ASTCompiler) PrependFile(file *ast.File)

type AstProgram ¶

type AstProgram struct {
	*Program

	Ast *ast.Package
	Now time.Time
}

AstProgram wraps a Program with an AST that will be evaluated upon Start. As such, the PlanSpec is populated after Start and evaluation errors are returned by Start.

func Compile(q string, now time.Time, opts ...CompileOption) (*AstProgram, error)

func CompileAST(astPkg *ast.Package, now time.Time, opts ...CompileOption) *AstProgram

func (p *AstProgram) Start(ctx context.Context, alloc *memory.Allocator) (flux.Query, error)

type CompileOption ¶

type CompileOption func(*compileOptions)

CompileOption represents an option for compilation.

func Verbose(v bool) CompileOption

func WithExtern(extern *ast.File) CompileOption

func WithLogPlanOpts(lopts ...plan.LogicalOption) CompileOption

func WithPhysPlanOpts(popts ...plan.PhysicalOption) CompileOption

type ExecutionDependencies ¶

type ExecutionDependencies struct {
	Allocator *memory.Allocator
	Logger    *zap.Logger
}

ExecutionDependencies represents the dependencies that a function call executed by the Interpreter needs in order to trigger the execution of a flux.Program

func GetExecutionDependencies(ctx context.Context) ExecutionDependencies

func (d ExecutionDependencies) Inject(ctx context.Context) context.Context

type FluxCompiler ¶

type FluxCompiler struct {
	Now    time.Time
	Extern *ast.File `json:"extern"`
	Query  string    `json:"query"`
}

FluxCompiler compiles a Flux script into a spec.

func (c FluxCompiler) Compile(ctx context.Context) (flux.Program, error)

func (c FluxCompiler) CompilerType() flux.CompilerType

type LoggingProgram ¶

type LoggingProgram interface {
	SetLogger(logger *zap.Logger)
}

type Program ¶

type Program struct {
	Logger   *zap.Logger
	PlanSpec *plan.Spec
	// contains filtered or unexported fields
}

Program implements the flux.Program interface. It will execute a compiled plan using an executor.

func CompileTableObject(ctx context.Context, to *flux.TableObject, now time.Time, opts ...CompileOption) (*Program, error)

func (p *Program) SetLogger(logger *zap.Logger)

func (p *Program) Start(ctx context.Context, alloc *memory.Allocator) (flux.Query, error)

type TableObjectCompiler ¶

type TableObjectCompiler struct {
	Tables *flux.TableObject
	Now    time.Time
}

TableObjectCompiler compiles a TableObject into an executable flux.Program. It is not added to CompilerMappings and it is not serializable, because it is impossible to use it outside of the context of an ongoing execution.

func (c *TableObjectCompiler) Compile(ctx context.Context) (flux.Program, error)

func (*TableObjectCompiler) CompilerType() flux.CompilerType