planner

package
v3.35.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 30, 2023 License: Apache-2.0, Apache-2.0 Imports: 39 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExprWalk 

func ExprWalk(v ExprVisitor, expr types.PlanExpression)

func ExprWithPlanOpWalk 

func ExprWithPlanOpWalk(v PlanOpExprVisitor, op types.PlanOperator, expr types.PlanExpression)

ExprWithPlanOpWalk traverses the expression tree in depth-first order. It starts by calling v.VisitPlanOpExpr(op, expr); expr must not be nil. If the visitor returned by v.VisitPlanOpExpr(op, expr) is not nil, Walk is invoked recursively with the returned visitor for each children of the expr, followed by a call of v.VisitPlanOpExpr(nil, nil) to the returned visitor.

func ExpressionToColumn 

func ExpressionToColumn(e types.PlanExpression) *types.PlannerColumn

func InspectExpression 

func InspectExpression(expr types.PlanExpression, f func(expr types.PlanExpression) bool)

InspectExpression traverses expressions in depth-first order

func InspectExpressionsWithPlanOp 

func InspectExpressionsWithPlanOp(op types.PlanOperator, f exprWithNodeInspector)

InspectExpressionsWithPlanOp traverses the plan and calls f on any expression it finds.

func InspectOperatorExpressions added in v3.27.0 

func InspectOperatorExpressions(op types.PlanOperator, f exprInspector)

InspectOperatorExpressions traverses the plan and calls WalkExpressions on any expression it finds.

func InspectPlan 

func InspectPlan(op types.PlanOperator, f planInspectionFunction)

InspectPlan traverses the plan op graph depth-first order if f(op) returns true, InspectPlan invokes f recursively for each of the children of op, followed by a call of f(nil).

func NewAggAvgBuffer 

func NewAggAvgBuffer(child types.PlanExpression) *aggregateAvg

func NewAggCountBuffer 

func NewAggCountBuffer(child types.PlanExpression) *aggregateCount

func NewAggCountDistinctBuffer 

func NewAggCountDistinctBuffer(child types.PlanExpression) *aggregateCountDistinct

func NewAggLastBuffer 

func NewAggLastBuffer(child types.PlanExpression) *aggregateLast

func NewAggMaxBuffer 

func NewAggMaxBuffer(child types.PlanExpression) *aggregateMax

func NewAggMinBuffer 

func NewAggMinBuffer(child types.PlanExpression) *aggregateMin

func NewAggSumBuffer 

func NewAggSumBuffer(child types.PlanExpression) *aggregateSum

func NewFirstBuffer 

func NewFirstBuffer(child types.PlanExpression) *aggregateFirst

func NewParquetReader added in v3.30.0 

func NewParquetReader(ctx context.Context, mappings []*bulkInsertMapColumn, r *os.File, mem memory.Allocator) (*parquetReader, error)

func PlanWalk 

func PlanWalk(v PlanVisitor, op types.PlanOperator)

PlanWalk traverses the plan depth-first. It starts by calling v.VisitOperator; node must not be nil. If the result returned by v.VisitOperator is not nil, PlanWalk is invoked recursively with the returned result for each of the children of the plan operator, followed by a call of v.VisitOperator(nil) to the returned result. If v.VisitOperator(op) returns non-nil, then all children are walked, even if one of them returns nil.

func ProjectRow 

func ProjectRow(ctx context.Context, projections []types.PlanExpression, row types.Row) (types.Row, error)

ProjectRow evaluates a set of projections.

func TransformExpr 

func TransformExpr(expr types.PlanExpression, transformFunction ExprFunc, selector ExprSelectorFunc) (types.PlanExpression, bool, error)

TransformExpr applies a depth first transformation function to an expression

func TransformPlanOp 

func TransformPlanOp(op types.PlanOperator, f PlanOpTransformFunc) (types.PlanOperator, bool, error)

TransformPlanOp applies a depth first transformation function to the given plan op It returns a tuple that is the result of the transformation; the new PlanOperator, a bool that is true if the resultant PlanOperator has not been transformed or an error. If the TransformPlanOp has children it will iterate the children and call the transformation function on each of them in turn. If those operators are transformed, it will create a new operator with those children. The last step is to call the transformation on the passed PlanOperator

func TransformPlanOpWithParent 

func TransformPlanOpWithParent(op types.PlanOperator, s ParentSelectorFunc, f ParentContextFunc) (types.PlanOperator, bool, error)

TransformPlanOpWithParent applies a transformation function to a plan operator in the context that plan operators parent

func TransformSinglePlanOpExpressions 

func TransformSinglePlanOpExpressions(op types.PlanOperator, f ExprFunc, selector ExprSelectorFunc) (types.PlanOperator, bool, error)

TransformSinglePlanOpExpressions applies a transformation function to all expressions on the given plan operator

func WalkExpressionsWithPlanOp 

func WalkExpressionsWithPlanOp(v PlanOpExprVisitor, op types.PlanOperator)

WalkExpressionsWithPlanOp traverses the plan and calls ExprWithPlanOpWalk on any expression it finds.

Types

type ExecutionPlanner 

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

ExecutionPlanner compiles SQL text into a query plan

func NewExecutionPlanner 

func NewExecutionPlanner(executor pilosa.Executor, schemaAPI pilosa.SchemaAPI, systemAPI pilosa.SystemAPI, systemLayerAPI pilosa.SystemLayerAPI, importer pilosa.Importer, logger logger.Logger, sql string) *ExecutionPlanner

func (*ExecutionPlanner) CompilePlan 

func (p *ExecutionPlanner) CompilePlan(ctx context.Context, stmt parser.Statement) (types.PlanOperator, error)

CompilePlan takes an AST (parser.Statement) and compiles into a query plan returning the root PlanOperator The act of compiling includes an analysis step that does semantic analysis of the AST, this includes type checking, and sometimes AST rewriting. The compile phase uses the type-checked and rewritten AST to produce a query plan.

func (*ExecutionPlanner) RehydratePlanOp added in v3.29.0 

func (p *ExecutionPlanner) RehydratePlanOp(ctx context.Context, reader io.Reader) (types.PlanOperator, error)

type ExprFunc 

type ExprFunc func(expr types.PlanExpression) (types.PlanExpression, bool, error)

ExprFunc is a function that given an expression will return that expression as is or transformed, or bool to indicate whether the expression was modified, and an error or nil.

type ExprSelectorFunc 

type ExprSelectorFunc func(parentExpr, childExpr types.PlanExpression) bool

ExprSelectorFunc is a function that can be used as a filter selector during expression transformation - it is called before calling a transformation function on a child expression; if it returns false, the child is skipped

type ExprVisitor 

type ExprVisitor interface {
	// VisitExpr method is invoked for each expr encountered by ExprWalk.
	// If the result is not nil, ExprWalk visits each of the children
	// of the expr, followed by a call of VisitExpr(nil) to the returned result.
	VisitExpr(expr types.PlanExpression) ExprVisitor
}

ExprVisitor visits expressions in an expression tree.

type ExprWithPlanOpFunc 

type ExprWithPlanOpFunc func(op types.PlanOperator, expr types.PlanExpression) (types.PlanExpression, bool, error)

ExprWithPlanOpFunc is a function that given an expression and the node that contains it, will return that expression as is or transformed along with an error, if any.

type OptimizerFunc 

type OptimizerFunc func(context.Context, *ExecutionPlanner, types.PlanOperator, *OptimizerScope) (types.PlanOperator, bool, error)

OptimizerFunc is a function prototype for all optimizer rules.

type OptimizerScope 

type OptimizerScope struct {
}

OptimizerScope will be used in future for symbol resolution when CTEs and subquery support matures and we need to introduce the concept of scope to symbol resolution.

type OrderByExpression 

type OrderByExpression struct {
	Expr         types.PlanExpression
	Order        orderByOrder
	NullOrdering nullOrdering
}

OrderByExpression is the expression on which an order by can be computed

type OrderBySorter 

type OrderBySorter struct {
	SortFields []*OrderByExpression
	Rows       []types.Row
	LastError  error
	Ctx        context.Context
}

func (*OrderBySorter) Len 

func (s *OrderBySorter) Len() int

func (*OrderBySorter) Less 

func (s *OrderBySorter) Less(i, j int) bool

func (*OrderBySorter) Swap 

func (s *OrderBySorter) Swap(i, j int)

type ParentContext 

type ParentContext struct {
	Operator   types.PlanOperator
	Parent     types.PlanOperator
	ChildCount int
}

ParentContext is a struct that enables transformation functions to include a parent operator

type ParentContextFunc 

type ParentContextFunc func(c ParentContext) (types.PlanOperator, bool, error)

type ParentSelectorFunc 

type ParentSelectorFunc func(c ParentContext) bool

type PlanOpAlterDatabase added in v3.32.0 

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

PlanOpAlterDatabase plan operator to alter a database.

func NewPlanOpAlterDatabase added in v3.32.0 

func NewPlanOpAlterDatabase(p *ExecutionPlanner, db *dax.Database, operation alterOperation, option parser.DatabaseOption) *PlanOpAlterDatabase

func (*PlanOpAlterDatabase) AddWarning added in v3.32.0 

func (p *PlanOpAlterDatabase) AddWarning(warning string)

func (*PlanOpAlterDatabase) Children added in v3.32.0 

func (p *PlanOpAlterDatabase) Children() []types.PlanOperator

func (*PlanOpAlterDatabase) Iterator added in v3.32.0 

func (p *PlanOpAlterDatabase) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpAlterDatabase) Plan added in v3.32.0 

func (p *PlanOpAlterDatabase) Plan() map[string]interface{}

func (*PlanOpAlterDatabase) Schema added in v3.32.0 

func (p *PlanOpAlterDatabase) Schema() types.Schema

func (*PlanOpAlterDatabase) String added in v3.32.0 

func (p *PlanOpAlterDatabase) String() string

func (*PlanOpAlterDatabase) Warnings added in v3.32.0 

func (p *PlanOpAlterDatabase) Warnings() []string

func (*PlanOpAlterDatabase) WithChildren added in v3.32.0 

func (p *PlanOpAlterDatabase) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpAlterTable 

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

PlanOpAlterTable plan operator to alter a table.

func NewPlanOpAlterTable 

func NewPlanOpAlterTable(p *ExecutionPlanner, tableName string, operation alterOperation, oldColumnName string, newColumnName string, columnDef *createTableField) *PlanOpAlterTable

func (*PlanOpAlterTable) AddWarning 

func (p *PlanOpAlterTable) AddWarning(warning string)

func (*PlanOpAlterTable) Children 

func (p *PlanOpAlterTable) Children() []types.PlanOperator

func (*PlanOpAlterTable) Iterator 

func (p *PlanOpAlterTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpAlterTable) Plan 

func (p *PlanOpAlterTable) Plan() map[string]interface{}

func (*PlanOpAlterTable) Schema 

func (p *PlanOpAlterTable) Schema() types.Schema

func (*PlanOpAlterTable) String 

func (p *PlanOpAlterTable) String() string

func (*PlanOpAlterTable) Warnings 

func (p *PlanOpAlterTable) Warnings() []string

func (*PlanOpAlterTable) WithChildren 

func (p *PlanOpAlterTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpAlterView added in v3.29.0 

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

PlanOpAlterView implements the ALTER VIEW operator

func NewPlanOpAlterView added in v3.29.0 

func NewPlanOpAlterView(planner *ExecutionPlanner, view *viewSystemObject) *PlanOpAlterView

func (*PlanOpAlterView) AddWarning added in v3.29.0 

func (p *PlanOpAlterView) AddWarning(warning string)

func (*PlanOpAlterView) Children added in v3.29.0 

func (p *PlanOpAlterView) Children() []types.PlanOperator

func (*PlanOpAlterView) Iterator added in v3.29.0 

func (p *PlanOpAlterView) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpAlterView) Plan added in v3.29.0 

func (p *PlanOpAlterView) Plan() map[string]interface{}

func (*PlanOpAlterView) Schema added in v3.29.0 

func (p *PlanOpAlterView) Schema() types.Schema

func (*PlanOpAlterView) String added in v3.29.0 

func (p *PlanOpAlterView) String() string

func (*PlanOpAlterView) Warnings added in v3.29.0 

func (p *PlanOpAlterView) Warnings() []string

func (*PlanOpAlterView) WithChildren added in v3.29.0 

func (p *PlanOpAlterView) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpBulkInsert 

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

PlanOpBulkInsert plan operator to handle INSERT.

func NewPlanOpBulkInsert 

func NewPlanOpBulkInsert(p *ExecutionPlanner, tableName string, options *bulkInsertOptions) *PlanOpBulkInsert

func (*PlanOpBulkInsert) AddWarning 

func (p *PlanOpBulkInsert) AddWarning(warning string)

func (*PlanOpBulkInsert) Children 

func (p *PlanOpBulkInsert) Children() []types.PlanOperator

func (*PlanOpBulkInsert) Iterator 

func (p *PlanOpBulkInsert) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpBulkInsert) Plan 

func (p *PlanOpBulkInsert) Plan() map[string]interface{}

func (*PlanOpBulkInsert) Schema 

func (p *PlanOpBulkInsert) Schema() types.Schema

func (*PlanOpBulkInsert) String 

func (p *PlanOpBulkInsert) String() string

func (*PlanOpBulkInsert) Warnings 

func (p *PlanOpBulkInsert) Warnings() []string

func (*PlanOpBulkInsert) WithChildren 

func (p *PlanOpBulkInsert) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpCreateDatabase added in v3.32.0 

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

PlanOpCreateDatabase is a plan operator that creates a database.

func NewPlanOpCreateDatabase added in v3.32.0 

func NewPlanOpCreateDatabase(p *ExecutionPlanner, databaseName string, failIfExists bool, units int, description string) *PlanOpCreateDatabase

NewPlanOpCreateDatabase returns a new PlanOpCreateDatabase planoperator

func (*PlanOpCreateDatabase) AddWarning added in v3.32.0 

func (p *PlanOpCreateDatabase) AddWarning(warning string)

func (*PlanOpCreateDatabase) Children added in v3.32.0 

func (p *PlanOpCreateDatabase) Children() []types.PlanOperator

func (*PlanOpCreateDatabase) Iterator added in v3.32.0 

func (p *PlanOpCreateDatabase) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpCreateDatabase) Plan added in v3.32.0 

func (p *PlanOpCreateDatabase) Plan() map[string]interface{}

func (*PlanOpCreateDatabase) Schema added in v3.32.0 

func (p *PlanOpCreateDatabase) Schema() types.Schema

func (*PlanOpCreateDatabase) String added in v3.32.0 

func (p *PlanOpCreateDatabase) String() string

func (*PlanOpCreateDatabase) Warnings added in v3.32.0 

func (p *PlanOpCreateDatabase) Warnings() []string

func (*PlanOpCreateDatabase) WithChildren added in v3.32.0 

func (p *PlanOpCreateDatabase) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpCreateTable 

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

PlanOpCreateTable plan operator that creates a table.

func NewPlanOpCreateTable 

func NewPlanOpCreateTable(p *ExecutionPlanner, tableName string, failIfExists bool, isKeyed bool, keyPartitions int, description string, columns []*createTableField) *PlanOpCreateTable

NewPlanOpCreateTable returns a new PlanOpCreateTable planoperator

func (*PlanOpCreateTable) AddWarning 

func (p *PlanOpCreateTable) AddWarning(warning string)

func (*PlanOpCreateTable) Children 

func (p *PlanOpCreateTable) Children() []types.PlanOperator

func (*PlanOpCreateTable) Iterator 

func (p *PlanOpCreateTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpCreateTable) Plan 

func (p *PlanOpCreateTable) Plan() map[string]interface{}

func (*PlanOpCreateTable) Schema 

func (p *PlanOpCreateTable) Schema() types.Schema

func (*PlanOpCreateTable) String 

func (p *PlanOpCreateTable) String() string

func (*PlanOpCreateTable) Warnings 

func (p *PlanOpCreateTable) Warnings() []string

func (*PlanOpCreateTable) WithChildren 

func (p *PlanOpCreateTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpCreateView added in v3.29.0 

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

PlanOpCreateView implements the CREATE VIEW operator

func NewPlanOpCreateView added in v3.29.0 

func NewPlanOpCreateView(planner *ExecutionPlanner, ifNotExists bool, view *viewSystemObject) *PlanOpCreateView

func (*PlanOpCreateView) AddWarning added in v3.29.0 

func (p *PlanOpCreateView) AddWarning(warning string)

func (*PlanOpCreateView) Children added in v3.29.0 

func (p *PlanOpCreateView) Children() []types.PlanOperator

func (*PlanOpCreateView) Iterator added in v3.29.0 

func (p *PlanOpCreateView) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpCreateView) Plan added in v3.29.0 

func (p *PlanOpCreateView) Plan() map[string]interface{}

func (*PlanOpCreateView) Schema added in v3.29.0 

func (p *PlanOpCreateView) Schema() types.Schema

func (*PlanOpCreateView) String added in v3.29.0 

func (p *PlanOpCreateView) String() string

func (*PlanOpCreateView) Warnings added in v3.29.0 

func (p *PlanOpCreateView) Warnings() []string

func (*PlanOpCreateView) WithChildren added in v3.29.0 

func (p *PlanOpCreateView) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpDistinct 

type PlanOpDistinct struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpDistinct plan operator handles DISTINCT DISTINCT returns unique rows from its iterator and does this by creating a hash table and probing new rows against that hash table, if the row has already been seen, it is skipped, it it has not been seen, a 'key' is created from all the values in the row and this is inserted into the hash table. The hash table is implemented using Extendible Hashing and is backed by a buffer pool. The buffer pool is allocated to 128 pages (or 1Mb) and the disk manager used by the buffer pool will use an in-memory implementation up to 128 pages and thereafter spill to disk

func NewPlanOpDistinct 

func NewPlanOpDistinct(p *ExecutionPlanner, child types.PlanOperator) *PlanOpDistinct

func (*PlanOpDistinct) AddWarning 

func (p *PlanOpDistinct) AddWarning(warning string)

func (*PlanOpDistinct) Children added in v3.27.0 

func (p *PlanOpDistinct) Children() []types.PlanOperator

func (*PlanOpDistinct) Iterator added in v3.27.0 

func (p *PlanOpDistinct) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpDistinct) Plan 

func (p *PlanOpDistinct) Plan() map[string]interface{}

func (*PlanOpDistinct) Schema added in v3.27.0 

func (p *PlanOpDistinct) Schema() types.Schema

func (*PlanOpDistinct) String added in v3.27.0 

func (p *PlanOpDistinct) String() string

func (*PlanOpDistinct) Warnings 

func (p *PlanOpDistinct) Warnings() []string

func (*PlanOpDistinct) WithChildren added in v3.27.0 

func (p *PlanOpDistinct) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpDropDatabase added in v3.32.0 

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

PlanOpDropDatabase plan operator to drop a database.

func NewPlanOpDropDatabase added in v3.32.0 

func NewPlanOpDropDatabase(p *ExecutionPlanner, db *dax.Database) *PlanOpDropDatabase

func (*PlanOpDropDatabase) AddWarning added in v3.32.0 

func (p *PlanOpDropDatabase) AddWarning(warning string)

func (*PlanOpDropDatabase) Children added in v3.32.0 

func (p *PlanOpDropDatabase) Children() []types.PlanOperator

func (*PlanOpDropDatabase) Iterator added in v3.32.0 

func (p *PlanOpDropDatabase) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpDropDatabase) Plan added in v3.32.0 

func (p *PlanOpDropDatabase) Plan() map[string]interface{}

func (*PlanOpDropDatabase) Schema added in v3.32.0 

func (p *PlanOpDropDatabase) Schema() types.Schema

func (*PlanOpDropDatabase) String added in v3.32.0 

func (p *PlanOpDropDatabase) String() string

func (*PlanOpDropDatabase) Warnings added in v3.32.0 

func (p *PlanOpDropDatabase) Warnings() []string

func (*PlanOpDropDatabase) WithChildren added in v3.32.0 

func (p *PlanOpDropDatabase) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpDropTable 

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

PlanOpDropTable plan operator to drop a table.

func NewPlanOpDropTable 

func NewPlanOpDropTable(p *ExecutionPlanner, index *pilosa.IndexInfo) *PlanOpDropTable

func (*PlanOpDropTable) AddWarning 

func (p *PlanOpDropTable) AddWarning(warning string)

func (*PlanOpDropTable) Children 

func (p *PlanOpDropTable) Children() []types.PlanOperator

func (*PlanOpDropTable) Iterator 

func (p *PlanOpDropTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpDropTable) Plan 

func (p *PlanOpDropTable) Plan() map[string]interface{}

func (*PlanOpDropTable) Schema 

func (p *PlanOpDropTable) Schema() types.Schema

func (*PlanOpDropTable) String 

func (p *PlanOpDropTable) String() string

func (*PlanOpDropTable) Warnings 

func (p *PlanOpDropTable) Warnings() []string

func (*PlanOpDropTable) WithChildren 

func (p *PlanOpDropTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpDropView added in v3.29.0 

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

PlanOpDropView plan operator to drop a view.

func NewPlanOpDropView added in v3.29.0 

func NewPlanOpDropView(p *ExecutionPlanner, ifExists bool, viewName string) *PlanOpDropView

func (*PlanOpDropView) AddWarning added in v3.29.0 

func (p *PlanOpDropView) AddWarning(warning string)

func (*PlanOpDropView) Children added in v3.29.0 

func (p *PlanOpDropView) Children() []types.PlanOperator

func (*PlanOpDropView) Iterator added in v3.29.0 

func (p *PlanOpDropView) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpDropView) Plan added in v3.29.0 

func (p *PlanOpDropView) Plan() map[string]interface{}

func (*PlanOpDropView) Schema added in v3.29.0 

func (p *PlanOpDropView) Schema() types.Schema

func (*PlanOpDropView) String added in v3.29.0 

func (p *PlanOpDropView) String() string

func (*PlanOpDropView) Warnings added in v3.29.0 

func (p *PlanOpDropView) Warnings() []string

func (*PlanOpDropView) WithChildren added in v3.29.0 

func (p *PlanOpDropView) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpExprVisitor 

type PlanOpExprVisitor interface {
	// VisitPlanOpExpr method is invoked for each expr encountered by Walk. If the result Visitor is not nil, Walk visits each of
	// the children of the expr with that visitor, followed by a call of VisitPlanOpExpr(nil, nil) to the returned visitor.
	VisitPlanOpExpr(op types.PlanOperator, expression types.PlanExpression) PlanOpExprVisitor
}

PlanOpExprVisitor visits expressions in an expression tree. Like ExprVisitor, but with the added context of the plan op in which an expression is embedded.

type PlanOpFanout added in v3.29.0 

type PlanOpFanout struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpFanout is a query fanout operator that will execute an operator across all cluster nodes

func NewPlanOpFanout added in v3.29.0 

func NewPlanOpFanout(planner *ExecutionPlanner, child types.PlanOperator) *PlanOpFanout

func (*PlanOpFanout) AddWarning added in v3.29.0 

func (p *PlanOpFanout) AddWarning(warning string)

func (*PlanOpFanout) Children added in v3.29.0 

func (p *PlanOpFanout) Children() []types.PlanOperator

func (*PlanOpFanout) Expressions added in v3.29.0 

func (p *PlanOpFanout) Expressions() []types.PlanExpression

func (*PlanOpFanout) Iterator added in v3.29.0 

func (p *PlanOpFanout) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpFanout) Plan added in v3.29.0 

func (p *PlanOpFanout) Plan() map[string]interface{}

func (*PlanOpFanout) Schema added in v3.29.0 

func (p *PlanOpFanout) Schema() types.Schema

func (*PlanOpFanout) String added in v3.29.0 

func (p *PlanOpFanout) String() string

func (*PlanOpFanout) Warnings added in v3.29.0 

func (p *PlanOpFanout) Warnings() []string

func (*PlanOpFanout) WithChildren added in v3.29.0 

func (p *PlanOpFanout) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpFanout) WithUpdatedExpressions added in v3.29.0 

func (p *PlanOpFanout) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpFeatureBaseColumns 

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

PlanOpFeatureBaseColumns wraps an Index that is returned from schemaAPI.Schema().

func NewPlanOpFeatureBaseColumns 

func NewPlanOpFeatureBaseColumns(tbl *dax.Table) *PlanOpFeatureBaseColumns

func (*PlanOpFeatureBaseColumns) AddWarning 

func (p *PlanOpFeatureBaseColumns) AddWarning(warning string)

func (*PlanOpFeatureBaseColumns) Children 

func (p *PlanOpFeatureBaseColumns) Children() []types.PlanOperator

func (*PlanOpFeatureBaseColumns) Iterator 

func (p *PlanOpFeatureBaseColumns) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpFeatureBaseColumns) Plan 

func (p *PlanOpFeatureBaseColumns) Plan() map[string]interface{}

func (*PlanOpFeatureBaseColumns) Schema 

func (p *PlanOpFeatureBaseColumns) Schema() types.Schema

func (*PlanOpFeatureBaseColumns) String 

func (p *PlanOpFeatureBaseColumns) String() string

func (*PlanOpFeatureBaseColumns) Warnings 

func (p *PlanOpFeatureBaseColumns) Warnings() []string

func (*PlanOpFeatureBaseColumns) WithChildren 

func (p *PlanOpFeatureBaseColumns) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpFeatureBaseDatabases added in v3.32.0 

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

PlanOpFeatureBaseDatabases wraps a []*Database that is returned from schemaAPI.Schema().

func NewPlanOpFeatureBaseDatabases added in v3.32.0 

func NewPlanOpFeatureBaseDatabases(planner *ExecutionPlanner, dbs []*dax.Database) *PlanOpFeatureBaseDatabases

func (*PlanOpFeatureBaseDatabases) AddWarning added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) AddWarning(warning string)

func (*PlanOpFeatureBaseDatabases) Children added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) Children() []types.PlanOperator

func (*PlanOpFeatureBaseDatabases) Iterator added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpFeatureBaseDatabases) Plan added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) Plan() map[string]interface{}

func (*PlanOpFeatureBaseDatabases) Schema added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) Schema() types.Schema

func (*PlanOpFeatureBaseDatabases) String added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) String() string

func (*PlanOpFeatureBaseDatabases) Warnings added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) Warnings() []string

func (*PlanOpFeatureBaseDatabases) WithChildren added in v3.32.0 

func (p *PlanOpFeatureBaseDatabases) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpFeatureBaseTables 

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

PlanOpFeatureBaseTables wraps a []*IndexInfo that is returned from schemaAPI.Schema().

func NewPlanOpFeatureBaseTables 

func NewPlanOpFeatureBaseTables(planner *ExecutionPlanner, indexInfo []*pilosa.IndexInfo) *PlanOpFeatureBaseTables

func (*PlanOpFeatureBaseTables) AddWarning 

func (p *PlanOpFeatureBaseTables) AddWarning(warning string)

func (*PlanOpFeatureBaseTables) Children 

func (p *PlanOpFeatureBaseTables) Children() []types.PlanOperator

func (*PlanOpFeatureBaseTables) Iterator 

func (p *PlanOpFeatureBaseTables) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpFeatureBaseTables) Plan 

func (p *PlanOpFeatureBaseTables) Plan() map[string]interface{}

func (*PlanOpFeatureBaseTables) Schema 

func (p *PlanOpFeatureBaseTables) Schema() types.Schema

func (*PlanOpFeatureBaseTables) String 

func (p *PlanOpFeatureBaseTables) String() string

func (*PlanOpFeatureBaseTables) Warnings 

func (p *PlanOpFeatureBaseTables) Warnings() []string

func (*PlanOpFeatureBaseTables) WithChildren 

func (p *PlanOpFeatureBaseTables) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpFilter 

type PlanOpFilter struct {
	ChildOp   types.PlanOperator
	Predicate types.PlanExpression
	// contains filtered or unexported fields
}

PlanOpFilter is a filter operator

func NewPlanOpFilter 

func NewPlanOpFilter(planner *ExecutionPlanner, predicate types.PlanExpression, child types.PlanOperator) *PlanOpFilter

func (*PlanOpFilter) AddWarning 

func (p *PlanOpFilter) AddWarning(warning string)

func (*PlanOpFilter) Children 

func (p *PlanOpFilter) Children() []types.PlanOperator

func (*PlanOpFilter) Expressions 

func (p *PlanOpFilter) Expressions() []types.PlanExpression

func (*PlanOpFilter) Iterator 

func (p *PlanOpFilter) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpFilter) Plan 

func (p *PlanOpFilter) Plan() map[string]interface{}

func (*PlanOpFilter) Schema 

func (p *PlanOpFilter) Schema() types.Schema

func (*PlanOpFilter) String 

func (p *PlanOpFilter) String() string

func (*PlanOpFilter) Warnings 

func (p *PlanOpFilter) Warnings() []string

func (*PlanOpFilter) WithChildren 

func (p *PlanOpFilter) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpFilter) WithUpdatedExpressions 

func (p *PlanOpFilter) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpGroupBy 

type PlanOpGroupBy struct {
	ChildOp      types.PlanOperator
	Aggregates   []types.PlanExpression
	GroupByExprs []types.PlanExpression
	// contains filtered or unexported fields
}

PlanOpGroupBy handles the GROUP BY clause this is the default GROUP BY operator and may be replaced by the optimizer with one or more of the PQL related group by or aggregate operators

func NewPlanOpGroupBy 

func NewPlanOpGroupBy(aggregates []types.PlanExpression, groupByExprs []types.PlanExpression, child types.PlanOperator) *PlanOpGroupBy

func (*PlanOpGroupBy) AddWarning 

func (p *PlanOpGroupBy) AddWarning(warning string)

func (*PlanOpGroupBy) Children 

func (p *PlanOpGroupBy) Children() []types.PlanOperator

func (*PlanOpGroupBy) Expressions 

func (p *PlanOpGroupBy) Expressions() []types.PlanExpression

func (*PlanOpGroupBy) Iterator 

func (p *PlanOpGroupBy) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpGroupBy) Plan 

func (p *PlanOpGroupBy) Plan() map[string]interface{}

func (*PlanOpGroupBy) Schema 

func (p *PlanOpGroupBy) Schema() types.Schema

Schema for GroupBy is the group by expressions followed by the aggregate expressions

func (*PlanOpGroupBy) String 

func (p *PlanOpGroupBy) String() string

func (*PlanOpGroupBy) Warnings 

func (p *PlanOpGroupBy) Warnings() []string

func (*PlanOpGroupBy) WithChildren 

func (p *PlanOpGroupBy) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpGroupBy) WithUpdatedExpressions 

func (p *PlanOpGroupBy) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpHaving added in v3.27.0 

type PlanOpHaving struct {
	ChildOp   types.PlanOperator
	Predicate types.PlanExpression
	// contains filtered or unexported fields
}

PlanOpHaving is a filter operator for the HAVING clause

func NewPlanOpHaving added in v3.27.0 

func NewPlanOpHaving(planner *ExecutionPlanner, predicate types.PlanExpression, child types.PlanOperator) *PlanOpHaving

func (*PlanOpHaving) AddWarning added in v3.27.0 

func (p *PlanOpHaving) AddWarning(warning string)

func (*PlanOpHaving) Children added in v3.27.0 

func (p *PlanOpHaving) Children() []types.PlanOperator

func (*PlanOpHaving) Expressions added in v3.27.0 

func (p *PlanOpHaving) Expressions() []types.PlanExpression

func (*PlanOpHaving) Iterator added in v3.27.0 

func (p *PlanOpHaving) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpHaving) Plan added in v3.27.0 

func (p *PlanOpHaving) Plan() map[string]interface{}

func (*PlanOpHaving) Schema added in v3.27.0 

func (p *PlanOpHaving) Schema() types.Schema

func (*PlanOpHaving) String added in v3.27.0 

func (p *PlanOpHaving) String() string

func (*PlanOpHaving) Warnings added in v3.27.0 

func (p *PlanOpHaving) Warnings() []string

func (*PlanOpHaving) WithChildren added in v3.27.0 

func (p *PlanOpHaving) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpHaving) WithUpdatedExpressions added in v3.27.0 

func (p *PlanOpHaving) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpInsert 

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

PlanOpInsert plan operator to handle INSERT.

func NewPlanOpInsert 

func NewPlanOpInsert(p *ExecutionPlanner, tableName string, targetColumns []*qualifiedRefPlanExpression, insertValues [][]types.PlanExpression) *PlanOpInsert

func (*PlanOpInsert) AddWarning 

func (p *PlanOpInsert) AddWarning(warning string)

func (*PlanOpInsert) Children 

func (p *PlanOpInsert) Children() []types.PlanOperator

func (*PlanOpInsert) Iterator 

func (p *PlanOpInsert) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpInsert) Plan 

func (p *PlanOpInsert) Plan() map[string]interface{}

func (*PlanOpInsert) Schema 

func (p *PlanOpInsert) Schema() types.Schema

func (*PlanOpInsert) String 

func (p *PlanOpInsert) String() string

func (*PlanOpInsert) Warnings 

func (p *PlanOpInsert) Warnings() []string

func (*PlanOpInsert) WithChildren 

func (p *PlanOpInsert) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpNestedLoops 

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

PlanOpNestedLoops plan operator handles a join For each row in the top input, scan the bottom input and output matching rows

func NewPlanOpNestedLoops 

func NewPlanOpNestedLoops(top, bottom types.PlanOperator, jType joinType, condition types.PlanExpression) *PlanOpNestedLoops

func (*PlanOpNestedLoops) AddWarning 

func (p *PlanOpNestedLoops) AddWarning(warning string)

func (*PlanOpNestedLoops) Children 

func (p *PlanOpNestedLoops) Children() []types.PlanOperator

func (*PlanOpNestedLoops) Expressions 

func (p *PlanOpNestedLoops) Expressions() []types.PlanExpression

func (*PlanOpNestedLoops) Iterator 

func (p *PlanOpNestedLoops) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpNestedLoops) Plan 

func (p *PlanOpNestedLoops) Plan() map[string]interface{}

func (*PlanOpNestedLoops) Schema 

func (p *PlanOpNestedLoops) Schema() types.Schema

func (*PlanOpNestedLoops) String 

func (p *PlanOpNestedLoops) String() string

func (*PlanOpNestedLoops) Warnings 

func (p *PlanOpNestedLoops) Warnings() []string

func (*PlanOpNestedLoops) WithChildren 

func (p *PlanOpNestedLoops) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpNestedLoops) WithUpdatedExpressions 

func (p *PlanOpNestedLoops) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpNullTable 

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

PlanOpNullTable is an operator for a null table basically when you do select 1, you're using the null table

func NewPlanOpNullTable 

func NewPlanOpNullTable() *PlanOpNullTable

func (*PlanOpNullTable) AddWarning 

func (p *PlanOpNullTable) AddWarning(warning string)

func (*PlanOpNullTable) Children 

func (p *PlanOpNullTable) Children() []types.PlanOperator

func (*PlanOpNullTable) Iterator 

func (p *PlanOpNullTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpNullTable) Plan 

func (p *PlanOpNullTable) Plan() map[string]interface{}

func (*PlanOpNullTable) Schema 

func (p *PlanOpNullTable) Schema() types.Schema

func (*PlanOpNullTable) String 

func (p *PlanOpNullTable) String() string

func (*PlanOpNullTable) Warnings 

func (p *PlanOpNullTable) Warnings() []string

func (*PlanOpNullTable) WithChildren 

func (p *PlanOpNullTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpOrderBy 

type PlanOpOrderBy struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpOrderBy plan operator handles ORDER BY

func NewPlanOpOrderBy 

func NewPlanOpOrderBy(orderByFields []*OrderByExpression, child types.PlanOperator) *PlanOpOrderBy

func (*PlanOpOrderBy) AddWarning 

func (n *PlanOpOrderBy) AddWarning(warning string)

func (*PlanOpOrderBy) Children 

func (n *PlanOpOrderBy) Children() []types.PlanOperator

func (*PlanOpOrderBy) Expressions added in v3.33.0 

func (n *PlanOpOrderBy) Expressions() []types.PlanExpression

func (*PlanOpOrderBy) Iterator 

func (n *PlanOpOrderBy) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpOrderBy) Plan 

func (n *PlanOpOrderBy) Plan() map[string]interface{}

func (*PlanOpOrderBy) Schema 

func (n *PlanOpOrderBy) Schema() types.Schema

func (*PlanOpOrderBy) String 

func (n *PlanOpOrderBy) String() string

func (*PlanOpOrderBy) Warnings 

func (n *PlanOpOrderBy) Warnings() []string

func (*PlanOpOrderBy) WithChildren 

func (n *PlanOpOrderBy) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpOrderBy) WithUpdatedExpressions added in v3.33.0 

func (n *PlanOpOrderBy) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpPQLAggregate 

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

PlanOpPQLAggregate plan operator handles a single pql aggregate

func NewPlanOpPQLAggregate 

func NewPlanOpPQLAggregate(p *ExecutionPlanner, tableName string, aggregate types.Aggregable, filter types.PlanExpression) *PlanOpPQLAggregate

func (*PlanOpPQLAggregate) AddWarning 

func (p *PlanOpPQLAggregate) AddWarning(warning string)

func (*PlanOpPQLAggregate) Children 

func (p *PlanOpPQLAggregate) Children() []types.PlanOperator

func (*PlanOpPQLAggregate) Iterator 

func (p *PlanOpPQLAggregate) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLAggregate) Plan 

func (p *PlanOpPQLAggregate) Plan() map[string]interface{}

func (*PlanOpPQLAggregate) Schema 

func (p *PlanOpPQLAggregate) Schema() types.Schema

func (*PlanOpPQLAggregate) String 

func (p *PlanOpPQLAggregate) String() string

func (*PlanOpPQLAggregate) Warnings 

func (p *PlanOpPQLAggregate) Warnings() []string

func (*PlanOpPQLAggregate) WithChildren 

func (p *PlanOpPQLAggregate) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLConstRowDelete added in v3.27.0 

type PlanOpPQLConstRowDelete struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpPQLConstRowDelete plan operator to delete rows from a table based on a single key.

func NewPlanOpPQLConstRowDelete added in v3.27.0 

func NewPlanOpPQLConstRowDelete(p *ExecutionPlanner, tableName string, child types.PlanOperator) *PlanOpPQLConstRowDelete

func (*PlanOpPQLConstRowDelete) AddWarning added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) AddWarning(warning string)

func (*PlanOpPQLConstRowDelete) Children added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Children() []types.PlanOperator

func (*PlanOpPQLConstRowDelete) Expressions added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Expressions() []types.PlanExpression

func (*PlanOpPQLConstRowDelete) Iterator added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLConstRowDelete) Plan added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Plan() map[string]interface{}

func (*PlanOpPQLConstRowDelete) Schema added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Schema() types.Schema

func (*PlanOpPQLConstRowDelete) String added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) String() string

func (*PlanOpPQLConstRowDelete) Warnings added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) Warnings() []string

func (*PlanOpPQLConstRowDelete) WithChildren added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpPQLConstRowDelete) WithUpdatedExpressions added in v3.27.0 

func (p *PlanOpPQLConstRowDelete) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpPQLDistinctScan added in v3.27.0 

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

PlanOpPQLDistinctScan plan operator handles a PQL distinct scan i.e. a scan with only one column that is used in a distinct query

func NewPlanOpPQLDistinctScan added in v3.27.0 

func NewPlanOpPQLDistinctScan(p *ExecutionPlanner, tableName string, column string) (*PlanOpPQLDistinctScan, error)

func (*PlanOpPQLDistinctScan) AddWarning added in v3.27.0 

func (p *PlanOpPQLDistinctScan) AddWarning(warning string)

func (*PlanOpPQLDistinctScan) Children added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Children() []types.PlanOperator

func (*PlanOpPQLDistinctScan) IsFilterable added in v3.33.0 

func (p *PlanOpPQLDistinctScan) IsFilterable() bool

func (*PlanOpPQLDistinctScan) Iterator added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLDistinctScan) Name added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Name() string

func (*PlanOpPQLDistinctScan) Plan added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Plan() map[string]interface{}

func (*PlanOpPQLDistinctScan) Schema added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Schema() types.Schema

func (*PlanOpPQLDistinctScan) String added in v3.27.0 

func (p *PlanOpPQLDistinctScan) String() string

func (*PlanOpPQLDistinctScan) UpdateFilters added in v3.27.0 

func (p *PlanOpPQLDistinctScan) UpdateFilters(filterCondition types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpPQLDistinctScan) UpdateTimeQuantumFilters added in v3.33.0 

func (p *PlanOpPQLDistinctScan) UpdateTimeQuantumFilters(filters ...types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpPQLDistinctScan) Warnings added in v3.27.0 

func (p *PlanOpPQLDistinctScan) Warnings() []string

func (*PlanOpPQLDistinctScan) WithChildren added in v3.27.0 

func (p *PlanOpPQLDistinctScan) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLFilteredDelete added in v3.27.0 

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

PlanOpPQLFilteredDelete plan operator to delete rows from a table based on a filter expression.

func NewPlanOpPQLFilteredDelete added in v3.27.0 

func NewPlanOpPQLFilteredDelete(p *ExecutionPlanner, tableName string, filter types.PlanExpression) *PlanOpPQLFilteredDelete

func (*PlanOpPQLFilteredDelete) AddWarning added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) AddWarning(warning string)

func (*PlanOpPQLFilteredDelete) Children added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) Children() []types.PlanOperator

func (*PlanOpPQLFilteredDelete) Iterator added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLFilteredDelete) Plan added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) Plan() map[string]interface{}

func (*PlanOpPQLFilteredDelete) Schema added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) Schema() types.Schema

func (*PlanOpPQLFilteredDelete) String added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) String() string

func (*PlanOpPQLFilteredDelete) Warnings added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) Warnings() []string

func (*PlanOpPQLFilteredDelete) WithChildren added in v3.27.0 

func (p *PlanOpPQLFilteredDelete) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLGroupBy 

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

PlanOpPQLGroupBy plan operator handles a PQL group by with a single aggregate

func NewPlanOpPQLGroupBy 

func NewPlanOpPQLGroupBy(p *ExecutionPlanner, tableName string, groupByExprs []types.PlanExpression, filter types.PlanExpression, aggregate types.Aggregable) *PlanOpPQLGroupBy

func (*PlanOpPQLGroupBy) AddWarning 

func (p *PlanOpPQLGroupBy) AddWarning(warning string)

func (*PlanOpPQLGroupBy) Children 

func (p *PlanOpPQLGroupBy) Children() []types.PlanOperator

func (*PlanOpPQLGroupBy) Iterator 

func (p *PlanOpPQLGroupBy) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLGroupBy) Plan 

func (p *PlanOpPQLGroupBy) Plan() map[string]interface{}

func (*PlanOpPQLGroupBy) Schema 

func (p *PlanOpPQLGroupBy) Schema() types.Schema

func (*PlanOpPQLGroupBy) String 

func (p *PlanOpPQLGroupBy) String() string

func (*PlanOpPQLGroupBy) Warnings 

func (p *PlanOpPQLGroupBy) Warnings() []string

func (*PlanOpPQLGroupBy) WithChildren 

func (p *PlanOpPQLGroupBy) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLMultiAggregate 

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

PlanOpPQLMultiAggregate plan operator handles executing multiple 'sibling' pql aggregate queries

func NewPlanOpPQLMultiAggregate 

func NewPlanOpPQLMultiAggregate(p *ExecutionPlanner, operators []*PlanOpPQLAggregate) *PlanOpPQLMultiAggregate

func (*PlanOpPQLMultiAggregate) AddWarning 

func (p *PlanOpPQLMultiAggregate) AddWarning(warning string)

func (*PlanOpPQLMultiAggregate) Children 

func (p *PlanOpPQLMultiAggregate) Children() []types.PlanOperator

func (*PlanOpPQLMultiAggregate) Iterator 

func (p *PlanOpPQLMultiAggregate) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLMultiAggregate) Plan 

func (p *PlanOpPQLMultiAggregate) Plan() map[string]interface{}

func (*PlanOpPQLMultiAggregate) Schema 

func (p *PlanOpPQLMultiAggregate) Schema() types.Schema

func (*PlanOpPQLMultiAggregate) String 

func (p *PlanOpPQLMultiAggregate) String() string

func (*PlanOpPQLMultiAggregate) Warnings 

func (p *PlanOpPQLMultiAggregate) Warnings() []string

func (*PlanOpPQLMultiAggregate) WithChildren 

func (p *PlanOpPQLMultiAggregate) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLMultiGroupBy 

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

PlanOpPQLMultiGroupBy plan operator handles executing multiple 'sibling' pql group by queries it will materialize the result sets from each of its operators and then merge them. Its iterator will return a row consisting of all the group by columns in the order specified followed by all aggregates in order

func NewPlanOpPQLMultiGroupBy 

func NewPlanOpPQLMultiGroupBy(p *ExecutionPlanner, operators []*PlanOpPQLGroupBy, groupByExprs []types.PlanExpression) *PlanOpPQLMultiGroupBy

func (*PlanOpPQLMultiGroupBy) AddWarning 

func (p *PlanOpPQLMultiGroupBy) AddWarning(warning string)

func (*PlanOpPQLMultiGroupBy) Children 

func (p *PlanOpPQLMultiGroupBy) Children() []types.PlanOperator

func (*PlanOpPQLMultiGroupBy) Expressions 

func (p *PlanOpPQLMultiGroupBy) Expressions() []types.PlanExpression

func (*PlanOpPQLMultiGroupBy) Iterator 

func (p *PlanOpPQLMultiGroupBy) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLMultiGroupBy) Plan 

func (p *PlanOpPQLMultiGroupBy) Plan() map[string]interface{}

func (*PlanOpPQLMultiGroupBy) Schema 

func (p *PlanOpPQLMultiGroupBy) Schema() types.Schema

func (*PlanOpPQLMultiGroupBy) String 

func (p *PlanOpPQLMultiGroupBy) String() string

func (*PlanOpPQLMultiGroupBy) Warnings 

func (p *PlanOpPQLMultiGroupBy) Warnings() []string

func (*PlanOpPQLMultiGroupBy) WithChildren 

func (p *PlanOpPQLMultiGroupBy) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpPQLMultiGroupBy) WithUpdatedExpressions 

func (p *PlanOpPQLMultiGroupBy) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpPQLTableScan 

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

PlanOpPQLTableScan plan operator handles a PQL table scan

func NewPlanOpPQLTableScan 

func NewPlanOpPQLTableScan(p *ExecutionPlanner, tableName string, columns []string) *PlanOpPQLTableScan

func (*PlanOpPQLTableScan) AddWarning 

func (p *PlanOpPQLTableScan) AddWarning(warning string)

func (*PlanOpPQLTableScan) Children 

func (p *PlanOpPQLTableScan) Children() []types.PlanOperator

func (*PlanOpPQLTableScan) IsFilterable added in v3.33.0 

func (p *PlanOpPQLTableScan) IsFilterable() bool

func (*PlanOpPQLTableScan) Iterator 

func (p *PlanOpPQLTableScan) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLTableScan) Name 

func (p *PlanOpPQLTableScan) Name() string

func (*PlanOpPQLTableScan) Plan 

func (p *PlanOpPQLTableScan) Plan() map[string]interface{}

func (*PlanOpPQLTableScan) PrimaryKeyType added in v3.33.0 

func (p *PlanOpPQLTableScan) PrimaryKeyType() (parser.ExprDataType, error)

func (*PlanOpPQLTableScan) Schema 

func (p *PlanOpPQLTableScan) Schema() types.Schema

func (*PlanOpPQLTableScan) String 

func (p *PlanOpPQLTableScan) String() string

func (*PlanOpPQLTableScan) UpdateFilters 

func (p *PlanOpPQLTableScan) UpdateFilters(filterCondition types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpPQLTableScan) UpdateTimeQuantumFilters added in v3.33.0 

func (p *PlanOpPQLTableScan) UpdateTimeQuantumFilters(filters ...types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpPQLTableScan) Warnings 

func (p *PlanOpPQLTableScan) Warnings() []string

func (*PlanOpPQLTableScan) WithChildren 

func (p *PlanOpPQLTableScan) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpPQLTruncateTable added in v3.27.0 

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

PlanOpPQLTruncateTable plan operator to delete rows from a table based on a single key.

func NewPlanOpPQLTruncateTable added in v3.27.0 

func NewPlanOpPQLTruncateTable(p *ExecutionPlanner, tableName string) *PlanOpPQLTruncateTable

func (*PlanOpPQLTruncateTable) AddWarning added in v3.27.0 

func (p *PlanOpPQLTruncateTable) AddWarning(warning string)

func (*PlanOpPQLTruncateTable) Children added in v3.27.0 

func (p *PlanOpPQLTruncateTable) Children() []types.PlanOperator

func (*PlanOpPQLTruncateTable) Iterator added in v3.27.0 

func (p *PlanOpPQLTruncateTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpPQLTruncateTable) Plan added in v3.27.0 

func (p *PlanOpPQLTruncateTable) Plan() map[string]interface{}

func (*PlanOpPQLTruncateTable) Schema added in v3.27.0 

func (p *PlanOpPQLTruncateTable) Schema() types.Schema

func (*PlanOpPQLTruncateTable) String added in v3.27.0 

func (p *PlanOpPQLTruncateTable) String() string

func (*PlanOpPQLTruncateTable) Warnings added in v3.27.0 

func (p *PlanOpPQLTruncateTable) Warnings() []string

func (*PlanOpPQLTruncateTable) WithChildren added in v3.27.0 

func (p *PlanOpPQLTruncateTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpProjection 

type PlanOpProjection struct {
	ChildOp     types.PlanOperator
	Projections []types.PlanExpression
	// contains filtered or unexported fields
}

PlanOpProjection handles row projection and expression evaluation

func NewPlanOpProjection 

func NewPlanOpProjection(expressions []types.PlanExpression, child types.PlanOperator) *PlanOpProjection

func (*PlanOpProjection) AddWarning 

func (p *PlanOpProjection) AddWarning(warning string)

func (*PlanOpProjection) Children 

func (p *PlanOpProjection) Children() []types.PlanOperator

func (*PlanOpProjection) Expressions 

func (p *PlanOpProjection) Expressions() []types.PlanExpression

func (*PlanOpProjection) Iterator 

func (p *PlanOpProjection) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpProjection) Plan 

func (p *PlanOpProjection) Plan() map[string]interface{}

func (*PlanOpProjection) Schema 

func (p *PlanOpProjection) Schema() types.Schema

func (*PlanOpProjection) String 

func (p *PlanOpProjection) String() string

func (*PlanOpProjection) Warnings 

func (p *PlanOpProjection) Warnings() []string

func (*PlanOpProjection) WithChildren 

func (p *PlanOpProjection) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

func (*PlanOpProjection) WithUpdatedExpressions 

func (p *PlanOpProjection) WithUpdatedExpressions(exprs ...types.PlanExpression) (types.PlanOperator, error)

type PlanOpQuery 

type PlanOpQuery struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpQuery is a query - this is the root node of an execution plan

func NewPlanOpQuery 

func NewPlanOpQuery(p *ExecutionPlanner, child types.PlanOperator, sql string) *PlanOpQuery

func (*PlanOpQuery) AddWarning 

func (p *PlanOpQuery) AddWarning(warning string)

func (*PlanOpQuery) Child 

func (p *PlanOpQuery) Child() types.PlanOperator

func (*PlanOpQuery) Children 

func (p *PlanOpQuery) Children() []types.PlanOperator

func (*PlanOpQuery) Iterator 

func (p *PlanOpQuery) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpQuery) Plan 

func (p *PlanOpQuery) Plan() map[string]interface{}

func (*PlanOpQuery) Schema 

func (p *PlanOpQuery) Schema() types.Schema

func (*PlanOpQuery) String 

func (p *PlanOpQuery) String() string

func (*PlanOpQuery) Warnings 

func (p *PlanOpQuery) Warnings() []string

func (*PlanOpQuery) WithChildren 

func (p *PlanOpQuery) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpRelAlias 

type PlanOpRelAlias struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpRelAlias implements an alias for a relation

func NewPlanOpRelAlias 

func NewPlanOpRelAlias(alias string, child types.PlanOperator) *PlanOpRelAlias

func (*PlanOpRelAlias) AddWarning 

func (p *PlanOpRelAlias) AddWarning(warning string)

func (*PlanOpRelAlias) Children 

func (p *PlanOpRelAlias) Children() []types.PlanOperator

func (*PlanOpRelAlias) IsFilterable added in v3.33.0 

func (p *PlanOpRelAlias) IsFilterable() bool

func (*PlanOpRelAlias) Iterator 

func (p *PlanOpRelAlias) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpRelAlias) Name 

func (p *PlanOpRelAlias) Name() string

func (*PlanOpRelAlias) Plan 

func (p *PlanOpRelAlias) Plan() map[string]interface{}

func (*PlanOpRelAlias) Schema 

func (p *PlanOpRelAlias) Schema() types.Schema

func (*PlanOpRelAlias) String 

func (p *PlanOpRelAlias) String() string

func (*PlanOpRelAlias) UpdateFilters added in v3.33.0 

func (p *PlanOpRelAlias) UpdateFilters(filterCondition types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpRelAlias) UpdateTimeQuantumFilters added in v3.33.0 

func (p *PlanOpRelAlias) UpdateTimeQuantumFilters(filters ...types.PlanExpression) (types.PlanOperator, error)

func (*PlanOpRelAlias) Warnings 

func (p *PlanOpRelAlias) Warnings() []string

func (*PlanOpRelAlias) WithChildren 

func (p *PlanOpRelAlias) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpSubquery 

type PlanOpSubquery struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpSubquery is an operator for a subquery

func NewPlanOpSubquery 

func NewPlanOpSubquery(child types.PlanOperator) *PlanOpSubquery

func (*PlanOpSubquery) AddWarning 

func (p *PlanOpSubquery) AddWarning(warning string)

func (*PlanOpSubquery) Children 

func (p *PlanOpSubquery) Children() []types.PlanOperator

func (*PlanOpSubquery) Iterator 

func (p *PlanOpSubquery) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpSubquery) Name 

func (p *PlanOpSubquery) Name() string

func (*PlanOpSubquery) Plan 

func (p *PlanOpSubquery) Plan() map[string]interface{}

func (*PlanOpSubquery) Schema 

func (p *PlanOpSubquery) Schema() types.Schema

func (*PlanOpSubquery) String 

func (p *PlanOpSubquery) String() string

func (*PlanOpSubquery) Warnings 

func (p *PlanOpSubquery) Warnings() []string

func (*PlanOpSubquery) WithChildren 

func (p *PlanOpSubquery) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpSystemTable 

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

PlanOpSystemTable handles system tables

func NewPlanOpSystemTable 

func NewPlanOpSystemTable(p *ExecutionPlanner, table *systemTable) *PlanOpSystemTable

func (*PlanOpSystemTable) AddWarning 

func (p *PlanOpSystemTable) AddWarning(warning string)

func (*PlanOpSystemTable) Children 

func (p *PlanOpSystemTable) Children() []types.PlanOperator

func (*PlanOpSystemTable) Iterator 

func (p *PlanOpSystemTable) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpSystemTable) Plan 

func (p *PlanOpSystemTable) Plan() map[string]interface{}

func (*PlanOpSystemTable) Schema 

func (p *PlanOpSystemTable) Schema() types.Schema

func (*PlanOpSystemTable) String 

func (p *PlanOpSystemTable) String() string

func (*PlanOpSystemTable) Warnings 

func (p *PlanOpSystemTable) Warnings() []string

func (*PlanOpSystemTable) WithChildren 

func (p *PlanOpSystemTable) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpTableValuedFunction 

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

PlanOpTableValuedFunction is an operator for a subquery

func NewPlanOpTableValuedFunction 

func NewPlanOpTableValuedFunction(p *ExecutionPlanner, callExpr types.PlanExpression) *PlanOpTableValuedFunction

func (*PlanOpTableValuedFunction) AddWarning 

func (p *PlanOpTableValuedFunction) AddWarning(warning string)

func (*PlanOpTableValuedFunction) Children 

func (p *PlanOpTableValuedFunction) Children() []types.PlanOperator

func (*PlanOpTableValuedFunction) Iterator 

func (p *PlanOpTableValuedFunction) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpTableValuedFunction) Name added in v3.33.0 

func (p *PlanOpTableValuedFunction) Name() string

func (*PlanOpTableValuedFunction) Plan 

func (p *PlanOpTableValuedFunction) Plan() map[string]interface{}

func (*PlanOpTableValuedFunction) Schema 

func (p *PlanOpTableValuedFunction) Schema() types.Schema

func (*PlanOpTableValuedFunction) String 

func (p *PlanOpTableValuedFunction) String() string

func (*PlanOpTableValuedFunction) Warnings 

func (p *PlanOpTableValuedFunction) Warnings() []string

func (*PlanOpTableValuedFunction) WithChildren 

func (p *PlanOpTableValuedFunction) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpTop 

type PlanOpTop struct {
	ChildOp types.PlanOperator
	// contains filtered or unexported fields
}

PlanOpTop implements the TOP operator

func NewPlanOpTop 

func NewPlanOpTop(expr types.PlanExpression, child types.PlanOperator) *PlanOpTop

func (*PlanOpTop) AddWarning 

func (p *PlanOpTop) AddWarning(warning string)

func (*PlanOpTop) Children 

func (p *PlanOpTop) Children() []types.PlanOperator

func (*PlanOpTop) Iterator 

func (p *PlanOpTop) Iterator(ctx context.Context, row types.Row) (types.RowIterator, error)

func (*PlanOpTop) Plan 

func (p *PlanOpTop) Plan() map[string]interface{}

func (*PlanOpTop) Schema 

func (p *PlanOpTop) Schema() types.Schema

func (*PlanOpTop) String 

func (p *PlanOpTop) String() string

func (*PlanOpTop) Warnings 

func (p *PlanOpTop) Warnings() []string

func (*PlanOpTop) WithChildren 

func (p *PlanOpTop) WithChildren(children ...types.PlanOperator) (types.PlanOperator, error)

type PlanOpTransformFunc 

type PlanOpTransformFunc func(op types.PlanOperator) (types.PlanOperator, bool, error)

PlanOpTransformFunc is a function that given a plan op will return either a transformed plan op or the original plan op. If there was a transformation, the bool will be true, and an error if there was an error

type PlanVisitor 

type PlanVisitor interface {
	// VisitOperator method is invoked for each node during PlanWalk. If the
	// resulting PlanVisitor is not nil, PlanWalk visits each of the children of
	// the node with that visitor, followed by a call of VisitOperator(nil) to
	// the returned visitor.
	VisitOperator(op types.PlanOperator) PlanVisitor
}

PlanVisitor visits nodes in the plan.

type RelationAliasesMap 

type RelationAliasesMap map[string]types.IdentifiableByName

RelationAliasesMap is a map of aliases to Relations

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.