analyzer

package
v0.15.0 Latest Latest
Warning

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

 Go to latest Published: Apr 18, 2023 License: Apache-2.0 Imports: 37 Imported by: 17

Documentation

Index

Constants

View Source 
const MaxBytePrefix = 3072

Variables

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

	SingleThreadFeatureFlag = false
)
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 DefaultRules = []Rule{
	{resolveNaturalJoinsId, resolveNaturalJoins},
	{qualifyColumnsId, qualifyColumns},
	{resolveOrderbyLiteralsId, resolveOrderByLiterals},
	{resolveFunctionsId, resolveFunctions},
	{validateStarExpressionsId, validateStarExpressions},
	{replaceCountStarId, replaceCountStar},
	{flattenTableAliasesId, flattenTableAliases},
	{pushdownSortId, pushdownSort},
	{pushdownGroupbyAliasesId, pushdownGroupByAliases},
	{pushdownSubqueryAliasFiltersId, pushdownSubqueryAliasFilters},
	{pruneTablesId, pruneTables},
	{resolveColumnsId, resolveColumns},
	{validateCheckConstraintId, validateCheckConstraints},
	{expandStarsId, expandStars},
	{transposeRightJoinsId, transposeRightJoins},
	{resolveHavingId, resolveHaving},
	{mergeUnionSchemasId, mergeUnionSchemas},
	{flattenAggregationExprsId, flattenAggregationExpressions},
	{reorderProjectionId, reorderProjection},
	{resolveSubqueriesId, resolveSubqueries},
	{resolveBarewordSetVariablesId, resolveBarewordSetVariables},
	{replaceCrossJoinsId, replaceCrossJoins},
	{moveJoinCondsToFilterId, moveJoinConditionsToFilter},
	{evalFilterId, simplifyFilters},
	{optimizeDistinctId, optimizeDistinct},
}

DefaultRules to apply when analyzing nodes.

View Source 
var DefaultValidationRules = []Rule{
	{validateResolvedId, validateIsResolved},
	{validateOrderById, validateOrderBy},
	{validateGroupById, validateGroupBy},
	{validateSchemaSourceId, validateSchemaSource},
	{validateIndexCreationId, validateIndexCreation},
	{validateOperandsId, validateOperands},
	{validateIntervalUsageId, validateIntervalUsage},
	{validateSubqueryColumnsId, validateSubqueryColumns},
	{validateUnionSchemasMatchId, validateUnionSchemasMatch},
	{validateAggregationsId, validateAggregations},
}

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 ExprDefs support.GenDefs = []support.MemoDef{
	{
		Name:   "crossJoin",
		IsJoin: true,
	},
	{
		Name:   "innerJoin",
		IsJoin: true,
	},
	{
		Name:   "leftJoin",
		IsJoin: true,
	},
	{
		Name:   "semiJoin",
		IsJoin: true,
	},
	{
		Name:   "antiJoin",
		IsJoin: true,
	},
	{
		Name:   "lookupJoin",
		IsJoin: true,
		Attrs: [][2]string{
			{"lookup", "*lookup"},
		},
	},
	{
		Name:   "concatJoin",
		IsJoin: true,
		Attrs: [][2]string{
			{"concat", "[]*lookup"},
		},
	},
	{
		Name:   "hashJoin",
		IsJoin: true,
		Attrs: [][2]string{
			{"innerAttrs", "[]sql.Expression"},
			{"outerAttrs", "[]sql.Expression"},
		},
	},
	{
		Name:   "mergeJoin",
		IsJoin: true,
		Attrs: [][2]string{
			{"innerScan", "*indexScan"},
			{"outerScan", "*indexScan"},
		},
	},
	{
		Name:   "fullOuterJoin",
		IsJoin: true,
	},
	{
		Name:       "tableScan",
		SourceType: "*plan.ResolvedTable",
	},
	{
		Name:       "values",
		SourceType: "*plan.ValueDerivedTable",
	},
	{
		Name:       "tableAlias",
		SourceType: "*plan.TableAlias",
	},
	{
		Name:       "recursiveTable",
		SourceType: "*plan.RecursiveTable",
	},
	{
		Name:       "recursiveCte",
		SourceType: "*plan.RecursiveCte",
	},
	{
		Name:       "subqueryAlias",
		SourceType: "*plan.SubqueryAlias",
	},
	{
		Name:       "max1Row",
		SourceType: "sql.NameableNode",
	},
	{
		Name:       "tableFunc",
		SourceType: "sql.TableFunction",
	},
	{
		Name:       "emptyTable",
		SourceType: "*plan.EmptyTable",
	},
	{
		Name:    "project",
		IsUnary: true,
		Attrs: [][2]string{
			{"projections", "[]sql.Expression"},
		},
	},
	{
		Name:     "distinct",
		IsUnary:  true,
		SkipExec: true,
	},
}
View Source 
var OnceAfterAll = []Rule{
	{cacheSubqueryResultsId, cacheSubqueryResults},
	{cacheSubqueryAliasesInJoinsId, cacheSubqueryAliasesInJoins},
	{AutocommitId, addAutocommitNode},
	{TrackProcessId, trackProcess},
	{parallelizeId, parallelize},
	{clearWarningsId, clearWarnings},
}

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

View Source 
var OnceAfterDefault = []Rule{
	{hoistOutOfScopeFiltersId, hoistOutOfScopeFilters},
	{transformJoinApplyId, transformJoinApply},
	{hoistSelectExistsId, hoistSelectExists},
	{finalizeUnionsId, finalizeUnions},
	{loadTriggersId, loadTriggers},
	{loadEventsId, loadEvents},
	{processTruncateId, processTruncate},
	{removeUnnecessaryConvertsId, removeUnnecessaryConverts},
	{stripTableNameInDefaultsId, stripTableNamesFromColumnDefaults},
	{foldEmptyJoinsId, foldEmptyJoins},
	{optimizeJoinsId, constructJoinPlan},
	{pushdownFiltersId, pushdownFilters},
	{pruneColumnsId, pruneColumns},
	{finalizeSubqueriesId, finalizeSubqueries},
	{subqueryIndexesId, applyIndexesFromOuterScope},
	{replaceSortPkId, replacePkSort},
	{setJoinScopeLenId, setJoinScopeLen},
	{eraseProjectionId, eraseProjection},
	{insertTopNId, insertTopNNodes},
	{applyHashInId, applyHashIn},
	{resolveInsertRowsId, resolveInsertRows},
	{resolvePreparedInsertId, resolvePreparedInsert},
	{applyTriggersId, applyTriggers},
	{applyProceduresId, applyProcedures},
	{assignRoutinesId, assignRoutines},
	{modifyUpdateExprsForJoinId, modifyUpdateExpressionsForJoin},
	{applyRowUpdateAccumulatorsId, applyUpdateAccumulators},
	{wrapWithRollbackId, wrapWritesWithRollback},
	{applyFKsId, applyForeignKeys},
}

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

View Source 
var OnceBeforeDefault = []Rule{
	{applyDefaultSelectLimitId, applyDefaultSelectLimit},
	{applyBinlogReplicaControllerId, applyBinlogReplicaController},
	{validateOffsetAndLimitId, validateLimitAndOffset},
	{validateCreateTableId, validateCreateTable},
	{validateExprSemId, validateExprSem},
	{resolveVariablesId, resolveVariables},
	{resolveNamedWindowsId, replaceNamedWindows},
	{resolveSetVariablesId, resolveSetVariables},
	{resolveViewsId, resolveViews},
	{liftCtesId, hoistCommonTableExpressions},
	{resolveCtesId, resolveCommonTableExpressions},
	{liftRecursiveCtesId, hoistRecursiveCte},
	{validateCreateProcedureId, validateCreateProcedure},
	{resolveDatabasesId, resolveDatabases},
	{resolveTablesId, resolveTables},
	{reresolveTablesId, reresolveTables},
	{setInsertColumnsId, setInsertColumns},
	{setTargetSchemasId, setTargetSchemas},
	{loadCheckConstraintsId, loadChecks},
	{resolveAlterColumnId, resolveAlterColumn},
	{validateDropTablesId, validateDropTables},
	{resolveCreateLikeId, resolveCreateLike},
	{resolveAnalyzeTablesId, resolveAnalyzeTables},
	{assignCatalogId, assignCatalog},
	{parseColumnDefaultsId, parseColumnDefaults},
	{resolveDropConstraintId, resolveDropConstraint},
	{validateDropConstraintId, validateDropConstraint},
	{resolveCreateSelectId, resolveCreateSelect},
	{resolveSubqueriesId, resolveSubqueries},
	{setViewTargetSchemaId, setViewTargetSchema},
	{resolveUnionsId, resolveUnions},
	{resolveDescribeQueryId, resolveDescribeQuery},
	{disambiguateTableFunctionsId, disambiguateTableFunctions},
	{checkUniqueTableNamesId, validateUniqueTableNames},
	{resolveTableFunctionsId, resolveTableFunctions},
	{resolveDeclarationsId, resolveDeclarations},
	{validateCreateTriggerId, validateCreateTrigger},
	{loadInfoSchemaId, loadInfoSchema},
	{resolveColumnDefaultsId, resolveColumnDefaults},
	{validateColumnDefaultsId, validateColumnDefaults},
	{validateReadOnlyDatabaseId, validateReadOnlyDatabase},
	{validateReadOnlyTransactionId, validateReadOnlyTransaction},
	{validateDatabaseSetId, validateDatabaseSet},
	{validateDeleteFromId, validateDeleteFrom},
	{validatePrivilegesId, validatePrivileges},
}

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

View Source 
var PreparedStmtDisabled bool

Functions

func ConvertCheckDefToConstraint added in v0.12.0 

func ConvertCheckDefToConstraint(ctx *sql.Context, check *sql.CheckDefinition) (*sql.CheckConstraint, error)

func DeepCopyNode added in v0.12.0 

func DeepCopyNode(node sql.Node) (sql.Node, error)

func DefaultRuleSelector added in v0.12.0 

func DefaultRuleSelector(id RuleId) bool

func FixFieldIndexes 

func FixFieldIndexes(scope *Scope, a *Analyzer, schema sql.Schema, exp sql.Expression) (sql.Expression, transform.TreeIdentity, 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(a *Analyzer, node sql.Node, scope *Scope) (sql.Node, transform.TreeIdentity, error)

FixFieldIndexesForExpressions transforms the expressions in the Node given, fixing the field indexes.

func FixFieldIndexesForNode added in v0.15.0 

func FixFieldIndexesForNode(a *Analyzer, scope *Scope, n sql.Node) (sql.Node, transform.TreeIdentity, error)

func FixFieldIndexesForTableNode 

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

FixFieldIndexesForTableNode 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(scope *Scope, a *Analyzer, schema sql.Schema, expressions ...sql.Expression) ([]sql.Expression, transform.TreeIdentity, error)

FixFieldIndexesOnExpressions executes FixFieldIndexes on a list of exprs.

func GetTransactionDatabase added in v0.12.0 

func GetTransactionDatabase(ctx *sql.Context, parsed sql.Node) string

GetTransactionDatabase returns the name of the database that should be considered current for the transaction about to begin. The database is not guaranteed to exist. For USE DATABASE statements, we consider the transaction database to be the one being USEd

func NewDatabaseProvider added in v0.11.0 

func NewDatabaseProvider(dbs ...sql.Database) sql.DatabaseProvider

TODO: kill this

func SelectAllBatches added in v0.12.0 

func SelectAllBatches(string) bool

func SetPreparedStmts added in v0.12.0 

func SetPreparedStmts(v bool)

func StripPassthroughNodes added in v0.12.0 

func StripPassthroughNodes(n sql.Node) sql.Node

StripPassthroughNodes strips all top-level passthrough nodes meant to apply only to top-level queries (query tracking, transaction logic, etc) from the node tree given and return the first non-passthrough child element. This is useful for when we invoke the analyzer recursively when e.g. analyzing subqueries or triggers TODO: instead of stripping this node off after analysis, it would be better to just not add it in the first place.

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 *Catalog
	// BinlogReplicaController holds an optional controller that receives forwarded binlog
	// replication messages (e.g. "start replica").
	BinlogReplicaController binlogreplication.BinlogReplicaController
	// Carder estimates the number of rows returned by a relational expression.
	Carder Carder
	// Coster estimates the incremental CPU+memory cost for execution operators.
	Coster Coster
	// ExecBuilder converts a sql.Node tree into an executable iterator.
	ExecBuilder sql.NodeExecBuilder
	// contains filtered or unexported fields
}

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

func NewDefault 

func NewDefault(provider sql.DatabaseProvider) *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) AnalyzePrepared added in v0.12.0 

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

AnalyzePrepared runs a partial rule set against a previously analyzed plan.

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) PrepareQuery added in v0.12.0 

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

PrepareQuery applies a partial set of transformations to a prepared plan.

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, sel RuleSelector) (sql.Node, transform.TreeIdentity, 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.

func (*Batch) EvalWithSelector added in v0.12.0 

func (b *Batch) EvalWithSelector(ctx *sql.Context, a *Analyzer, n sql.Node, scope *Scope, sel RuleSelector) (sql.Node, transform.TreeIdentity, error)

type BatchSelector added in v0.12.0 

type BatchSelector func(string) bool

BatchSelector filters analysis batches by name

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(pro sql.DatabaseProvider) *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(id RuleId, fn RuleFunc) *Builder

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

func (*Builder) AddPostValidationRule 

func (ab *Builder) AddPostValidationRule(id RuleId, fn RuleFunc) *Builder

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

func (*Builder) AddPreAnalyzeRule 

func (ab *Builder) AddPreAnalyzeRule(id RuleId, fn RuleFunc) *Builder

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

func (*Builder) AddPreValidationRule 

func (ab *Builder) AddPreValidationRule(id RuleId, 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 from the builder parameters

func (*Builder) RemoveAfterAllRule 

func (ab *Builder) RemoveAfterAllRule(id RuleId) *Builder

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

func (*Builder) RemoveDefaultRule 

func (ab *Builder) RemoveDefaultRule(id RuleId) *Builder

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

func (*Builder) RemoveOnceAfterRule 

func (ab *Builder) RemoveOnceAfterRule(id RuleId) *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(id RuleId) *Builder

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

func (*Builder) RemoveValidationRule 

func (ab *Builder) RemoveValidationRule(id RuleId) *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 Carder added in v0.15.0 

type Carder interface {
	// EstimateCard returns the estimate row count outputs for a relational
	// expression. Cardinality is an expression group property.
	EstimateCard(*sql.Context, relExpr, sql.StatsReader) (float64, error)
}

Carder types can estimate the cardinality (row count) of relational expressions.

func NewDefaultCarder added in v0.15.0 

func NewDefaultCarder() Carder

type Catalog added in v0.11.0 

type Catalog struct {
	MySQLDb    *mysql_db.MySQLDb
	InfoSchema sql.Database

	Provider sql.DatabaseProvider
	// contains filtered or unexported fields
}

func NewCatalog added in v0.11.0 

func NewCatalog(provider sql.DatabaseProvider) *Catalog

NewCatalog returns a new empty Catalog with the given provider

func (*Catalog) AllDatabases added in v0.11.0 

func (c *Catalog) AllDatabases(ctx *sql.Context) []sql.Database

func (*Catalog) CreateDatabase added in v0.11.0 

func (c *Catalog) CreateDatabase(ctx *sql.Context, dbName string, collation sql.CollationID) error

CreateDatabase creates a new Database and adds it to the catalog.

func (*Catalog) Database added in v0.11.0 

func (c *Catalog) Database(ctx *sql.Context, db string) (sql.Database, error)

Database returns the database with the given name.

func (*Catalog) ExternalStoredProcedure added in v0.14.0 

func (c *Catalog) ExternalStoredProcedure(ctx *sql.Context, name string, numOfParams int) (*sql.ExternalStoredProcedureDetails, error)

ExternalStoredProcedure implements sql.ExternalStoredProcedureProvider

func (*Catalog) ExternalStoredProcedures added in v0.14.0 

func (c *Catalog) ExternalStoredProcedures(ctx *sql.Context, name string) ([]sql.ExternalStoredProcedureDetails, error)

ExternalStoredProcedures implements sql.ExternalStoredProcedureProvider

func (*Catalog) Function added in v0.11.0 

func (c *Catalog) Function(ctx *sql.Context, name string) (sql.Function, error)

Function returns the function with the name given, or sql.ErrFunctionNotFound if it doesn't exist

func (*Catalog) HasDB added in v0.11.0 

func (c *Catalog) HasDB(ctx *sql.Context, db string) bool

func (*Catalog) LockTable added in v0.11.0 

func (c *Catalog) LockTable(ctx *sql.Context, table string)

LockTable adds a lock for the given table and session client. It is assumed the database is the current database in use.

func (*Catalog) RegisterFunction added in v0.11.0 

func (c *Catalog) RegisterFunction(ctx *sql.Context, fns ...sql.Function)

RegisterFunction registers the functions given, adding them to the built-in functions. Integrators with custom functions should typically use the FunctionProvider interface instead.

func (*Catalog) RemoveDatabase added in v0.11.0 

func (c *Catalog) RemoveDatabase(ctx *sql.Context, dbName string) error

RemoveDatabase removes a database from the catalog.

func (*Catalog) Statistics added in v0.15.0 

func (c *Catalog) Statistics(ctx *sql.Context) (sql.StatsReadWriter, error)

func (*Catalog) Table added in v0.11.0 

func (c *Catalog) Table(ctx *sql.Context, dbName, tableName string) (sql.Table, sql.Database, error)

Table returns the table in the given database with the given name.

func (*Catalog) TableAsOf added in v0.11.0 

func (c *Catalog) TableAsOf(ctx *sql.Context, dbName, tableName string, asOf interface{}) (sql.Table, sql.Database, error)

TableAsOf returns the table in the given database with the given name, as it existed at the time given. The database named must support timed queries.

func (*Catalog) TableFunction added in v0.12.0 

func (c *Catalog) TableFunction(ctx *sql.Context, name string) (sql.TableFunction, error)

TableFunction implements the TableFunctionProvider interface

func (*Catalog) UnlockTables added in v0.11.0 

func (c *Catalog) UnlockTables(ctx *sql.Context, id uint32) error

UnlockTables unlocks all tables for which the given session client has a lock.

type Coster added in v0.15.0 

type Coster interface {
	// EstimateCost cost returns the incremental CPU and memory cost for an
	// operator, or an error. Cost is dependent on physical operator type,
	// and the cardinality of inputs.
	EstimateCost(*sql.Context, relExpr, sql.StatsReader) (float64, error)
}

Coster types can estimate the CPU and memory cost of physical execution operators.

func NewDefaultCoster added in v0.15.0 

func NewDefaultCoster() Coster

func NewHashBiasedCoster added in v0.15.0 

func NewHashBiasedCoster() Coster

func NewInnerBiasedCoster added in v0.15.0 

func NewInnerBiasedCoster() Coster

func NewLookupBiasedCoster added in v0.15.0 

func NewLookupBiasedCoster() Coster

func NewMergeBiasedCoster added in v0.15.0 

func NewMergeBiasedCoster() Coster

type ExecBuilder added in v0.14.0 

type ExecBuilder struct{}

func NewExecBuilder added in v0.14.0 

func NewExecBuilder() *ExecBuilder

type GroupId added in v0.14.0 

type GroupId uint16

type Hint added in v0.15.0 

type Hint struct {
	Typ  HintType
	Args []string
}

func (Hint) String added in v0.15.0 

func (h Hint) String() string

type HintType added in v0.15.0 

type HintType uint8
const (
	HintTypeUnknown                  HintType = iota //
	HintTypeJoinOrder                                // JOIN_ORDER
	HintTypeJoinFixedOrder                           // JOIN_FIXED_ORDER
	HintTypeMergeJoin                                // MERGE_JOIN
	HintTypeLookupJoin                               // LOOKUP_JOIN
	HintTypeHashJoin                                 // HASH_JOIN
	HintTypeSemiJoin                                 // SEMI_JOIN
	HintTypeAntiJoin                                 // ANTI_JOIN
	HintTypeInnerJoin                                // INNER_JOIN
	HintTypeRightSemiLookupJoin                      // RIGHT_SEMI_LOOKUP_JOIN
	HintTypeNoIndexConditionPushDown                 // NO_ICP
)

TODO implement NO_ICP and JOIN_FIXED_ORDER

func (HintType) String added in v0.15.0 

func (i HintType) String() string

type Memo added in v0.14.0 

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

Memo collects a forest of query plans structured by logical and physical equivalency. Logically equivalent plans, represented by an exprGroup, produce the same rows (possibly unordered) and schema. Physical plans are stored in a linked list within an expression group.

func NewMemo added in v0.14.0 

func NewMemo(ctx *sql.Context, stats sql.StatsReadWriter, s *Scope, cost Coster, card Carder) *Memo

func (*Memo) String added in v0.14.0 

func (m *Memo) String() string

func (*Memo) WithJoinOp added in v0.15.0 

func (m *Memo) WithJoinOp(op HintType, left, right string)

func (*Memo) WithJoinOrder added in v0.14.0 

func (m *Memo) WithJoinOrder(tables []string)

type ProcedureCache added in v0.9.0 

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

ProcedureCache contains all non-built-in stored procedures for each database.

func NewProcedureCache added in v0.9.0 

func NewProcedureCache() *ProcedureCache

NewProcedureCache returns a *ProcedureCache.

func (*ProcedureCache) AllForDatabase added in v0.9.0 

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

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

func (*ProcedureCache) Get added in v0.9.0 

func (pc *ProcedureCache) Get(dbName, procedureName string, numOfParams int) *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. If the number of parameters do not match any given procedure, then returns the procedure with the largest number of parameters.

func (*ProcedureCache) Register added in v0.9.0 

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

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

type RoutineTable added in v0.12.0 

type RoutineTable interface {
	sql.Table

	// AssignProcedures assigns a map of db-procedures to the routines table.
	AssignProcedures(p map[string][]*plan.Procedure) sql.Table
}

RoutineTable is a Table that depends on a procedures and functions.

type Rule 

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

Rule to transform nodes.

type RuleFunc 

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

RuleFunc is the function to be applied in a rule.

type RuleId added in v0.12.0 

type RuleId int
const (
	AutocommitId   RuleId // addAutocommitNode
	TrackProcessId        // trackProcess

)

func (RuleId) String added in v0.12.0 

func (i RuleId) String() string

type RuleSelector added in v0.12.0 

type RuleSelector func(RuleId) bool

RuleSelector filters analysis rules by id

func NewFinalizeSubquerySel added in v0.15.0 

func NewFinalizeSubquerySel(sel RuleSelector) RuleSelector

func NewFinalizeUnionSel added in v0.15.0 

func NewFinalizeUnionSel(sel RuleSelector) RuleSelector

func NewProcRuleSelector added in v0.15.0 

func NewProcRuleSelector(sel RuleSelector) RuleSelector

func NewResolveSubqueryExprSelector added in v0.14.0 

func NewResolveSubqueryExprSelector(sel RuleSelector) RuleSelector

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) EnforcesReadOnly added in v0.15.0 

func (s *Scope) EnforcesReadOnly() bool

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) IsEmpty added in v0.14.0 

func (s *Scope) IsEmpty() bool

func (*Scope) MemoNodes 

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

func (*Scope) OuterRelUnresolved added in v0.15.0 

func (s *Scope) OuterRelUnresolved() bool

OuterRelUnresolved returns true if the relations in the outer scope are not qualified and resolved. note: a subquery in the outer scope is itself a scope, and by definition not an outer relation

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) RecursionDepth added in v0.14.0 

func (s *Scope) RecursionDepth() int

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

type TableId added in v0.14.0 

type TableId uint16

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.