analyzer

package
v0.20.0 Latest Latest
Warning

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

 Go to latest Published: May 13, 2025 License: Apache-2.0 Imports: 40 Imported by: 14

Documentation

Index

Constants

View Source 
const MaxBytePrefix = 3072

Variables

View Source 
var AlwaysBeforeDefault []Rule

AlwaysBeforeDefault contains the rules to be applied just once before the DefaultRules. These are an extension of the OnceBeforeDefault rules that will always apply to nodes, unlike the OnceBeforeDefault rules that may be excluded depending on the node. This is only used by integrators.

View Source 
var DefaultRules = []Rule{
	{validateStarExpressionsId, validateStarExpressions},
	{pushdownSubqueryAliasFiltersId, pushdownSubqueryAliasFilters},
	{pruneTablesId, pruneTables},
	{validateCheckConstraintId, validateCheckConstraints},
	{unnestInSubqueriesId, unnestInSubqueries},
	{resolveSubqueriesId, resolveSubqueries},
	{replaceCrossJoinsId, replaceCrossJoins},
}

DefaultRules to apply when analyzing nodes.

View Source 
var DefaultValidationRules = []Rule{
	{validateResolvedId, validateResolved},
	{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 (
	// 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 ExternalFunctionProvider sql.FunctionProvider

ExternalFunctionProvider is a function provider that may be set by an integrator for cases that the DatabaseProvider does not implement the necessary function provider logic (and we need more than the built-in functions). This is used by Catalog to check for functions if it is non-nil.

View Source 
var OnceAfterAll []Rule
View Source 
var OnceAfterDefault = []Rule{
	{unnestExistsSubqueriesId, unnestExistsSubqueries},
	{moveJoinCondsToFilterId, moveJoinConditionsToFilter},
	{finalizeUnionsId, finalizeUnions},
	{loadTriggersId, loadTriggers},
	{processTruncateId, processTruncate},
	{stripTableNameInDefaultsId, stripTableNamesFromColumnDefaults},
	{pushFiltersId, pushFilters},
	{optimizeJoinsId, optimizeJoins},
	{finalizeSubqueriesId, finalizeSubqueries},
	{applyIndexesFromOuterScopeId, applyIndexesFromOuterScope},
	{replaceAggId, replaceAgg},
	{replaceIdxSortId, replaceIdxSort},
	{eraseProjectionId, eraseProjection},
	{flattenDistinctId, flattenDistinct},
	{insertTopNId, insertTopNNodes},
	{replaceIdxOrderByDistanceId, replaceIdxOrderByDistance},
	{applyHashInId, applyHashIn},
	{assignRoutinesId, assignRoutines},
	{modifyUpdateExprsForJoinId, modifyUpdateExprsForJoin},
	{applyForeignKeysId, applyForeignKeys},
	{interpreterId, interpreter},
}
View Source 
var OnceBeforeDefault = []Rule{
	{applyDefaultSelectLimitId, applyDefaultSelectLimit},
	{replaceCountStarId, replaceCountStar},
	{validateOffsetAndLimitId, validateOffsetAndLimit},
	{ValidateCreateTableId, validateCreateTable},
	{validateAlterTableId, validateAlterTable},
	{validateExprSemId, validateExprSem},
	{resolveDropConstraintId, resolveDropConstraint},
	{ResolveAlterColumnId, resolveAlterColumn},
	{validateDropTablesId, validateDropTables},
	{resolveCreateSelectId, resolveCreateSelect},
	{validateDropConstraintId, validateDropConstraint},
	{resolveUnionsId, resolveUnions},
	{validateCreateTriggerId, validateCreateTrigger},
	{ValidateColumnDefaultsId, validateColumnDefaults},
	{validateReadOnlyDatabaseId, validateReadOnlyDatabase},
	{validateReadOnlyTransactionId, validateReadOnlyTransaction},
	{validateDatabaseSetId, validateDatabaseSet},
	{validateDeleteFromId, validateDeleteFrom},
	{simplifyFiltersId, simplifyFilters},
	{pushNotFiltersId, pushNotFilters},
	{hoistOutOfScopeFiltersId, hoistOutOfScopeFilters},
}

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

View Source 
var PreparedStmtDisabled bool

Functions

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 FlagIsSet added in v0.19.0 

func FlagIsSet(flags *sql.QueryFlags, flag int) bool

FlagIsSet returns whether a set of query flag has the |flag| bit marked, or a default value if |flags| is nil. Flags for rule selecting are enabled by default (true), flags for execution behavior are disabled by default (false).

func GetTableIndexColumns added in v0.20.0 

func GetTableIndexColumns(ctx *sql.Context, table sql.Node) (map[string]bool, error)

GetTableIndexColumns returns the columns over which indexes are defined

func GetTableIndexNames added in v0.20.0 

func GetTableIndexNames(ctx *sql.Context, _ *Analyzer, table sql.Node) ([]string, error)

GetTableIndexNames returns the names of indexes associated with a table.

func HasPrimaryKeys added in v0.20.0 

func HasPrimaryKeys(sch sql.Schema) bool

func Schemas added in v0.18.0 

func Schemas(nodes []sql.Node) sql.Schema

Schemas returns the Schemas for the nodes given appended in to a single one

func SelectAllBatches added in v0.12.0 

func SelectAllBatches(string) bool

func SetOutput added in v0.20.0 

func SetOutput(w io.Writer)

func SetPreparedStmts added in v0.12.0 

func SetPreparedStmts(v bool)

func UpdateKeyedColumns added in v0.20.0 

func UpdateKeyedColumns(keyedColumns map[string]bool, n *plan.AlterIndex) map[string]bool

UpdateKeyedColumns updates the keyedColumns map based on the action of the AlterIndex node

func ValidateAddColumn added in v0.19.0 

func ValidateAddColumn(schema sql.Schema, ac *plan.AddColumn) (sql.Schema, error)

ValidateAddColumn validates that the column specified in |ac| can be added to the specified |schema|. A new Schema is returned, with the added column, if the column can be added. Otherwise, an error is returned if there are any validation errors.

func ValidateAlterDefault added in v0.20.0 

func ValidateAlterDefault(initialSch, sch sql.Schema, as *plan.AlterDefaultSet) (sql.Schema, error)

ValidateAlterDefault validates the addition of a default value to a column.

func ValidateColumnNotUsedInCheckConstraint added in v0.20.0 

func ValidateColumnNotUsedInCheckConstraint(columnName string, checks sql.CheckConstraints) error

ValidateColumnNotUsedInCheckConstraint validates that the specified column name is not referenced in any of the specified table check constraints.

func ValidateDropColumn added in v0.20.0 

func ValidateDropColumn(initialSch, sch sql.Schema, dc *plan.DropColumn) (sql.Schema, error)

func ValidateDropDefault added in v0.20.0 

func ValidateDropDefault(initialSch, sch sql.Schema, ad *plan.AlterDefaultDrop) (sql.Schema, error)

ValidateDropDefault validates the dropping of a default value.

func ValidateIdentifier added in v0.20.0 

func ValidateIdentifier(name string) error

func ValidateModifyColumn added in v0.20.0 

func ValidateModifyColumn(ctx *sql.Context, initialSch sql.Schema, schema sql.Schema, mc *plan.ModifyColumn, keyedColumns map[string]bool) (sql.Schema, error)

func ValidateRenameColumn added in v0.20.0 

func ValidateRenameColumn(initialSch, sch sql.Schema, rc *plan.RenameColumn) (sql.Schema, error)

ValidateRenameColumn checks that a DDL RenameColumn node can be safely executed (e.g. no collision with other column names, doesn't invalidate any table check constraints).

Note that schema is passed in twice, because one version is the initial version before the alter column expressions are applied, and the second version is the current schema that is being modified as multiple nodes are processed.

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

	// Batches of Rules to apply.
	Batches []*Batch
	// Catalog of databases and registered functions.
	Catalog *Catalog
	// Coster estimates the incremental CPU+memory cost for execution operators.
	Coster memo.Coster
	// ExecBuilder converts a sql.Node tree into an executable iterator.
	ExecBuilder sql.NodeExecBuilder
	// Runner represents the engine, which is represented as a separate interface to work around circular dependencies
	Runner sql.StatementRunner
	// Parser is the parser used to parse SQL statements.
	Parser sql.Parser
	// SchemaFormatter is used to format the schema of a node to a string.
	SchemaFormatter sql.SchemaFormatter
	// 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 NewDefaultWithVersion added in v0.16.0 

func NewDefaultWithVersion(provider sql.DatabaseProvider) *Analyzer

NewDefaultWithVersion creates a default Analyzer instance either experimental or

func (*Analyzer) Analyze 

func (a *Analyzer) Analyze(ctx *sql.Context, node sql.Node, scope *plan.Scope, qFlags *sql.QueryFlags) (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) LogFn added in v0.16.0 

func (a *Analyzer) LogFn() func(string, ...any)

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 *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (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 *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (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.

type Catalog added in v0.11.0 

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

	DbProvider  sql.DatabaseProvider
	AuthHandler sql.AuthorizationHandler

	// BinlogReplicaController holds an optional controller that receives forwarded binlog
	// replication messages (e.g. "start replica").
	BinlogReplicaController binlogreplication.BinlogReplicaController

	// BinlogPrimaryController holds an optional controller that receives forwarded binlog
	// replication messages (e.g. "show replicas") and commands (e.g. COM_REGISTER_REPLICA).
	BinlogPrimaryController binlogreplication.BinlogPrimaryController
	// 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) AnalyzeTable added in v0.20.0 

func (c *Catalog) AnalyzeTable(ctx *sql.Context, table sql.Table, db string) error

func (*Catalog) AuthorizationHandler added in v0.19.0 

func (c *Catalog) AuthorizationHandler() sql.AuthorizationHandler

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) DataLength added in v0.18.0 

func (c *Catalog) DataLength(ctx *sql.Context, db string, table sql.Table) (uint64, error)

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) DatabaseTable added in v0.16.0 

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

func (*Catalog) DatabaseTableAsOf added in v0.16.0 

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

func (*Catalog) DropDbStats added in v0.18.0 

func (c *Catalog) DropDbStats(ctx *sql.Context, db string, flush bool) error

func (*Catalog) DropStats added in v0.18.0 

func (c *Catalog) DropStats(ctx *sql.Context, qual sql.StatQualifier, cols []string) error

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, bool)

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

func (*Catalog) GetBinlogPrimaryController added in v0.18.1 

func (c *Catalog) GetBinlogPrimaryController() binlogreplication.BinlogPrimaryController

func (*Catalog) GetBinlogReplicaController added in v0.18.0 

func (c *Catalog) GetBinlogReplicaController() binlogreplication.BinlogReplicaController

func (*Catalog) GetStats added in v0.18.0 

func (c *Catalog) GetStats(ctx *sql.Context, qual sql.StatQualifier, cols []string) (sql.Statistic, bool)

func (*Catalog) GetTableStats added in v0.18.0 

func (c *Catalog) GetTableStats(ctx *sql.Context, db string, table sql.Table) ([]sql.Statistic, error)

func (*Catalog) HasBinlogPrimaryController added in v0.18.1 

func (c *Catalog) HasBinlogPrimaryController() bool

func (*Catalog) HasBinlogReplicaController added in v0.18.1 

func (c *Catalog) HasBinlogReplicaController() bool

func (*Catalog) HasDatabase added in v0.16.0 

func (c *Catalog) HasDatabase(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) RowCount added in v0.18.0 

func (c *Catalog) RowCount(ctx *sql.Context, db string, table sql.Table) (uint64, error)

func (*Catalog) SetStats added in v0.18.0 

func (c *Catalog) SetStats(ctx *sql.Context, stats sql.Statistic) 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, bool)

TableFunction implements the TableFunctionProvider interface

func (*Catalog) TableSchema added in v0.19.0 

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

TableSchema returns the table in the given database with the given name, in the given schema name

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.

func (*Catalog) WithTableFunctions added in v0.18.0 

func (c *Catalog) WithTableFunctions(fns ...sql.TableFunction) (sql.TableFunctionProvider, error)

type IndexScanOp added in v0.19.0 

type IndexScanOp uint8
const (
	IndexScanOpEq         IndexScanOp = iota // =
	IndexScanOpNullSafeEq                    // <=>
	IndexScanOpInSet                         // =
	IndexScanOpNotInSet                      // !=
	IndexScanOpNotEq                         // !=
	IndexScanOpGt                            // >
	IndexScanOpGte                           // >=
	IndexScanOpLt                            // <
	IndexScanOpLte                           // <=
	IndexScanOpAnd                           // &&
	IndexScanOpOr                            // ||
	IndexScanOpIsNull                        // IS NULL
	IndexScanOpIsNotNull                     // IS NOT NULL
	IndexScanOpSpatialEq                     // SpatialEq
	IndexScanOpFulltextEq                    // FulltextEq
)

func IndexLeafChildren added in v0.19.0 

func IndexLeafChildren(e sql.Expression) (IndexScanOp, sql.Expression, sql.Expression, bool)

IndexLeafChildren handles the struct types that may be found on a leaf node while creating indexes.

func (IndexScanOp) String added in v0.19.0 

func (i IndexScanOp) String() string

func (IndexScanOp) Swap added in v0.19.0 

func (o IndexScanOp) Swap() IndexScanOp

Swap returns the identity op for swapping a comparison's LHS and RHS

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, *plan.Scope, RuleSelector, *sql.QueryFlags) (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 (
	ValidateCreateTableId RuleId // validateCreateTable

	ValidateColumnDefaultsId // validateColumnDefaults

	ResolveAlterColumnId // ResolveAlterColumn

	ValidateOperandsId // validateOperands

	QuoteDefaultColumnValueNamesId // quoteDefaultColumnValueNames
	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 TableAliases 

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

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.