analyzer

package
v0.10.1-0...-0d403c5 Latest Latest
Warning

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

Go to latest
Published: Jul 8, 2021 License: Apache-2.0 Imports: 23 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrFieldMissing is returned when the field is not on the schema.
	ErrFieldMissing = errors.NewKind("field %q is not on schema")
	// ErrOrderByColumnIndex is returned when in an order clause there is a
	// column that is unknown.
	ErrOrderByColumnIndex = errors.NewKind("unknown column %d in order by clause")
)
View Source
var (
	// ErrValidationResolved is returned when the plan can not be resolved.
	ErrValidationResolved = errors.NewKind("plan is not resolved because of node '%T'")
	// ErrValidationOrderBy is returned when the order by contains aggregation
	// expressions.
	ErrValidationOrderBy = errors.NewKind("OrderBy does not support aggregation expressions")
	// ErrValidationGroupBy is returned when the aggregation expression does not
	// appear in the grouping columns.
	ErrValidationGroupBy = errors.NewKind("expression '%v' doesn't appear in the group by expressions")
	// ErrValidationSchemaSource is returned when there is any column source
	// that does not match the table name.
	ErrValidationSchemaSource = errors.NewKind("one or more schema sources are empty")
	// ErrProjectTuple is returned when there is a tuple of more than 1 column
	// inside a projection.
	ErrProjectTuple = errors.NewKind("selected field %d should have 1 column, but has %d")
	// ErrUnknownIndexColumns is returned when there are columns in the expr
	// to index that are unknown in the table.
	ErrUnknownIndexColumns = errors.NewKind("unknown columns to index for table %q: %s")
	// ErrCaseResultType is returned when one or more of the types of the values in
	// a case expression don't match.
	ErrCaseResultType = errors.NewKind(
		"expecting all case branches to return values of type %s, " +
			"but found value %q of type %s on %s",
	)
	// ErrIntervalInvalidUse is returned when an interval expression is not
	// correctly used.
	ErrIntervalInvalidUse = errors.NewKind(
		"invalid use of an interval, which can only be used with DATE_ADD, " +
			"DATE_SUB and +/- operators to subtract from or add to a date",
	)
	// ErrExplodeInvalidUse is returned when an EXPLODE function is used
	// outside a Project node.
	ErrExplodeInvalidUse = errors.NewKind(
		"using EXPLODE is not supported outside a Project node",
	)

	// ErrSubqueryFieldIndex is returned when an expression subquery references a field outside the range of the rows it
	// works on.
	ErrSubqueryFieldIndex = errors.NewKind(
		"subquery field index out of range for expression %s: only %d columns available",
	)

	// ErrUnionSchemasMatch is returned when both sides of a UNION do not
	// have the same schema.
	ErrUnionSchemasMatch = errors.NewKind(
		"the schema of the left side of union does not match the right side, expected %s to match %s",
	)

	// ErrReadOnlyDatabase is returned when a write is attempted to a ReadOnlyDatabse.
	ErrReadOnlyDatabase = errors.NewKind("Database %s is read-only.")
)
View Source
var DefaultRules = []Rule{
	{"resolve_natural_joins", resolveNaturalJoins},
	{"resolve_orderby_literals", resolveOrderByLiterals},
	{"resolve_functions", resolveFunctions},
	{"flatten_table_aliases", flattenTableAliases},
	{"pushdown_sort", pushdownSort},
	{"pushdown_groupby_aliases", pushdownGroupByAliases},
	{"pushdown_subquery_alias_filters", pushdownSubqueryAliasFilters},
	{"qualify_columns", qualifyColumns},
	{"resolve_columns", resolveColumns},
	{"validate_check_constraint", validateCreateCheck},
	{"resolve_bareword_set_variables", resolveBarewordSetVariables},
	{"resolve_database", resolveDatabase},
	{"expand_stars", expandStars},
	{"resolve_having", resolveHaving},
	{"merge_union_schemas", mergeUnionSchemas},
	{"flatten_aggregation_exprs", flattenAggregationExpressions},
	{"reorder_projection", reorderProjection},
	{"resolve_subquery_exprs", resolveSubqueryExpressions},
	{"move_join_conds_to_filter", moveJoinConditionsToFilter},
	{"eval_filter", evalFilter},
	{"optimize_distinct", optimizeDistinct},
}

DefaultRules to apply when analyzing nodes.

View Source
var DefaultValidationRules = []Rule{
	{validateResolvedRule, validateIsResolved},
	{validateOrderByRule, validateOrderBy},
	{validateGroupByRule, validateGroupBy},
	{validateSchemaSourceRule, validateSchemaSource},
	{validateProjectTuplesRule, validateProjectTuples},
	{validateIndexCreationRule, validateIndexCreation},
	{validateCaseResultTypesRule, validateCaseResultTypes},
	{validateIntervalUsageRule, validateIntervalUsage},
	{validateExplodeUsageRule, validateExplodeUsage},
	{validateSubqueryColumnsRule, validateSubqueryColumns},
	{validateUnionSchemasMatchRule, validateUnionSchemasMatch},
}

DefaultValidationRules to apply while analyzing nodes.

View Source
var ErrInAnalysis = errors.NewKind("error in analysis: %s")

ErrInAnalysis is thrown for generic analyzer errors

View Source
var ErrInvalidNodeType = errors.NewKind("%s: invalid node of type: %T")

ErrInvalidNodeType is thrown when the analyzer can't handle a particular kind of node type

View Source
var ErrMaxAnalysisIters = errors.NewKind("exceeded max analysis iterations (%d)")

ErrMaxAnalysisIters is thrown when the analysis iterations are exceeded

View Source
var (
	// ErrUnionSchemasDifferentLength is returned when the two sides of a
	// UNION do not have the same number of columns in their schemas.
	ErrUnionSchemasDifferentLength = errors.NewKind(
		"cannot union two queries whose schemas are different lengths; left has %d column(s) right has %d column(s).",
	)
)
View Source
var OnceAfterAll = []Rule{
	{"track_process", trackProcess},
	{"parallelize", parallelize},

	{"clear_warnings", clearWarnings},
}

OnceAfterAll contains the rules to be applied just once after all other rules have been applied.

View Source
var OnceAfterDefault = []Rule{
	{"finalize_subqueries", finalizeSubqueries},
	{"finalize_unions", finalizeUnions},
	{"load_triggers", loadTriggers},
	{"process_truncate", processTruncate},
	{"resolve_column_defaults", resolveColumnDefaults},
	{"resolve_generators", resolveGenerators},
	{"remove_unnecessary_converts", removeUnnecessaryConverts},
	{"assign_catalog", assignCatalog},
	{"prune_columns", pruneColumns},
	{"optimize_joins", constructJoinPlan},
	{"pushdown_filters", pushdownFilters},
	{"subquery_indexes", applyIndexesFromOuterScope},
	{"in_subquery_indexes", applyIndexesForSubqueryComparisons},
	{"pushdown_projections", pushdownProjections},
	{"set_join_scope_len", setJoinScopeLen},
	{"erase_projection", eraseProjection},

	{"resolve_subquery_exprs", resolveSubqueryExpressions},
	{"cache_subquery_results", cacheSubqueryResults},
	{"cache_subquery_aliases_in_joins", cacheSubqueryAlisesInJoins},
	{"apply_hash_lookups", applyHashLookups},
	{"resolve_insert_rows", resolveInsertRows},
	{"apply_triggers", applyTriggers},
	{"apply_procedures", applyProcedures},
	{"apply_row_update_accumulators", applyUpdateAccumulators},
}

OnceAfterDefault contains the rules to be applied just once after the DefaultRules.

View Source
var OnceBeforeDefault = []Rule{
	{"validate_offset_and_limit", validateLimitAndOffset},
	{"load_stored_procedures", loadStoredProcedures},
	{"resolve_views", resolveViews},
	{"lift_common_table_expressions", liftCommonTableExpressions},
	{"resolve_common_table_expressions", resolveCommonTableExpressions},
	{"resolve_tables", resolveTables},
	{"resolve_drop_constraint", resolveDropConstraint},
	{"validate_drop_constraint", validateDropConstraint},
	{"load_check_constraints", loadChecks},
	{"resolve_set_variables", resolveSetVariables},
	{"resolve_create_like", resolveCreateLike},
	{"resolve_create_select", resolveCreateSelect},
	{"resolve_subqueries", resolveSubqueries},
	{"resolve_unions", resolveUnions},
	{"resolve_describe_query", resolveDescribeQuery},
	{"check_unique_table_names", checkUniqueTableNames},
	{"resolve_declarations", resolveDeclarations},
	{"validate_create_trigger", validateCreateTrigger},
	{"validate_create_procedure", validateCreateProcedure},
	{"assign_info_schema", assignInfoSchema},
	{"validate_read_only_database", validateReadOnlyDatabase},
}

OnceBeforeDefault contains the rules to be applied just once before the DefaultRules.

View Source
var (
	// ParallelQueryCounter describes a metric that accumulates
	// number of parallel queries monotonically.
	ParallelQueryCounter = discard.NewCounter()
)

Functions

func FixFieldIndexes

func FixFieldIndexes(ctx *sql.Context, scope *Scope, a *Analyzer, schema sql.Schema, exp sql.Expression) (sql.Expression, error)

FixFieldIndexes transforms the given expression by correcting the indexes of columns in GetField expressions, according to the schema given. Used when combining multiple tables together into a single join result, or when otherwise changing / combining schemas in the node tree.

func FixFieldIndexesForExpressions

func FixFieldIndexesForExpressions(ctx *sql.Context, a *Analyzer, node sql.Node, scope *Scope) (sql.Node, error)

Transforms the expressions in the Node given, fixing the field indexes.

func FixFieldIndexesForTableNode

func FixFieldIndexesForTableNode(ctx *sql.Context, a *Analyzer, node sql.Node, scope *Scope) (sql.Node, error)

Transforms the expressions in the Node given, fixing the field indexes. This is useful for Table nodes that have expressions but no children.

func FixFieldIndexesOnExpressions

func FixFieldIndexesOnExpressions(ctx *sql.Context, scope *Scope, a *Analyzer, schema sql.Schema, expressions ...sql.Expression) ([]sql.Expression, error)

FixFieldIndexesOnExpressions executes FixFieldIndexes on a list of exprs.

func OrderTriggers

func OrderTriggers(triggers []*plan.CreateTrigger) (beforeTriggers []*plan.CreateTrigger, afterTriggers []*plan.CreateTrigger)

Types

type Analyzer

type Analyzer struct {
	// Whether to log various debugging messages
	Debug bool
	// Whether to output the query plan at each step of the analyzer
	Verbose bool

	Parallelism int
	// Batches of Rules to apply.
	Batches []*Batch
	// Catalog of databases and registered functions.
	Catalog *sql.Catalog
	// ProcedureCache is a cache of stored procedures.
	ProcedureCache *ProcedureCache
	// contains filtered or unexported fields
}

Analyzer analyzes nodes of the execution plan and applies rules and validations to them.

func NewDefault

func NewDefault(c *sql.Catalog) *Analyzer

NewDefault creates a default Analyzer instance with all default Rules and configuration. To add custom rules, the easiest way is use the Builder.

func (*Analyzer) Analyze

func (a *Analyzer) Analyze(ctx *sql.Context, n sql.Node, scope *Scope) (sql.Node, error)

Analyze applies the transformation rules to the node given. In the case of an error, the last successfully transformed node is returned along with the error.

func (*Analyzer) Log

func (a *Analyzer) Log(msg string, args ...interface{})

Log prints an INFO message to stdout with the given message and args if the analyzer is in debug mode.

func (*Analyzer) LogDiff

func (a *Analyzer) LogDiff(prev, next sql.Node)

LogDiff logs the diff between the query plans after a transformation rules has been applied. Only can print a diff when the string representations of the nodes differ, which isn't always the case.

func (*Analyzer) LogNode

func (a *Analyzer) LogNode(n sql.Node)

LogNode prints the node given if Verbose logging is enabled.

func (*Analyzer) PopDebugContext

func (a *Analyzer) PopDebugContext()

PopDebugContext pops a context message off the context stack.

func (*Analyzer) PushDebugContext

func (a *Analyzer) PushDebugContext(msg string)

PushDebugContext pushes the given context string onto the context stack, to use when logging debug messages.

type Batch

type Batch struct {
	Desc       string
	Iterations int
	Rules      []Rule
}

Batch executes a set of rules a specific number of times. When this number of times is reached, the actual node and ErrMaxAnalysisIters is returned.

func (*Batch) Eval

func (b *Batch) Eval(ctx *sql.Context, a *Analyzer, n sql.Node, scope *Scope) (sql.Node, error)

Eval executes the rules of the batch. On any error, the partially transformed node is returned along with the error. If the batch's max number of iterations is reached without achieving stabilization (batch evaluation no longer changes the node), then this method returns ErrMaxAnalysisIters.

type Builder

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

Builder provides an easy way to generate Analyzer with custom rules and options.

func NewBuilder

func NewBuilder(c *sql.Catalog) *Builder

NewBuilder creates a new Builder from a specific catalog. This builder allow us add custom Rules and modify some internal properties.

func (*Builder) AddPostAnalyzeRule

func (ab *Builder) AddPostAnalyzeRule(name string, fn RuleFunc) *Builder

AddPostAnalyzeRule adds a new rule to the analyzer after standard analyzer rules.

func (*Builder) AddPostValidationRule

func (ab *Builder) AddPostValidationRule(name string, fn RuleFunc) *Builder

AddPostValidationRule adds a new rule to the analyzer after standard validation rules.

func (*Builder) AddPreAnalyzeRule

func (ab *Builder) AddPreAnalyzeRule(name string, fn RuleFunc) *Builder

AddPreAnalyzeRule adds a new rule to the analyze before the standard analyzer rules.

func (*Builder) AddPreValidationRule

func (ab *Builder) AddPreValidationRule(name string, fn RuleFunc) *Builder

AddPreValidationRule adds a new rule to the analyzer before standard validation rules.

func (*Builder) Build

func (ab *Builder) Build() *Analyzer

Build creates a new Analyzer using all previous data setted to the Builder

func (*Builder) RemoveAfterAllRule

func (ab *Builder) RemoveAfterAllRule(name string) *Builder

RemoveAfterAllRule removes a default rule from the analyzer which would occur after all other rules

func (*Builder) RemoveDefaultRule

func (ab *Builder) RemoveDefaultRule(name string) *Builder

RemoveDefaultRule removes a default rule from the analyzer that is executed as part of the analysis

func (*Builder) RemoveOnceAfterRule

func (ab *Builder) RemoveOnceAfterRule(name string) *Builder

RemoveOnceAfterRule removes a default rule from the analyzer which would occur just once after the default analysis

func (*Builder) RemoveOnceBeforeRule

func (ab *Builder) RemoveOnceBeforeRule(name string) *Builder

RemoveOnceBeforeRule removes a default rule from the analyzer which would occur before other rules

func (*Builder) RemoveValidationRule

func (ab *Builder) RemoveValidationRule(name string) *Builder

RemoveValidationRule removes a default rule from the analyzer which would occur as part of the validation rules

func (*Builder) WithDebug

func (ab *Builder) WithDebug() *Builder

WithDebug activates debug on the Analyzer.

func (*Builder) WithParallelism

func (ab *Builder) WithParallelism(parallelism int) *Builder

WithParallelism sets the parallelism level on the analyzer.

type JoinOrder

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

func (JoinOrder) HintType

func (j JoinOrder) HintType() string

func (JoinOrder) String

func (j JoinOrder) String() string

type NameableNode

type NameableNode interface {
	sql.Nameable
	sql.Node
}

type ProcedureCache

type ProcedureCache struct {
	IsPopulating bool
	// contains filtered or unexported fields
}

ProcedureCache contains all of the stored procedures for each database.

func NewProcedureCache

func NewProcedureCache() *ProcedureCache

NewProcedureCache returns a *ProcedureCache.

func (*ProcedureCache) AllForDatabase

func (pc *ProcedureCache) AllForDatabase(dbName string) []*plan.Procedure

AllForDatabase returns all of the stored procedures for the given database, sorted by name ascending. The database name is case-insensitive.

func (*ProcedureCache) Get

func (pc *ProcedureCache) Get(dbName, procedureName string) *plan.Procedure

Get returns the stored procedure with the given name from the given database. All names are case-insensitive. If the procedure does not exist, then this returns nil.

func (*ProcedureCache) Register

func (pc *ProcedureCache) Register(dbName string, procedure *plan.Procedure)

Register adds the given stored procedure to the cache. Will overwrite any procedures that already exist with the same name for the given database name.

type QueryHint

type QueryHint interface {
	fmt.Stringer
	HintType() string
}

type Releaser

type Releaser struct {
	Child   sql.Node
	Release func()
}

func (*Releaser) Children

func (r *Releaser) Children() []sql.Node

func (*Releaser) Equal

func (r *Releaser) Equal(n sql.Node) bool

func (*Releaser) Resolved

func (r *Releaser) Resolved() bool

func (*Releaser) RowIter

func (r *Releaser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

func (*Releaser) Schema

func (r *Releaser) Schema() sql.Schema

func (*Releaser) String

func (r *Releaser) String() string

func (*Releaser) WithChildren

func (r *Releaser) WithChildren(children ...sql.Node) (sql.Node, error)

type Rule

type Rule struct {
	// Name of the rule.
	Name string
	// Apply transforms a node.
	Apply RuleFunc
}

Rule to transform nodes.

type RuleFunc

type RuleFunc func(*sql.Context, *Analyzer, sql.Node, *Scope) (sql.Node, error)

RuleFunc is the function to be applied in a rule.

type Scope

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

Scope of the analysis being performed, used when analyzing subqueries to give such analysis access to outer scope.

func (*Scope) InnerToOuter

func (s *Scope) InnerToOuter() []sql.Node

InnerToOuter returns the scope Nodes in order of innermost scope to outermost scope. When using these nodes for analysis, always inspect the children of the nodes, rather than the nodes themselves. The children define the schema of the rows being processed by the scope node itself.

func (*Scope) MemoNodes

func (s *Scope) MemoNodes() []sql.Node

func (*Scope) OuterToInner

func (s *Scope) OuterToInner() []sql.Node

OuterToInner returns the scope nodes in order of outermost scope to innermost scope. When using these nodes for analysis, always inspect the children of the nodes, rather than the nodes themselves. The children define the schema of the rows being processed by the scope node itself.

func (*Scope) Schema

func (s *Scope) Schema() sql.Schema

Schema returns the equivalent schema of this scope, which consists of the schemas of all constituent scope nodes concatenated from outer to inner. Because we can only calculate the Schema() of nodes that are Resolved(), this method fills in place holder columns as necessary.

type TableAliases

type TableAliases map[string]sql.Nameable

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL