plan

package
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Jul 31, 2024 License: Apache-2.0 Imports: 28 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ItaTypeStatic itaType = iota
	ItaTypeLookup
)
View Source 
const (
	QueryTypeSelect = iota
	QueryTypeDdl
	QueryTypeUpdate
)
View Source 
const (
	UnionType = iota
	IntersectType
	ExceptType
)
View Source 
const (
	InsertTrigger TriggerEvent = "insert"
	UpdateTrigger              = "update"
	DeleteTrigger              = "delete"
)
View Source 
const DualTableName = ""

DualTableName is empty string because no table with empty name can be created

View Source 
const DynamicPrivilege_CloneAdmin = "clone_admin"

DynamicPrivilege_CloneAdmin is the dynamic privilege required to execute clone commands. https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_clone-admin

View Source 
const DynamicPrivilege_ReplicationSlaveAdmin = "replication_slave_admin"

DynamicPrivilege_ReplicationSlaveAdmin is the dynamic privilege required to execute replication commands. https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_replication-slave-admin

View Source 
const ShowStatusValueCol = "Value"
View Source 
const ShowStatusVariableCol = "Variable_name"
View Source 
const ShowVariablesValueCol = "Value"
View Source 
const ShowVariablesVariableCol = "Variable_name"

Variables

View Source 
var (
	// ErrNoCheckConstraintSupport is returned when the table does not support CONSTRAINT CHECK operations.
	ErrNoCheckConstraintSupport = errors.NewKind("the table does not support check constraint operations: %s")

	// ErrCheckViolated is returned when the check constraint evaluates to false
	ErrCheckViolated = errors.NewKind("check constraint %s is violated.")
)
View Source 
var (
	// ErrIndexActionNotImplemented is returned when the action has not been implemented
	ErrIndexActionNotImplemented = errors.NewKind("alter table index action is not implemented: %v")
	// ErrCreateIndexMissingColumns is returned when a CREATE INDEX statement does not provide any columns
	ErrCreateIndexMissingColumns = errors.NewKind("cannot create an index without columns")
	// ErrCreateIndexNonExistentColumn is returned when a key is provided in the index that isn't in the table
	ErrCreateIndexNonExistentColumn = errors.NewKind("column `%v` does not exist in the table")
	// ErrCreateIndexDuplicateColumn is returned when a CREATE INDEX statement has the same column multiple times
	ErrCreateIndexDuplicateColumn = errors.NewKind("cannot have duplicates of columns in an index: `%v`")
)
View Source 
var (
	// ErrNotIndexable is returned when the table is not indexable.
	ErrNotIndexable = errors.NewKind("the table is not indexable")

	// ErrInvalidIndexDriver is returned when the index driver can't be found.
	ErrInvalidIndexDriver = errors.NewKind("invalid driver index %q")

	// ErrExprTypeNotIndexable is returned when the expression type cannot be
	// indexed, such as BLOB or JSON.
	ErrExprTypeNotIndexable = errors.NewKind("expression %q with type %s cannot be indexed")
)
View Source 
var (
	// ErrIndexNotFound is returned when the index cannot be found.
	ErrIndexNotFound = errors.NewKind("unable to find index %q on table %q of database %q")
	// ErrTableNotValid is returned when the table is not valid
	ErrTableNotValid = errors.NewKind("table is not valid")
	// ErrTableNotNameable is returned when the table is not nameable.
	ErrTableNotNameable = errors.NewKind("can't get name from table")
	// ErrIndexNotAvailable is returned when trying to delete an index that is
	// still not ready for usage.
	ErrIndexNotAvailable = errors.NewKind("index %q is still not ready for usage and can't be deleted")
)
View Source 
var CachedResultsGlobalCache = NewCachedResultsManager()

CachedResultsGlobalCache manages the caches created by CachedResults nodes.

View Source 
var DescribeSchema = sql.Schema{
	{Name: "plan", Type: VarChar25000},
}

DescribeSchema is the schema returned by a DescribeQuery node.

View Source 
var EmptyIter = &emptyCacheIter{}
View Source 
var ErrAggregationMissingWindow = errors.New("aggregation missing window expression")
View Source 
var ErrAutoIncrementNotSupported = errors.NewKind("table doesn't support AUTO_INCREMENT")
View Source 
var ErrDeleteFromNotSupported = errors.NewKind("table doesn't support DELETE FROM")
View Source 
var ErrDropViewChild = errors.NewKind("any child of DropView must be of type SingleDropView")
View Source 
var ErrEmptyCachedResult = errors.New("CachedResult contains no rows")
View Source 
var ErrGroupBy = errors.NewKind("group by aggregation '%v' not supported")

ErrGroupBy is returned when the aggregation is not supported.

View Source 
var ErrInsertIntoIncompatibleTypes = errors.NewKind("cannot convert type %s to %s")
View Source 
var ErrInsertIntoNotSupported = errors.NewKind("table doesn't support INSERT INTO")

ErrInsertIntoNotSupported is thrown when a table doesn't support inserts

View Source 
var ErrInsertIntoUnsupportedValues = errors.NewKind("%T is unsupported for inserts")
View Source 
var ErrInvalidLookupForIndexedTable = errors.NewKind("indexable table does not support given lookup: %s")
View Source 
var ErrNoPartitionable = errors.NewKind("no partitionable node found in exchange tree")

ErrNoPartitionable is returned when no Partitionable node is found in the Exchange tree.

View Source 
var ErrNoReplicationController = errors.NewKind("no replication controller available")

ErrNoReplicationController is returned when replication commands are executed without a configured replication controller to dispatch the command to.

View Source 
var ErrNotPrimaryKeyAlterable = errors.NewKind("error: table is not primary key alterable")

ErrNotPrimaryKeyAlterable is return when a table cannot be determined to be primary key alterable

View Source 
var ErrNotView = errors.NewKind("'%' is not VIEW")
View Source 
var ErrOnDuplicateKeyUpdateNotSupported = errors.NewKind("table doesn't support ON DUPLICATE KEY UPDATE")
View Source 
var ErrReplaceIntoNotSupported = errors.NewKind("table doesn't support REPLACE INTO")
View Source 
var ErrRowIterDisposed = errors.New("attempted to call RowIter() on a disposed Node")
View Source 
var ErrTruncateNotSupported = errors.NewKind("table doesn't support TRUNCATE")
View Source 
var ErrUnresolvedTable = errors.NewKind("unresolved table")

ErrUnresolvedTable is thrown when a table cannot be resolved

View Source 
var ErrUpdateForTableNotSupported = errors.NewKind("The target table %s of the UPDATE is not updatable")
View Source 
var ErrUpdateNotSupported = errors.NewKind("table doesn't support UPDATE")
View Source 
var ErrUpdateUnexpectedSetResult = errors.NewKind("attempted to set field but expression returned %T")
View Source 
var IgnorableErrors = []*errors.Kind{sql.ErrInsertIntoNonNullableProvidedNull,
	sql.ErrPrimaryKeyViolation,
	sql.ErrPartitionNotFound,
	sql.ErrExpectedSingleRow,
	sql.ErrForeignKeyChildViolation,
	sql.ErrForeignKeyParentViolation,
	sql.ErrDuplicateEntry,
	sql.ErrUniqueKeyViolation,
	sql.ErrCheckConstraintViolated,
}

cc: https://dev.mysql.com/doc/refman/8.0/en/sql-mode.html#sql-mode-strict The INSERT IGNORE syntax applies to these ignorable errors ER_BAD_NULL_ERROR - yes ER_DUP_ENTRY - yes ER_DUP_ENTRY_WITH_KEY_NAME - Yes ER_DUP_KEY - kinda ER_NO_PARTITION_FOR_GIVEN_VALUE - yes ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT - No ER_NO_REFERENCED_ROW_2 - Yes ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET - No ER_ROW_IS_REFERENCED_2 - Yes ER_SUBQUERY_NO_1_ROW - yes ER_VIEW_CHECK_FAILED - No

View Source 
var SignalItems = []SignalConditionItemName{
	SignalConditionItemName_ClassOrigin,
	SignalConditionItemName_SubclassOrigin,
	SignalConditionItemName_MessageText,
	SignalConditionItemName_MysqlErrno,
	SignalConditionItemName_ConstraintCatalog,
	SignalConditionItemName_ConstraintSchema,
	SignalConditionItemName_ConstraintName,
	SignalConditionItemName_CatalogName,
	SignalConditionItemName_SchemaName,
	SignalConditionItemName_TableName,
	SignalConditionItemName_ColumnName,
	SignalConditionItemName_CursorName,
}
View Source 
var VarChar25000 = types.MustCreateStringWithDefaults(sqltypes.VarChar, 25_000)

Functions

func AliasSubqueryString 

func AliasSubqueryString(e sql.Expression) string

AliasSubqueryString returns a string with subquery expressions simplified into static query strings, rather than the plan string (which is mutable through analysis).

func ApplyBindings 

func ApplyBindings(n sql.Node, bindings map[string]sql.Expression) (sql.Node, map[string]bool, error)

ApplyBindings replaces all `BindVar` expressions in the given sql.Node with their corresponding sql.Expression entries in the provided |bindings| map. If a binding for a |BindVar| expression is not found in the map, no error is returned and the |BindVar| expression is left in place. There is no check on whether all entries in |bindings| are used at least once throughout the |n| but a map of all the used |bindings| are returned. sql.DeferredType instances will be resolved by the binding types.

func CheckPrivilegeNameForDatabase 

func CheckPrivilegeNameForDatabase(db sql.Database) string

CheckPrivilegeNameForDatabase returns the name of the database to check privileges for, which may not be the result of db.Name()

func FindFKIndexWithPrefix 

func FindFKIndexWithPrefix(ctx *sql.Context, tbl sql.IndexAddressableTable, prefixCols []string, useExtendedIndexes bool, ignoredIndexes ...string) (sql.Index, bool, error)

FindFKIndexWithPrefix returns an index that has the given columns as a prefix, with the index intended for use with foreign keys. The returned index is deterministic and follows the given rules, from the highest priority in descending order:

1. Columns exactly match the index 2. Columns match as much of the index prefix as possible 3. Unique index before non-unique 4. Largest index by column count 5. Index ID in ascending order

The prefix columns may be in any order, and the returned index will contain all of the prefix columns within its prefix. For example, the slices [col1, col2] and [col2, col1] will match the same index, as their ordering does not matter. The index [col1, col2, col3] would match, but the index [col1, col3] would not match as it is missing "col2". Prefix columns are case-insensitive.

If `useExtendedIndexes` is true, then this will include any implicit primary keys that were not explicitly defined on the index. Some operations only consider explicitly indexed columns, while others also consider any implicit primary keys as well, therefore this is a boolean to control the desired behavior.

func FindForeignKeyColMapping 

func FindForeignKeyColMapping(
	ctx *sql.Context,
	fkName string,
	localTbl sql.ForeignKeyTable,
	localFKCols []string,
	destFKCols []string,
	index sql.Index,
) ([]int, []sql.Type, error)

FindForeignKeyColMapping returns the mapping from a given row to its equivalent index position, based on the matching foreign key columns. This also verifies that the column types match, as it is a prerequisite for mapping. For foreign keys that do not match the full index, also returns the types to append during the key mapping, as all index columns must have a column expression. All strings are case-insensitive.

func GetColumnFromIndexExpr 

func GetColumnFromIndexExpr(expr string, table sql.Table) *sql.Column

GetColumnFromIndexExpr returns column from the table given using the expression string given, in the form "table.column". Returns nil if the expression doesn't represent a column.

func GetDatabase 

func GetDatabase(node sql.Node) sql.Database

GetDatabase returns the first database found in the node tree given

func GetDatabaseCollation 

func GetDatabaseCollation(ctx *sql.Context, db sql.Database) sql.CollationID

GetDatabaseCollation returns a database's collation. Also handles when a database does not explicitly support collations.

func GetDatabaseName 

func GetDatabaseName(nodeToSearch sql.Node) string

GetDatabaseName attempts to fetch the database name from the node. If not found directly on the node, searches the children. Returns the first database name found, regardless of whether there are more, therefore this is only intended to be used in situations where only a single database is expected to be found. Unlike how tables are handled in most nodes, databases may be stored as a string field therefore there will be situations where a database name exists on a node, but cannot be found through inspection.

func GetDeletable 

func GetDeletable(node sql.Node) (sql.DeletableTable, error)

func GetIndexLookup 

func GetIndexLookup(ita *IndexedTableAccess) sql.IndexLookup

GetIndexLookup returns the sql.IndexLookup from an IndexedTableAccess. This method is exported for use in integration tests.

func GetInsertable 

func GetInsertable(node sql.Node) (sql.InsertableTable, error)

func GetIsUpdatableFromCreateView 

func GetIsUpdatableFromCreateView(cv *CreateView) bool

GetIsUpdatableFromCreateView returns whether the view is updatable or not. https://dev.mysql.com/doc/refman/8.0/en/view-updatability.html

func GetQueryType 

func GetQueryType(child sql.Node) queryType

func GetTruncatable 

func GetTruncatable(node sql.Node) (sql.TruncateableTable, error)

func GetUpdatable 

func GetUpdatable(node sql.Node) (sql.UpdatableTable, error)

func HasEmptyTable 

func HasEmptyTable(n sql.Node) bool

func HasPrimaryKeys 

func HasPrimaryKeys(table sql.Table) bool

func IsBinary 

func IsBinary(node sql.Node) bool

IsBinary returns whether the node is binary or not.

func IsDDLNode 

func IsDDLNode(node sql.Node) bool

func IsDualTable 

func IsDualTable(t sql.Table) bool

IsDualTable returns whether the given table is the "dual" table.

func IsEmptyIter 

func IsEmptyIter(i sql.RowIter) bool

func IsEmptyTable 

func IsEmptyTable(n sql.Node) bool

func IsNoRowNode 

func IsNoRowNode(node sql.Node) bool

IsNoRowNode returns whether this are node interacts only with schema and the catalog, not with any table rows.

func IsNullRejecting 

func IsNullRejecting(e sql.Expression) bool

IsNullRejecting returns whether the expression always returns false for nil inputs.

func IsReadOnly 

func IsReadOnly(node sql.Node) bool

func IsSessionAutocommit 

func IsSessionAutocommit(ctx *sql.Context) (bool, error)

IsSessionAutocommit returns true if the current session is using implicit transaction management through autocommit.

func IsShowNode 

func IsShowNode(node sql.Node) bool

func IsUnary 

func IsUnary(node sql.Node) bool

IsUnary returns whether the node is unary or not.

func NewCachedResultsManager 

func NewCachedResultsManager() *cachedResultsManager

func NewCaseStatement 

func NewCaseStatement(caseExpr sql.Expression, ifConditionals []*IfConditional, elseStatement sql.Node) sql.Node

NewCaseStatement creates a new *NewCaseStatement or *IfElseBlock node.

func NewCheckDefinition 

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

func NewCheckpointingTableEditorIter 

func NewCheckpointingTableEditorIter(wrappedIter sql.RowIter, table sql.EditOpenerCloser) sql.RowIter

NewCheckpointingTableEditorIter is similar to NewTableEditorIter except that it returns an iter that calls BeginStatement and CompleteStatement on |table| after every iter of |wrappedIter|. While SLOW, this functionality ensures correctness for statements that need to rollback individual statements that error such as INSERT IGNORE INTO.

func NewCreateSpatialRefSys 

func NewCreateSpatialRefSys(srid uint32, orReplace, ifNotExists bool, srsAttr SrsAttribute) (sql.Node, error)

func NewDualSqlTable 

func NewDualSqlTable() sql.Table

NewDualSqlTable creates a new Dual table.

func NewEmptyTableWithSchema 

func NewEmptyTableWithSchema(schema sql.Schema) sql.Node

func NewNotInSubquery 

func NewNotInSubquery(left sql.Expression, right sql.Expression) sql.Expression

NewNotInSubquery creates a new NotInSubquery expression.

func NewPrependNode 

func NewPrependNode(child sql.Node, row sql.Row) sql.Node

func NewStripRowNode 

func NewStripRowNode(child sql.Node, numCols int) sql.Node

func NewTableCount 

func NewTableCount(aliasName string, db sql.Database, table sql.StatisticsTable, cnt uint64, id sql.ColumnId) sql.Node

func NewTableEditorIter 

func NewTableEditorIter(wrappedIter sql.RowIter, openerClosers ...sql.EditOpenerCloser) sql.RowIter

NewTableEditorIter returns a new *tableEditorIter by wrapping the given iterator. If the "statement_boundaries" session variable is set to false, then the original iterator is returned. Each of the |openerClosers| specified will be called to begin, complete, and discard statements as needed as the |wrappedIter| is processed.

func NewTrackedRowIter 

func NewTrackedRowIter(
	node sql.Node,
	iter sql.RowIter,
	onNext NotifyFunc,
	onDone NotifyFunc,
) *trackedRowIter

func NillaryWithChildren 

func NillaryWithChildren(node sql.Node, children ...sql.Node) (sql.Node, error)

NillaryNode is a node with no children. This is a common WithChildren implementation for all nodes that have none.

func NodeRepresentsSelect 

func NodeRepresentsSelect(s sql.Node) bool

NodeRepresentsSelect attempts to walk a sql.Node to determine if it represents a SELECT statement.

func OrderTriggers 

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

OrderTriggers is a utility method that first sorts triggers into their precedence. It then splits the triggers into before and after pairs.

func PrependRowInPlan 

func PrependRowInPlan(row sql.Row, lateral bool) func(n sql.Node) (sql.Node, transform.TreeIdentity, error)

PrependRowInPlan returns a transformation function that prepends the row given to any row source in a query plan. Any source of rows, as well as any node that alters the schema of its children, will be wrapped so that its result rows are prepended with the row given.

func ReadCommitted 

func ReadCommitted(ctx *sql.Context) bool

func RecreateTableSchemaFromJoinSchema 

func RecreateTableSchemaFromJoinSchema(joinSchema sql.Schema) map[string]sql.Schema

RecreateTableSchemaFromJoinSchema takes a join schema and recreates each individual tables schema.

func ResolveForeignKey 

func ResolveForeignKey(ctx *sql.Context, tbl sql.ForeignKeyTable, refTbl sql.ForeignKeyTable, fkDef sql.ForeignKeyConstraint, shouldAdd, fkChecks, checkRows bool) error

ResolveForeignKey verifies the foreign key definition and resolves the foreign key, creating indexes and validating data as necessary. fkChecks - whether to check the foreign key against the data in the table checkRows - whether to check the existing rows in the table against the foreign key

func SplitRowIntoTableRowMap 

func SplitRowIntoTableRowMap(row sql.Row, joinSchema sql.Schema) map[string]sql.Row

SplitRowIntoTableRowMap takes a join table row and breaks into a map of tables and their respective row.

func TableDebugString 

func TableDebugString(table sql.Table, additionalChildren ...string) string

Types

type AccountLimits 

type AccountLimits struct {
	MaxQueriesPerHour     *int64
	MaxUpdatesPerHour     *int64
	MaxConnectionsPerHour *int64
	MaxUserConnections    *int64
}

AccountLimits represents the limits imposed upon an account.

type AddColumn 

type AddColumn struct {
	Table sql.Node
	// contains filtered or unexported fields
}

func NewAddColumn 

func NewAddColumn(database sql.Database, table *UnresolvedTable, column *sql.Column, order *sql.ColumnOrder) *AddColumn

func NewAddColumnResolved 

func NewAddColumnResolved(table *ResolvedTable, column sql.Column, order *sql.ColumnOrder) *AddColumn

func (*AddColumn) CheckPrivileges 

func (a *AddColumn) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AddColumn) Children 

func (a *AddColumn) Children() []sql.Node

func (*AddColumn) CollationCoercibility 

func (*AddColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AddColumn) Column 

func (a *AddColumn) Column() *sql.Column

func (*AddColumn) Database 

func (c *AddColumn) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AddColumn) DebugString 

func (a *AddColumn) DebugString() string

func (*AddColumn) Expressions 

func (a *AddColumn) Expressions() []sql.Expression

func (*AddColumn) IsReadOnly 

func (a *AddColumn) IsReadOnly() bool

func (*AddColumn) Order 

func (a *AddColumn) Order() *sql.ColumnOrder

func (*AddColumn) Resolved 

func (a *AddColumn) Resolved() bool

Resolved implements the Resolvable interface.

func (*AddColumn) Schema 

func (a *AddColumn) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*AddColumn) String 

func (a *AddColumn) String() string

func (*AddColumn) TargetSchema 

func (a *AddColumn) TargetSchema() sql.Schema

func (*AddColumn) ValidateDefaultPosition 

func (a *AddColumn) ValidateDefaultPosition(tblSch sql.Schema) error

func (AddColumn) WithChildren 

func (a AddColumn) WithChildren(children ...sql.Node) (sql.Node, error)

func (*AddColumn) WithDatabase 

func (a *AddColumn) WithDatabase(db sql.Database) (sql.Node, error)

func (AddColumn) WithExpressions 

func (a AddColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (AddColumn) WithTargetSchema 

func (a AddColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error)

WithTargetSchema implements sql.SchemaTarget

type AlterAutoIncrement 

type AlterAutoIncrement struct {
	Table   sql.Node
	AutoVal uint64
	// contains filtered or unexported fields
}

func NewAlterAutoIncrement 

func NewAlterAutoIncrement(database sql.Database, table sql.Node, autoVal uint64) *AlterAutoIncrement

func (*AlterAutoIncrement) CheckPrivileges 

func (p *AlterAutoIncrement) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterAutoIncrement) Children 

func (p *AlterAutoIncrement) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterAutoIncrement) CollationCoercibility 

func (p *AlterAutoIncrement) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterAutoIncrement) Database 

func (c *AlterAutoIncrement) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterAutoIncrement) IsReadOnly 

func (p *AlterAutoIncrement) IsReadOnly() bool

func (*AlterAutoIncrement) Resolved 

func (p *AlterAutoIncrement) Resolved() bool

Resolved implements the sql.Node interface.

func (*AlterAutoIncrement) Schema 

func (p *AlterAutoIncrement) Schema() sql.Schema

func (AlterAutoIncrement) String 

func (p AlterAutoIncrement) String() string

func (*AlterAutoIncrement) WithChildren 

func (p *AlterAutoIncrement) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*AlterAutoIncrement) WithDatabase 

func (p *AlterAutoIncrement) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type AlterDB 

type AlterDB struct {
	Catalog sql.Catalog

	Collation sql.CollationID
	// contains filtered or unexported fields
}

AlterDB alters a database from the Catalog.

func NewAlterDatabase 

func NewAlterDatabase(dbName string, collation sql.CollationID) *AlterDB

NewAlterDatabase returns a new AlterDB.

func (*AlterDB) CheckPrivileges 

func (c *AlterDB) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterDB) Children 

func (c *AlterDB) Children() []sql.Node

Children implements the interface sql.Node.

func (*AlterDB) CollationCoercibility 

func (*AlterDB) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterDB) Database 

func (c *AlterDB) Database(ctx *sql.Context) string

Database returns the name of the database that will be used.

func (*AlterDB) IsReadOnly 

func (c *AlterDB) IsReadOnly() bool

func (*AlterDB) Resolved 

func (c *AlterDB) Resolved() bool

Resolved implements the interface sql.Node.

func (*AlterDB) Schema 

func (c *AlterDB) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*AlterDB) String 

func (c *AlterDB) String() string

String implements the interface sql.Node.

func (*AlterDB) WithChildren 

func (c *AlterDB) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type AlterDefaultDrop 

type AlterDefaultDrop struct {
	Table      sql.Node
	ColumnName string
	// contains filtered or unexported fields
}

AlterDefaultDrop represents the ALTER COLUMN DROP DEFAULT statement.

func NewAlterDefaultDrop 

func NewAlterDefaultDrop(database sql.Database, table sql.Node, columnName string) *AlterDefaultDrop

NewAlterDefaultDrop returns a *AlterDefaultDrop node.

func (*AlterDefaultDrop) CheckPrivileges 

func (d *AlterDefaultDrop) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterDefaultDrop) Children 

func (d *AlterDefaultDrop) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterDefaultDrop) CollationCoercibility 

func (d *AlterDefaultDrop) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterDefaultDrop) Database 

func (c *AlterDefaultDrop) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterDefaultDrop) Expressions 

func (d *AlterDefaultDrop) Expressions() []sql.Expression

func (*AlterDefaultDrop) IsReadOnly 

func (d *AlterDefaultDrop) IsReadOnly() bool

func (*AlterDefaultDrop) Resolved 

func (d *AlterDefaultDrop) Resolved() bool

Resolved implements the sql.Node interface.

func (*AlterDefaultDrop) Schema 

func (*AlterDefaultDrop) Schema() sql.Schema

Schema implements the Node interface.

func (*AlterDefaultDrop) String 

func (d *AlterDefaultDrop) String() string

String implements the sql.Node interface.

func (*AlterDefaultDrop) TargetSchema 

func (d *AlterDefaultDrop) TargetSchema() sql.Schema

func (*AlterDefaultDrop) WithChildren 

func (d *AlterDefaultDrop) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*AlterDefaultDrop) WithDatabase 

func (d *AlterDefaultDrop) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (AlterDefaultDrop) WithExpressions 

func (d AlterDefaultDrop) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (AlterDefaultDrop) WithTargetSchema 

func (d AlterDefaultDrop) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type AlterDefaultSet 

type AlterDefaultSet struct {
	Table      sql.Node
	ColumnName string
	Default    *sql.ColumnDefaultValue
	// contains filtered or unexported fields
}

AlterDefaultSet represents the ALTER COLUMN SET DEFAULT statement.

func NewAlterDefaultSet 

func NewAlterDefaultSet(database sql.Database, table sql.Node, columnName string, defVal *sql.ColumnDefaultValue) *AlterDefaultSet

NewAlterDefaultSet returns a *AlterDefaultSet node.

func (*AlterDefaultSet) CheckPrivileges 

func (d *AlterDefaultSet) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterDefaultSet) Children 

func (d *AlterDefaultSet) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterDefaultSet) CollationCoercibility 

func (d *AlterDefaultSet) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterDefaultSet) Database 

func (c *AlterDefaultSet) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterDefaultSet) Expressions 

func (d *AlterDefaultSet) Expressions() []sql.Expression

func (*AlterDefaultSet) IsReadOnly 

func (d *AlterDefaultSet) IsReadOnly() bool

func (*AlterDefaultSet) Resolved 

func (d *AlterDefaultSet) Resolved() bool

Resolved implements the sql.Node interface.

func (*AlterDefaultSet) Schema 

func (*AlterDefaultSet) Schema() sql.Schema

Schema implements the Node interface.

func (*AlterDefaultSet) String 

func (d *AlterDefaultSet) String() string

String implements the sql.Node interface.

func (*AlterDefaultSet) TargetSchema 

func (d *AlterDefaultSet) TargetSchema() sql.Schema

func (*AlterDefaultSet) WithChildren 

func (d *AlterDefaultSet) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*AlterDefaultSet) WithDatabase 

func (d *AlterDefaultSet) WithDatabase(database sql.Database) (sql.Node, error)

func (AlterDefaultSet) WithDefault 

func (d AlterDefaultSet) WithDefault(expr sql.Expression) (sql.Node, error)

func (AlterDefaultSet) WithExpressions 

func (d AlterDefaultSet) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (AlterDefaultSet) WithTargetSchema 

func (d AlterDefaultSet) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type AlterEvent 

type AlterEvent struct {
	EventName string
	Definer   string

	AlterOnSchedule bool
	At              *OnScheduleTimestamp
	Every           *expression.Interval
	Starts          *OnScheduleTimestamp
	Ends            *OnScheduleTimestamp

	AlterOnComp    bool
	OnCompPreserve bool

	AlterName    bool
	RenameToDb   string
	RenameToName string

	AlterStatus bool
	Status      sql.EventStatus

	AlterComment bool
	Comment      string

	AlterDefinition  bool
	DefinitionString string
	DefinitionNode   sql.Node

	// Event will be set during analysis
	Event sql.EventDefinition
	// contains filtered or unexported fields
}

func NewAlterEvent 

func NewAlterEvent(
	db sql.Database,
	name, definer string,
	alterSchedule bool,
	at, starts, ends *OnScheduleTimestamp,
	every *expression.Interval,
	alterOnComp bool,
	onCompletionPreserve bool,
	alterName bool,
	newName string,
	alterStatus bool,
	status sql.EventStatus,
	alterComment bool,
	comment string,
	alterDefinition bool,
	definitionString string,
	definition sql.Node,
) *AlterEvent

NewAlterEvent returns a *AlterEvent node.

func (*AlterEvent) CheckPrivileges 

func (a *AlterEvent) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the sql.Node interface.

func (*AlterEvent) Children 

func (a *AlterEvent) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterEvent) Database 

func (a *AlterEvent) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterEvent) Expressions 

func (a *AlterEvent) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*AlterEvent) IsReadOnly 

func (a *AlterEvent) IsReadOnly() bool

func (*AlterEvent) Resolved 

func (a *AlterEvent) Resolved() bool

Resolved implements the sql.Node interface.

func (*AlterEvent) RowIter 

func (a *AlterEvent) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*AlterEvent) Schema 

func (a *AlterEvent) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*AlterEvent) String 

func (a *AlterEvent) String() string

String implements the sql.Node interface.

func (*AlterEvent) WithChildren 

func (a *AlterEvent) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*AlterEvent) WithDatabase 

func (a *AlterEvent) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*AlterEvent) WithEventScheduler 

func (a *AlterEvent) WithEventScheduler(scheduler sql.EventScheduler) sql.Node

WithEventScheduler is used to notify EventSchedulerStatus to update the events list for ALTER EVENT.

func (*AlterEvent) WithExpressions 

func (a *AlterEvent) WithExpressions(e ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type AlterIndex 

type AlterIndex struct {
	// Action states whether it's a CREATE, DROP, or RENAME
	Action IndexAction

	// Table is the table that is being referenced
	Table sql.Node
	// IndexName is the index name, and in the case of a RENAME it represents the new name
	IndexName string
	// PreviousIndexName states the old name when renaming an index
	PreviousIndexName string
	// Using states whether you're using BTREE, HASH, or none
	Using sql.IndexUsing
	// Constraint specifies whether this is UNIQUE, FULLTEXT, SPATIAL, or none
	Constraint sql.IndexConstraint
	// Columns contains the column names (and possibly lengths) when creating an index
	Columns []sql.IndexColumn
	// Comment is the comment that was left at index creation, if any
	Comment string
	// DisableKeys determines whether to DISABLE KEYS if true or ENABLE KEYS if false
	DisableKeys bool
	// contains filtered or unexported fields
}

func NewAlterCreateIndex 

func NewAlterCreateIndex(db sql.Database, table sql.Node, indexName string, using sql.IndexUsing, constraint sql.IndexConstraint, columns []sql.IndexColumn, comment string) *AlterIndex

func NewAlterDisableEnableKeys 

func NewAlterDisableEnableKeys(db sql.Database, table sql.Node, disableKeys bool) *AlterIndex

func NewAlterDropIndex 

func NewAlterDropIndex(db sql.Database, table sql.Node, indexName string) *AlterIndex

func NewAlterRenameIndex 

func NewAlterRenameIndex(db sql.Database, table sql.Node, fromIndexName, toIndexName string) *AlterIndex

func (*AlterIndex) CheckPrivileges 

func (p *AlterIndex) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterIndex) Children 

func (p *AlterIndex) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterIndex) CollationCoercibility 

func (*AlterIndex) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterIndex) ColumnNames 

func (p *AlterIndex) ColumnNames() []string

ColumnNames returns each column's name without the length property.

func (*AlterIndex) Database 

func (c *AlterIndex) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterIndex) Expressions 

func (p *AlterIndex) Expressions() []sql.Expression

Expressions on the AlterIndex object are specifically column default expresions, Nothing else.

func (*AlterIndex) IsReadOnly 

func (p *AlterIndex) IsReadOnly() bool

func (*AlterIndex) Resolved 

func (p *AlterIndex) Resolved() bool

func (*AlterIndex) Schema 

func (p *AlterIndex) Schema() sql.Schema

Schema implements the Node interface.

func (AlterIndex) String 

func (p AlterIndex) String() string

func (*AlterIndex) TargetSchema 

func (p *AlterIndex) TargetSchema() sql.Schema

func (AlterIndex) WithChildren 

func (p AlterIndex) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface. For AlterIndex, the only appropriate input is a single child - The Table.

func (*AlterIndex) WithDatabase 

func (p *AlterIndex) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (AlterIndex) WithExpressions 

func (p AlterIndex) WithExpressions(expressions ...sql.Expression) (sql.Node, error)

WithExpressions implements the Node Interface. For AlterIndex, expressions represent column defaults on the targetSchema instance - required to be the same number of columns on the target schema.

func (AlterIndex) WithTargetSchema 

func (p AlterIndex) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type AlterPK 

type AlterPK struct {
	Action  PKAction
	Table   sql.Node
	Columns []sql.IndexColumn
	Catalog sql.Catalog
	// contains filtered or unexported fields
}

func NewAlterCreatePk 

func NewAlterCreatePk(db sql.Database, table sql.Node, columns []sql.IndexColumn) *AlterPK

func NewAlterDropPk 

func NewAlterDropPk(db sql.Database, table sql.Node) *AlterPK

func (*AlterPK) CheckPrivileges 

func (a *AlterPK) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterPK) Children 

func (a *AlterPK) Children() []sql.Node

Children implements the sql.Node interface.

func (*AlterPK) CollationCoercibility 

func (*AlterPK) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterPK) Database 

func (c *AlterPK) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterPK) Expressions 

func (a *AlterPK) Expressions() []sql.Expression

func (*AlterPK) IsReadOnly 

func (a *AlterPK) IsReadOnly() bool

func (*AlterPK) Resolved 

func (a *AlterPK) Resolved() bool

func (*AlterPK) Schema 

func (a *AlterPK) Schema() sql.Schema

func (*AlterPK) String 

func (a *AlterPK) String() string

func (*AlterPK) TargetSchema 

func (a *AlterPK) TargetSchema() sql.Schema

func (AlterPK) WithChildren 

func (a AlterPK) WithChildren(children ...sql.Node) (sql.Node, error)

func (AlterPK) WithDatabase 

func (a AlterPK) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (AlterPK) WithExpressions 

func (a AlterPK) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (AlterPK) WithTargetSchema 

func (a AlterPK) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type AlterTableCollation 

type AlterTableCollation struct {
	Table     sql.Node
	Collation sql.CollationID
	// contains filtered or unexported fields
}

func NewAlterTableCollation 

func NewAlterTableCollation(database sql.Database, table *UnresolvedTable, collation sql.CollationID) *AlterTableCollation

NewAlterTableCollation returns a new *AlterTableCollation

func NewAlterTableCollationResolved 

func NewAlterTableCollationResolved(table *ResolvedTable, collation sql.CollationID) *AlterTableCollation

NewAlterTableCollationResolved returns a new *AlterTableCollation

func (*AlterTableCollation) CheckPrivileges 

func (atc *AlterTableCollation) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterTableCollation) Children 

func (atc *AlterTableCollation) Children() []sql.Node

Children implements the interface sql.Node.

func (*AlterTableCollation) Database 

func (c *AlterTableCollation) Database() sql.Database

Database implements the sql.Databaser interface.

func (*AlterTableCollation) DebugString 

func (atc *AlterTableCollation) DebugString() string

DebugString implements the interface sql.Node.

func (*AlterTableCollation) IsReadOnly 

func (atc *AlterTableCollation) IsReadOnly() bool

func (*AlterTableCollation) Resolved 

func (atc *AlterTableCollation) Resolved() bool

Resolved implements the interface sql.Node.

func (*AlterTableCollation) Schema 

func (atc *AlterTableCollation) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*AlterTableCollation) String 

func (atc *AlterTableCollation) String() string

String implements the interface sql.Node.

func (*AlterTableCollation) WithChildren 

func (atc *AlterTableCollation) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*AlterTableCollation) WithDatabase 

func (atc *AlterTableCollation) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type AlterUser 

type AlterUser struct {
	IfExists bool
	User     AuthenticatedUser
	MySQLDb  sql.Database
}

AlterUser represents the statement ALTER USER.

func (*AlterUser) CheckPrivileges 

func (a *AlterUser) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AlterUser) Children 

func (a *AlterUser) Children() []sql.Node

Children implements the interface sql.Node.

func (*AlterUser) CollationCoercibility 

func (a *AlterUser) CollationCoercibility(_ *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AlterUser) Database 

func (a *AlterUser) Database() sql.Database

Database implements the interface sql.Databaser.

func (*AlterUser) IsReadOnly 

func (a *AlterUser) IsReadOnly() bool

IsReadOnly implements the interface sql.Node.

func (*AlterUser) Resolved 

func (a *AlterUser) Resolved() bool

Resolved implements the interface sql.Node.

func (*AlterUser) Schema 

func (a *AlterUser) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*AlterUser) String 

func (a *AlterUser) String() string

String implements the interface sql.Node.

func (*AlterUser) WithChildren 

func (a *AlterUser) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*AlterUser) WithDatabase 

func (a *AlterUser) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type AnalyzeTable 

type AnalyzeTable struct {
	Db     string
	Stats  sql.StatsProvider
	Tables []sql.Table
}

func NewAnalyze 

func NewAnalyze(names []sql.Table) *AnalyzeTable

func (*AnalyzeTable) CheckPrivileges 

func (n *AnalyzeTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*AnalyzeTable) Children 

func (n *AnalyzeTable) Children() []sql.Node

Children implements the interface sql.Node.

func (*AnalyzeTable) CollationCoercibility 

func (*AnalyzeTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*AnalyzeTable) IsReadOnly 

func (n *AnalyzeTable) IsReadOnly() bool

func (*AnalyzeTable) Resolved 

func (n *AnalyzeTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*AnalyzeTable) Schema 

func (n *AnalyzeTable) Schema() sql.Schema

Schema implements the interface sql.Node. TODO: should be |Tables|Op|Msg_type|Msg_text|

func (*AnalyzeTable) String 

func (n *AnalyzeTable) String() string

String implements the interface sql.Node.

func (*AnalyzeTable) WithCatalog 

func (n *AnalyzeTable) WithCatalog(cat sql.Catalog) *AnalyzeTable

func (*AnalyzeTable) WithChildren 

func (n *AnalyzeTable) WithChildren(_ ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*AnalyzeTable) WithDb 

func (n *AnalyzeTable) WithDb(db string) *AnalyzeTable

func (*AnalyzeTable) WithStats 

func (n *AnalyzeTable) WithStats(stats sql.StatsProvider) *AnalyzeTable

func (*AnalyzeTable) WithTables 

func (n *AnalyzeTable) WithTables(tables []sql.Table) *AnalyzeTable

type AuthenticatedUser 

type AuthenticatedUser struct {
	UserName
	Auth1       Authentication
	Auth2       Authentication
	Auth3       Authentication
	AuthInitial Authentication
	Identity    string
}

AuthenticatedUser represents a user with the relevant methods of authentication.

type Authentication 

type Authentication interface {
	// Plugin returns the name of the plugin that this authentication represents.
	Plugin() string
	// Password returns the value to insert into the database as the password.
	Password() string
}

Authentication represents an authentication method for a user.

func NewDefaultAuthentication 

func NewDefaultAuthentication(password string) Authentication

NewDefaultAuthentication returns the given password with the default authentication method.

func NewOtherAuthentication 

func NewOtherAuthentication(password, plugin string) Authentication

type AuthenticationMysqlNativePassword 

type AuthenticationMysqlNativePassword string

AuthenticationMysqlNativePassword is an authentication type that represents "mysql_native_password".

func (AuthenticationMysqlNativePassword) Password 

func (a AuthenticationMysqlNativePassword) Password() string

Password implements the interface Authentication.

func (AuthenticationMysqlNativePassword) Plugin 

func (a AuthenticationMysqlNativePassword) Plugin() string

Plugin implements the interface Authentication.

type AuthenticationOther 

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

AuthenticationOther is an authentication type that represents plugin types other than "mysql_native_password". There must be a mysqldb plugin provided to use this plugin.

func (AuthenticationOther) Password 

func (a AuthenticationOther) Password() string

func (AuthenticationOther) Plugin 

func (a AuthenticationOther) Plugin() string

type BeginEndBlock 

type BeginEndBlock struct {
	*Block
	Label string
	Pref  *expression.ProcedureReference
}

BeginEndBlock represents a BEGIN/END block.

func NewBeginEndBlock 

func NewBeginEndBlock(label string, block *Block) *BeginEndBlock

NewBeginEndBlock creates a new *BeginEndBlock node.

func (*BeginEndBlock) CheckPrivileges 

func (b *BeginEndBlock) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*BeginEndBlock) CollationCoercibility 

func (b *BeginEndBlock) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*BeginEndBlock) DebugString 

func (b *BeginEndBlock) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*BeginEndBlock) GetBlockLabel 

func (b *BeginEndBlock) GetBlockLabel(ctx *sql.Context) string

GetBlockLabel implements the interface RepresentsLabeledBlock.

func (*BeginEndBlock) RepresentsLoop 

func (b *BeginEndBlock) RepresentsLoop() bool

RepresentsLoop implements the interface RepresentsLabeledBlock.

func (*BeginEndBlock) String 

func (b *BeginEndBlock) String() string

String implements the interface sql.Node.

func (*BeginEndBlock) WithChildren 

func (b *BeginEndBlock) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*BeginEndBlock) WithParamReference 

func (b *BeginEndBlock) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type BinaryNode 

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

BinaryNode is a node with two children.

func (BinaryNode) Children 

func (n BinaryNode) Children() []sql.Node

Children implements the Node interface.

func (BinaryNode) Left 

func (n BinaryNode) Left() sql.Node

func (BinaryNode) Resolved 

func (n BinaryNode) Resolved() bool

Resolved implements the Resolvable interface.

func (BinaryNode) Right 

func (n BinaryNode) Right() sql.Node

type BinlogReplicaControllerCommand 

type BinlogReplicaControllerCommand interface {
	sql.Node

	// WithBinlogReplicaController returns a new instance of this BinlogReplicaController, with the binlog replica
	// controller configured.
	WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node
}

BinlogReplicaControllerCommand represents a SQL statement that requires a BinlogReplicaController (e.g. Start Replica, Show Replica Status).

type Block 

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

Block represents a collection of statements that should be executed in sequence.

func NewBlock 

func NewBlock(statements []sql.Node) *Block

NewBlock creates a new *Block node.

func (*Block) CheckPrivileges 

func (b *Block) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Block) Children 

func (b *Block) Children() []sql.Node

Children implements the sql.Node interface.

func (*Block) CollationCoercibility 

func (b *Block) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Block) DebugString 

func (b *Block) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*Block) IsReadOnly 

func (b *Block) IsReadOnly() bool

func (*Block) Resolved 

func (b *Block) Resolved() bool

Resolved implements the sql.Node interface.

func (*Block) Schema 

func (b *Block) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Block) SetSchema 

func (b *Block) SetSchema(sch sql.Schema)

func (*Block) String 

func (b *Block) String() string

String implements the sql.Node interface.

func (*Block) WithChildren 

func (b *Block) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type BlockRowIter 

type BlockRowIter interface {
	sql.RowIter
	// RepresentingNode returns the Node that most directly represents this RowIter. For example, in the case of
	// an IF/ELSE block, the RowIter represents the Node where the condition evaluated to true.
	RepresentingNode() sql.Node
	// Schema returns the schema of this RowIter.
	Schema() sql.Schema
}

BlockRowIter is an iterator that produces rows. It is an extended interface over RowIter. This is primarily used by block statements. In order to track the schema of a sql.RowIter from nested blocks, this extended row iter returns the relevant information inside of the iter itself. In addition, the most specific top-level Node for that iter is returned, as stored procedures use that Node to determine whether the iter represents a SELECT statement.

type CachedResults 

type CachedResults struct {
	UnaryNode
	Id    uint64
	Mutex sync.Mutex
	//NoCache is set when the memory manager is unable to build
	// a cache, so we fallback to a passthrough RowIter
	NoCache bool
	// Finalized is set when we exhaust the child iter, and subsequent
	// RowIters will read from the cache rather than the child
	Finalized bool
	// Disposed is set after this CachedResults is invalidated
	Disposed bool
}

CachedResults tees the child node iterator into an in-memory cache for faster subsequent retrieval. This is usually combined with a HashLookup, whose RowIter defers to a CachedResult child to populate rows in memory on a first iteration. The second RowIter moves the rows from the memory cache to a hash map attached to HashLookup, disposing the CachedResult afterwards.

In the special case where we fill a CachedResult on pass one, but pass two never happens, we have to take care not to orphan the cache.

When we exhaust the source, but the cache is empty, subsequent calls to RowIter return an ErrEmptyCachedResult error for short-circuiting join trees.

When the memory manager cannot accommodate expanding the cache, we fall back to a passthrough iterator.

func NewCachedResults 

func NewCachedResults(n sql.Node) *CachedResults

NewCachedResults returns a cached results plan Node, which will use a RowCache to cache results generated by Child.RowIter() and return those results for future calls to RowIter. This node is only safe to use if the Child is deterministic and is not dependent on the |row| parameter in the call to RowIter.

func (*CachedResults) CheckPrivileges 

func (n *CachedResults) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CachedResults) CollationCoercibility 

func (n *CachedResults) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CachedResults) DebugString 

func (n *CachedResults) DebugString() string

func (*CachedResults) Dispose 

func (n *CachedResults) Dispose()

func (*CachedResults) GetCachedResults 

func (n *CachedResults) GetCachedResults() []sql.Row

func (*CachedResults) IsReadOnly 

func (n *CachedResults) IsReadOnly() bool

func (*CachedResults) String 

func (n *CachedResults) String() string

func (*CachedResults) WithChildren 

func (n *CachedResults) WithChildren(children ...sql.Node) (sql.Node, error)

type Call 

type Call struct {
	Name   string
	Params []sql.Expression

	Procedure *Procedure
	Pref      *expression.ProcedureReference
	// contains filtered or unexported fields
}

func NewCall 

func NewCall(db sql.Database, name string, params []sql.Expression, asOf sql.Expression, catalog *sql.Catalog) *Call

NewCall returns a *Call node.

func (*Call) AsOf 

func (c *Call) AsOf() sql.Expression

AsOf implements the Versionable interface.

func (*Call) CheckPrivileges 

func (c *Call) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Call) Children 

func (c *Call) Children() []sql.Node

Children implements the sql.Node interface.

func (*Call) CollationCoercibility 

func (c *Call) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Call) Database 

func (c *Call) Database() sql.Database

Database implements the sql.Databaser interface.

func (*Call) DebugString 

func (c *Call) DebugString() string

DebugString implements sql.DebugStringer

func (*Call) Dispose 

func (c *Call) Dispose()

func (*Call) Expressions 

func (c *Call) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*Call) IsReadOnly 

func (c *Call) IsReadOnly() bool

func (*Call) Resolved 

func (c *Call) Resolved() bool

Resolved implements the sql.Node interface.

func (*Call) Schema 

func (c *Call) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Call) String 

func (c *Call) String() string

String implements the sql.Node interface.

func (*Call) WithAsOf 

func (c *Call) WithAsOf(asOf sql.Expression) (sql.Node, error)

WithAsOf implements the Versionable interface.

func (*Call) WithChildren 

func (c *Call) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*Call) WithDatabase 

func (c *Call) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*Call) WithExpressions 

func (c *Call) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

func (*Call) WithParamReference 

func (c *Call) WithParamReference(pRef *expression.ProcedureReference) *Call

WithParamReference returns a new *Call containing the given *expression.ProcedureReference.

func (*Call) WithProcedure 

func (c *Call) WithProcedure(proc *Procedure) *Call

WithProcedure returns a new *Call containing the given *sql.Procedure.

type CaseStatement 

type CaseStatement struct {
	Expr   sql.Expression
	IfElse *IfElseBlock
}

CaseStatement represents CASE statements, which are different from CASE expressions. These are intended for use in triggers and stored procedures. Specifically, this implements CASE statements when comparing each conditional to a value. The version of CASE that does not compare each conditional to a value is functionally equivalent to a series of IF/ELSE statements, and therefore we simply use an IfElseBlock.

func (*CaseStatement) CheckPrivileges 

func (c *CaseStatement) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CaseStatement) Children 

func (c *CaseStatement) Children() []sql.Node

Children implements the interface sql.Node.

func (*CaseStatement) CollationCoercibility 

func (c *CaseStatement) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CaseStatement) DebugString 

func (c *CaseStatement) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*CaseStatement) Expressions 

func (c *CaseStatement) Expressions() []sql.Expression

Expressions implements the interface sql.Node.

func (*CaseStatement) IsReadOnly 

func (c *CaseStatement) IsReadOnly() bool

func (*CaseStatement) Resolved 

func (c *CaseStatement) Resolved() bool

Resolved implements the interface sql.Node.

func (*CaseStatement) Schema 

func (c *CaseStatement) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*CaseStatement) String 

func (c *CaseStatement) String() string

String implements the interface sql.Node.

func (*CaseStatement) WithChildren 

func (c *CaseStatement) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*CaseStatement) WithExpressions 

func (c *CaseStatement) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the interface sql.Node.

type ChangeReplicationFilter 

type ChangeReplicationFilter struct {
	ReplicaController binlogreplication.BinlogReplicaController
	Options           []binlogreplication.ReplicationOption
}

ChangeReplicationFilter is a plan node for the "CHANGE REPLICATION FILTER" statement. https://dev.mysql.com/doc/refman/8.0/en/change-replication-filter.html

func NewChangeReplicationFilter 

func NewChangeReplicationFilter(options []binlogreplication.ReplicationOption) *ChangeReplicationFilter

func (*ChangeReplicationFilter) CheckPrivileges 

func (c *ChangeReplicationFilter) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*ChangeReplicationFilter) Children 

func (c *ChangeReplicationFilter) Children() []sql.Node

func (*ChangeReplicationFilter) CollationCoercibility 

func (*ChangeReplicationFilter) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ChangeReplicationFilter) IsReadOnly 

func (c *ChangeReplicationFilter) IsReadOnly() bool

func (*ChangeReplicationFilter) Resolved 

func (c *ChangeReplicationFilter) Resolved() bool

func (*ChangeReplicationFilter) Schema 

func (c *ChangeReplicationFilter) Schema() sql.Schema

func (*ChangeReplicationFilter) String 

func (c *ChangeReplicationFilter) String() string

func (*ChangeReplicationFilter) WithBinlogReplicaController 

func (c *ChangeReplicationFilter) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*ChangeReplicationFilter) WithChildren 

func (c *ChangeReplicationFilter) WithChildren(children ...sql.Node) (sql.Node, error)

type ChangeReplicationSource 

type ChangeReplicationSource struct {
	ReplicaController binlogreplication.BinlogReplicaController
	Options           []binlogreplication.ReplicationOption
}

ChangeReplicationSource is the plan node for the "CHANGE REPLICATION SOURCE TO" statement. https://dev.mysql.com/doc/refman/8.0/en/change-replication-source-to.html

func NewChangeReplicationSource 

func NewChangeReplicationSource(options []binlogreplication.ReplicationOption) *ChangeReplicationSource

func (*ChangeReplicationSource) CheckPrivileges 

func (c *ChangeReplicationSource) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*ChangeReplicationSource) Children 

func (c *ChangeReplicationSource) Children() []sql.Node

func (*ChangeReplicationSource) CollationCoercibility 

func (*ChangeReplicationSource) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ChangeReplicationSource) IsReadOnly 

func (c *ChangeReplicationSource) IsReadOnly() bool

func (*ChangeReplicationSource) Resolved 

func (c *ChangeReplicationSource) Resolved() bool

func (*ChangeReplicationSource) Schema 

func (c *ChangeReplicationSource) Schema() sql.Schema

func (*ChangeReplicationSource) String 

func (c *ChangeReplicationSource) String() string

func (*ChangeReplicationSource) WithBinlogReplicaController 

func (c *ChangeReplicationSource) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*ChangeReplicationSource) WithChildren 

func (c *ChangeReplicationSource) WithChildren(children ...sql.Node) (sql.Node, error)

type Characteristic 

type Characteristic byte

Characteristic represents a characteristic that is defined on either a stored procedure or stored function. 

const (
	Characteristic_LanguageSql Characteristic = iota
	Characteristic_Deterministic
	Characteristic_NotDeterministic
	Characteristic_ContainsSql
	Characteristic_NoSql
	Characteristic_ReadsSqlData
	Characteristic_ModifiesSqlData
)

func (Characteristic) String 

func (c Characteristic) String() string

String returns the original SQL representation.

type CheckpointingTableEditorIter 

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

func (CheckpointingTableEditorIter) Close 

func (c CheckpointingTableEditorIter) Close(context *sql.Context) error

func (CheckpointingTableEditorIter) InnerIter 

func (c CheckpointingTableEditorIter) InnerIter() sql.RowIter

func (CheckpointingTableEditorIter) Next 

func (c CheckpointingTableEditorIter) Next(ctx *sql.Context) (sql.Row, error)

type ChildParentMapping 

type ChildParentMapping []int

ChildParentMapping is a mapping from the foreign key columns of a child schema to the parent schema. The position in the slice corresponds to the position in the child schema, while the value at a given position refers to the position in the parent schema. For all columns that are not in the foreign key definition, a value of -1 is returned.

Here's an example: parent Schema: x1, x2, x3, x4, x5 child Schema: y1, y2, y3, y4 FOREIGN KEY (y2) REFERENCES parent (x4)

The slice for the above would be [-1, 3, -1, -1]. The foreign key uses the column "y2" on the child, which is the second position in the schema (and therefore the second position in the mapping). The equivalent parent column is "x4", which is in the fourth position (so 3 with zero-based indexed).

func GetChildParentMapping 

func GetChildParentMapping(parentSch sql.Schema, childSch sql.Schema, fkDef sql.ForeignKeyConstraint) (ChildParentMapping, error)

GetChildParentMapping returns a mapping from the foreign key columns of a child schema to the parent schema.

type Close 

type Close struct {
	Name string
	Pref *expression.ProcedureReference
}

Close represents the CLOSE statement, which closes a cursor.

func NewClose 

func NewClose(name string) *Close

NewClose returns a new *Close node.

func (*Close) CheckPrivileges 

func (c *Close) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Close) Children 

func (c *Close) Children() []sql.Node

Children implements the interface sql.Node.

func (*Close) CollationCoercibility 

func (*Close) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Close) IsReadOnly 

func (c *Close) IsReadOnly() bool

func (*Close) Resolved 

func (c *Close) Resolved() bool

Resolved implements the interface sql.Node.

func (*Close) Schema 

func (c *Close) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Close) String 

func (c *Close) String() string

String implements the interface sql.Node.

func (*Close) WithChildren 

func (c *Close) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Close) WithParamReference 

func (c *Close) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type ColDefaultExpression 

type ColDefaultExpression struct {
	Column *sql.Column
}

colDefault expression evaluates the column default for a row being inserted, correctly handling zero values and nulls

func (ColDefaultExpression) Children 

func (c ColDefaultExpression) Children() []sql.Expression

func (ColDefaultExpression) CollationCoercibility 

func (c ColDefaultExpression) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

func (ColDefaultExpression) Eval 

func (c ColDefaultExpression) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

func (ColDefaultExpression) IsNullable 

func (c ColDefaultExpression) IsNullable() bool

func (ColDefaultExpression) Resolved 

func (c ColDefaultExpression) Resolved() bool

func (ColDefaultExpression) String 

func (c ColDefaultExpression) String() string

func (ColDefaultExpression) Type 

func (c ColDefaultExpression) Type() sql.Type

func (ColDefaultExpression) WithChildren 

func (c ColDefaultExpression) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Commit 

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

Commit commits the changes performed in a transaction. For sessions that don't implement sql.TransactionSession, this operation is a no-op.

func NewCommit 

func NewCommit() *Commit

NewCommit creates a new Commit node.

func (Commit) CheckPrivileges 

func (Commit) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (Commit) Children 

func (Commit) Children() []sql.Node

func (*Commit) CollationCoercibility 

func (*Commit) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Commit) IsReadOnly 

func (Commit) IsReadOnly() bool

func (Commit) Resolved 

func (Commit) Resolved() bool

Resolved implements the sql.Node interface.

func (*Commit) RowIter 

func (c *Commit) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (Commit) Schema 

func (Commit) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Commit) String 

func (*Commit) String() string

func (*Commit) WithChildren 

func (c *Commit) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type CommonTableExpression 

type CommonTableExpression struct {
	Subquery *SubqueryAlias
	Columns  []string
}

func NewCommonTableExpression 

func NewCommonTableExpression(subquery *SubqueryAlias, columns []string) *CommonTableExpression

func (*CommonTableExpression) DebugString 

func (e *CommonTableExpression) DebugString() string

func (*CommonTableExpression) String 

func (e *CommonTableExpression) String() string

type Concat 

type Concat struct {
	BinaryNode
}

Concat is a node that returns everything in Left and then everything in Right, but it excludes any results in Right that already appeared in Left. Similar to Distinct(Union(...)) but allows Left to return the same row more than once.

func NewConcat 

func NewConcat(left, right sql.Node) *Concat

NewConcat creates a new Concat node with the given children. See concatJoin memo expression for more details.

func (*Concat) CheckPrivileges 

func (c *Concat) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Concat) CollationCoercibility 

func (*Concat) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Concat) DebugString 

func (c Concat) DebugString() string

func (*Concat) IsReadOnly 

func (c *Concat) IsReadOnly() bool

func (*Concat) Schema 

func (c *Concat) Schema() sql.Schema

func (Concat) String 

func (c Concat) String() string

func (*Concat) WithChildren 

func (c *Concat) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type CopierProps 

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

type CreateCheck 

type CreateCheck struct {
	Table *ResolvedTable
	Check *sql.CheckConstraint
	// contains filtered or unexported fields
}

func NewAlterAddCheck 

func NewAlterAddCheck(table *ResolvedTable, check *sql.CheckConstraint) *CreateCheck

func (*CreateCheck) CheckPrivileges 

func (c *CreateCheck) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateCheck) Children 

func (c *CreateCheck) Children() []sql.Node

func (*CreateCheck) CollationCoercibility 

func (c *CreateCheck) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateCheck) Database 

func (c *CreateCheck) Database() sql.Database

Database implements the sql.Databaser interface.

func (*CreateCheck) Expressions 

func (c *CreateCheck) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*CreateCheck) IsReadOnly 

func (c *CreateCheck) IsReadOnly() bool

func (*CreateCheck) Resolved 

func (c *CreateCheck) Resolved() bool

Resolved implements the Resolvable interface.

func (*CreateCheck) Schema 

func (c *CreateCheck) Schema() sql.Schema

func (CreateCheck) String 

func (c CreateCheck) String() string

func (*CreateCheck) WithChildren 

func (c *CreateCheck) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*CreateCheck) WithExpressions 

func (c *CreateCheck) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type CreateDB 

type CreateDB struct {
	Catalog     sql.Catalog
	DbName      string
	IfNotExists bool
	Collation   sql.CollationID
}

CreateDB creates an in memory database that lasts the length of the process only.

func NewCreateDatabase 

func NewCreateDatabase(dbName string, ifNotExists bool, collation sql.CollationID) *CreateDB

func (*CreateDB) CheckPrivileges 

func (c *CreateDB) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateDB) Children 

func (c *CreateDB) Children() []sql.Node

func (*CreateDB) CollationCoercibility 

func (*CreateDB) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateDB) Database 

func (c *CreateDB) Database() string

Database returns the name of the database that will be used.

func (*CreateDB) IsReadOnly 

func (c *CreateDB) IsReadOnly() bool

func (*CreateDB) Resolved 

func (c *CreateDB) Resolved() bool

func (*CreateDB) Schema 

func (c *CreateDB) Schema() sql.Schema

func (*CreateDB) String 

func (c *CreateDB) String() string

func (*CreateDB) WithChildren 

func (c *CreateDB) WithChildren(children ...sql.Node) (sql.Node, error)

type CreateEvent 

type CreateEvent struct {
	EventName        string
	Definer          string
	At               *OnScheduleTimestamp
	Every            *expression.Interval
	Starts           *OnScheduleTimestamp
	Ends             *OnScheduleTimestamp
	OnCompPreserve   bool
	Status           sql.EventStatus
	Comment          string
	DefinitionString string
	DefinitionNode   sql.Node
	IfNotExists      bool
	// contains filtered or unexported fields
}

func NewCreateEvent 

func NewCreateEvent(
	db sql.Database,
	name, definer string,
	at, starts, ends *OnScheduleTimestamp,
	every *expression.Interval,
	onCompletionPreserve bool,
	status sql.EventStatus,
	comment, definitionString string,
	definition sql.Node,
	ifNotExists bool,
) *CreateEvent

NewCreateEvent returns a *CreateEvent node.

func (*CreateEvent) CheckPrivileges 

func (c *CreateEvent) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateEvent) Children 

func (c *CreateEvent) Children() []sql.Node

Children implements the sql.Node interface.

func (*CreateEvent) Database 

func (c *CreateEvent) Database() sql.Database

Database implements the sql.Databaser interface.

func (*CreateEvent) Expressions 

func (c *CreateEvent) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*CreateEvent) GetEventDefinition 

func (c *CreateEvent) GetEventDefinition(ctx *sql.Context, eventCreationTime, lastAltered, lastExecuted time.Time, tz string) (sql.EventDefinition, error)

GetEventDefinition returns an EventDefinition object with all of its fields populated from the details of this CREATE EVENT statement.

func (*CreateEvent) IsReadOnly 

func (c *CreateEvent) IsReadOnly() bool

func (*CreateEvent) Resolved 

func (c *CreateEvent) Resolved() bool

Resolved implements the sql.Node interface.

func (*CreateEvent) RowIter 

func (c *CreateEvent) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*CreateEvent) Schema 

func (c *CreateEvent) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*CreateEvent) String 

func (c *CreateEvent) String() string

String implements the sql.Node interface.

func (*CreateEvent) WithChildren 

func (c *CreateEvent) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*CreateEvent) WithDatabase 

func (c *CreateEvent) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*CreateEvent) WithEventScheduler 

func (c *CreateEvent) WithEventScheduler(scheduler sql.EventScheduler) sql.Node

WithEventScheduler is used to notify EventSchedulerStatus to update the events list for CREATE EVENT.

func (*CreateEvent) WithExpressions 

func (c *CreateEvent) WithExpressions(e ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type CreateForeignKey 

type CreateForeignKey struct {
	// In the cases where we have multiple ALTER statements, we need to resolve the table at execution time rather than
	// during analysis. Otherwise, you could add a column in the preceding alter and we may have analyzed to a table
	// that did not yet have that column.
	DbProvider sql.DatabaseProvider
	FkDef      *sql.ForeignKeyConstraint
}

func NewAlterAddForeignKey 

func NewAlterAddForeignKey(fkDef *sql.ForeignKeyConstraint) *CreateForeignKey

func (*CreateForeignKey) CheckPrivileges 

func (p *CreateForeignKey) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateForeignKey) Children 

func (p *CreateForeignKey) Children() []sql.Node

Children implements the interface sql.Node.

func (*CreateForeignKey) CollationCoercibility 

func (*CreateForeignKey) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateForeignKey) Database 

func (p *CreateForeignKey) Database() string

func (*CreateForeignKey) DatabaseProvider 

func (p *CreateForeignKey) DatabaseProvider() sql.DatabaseProvider

DatabaseProvider implements the interface sql.MultiDatabaser.

func (*CreateForeignKey) IsReadOnly 

func (p *CreateForeignKey) IsReadOnly() bool

func (*CreateForeignKey) Resolved 

func (p *CreateForeignKey) Resolved() bool

Resolved implements the interface sql.Node.

func (*CreateForeignKey) Schema 

func (p *CreateForeignKey) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*CreateForeignKey) String 

func (p *CreateForeignKey) String() string

String implements the interface sql.Node.

func (*CreateForeignKey) WithChildren 

func (p *CreateForeignKey) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*CreateForeignKey) WithDatabaseProvider 

func (p *CreateForeignKey) WithDatabaseProvider(provider sql.DatabaseProvider) (sql.Node, error)

WithDatabaseProvider implements the interface sql.MultiDatabaser.

type CreateIndex 

type CreateIndex struct {
	Name            string
	Table           sql.Node
	Exprs           []sql.Expression
	Driver          string
	Config          map[string]string
	Catalog         sql.Catalog
	CurrentDatabase string
}

CreateIndex is a node to create an index.

func NewCreateIndex 

func NewCreateIndex(
	name string,
	table sql.Node,
	exprs []sql.Expression,
	driver string,
	config map[string]string,
) *CreateIndex

NewCreateIndex creates a new CreateIndex node.

func (*CreateIndex) CheckPrivileges 

func (c *CreateIndex) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateIndex) Children 

func (c *CreateIndex) Children() []sql.Node

Children implements the Node interface.

func (*CreateIndex) CollationCoercibility 

func (*CreateIndex) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateIndex) Database 

func (c *CreateIndex) Database() string

func (*CreateIndex) Expressions 

func (c *CreateIndex) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*CreateIndex) IsReadOnly 

func (c *CreateIndex) IsReadOnly() bool

func (*CreateIndex) Resolved 

func (c *CreateIndex) Resolved() bool

Resolved implements the Node interface.

func (*CreateIndex) Schema 

func (c *CreateIndex) Schema() sql.Schema

Schema implements the Node interface.

func (*CreateIndex) String 

func (c *CreateIndex) String() string

func (*CreateIndex) WithChildren 

func (c *CreateIndex) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*CreateIndex) WithExpressions 

func (c *CreateIndex) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type CreateProcedure 

type CreateProcedure struct {
	*Procedure

	BodyString string
	// contains filtered or unexported fields
}

func NewCreateProcedure 

func NewCreateProcedure(
	db sql.Database,
	name,
	definer string,
	params []ProcedureParam,
	createdAt, modifiedAt time.Time,
	securityContext ProcedureSecurityContext,
	characteristics []Characteristic,
	body sql.Node,
	comment, createString, bodyString string,
) *CreateProcedure

NewCreateProcedure returns a *CreateProcedure node.

func (*CreateProcedure) CheckPrivileges 

func (c *CreateProcedure) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateProcedure) Children 

func (c *CreateProcedure) Children() []sql.Node

Children implements the sql.Node interface.

func (*CreateProcedure) CollationCoercibility 

func (*CreateProcedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateProcedure) Database 

func (c *CreateProcedure) Database() sql.Database

Database implements the sql.Databaser interface.

func (*CreateProcedure) DebugString 

func (c *CreateProcedure) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*CreateProcedure) IsReadOnly 

func (c *CreateProcedure) IsReadOnly() bool

func (*CreateProcedure) Resolved 

func (c *CreateProcedure) Resolved() bool

Resolved implements the sql.Node interface.

func (*CreateProcedure) Schema 

func (c *CreateProcedure) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*CreateProcedure) String 

func (c *CreateProcedure) String() string

String implements the sql.Node interface.

func (*CreateProcedure) WithChildren 

func (c *CreateProcedure) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*CreateProcedure) WithDatabase 

func (c *CreateProcedure) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type CreateRole 

type CreateRole struct {
	IfNotExists bool
	Roles       []UserName
	MySQLDb     sql.Database
}

CreateRole represents the statement CREATE ROLE.

func NewCreateRole 

func NewCreateRole(ifNotExists bool, roles []UserName) *CreateRole

NewCreateRole returns a new CreateRole node.

func (*CreateRole) CheckPrivileges 

func (n *CreateRole) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateRole) Children 

func (n *CreateRole) Children() []sql.Node

Children implements the interface sql.Node.

func (*CreateRole) CollationCoercibility 

func (*CreateRole) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateRole) Database 

func (n *CreateRole) Database() sql.Database

Database implements the interface sql.Databaser.

func (*CreateRole) IsReadOnly 

func (n *CreateRole) IsReadOnly() bool

func (*CreateRole) Resolved 

func (n *CreateRole) Resolved() bool

Resolved implements the interface sql.Node.

func (*CreateRole) Schema 

func (n *CreateRole) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*CreateRole) String 

func (n *CreateRole) String() string

String implements the interface sql.Node.

func (*CreateRole) WithChildren 

func (n *CreateRole) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*CreateRole) WithDatabase 

func (n *CreateRole) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type CreateSavepoint 

type CreateSavepoint struct {
	Name string
	// contains filtered or unexported fields
}

CreateSavepoint creates a savepoint with the given name. For sessions that don't implement sql.TransactionSession, this is a no-op.

func NewCreateSavepoint 

func NewCreateSavepoint(name string) *CreateSavepoint

NewCreateSavepoint creates a new CreateSavepoint node.

func (CreateSavepoint) CheckPrivileges 

func (CreateSavepoint) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (CreateSavepoint) Children 

func (CreateSavepoint) Children() []sql.Node

func (*CreateSavepoint) CollationCoercibility 

func (*CreateSavepoint) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (CreateSavepoint) IsReadOnly 

func (CreateSavepoint) IsReadOnly() bool

func (CreateSavepoint) Resolved 

func (CreateSavepoint) Resolved() bool

Resolved implements the sql.Node interface.

func (*CreateSavepoint) RowIter 

func (c *CreateSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (CreateSavepoint) Schema 

func (CreateSavepoint) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*CreateSavepoint) String 

func (c *CreateSavepoint) String() string

func (*CreateSavepoint) WithChildren 

func (c *CreateSavepoint) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type CreateSpatialRefSys 

type CreateSpatialRefSys struct {
	SRID        uint32
	OrReplace   bool
	IfNotExists bool
	SrsAttr     SrsAttribute
}

CreateSpatialRefSys represents the statement CREATE SPATIAL REFERENCE SYSTEM ...

func (*CreateSpatialRefSys) CheckPrivileges 

func (n *CreateSpatialRefSys) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node

func (*CreateSpatialRefSys) Children 

func (n *CreateSpatialRefSys) Children() []sql.Node

Children implements the interface sql.Node

func (*CreateSpatialRefSys) IsReadOnly 

func (n *CreateSpatialRefSys) IsReadOnly() bool

func (*CreateSpatialRefSys) Resolved 

func (n *CreateSpatialRefSys) Resolved() bool

Resolved implements the interface sql.Node

func (*CreateSpatialRefSys) Schema 

func (n *CreateSpatialRefSys) Schema() sql.Schema

Schema implements the interface sql.Node

func (*CreateSpatialRefSys) String 

func (n *CreateSpatialRefSys) String() string

String implements the interface sql.Node

func (*CreateSpatialRefSys) WithChildren 

func (n *CreateSpatialRefSys) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node

type CreateTable 

type CreateTable struct {
	Collation sql.CollationID
	TableOpts map[string]interface{}
	// contains filtered or unexported fields
}

CreateTable is a node describing the creation of some table.

func NewCreateTable 

func NewCreateTable(db sql.Database, name string, ifn, temp bool, tableSpec *TableSpec) *CreateTable

NewCreateTable creates a new CreateTable node

func NewCreateTableSelect 

func NewCreateTableSelect(db sql.Database, name string, ifn, temp bool, selectNode sql.Node, tableSpec *TableSpec) *CreateTable

NewCreateTableSelect create a new CreateTable node for CREATE TABLE [AS] SELECT

func (*CreateTable) CheckPrivileges 

func (c *CreateTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the Node interface.

func (*CreateTable) Checks 

func (c *CreateTable) Checks() sql.CheckConstraints

Checks returns any check constraints that will be declared on this table.

func (*CreateTable) Children 

func (c *CreateTable) Children() []sql.Node

Children implements the Node interface.

func (*CreateTable) CollationCoercibility 

func (*CreateTable) CollationCoercibility(_ *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the sql.CollationCoercible interface.

func (*CreateTable) CreateChecks 

func (c *CreateTable) CreateChecks(ctx *sql.Context, tableNode sql.Table) error

CreateChecks creates the check constraints on the table.

func (*CreateTable) CreateForeignKeys 

func (c *CreateTable) CreateForeignKeys(ctx *sql.Context, tableNode sql.Table) error

CreateForeignKeys creates the foreign keys on the table.

func (*CreateTable) Database 

func (c *CreateTable) Database() sql.Database

Database implements the sql.Databaser interface.

func (*CreateTable) DebugString 

func (c *CreateTable) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*CreateTable) Expressions 

func (c *CreateTable) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*CreateTable) ForeignKeys 

func (c *CreateTable) ForeignKeys() []*sql.ForeignKeyConstraint

ForeignKeys returns any foreign keys that will be declared on this table.

func (*CreateTable) IfNotExists 

func (c *CreateTable) IfNotExists() bool

func (*CreateTable) Indexes 

func (c *CreateTable) Indexes() sql.IndexDefs

Indexes returns any indexes that will be declared on this table.

func (*CreateTable) IsReadOnly 

func (c *CreateTable) IsReadOnly() bool

IsReadOnly implements the Node interface.

func (*CreateTable) Like 

func (c *CreateTable) Like() sql.Node

func (*CreateTable) Name 

func (c *CreateTable) Name() string

Name implements the Nameable interface.

func (*CreateTable) PkSchema 

func (c *CreateTable) PkSchema() sql.PrimaryKeySchema

func (*CreateTable) Resolved 

func (c *CreateTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*CreateTable) Schema 

func (c *CreateTable) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*CreateTable) Select 

func (c *CreateTable) Select() sql.Node

func (*CreateTable) String 

func (c *CreateTable) String() string

String implements the fmt.Stringer interface.

func (*CreateTable) TargetSchema 

func (c *CreateTable) TargetSchema() sql.Schema

TargetSchema implements the sql.TargetSchema interface.

func (*CreateTable) Temporary 

func (c *CreateTable) Temporary() bool

func (*CreateTable) ValidateDefaultPosition 

func (c *CreateTable) ValidateDefaultPosition() error

func (*CreateTable) WithChecks 

func (c *CreateTable) WithChecks(checks sql.CheckConstraints) sql.Node

WithChecks returns a new CreateTable node with the given check constraints.

func (*CreateTable) WithChildren 

func (c *CreateTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*CreateTable) WithDatabase 

func (c *CreateTable) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*CreateTable) WithExpressions 

func (c *CreateTable) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

func (*CreateTable) WithParentForeignKeyTables 

func (c *CreateTable) WithParentForeignKeyTables(refTbls []sql.ForeignKeyTable) (*CreateTable, error)

WithParentForeignKeyTables adds the tables that are referenced in each foreign key. The table indices is assumed to match the foreign key indices in their respective slices.

func (*CreateTable) WithTargetSchema 

func (c *CreateTable) WithTargetSchema(_ sql.Schema) (sql.Node, error)

WithTargetSchema implements the sql.TargetSchema interface.

type CreateTrigger 

type CreateTrigger struct {
	TriggerName         string
	TriggerTime         string
	TriggerEvent        string
	TriggerOrder        *TriggerOrder
	Table               sql.Node
	Body                sql.Node
	CreateTriggerString string
	BodyString          string
	CreatedAt           time.Time
	Definer             string
	SqlMode             string
	// contains filtered or unexported fields
}

func NewCreateTrigger 

func NewCreateTrigger(triggerDb sql.Database,
	triggerName,
	triggerTime,
	triggerEvent string,
	triggerOrder *TriggerOrder,
	table sql.Node,
	body sql.Node,
	createTriggerString,
	bodyString string,
	createdAt time.Time,
	definer string) *CreateTrigger

func (*CreateTrigger) CheckPrivileges 

func (c *CreateTrigger) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateTrigger) Children 

func (c *CreateTrigger) Children() []sql.Node

func (*CreateTrigger) CollationCoercibility 

func (*CreateTrigger) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateTrigger) Database 

func (c *CreateTrigger) Database() sql.Database

func (*CreateTrigger) DebugString 

func (c *CreateTrigger) DebugString() string

func (*CreateTrigger) IsReadOnly 

func (c *CreateTrigger) IsReadOnly() bool

func (*CreateTrigger) Resolved 

func (c *CreateTrigger) Resolved() bool

func (*CreateTrigger) Schema 

func (c *CreateTrigger) Schema() sql.Schema

func (*CreateTrigger) String 

func (c *CreateTrigger) String() string

func (*CreateTrigger) WithChildren 

func (c *CreateTrigger) WithChildren(children ...sql.Node) (sql.Node, error)

func (*CreateTrigger) WithDatabase 

func (c *CreateTrigger) WithDatabase(database sql.Database) (sql.Node, error)

type CreateUser 

type CreateUser struct {
	IfNotExists     bool
	Users           []AuthenticatedUser
	DefaultRoles    []UserName
	TLSOptions      *TLSOptions
	AccountLimits   *AccountLimits
	PasswordOptions *PasswordOptions
	Locked          bool
	Attribute       string
	MySQLDb         sql.Database
}

CreateUser represents the statement CREATE USER.

func (*CreateUser) CheckPrivileges 

func (n *CreateUser) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateUser) Children 

func (n *CreateUser) Children() []sql.Node

Children implements the interface sql.Node.

func (*CreateUser) CollationCoercibility 

func (*CreateUser) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateUser) Database 

func (n *CreateUser) Database() sql.Database

Database implements the interface sql.Databaser.

func (*CreateUser) IsReadOnly 

func (n *CreateUser) IsReadOnly() bool

func (*CreateUser) Resolved 

func (n *CreateUser) Resolved() bool

Resolved implements the interface sql.Node.

func (*CreateUser) Schema 

func (n *CreateUser) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*CreateUser) String 

func (n *CreateUser) String() string

String implements the interface sql.Node.

func (*CreateUser) WithChildren 

func (n *CreateUser) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*CreateUser) WithDatabase 

func (n *CreateUser) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type CreateView 

type CreateView struct {
	UnaryNode

	Name             string
	IsReplace        bool
	Definition       *SubqueryAlias
	CreateViewString string
	Algorithm        string
	Definer          string
	Security         string
	CheckOpt         string
	// contains filtered or unexported fields
}

CreateView is a node representing the creation (or replacement) of a view, which is defined by the Child node. The Columns member represent the explicit columns specified by the query, if any.

func NewCreateView 

func NewCreateView(database sql.Database, name string, definition *SubqueryAlias, isReplace bool, createViewStr, algorithm, definer, security string) *CreateView

NewCreateView creates a CreateView node with the specified parameters, setting its catalog to nil.

func (*CreateView) CheckPrivileges 

func (cv *CreateView) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*CreateView) Children 

func (cv *CreateView) Children() []sql.Node

Children implements the Node interface. It returns the Child of the CreateView node; i.e., the definition of the view that will be created.

func (*CreateView) CollationCoercibility 

func (*CreateView) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*CreateView) Database 

func (cv *CreateView) Database() sql.Database

Database implements the Databaser interface, and it returns the database in which CreateView will create the view.

func (*CreateView) IsReadOnly 

func (cv *CreateView) IsReadOnly() bool

func (*CreateView) Resolved 

func (cv *CreateView) Resolved() bool

Resolved implements the Node interface. This node is resolved if and only if the database and the Child are both resolved.

func (*CreateView) Schema 

func (cv *CreateView) Schema() sql.Schema

Schema implements the Node interface. It always returns Query OK result.

func (*CreateView) String 

func (cv *CreateView) String() string

String implements the fmt.Stringer interface, using sql.TreePrinter to generate the string.

func (*CreateView) View 

func (cv *CreateView) View() *sql.View

View returns the view that will be created by this node.

func (*CreateView) WithChildren 

func (cv *CreateView) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface. It only succeeds if the length of the specified children equals 1.

func (*CreateView) WithDatabase 

func (cv *CreateView) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the Databaser interface, and it returns a copy of this node with the specified database.

type DeallocateQuery 

type DeallocateQuery struct {
	Name string
}

DeallocateQuery is a node that prepares the query

func NewDeallocateQuery 

func NewDeallocateQuery(name string) *DeallocateQuery

NewDeallocateQuery executes a prepared statement

func (*DeallocateQuery) CheckPrivileges 

func (p *DeallocateQuery) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeallocateQuery) Children 

func (p *DeallocateQuery) Children() []sql.Node

Children implements the Node interface.

func (*DeallocateQuery) CollationCoercibility 

func (*DeallocateQuery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeallocateQuery) IsReadOnly 

func (p *DeallocateQuery) IsReadOnly() bool

func (*DeallocateQuery) Resolved 

func (p *DeallocateQuery) Resolved() bool

func (*DeallocateQuery) RowIter 

func (p *DeallocateQuery) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the Node interface.

func (*DeallocateQuery) Schema 

func (p *DeallocateQuery) Schema() sql.Schema

Schema implements the Node interface.

func (*DeallocateQuery) String 

func (p *DeallocateQuery) String() string

func (*DeallocateQuery) WithChildren 

func (p *DeallocateQuery) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type DeclareCondition 

type DeclareCondition struct {
	Name          string
	MysqlErrCode  int64
	SqlStateValue string
}

DeclareCondition represents the DECLARE ... CONDITION statement.

func NewDeclareCondition 

func NewDeclareCondition(name string, errCode int64, sqlStateValue string) *DeclareCondition

NewDeclareCondition returns a *DeclareCondition node.

func (*DeclareCondition) CheckPrivileges 

func (d *DeclareCondition) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeclareCondition) Children 

func (d *DeclareCondition) Children() []sql.Node

Children implements the sql.Node interface.

func (*DeclareCondition) CollationCoercibility 

func (*DeclareCondition) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeclareCondition) IsReadOnly 

func (d *DeclareCondition) IsReadOnly() bool

func (*DeclareCondition) Resolved 

func (d *DeclareCondition) Resolved() bool

Resolved implements the sql.Node interface.

func (*DeclareCondition) RowIter 

func (d *DeclareCondition) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*DeclareCondition) Schema 

func (d *DeclareCondition) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*DeclareCondition) String 

func (d *DeclareCondition) String() string

String implements the sql.Node interface.

func (*DeclareCondition) WithChildren 

func (d *DeclareCondition) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type DeclareCursor 

type DeclareCursor struct {
	Name   string
	Select sql.Node
	Pref   *expression.ProcedureReference
}

DeclareCursor represents the DECLARE ... CURSOR statement.

func NewDeclareCursor 

func NewDeclareCursor(name string, selectStatement sql.Node) *DeclareCursor

NewDeclareCursor returns a new *DeclareCursor node.

func (*DeclareCursor) CheckPrivileges 

func (d *DeclareCursor) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeclareCursor) Children 

func (d *DeclareCursor) Children() []sql.Node

Children implements the interface sql.Node.

func (*DeclareCursor) CollationCoercibility 

func (*DeclareCursor) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeclareCursor) DebugString 

func (d *DeclareCursor) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*DeclareCursor) IsReadOnly 

func (d *DeclareCursor) IsReadOnly() bool

func (*DeclareCursor) Resolved 

func (d *DeclareCursor) Resolved() bool

Resolved implements the interface sql.Node.

func (*DeclareCursor) Schema 

func (d *DeclareCursor) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DeclareCursor) String 

func (d *DeclareCursor) String() string

String implements the interface sql.Node.

func (*DeclareCursor) WithChildren 

func (d *DeclareCursor) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DeclareCursor) WithParamReference 

func (d *DeclareCursor) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type DeclareHandler 

type DeclareHandler struct {
	Action    expression.DeclareHandlerAction
	Statement sql.Node
	Pref      *expression.ProcedureReference
	Condition expression.HandlerCondition
}

DeclareHandler represents the DECLARE ... HANDLER statement.

func NewDeclareHandler 

func NewDeclareHandler(action expression.DeclareHandlerAction, statement sql.Node, cond expression.HandlerCondition) (*DeclareHandler, error)

NewDeclareHandler returns a new *DeclareHandler node.

func (*DeclareHandler) CheckPrivileges 

func (d *DeclareHandler) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeclareHandler) Children 

func (d *DeclareHandler) Children() []sql.Node

Children implements the interface sql.Node.

func (*DeclareHandler) CollationCoercibility 

func (*DeclareHandler) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeclareHandler) DebugString 

func (d *DeclareHandler) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*DeclareHandler) IsReadOnly 

func (d *DeclareHandler) IsReadOnly() bool

func (*DeclareHandler) Resolved 

func (d *DeclareHandler) Resolved() bool

Resolved implements the interface sql.Node.

func (*DeclareHandler) Schema 

func (d *DeclareHandler) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DeclareHandler) String 

func (d *DeclareHandler) String() string

String implements the interface sql.Node.

func (*DeclareHandler) WithChildren 

func (d *DeclareHandler) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DeclareHandler) WithParamReference 

func (d *DeclareHandler) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type DeclareVariables 

type DeclareVariables struct {
	Names      []string
	Type       sql.Type
	DefaultVal *sql.ColumnDefaultValue
	Pref       *expression.ProcedureReference
}

DeclareVariables represents the DECLARE statement for local variables.

func NewDeclareVariables 

func NewDeclareVariables(names []string, typ sql.Type, defaultVal *sql.ColumnDefaultValue) *DeclareVariables

NewDeclareVariables returns a new *DeclareVariables node.

func (*DeclareVariables) CheckPrivileges 

func (d *DeclareVariables) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeclareVariables) Children 

func (d *DeclareVariables) Children() []sql.Node

Children implements the interface sql.Node.

func (*DeclareVariables) CollationCoercibility 

func (*DeclareVariables) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeclareVariables) IsReadOnly 

func (d *DeclareVariables) IsReadOnly() bool

func (*DeclareVariables) Resolved 

func (d *DeclareVariables) Resolved() bool

Resolved implements the interface sql.Node.

func (*DeclareVariables) Schema 

func (d *DeclareVariables) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DeclareVariables) String 

func (d *DeclareVariables) String() string

String implements the interface sql.Node.

func (*DeclareVariables) WithChildren 

func (d *DeclareVariables) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DeclareVariables) WithParamReference 

func (d *DeclareVariables) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type DeferredAsOfTable 

type DeferredAsOfTable struct {
	*ResolvedTable
	// contains filtered or unexported fields
}

func NewDeferredAsOfTable 

func NewDeferredAsOfTable(t *ResolvedTable, asOf sql.Expression) *DeferredAsOfTable

func (*DeferredAsOfTable) AsOf 

func (t *DeferredAsOfTable) AsOf() sql.Expression

AsOf implements sql.UnresolvedTable

func (*DeferredAsOfTable) Database 

func (t *DeferredAsOfTable) Database() sql.Database

Database implements sql.UnresolvedTable

func (*DeferredAsOfTable) Expressions 

func (t *DeferredAsOfTable) Expressions() []sql.Expression

func (*DeferredAsOfTable) IsReadOnly 

func (t *DeferredAsOfTable) IsReadOnly() bool

func (*DeferredAsOfTable) Name 

func (t *DeferredAsOfTable) Name() string

Name implements the Nameable interface.

func (*DeferredAsOfTable) WithAsOf 

func (t *DeferredAsOfTable) WithAsOf(asOf sql.Expression) (sql.Node, error)

WithAsOf implements sql.UnresolvedTable

func (*DeferredAsOfTable) WithExpressions 

func (t *DeferredAsOfTable) WithExpressions(expressions ...sql.Expression) (sql.Node, error)

type DeferredFilteredTable 

type DeferredFilteredTable struct {
	*ResolvedTable
}

func NewDeferredFilteredTable 

func NewDeferredFilteredTable(t *ResolvedTable) *DeferredFilteredTable

type DeleteFrom 

type DeleteFrom struct {
	UnaryNode
	// contains filtered or unexported fields
}

DeleteFrom is a node describing a deletion from some table.

func NewDeleteFrom 

func NewDeleteFrom(n sql.Node, targets []sql.Node) *DeleteFrom

NewDeleteFrom creates a DeleteFrom node.

func (*DeleteFrom) CheckPrivileges 

func (p *DeleteFrom) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DeleteFrom) CollationCoercibility 

func (*DeleteFrom) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DeleteFrom) DB 

func (p *DeleteFrom) DB() sql.Database

DB returns the database being deleted from. |Database| is used by another interface we implement.

func (*DeleteFrom) Database 

func (p *DeleteFrom) Database() string

func (*DeleteFrom) DebugString 

func (p *DeleteFrom) DebugString() string

func (*DeleteFrom) GetDeleteTargets 

func (p *DeleteFrom) GetDeleteTargets() []sql.Node

GetDeleteTargets returns the sql.Nodes representing the tables from which rows should be deleted. For a DELETE FROM JOIN statement, this will return the tables explicitly specified by the caller. For a DELETE FROM statement this will return the single table in the DELETE FROM source that is implicitly assumed to be the target of the delete operation.

func (*DeleteFrom) HasExplicitTargets 

func (p *DeleteFrom) HasExplicitTargets() bool

HasExplicitTargets returns true if the target delete tables were explicitly specified. This can only happen with DELETE FROM JOIN statements – for DELETE FROM statements using a single source table, the target is NOT explicitly specified and is assumed to be the single source table.

func (*DeleteFrom) IsReadOnly 

func (p *DeleteFrom) IsReadOnly() bool

func (*DeleteFrom) Resolved 

func (p *DeleteFrom) Resolved() bool

Resolved implements the sql.Resolvable interface.

func (*DeleteFrom) String 

func (p *DeleteFrom) String() string

func (*DeleteFrom) WithChildren 

func (p *DeleteFrom) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*DeleteFrom) WithExplicitTargets 

func (p *DeleteFrom) WithExplicitTargets(targets []sql.Node) *DeleteFrom

WithExplicitTargets returns a new DeleteFrom node instance with the specified |targets| set as the explicitly specified targets of the delete operation.

type Describe 

type Describe struct {
	UnaryNode
}

Describe is a node that describes its children.

func NewDescribe 

func NewDescribe(child sql.Node) *Describe

NewDescribe creates a new Describe node.

func (*Describe) CheckPrivileges 

func (d *Describe) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Describe) CollationCoercibility 

func (*Describe) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Describe) IsReadOnly 

func (d *Describe) IsReadOnly() bool

func (*Describe) Schema 

func (d *Describe) Schema() sql.Schema

Schema implements the Node interface.

func (Describe) String 

func (d Describe) String() string

func (*Describe) WithChildren 

func (d *Describe) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type DescribeQuery 

type DescribeQuery struct {
	UnaryNode
	Format sql.DescribeOptions
}

DescribeQuery returns the description of the query plan.

func NewDescribeQuery 

func NewDescribeQuery(format sql.DescribeOptions, child sql.Node) *DescribeQuery

NewDescribeQuery creates a new DescribeQuery node.

func (*DescribeQuery) CheckPrivileges 

func (d *DescribeQuery) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DescribeQuery) Children 

func (d *DescribeQuery) Children() []sql.Node

func (*DescribeQuery) CollationCoercibility 

func (*DescribeQuery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DescribeQuery) DebugString 

func (d *DescribeQuery) DebugString() string

func (*DescribeQuery) Describe 

func (d *DescribeQuery) Describe(options sql.DescribeOptions) string

func (*DescribeQuery) IsReadOnly 

func (d *DescribeQuery) IsReadOnly() bool

func (*DescribeQuery) Query 

func (d *DescribeQuery) Query() sql.Node

Query returns the query node being described

func (*DescribeQuery) Resolved 

func (d *DescribeQuery) Resolved() bool

func (*DescribeQuery) Schema 

func (d *DescribeQuery) Schema() sql.Schema

Schema implements the Node interface.

func (*DescribeQuery) String 

func (d *DescribeQuery) String() string

func (*DescribeQuery) WithChildren 

func (d *DescribeQuery) WithChildren(node ...sql.Node) (sql.Node, error)

func (*DescribeQuery) WithQuery 

func (d *DescribeQuery) WithQuery(child sql.Node) sql.Node

WithQuery returns a copy of this node with the query node given

type DisjointedChildrenNode 

type DisjointedChildrenNode interface {
	sql.Node
	// DisjointedChildren returns multiple groupings of child nodes, with each group being unrelated to the other groups.
	DisjointedChildren() [][]sql.Node
	// WithDisjointedChildren returns a copy of the node with all child groups replaced.
	// Returns an error if the number of children in each group is different than the current number of children in each
	// group. They must be given in the same order as they are returned by DisjointedChildren.
	WithDisjointedChildren(children [][]sql.Node) (sql.Node, error)
}

DisjointedChildrenNode is a sql.Node that contains multiple, disjointed groupings of child nodes. This is a highly specialized node that will not be applicable to the majority, as most nodes will return all children in the Children() function. For those nodes that do not return all of their children in the Children() function (such as InsertInto), operations such as stored procedures require the implementation of this interface so that those unexposed children may be accessed.

type Distinct 

type Distinct struct {
	UnaryNode
}

Distinct is a node that ensures all rows that come from it are unique.

func NewDistinct 

func NewDistinct(child sql.Node) *Distinct

NewDistinct creates a new Distinct node.

func (*Distinct) CheckPrivileges 

func (d *Distinct) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Distinct) CollationCoercibility 

func (d *Distinct) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Distinct) DebugString 

func (d Distinct) DebugString() string

DebugString implements sql.DebugStringer

func (Distinct) Describe 

func (d Distinct) Describe(options sql.DescribeOptions) string

Describe implements sql.Describable

func (*Distinct) IsReadOnly 

func (d *Distinct) IsReadOnly() bool

func (*Distinct) Resolved 

func (d *Distinct) Resolved() bool

Resolved implements the Resolvable interface.

func (Distinct) String 

func (d Distinct) String() string

String implements fmt.Stringer

func (*Distinct) WithChildren 

func (d *Distinct) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type DropCheck 

type DropCheck struct {
	Table *ResolvedTable
	Name  string
	// contains filtered or unexported fields
}

func NewAlterDropCheck 

func NewAlterDropCheck(table *ResolvedTable, name string) *DropCheck

func (*DropCheck) CheckPrivileges 

func (d *DropCheck) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropCheck) Children 

func (d *DropCheck) Children() []sql.Node

func (*DropCheck) CollationCoercibility 

func (d *DropCheck) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropCheck) Database 

func (c *DropCheck) Database() sql.Database

Database implements the sql.Databaser interface.

func (*DropCheck) IsReadOnly 

func (d *DropCheck) IsReadOnly() bool

func (*DropCheck) Resolved 

func (c *DropCheck) Resolved() bool

Resolved implements the Resolvable interface.

func (*DropCheck) Schema 

func (d *DropCheck) Schema() sql.Schema

func (DropCheck) String 

func (d DropCheck) String() string

func (*DropCheck) WithChildren 

func (d *DropCheck) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type DropColumn 

type DropColumn struct {
	Table  sql.Node
	Column string
	// contains filtered or unexported fields
}

func NewDropColumn 

func NewDropColumn(database sql.Database, table *UnresolvedTable, column string) *DropColumn

func NewDropColumnResolved 

func NewDropColumnResolved(table *ResolvedTable, column string) *DropColumn

func (*DropColumn) CheckPrivileges 

func (d *DropColumn) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropColumn) Checks 

func (d *DropColumn) Checks() sql.CheckConstraints

func (*DropColumn) Children 

func (d *DropColumn) Children() []sql.Node

func (*DropColumn) CollationCoercibility 

func (*DropColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropColumn) Database 

func (c *DropColumn) Database() sql.Database

Database implements the sql.Databaser interface.

func (*DropColumn) Expressions 

func (d *DropColumn) Expressions() []sql.Expression

func (*DropColumn) IsReadOnly 

func (d *DropColumn) IsReadOnly() bool

func (*DropColumn) Resolved 

func (d *DropColumn) Resolved() bool

func (*DropColumn) Schema 

func (d *DropColumn) Schema() sql.Schema

func (*DropColumn) String 

func (d *DropColumn) String() string

func (*DropColumn) TargetSchema 

func (d *DropColumn) TargetSchema() sql.Schema

func (*DropColumn) Validate 

func (d *DropColumn) Validate(ctx *sql.Context, tbl sql.Table) error

Validate returns an error if this drop column operation is invalid (because it would invalidate a column default or other constraint). TODO: move this check to analyzer

func (*DropColumn) WithChecks 

func (d *DropColumn) WithChecks(checks sql.CheckConstraints) sql.Node

func (DropColumn) WithChildren 

func (d DropColumn) WithChildren(children ...sql.Node) (sql.Node, error)

func (*DropColumn) WithDatabase 

func (d *DropColumn) WithDatabase(db sql.Database) (sql.Node, error)

func (DropColumn) WithExpressions 

func (d DropColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (DropColumn) WithTargetSchema 

func (d DropColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type DropConstraint 

type DropConstraint struct {
	UnaryNode
	Name string
}

DropConstraint is a temporary node to handle dropping a named constraint on a table. The type of the constraint is not known, and is determined during analysis.

func NewDropConstraint 

func NewDropConstraint(table *UnresolvedTable, name string) *DropConstraint

NewDropConstraint returns a new DropConstraint node

func (*DropConstraint) CheckPrivileges 

func (d *DropConstraint) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropConstraint) CollationCoercibility 

func (d *DropConstraint) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropConstraint) IsReadOnly 

func (d *DropConstraint) IsReadOnly() bool

func (*DropConstraint) String 

func (d *DropConstraint) String() string

func (DropConstraint) WithChildren 

func (d DropConstraint) WithChildren(children ...sql.Node) (sql.Node, error)

type DropDB 

type DropDB struct {
	Catalog  sql.Catalog
	DbName   string
	IfExists bool
	// EventScheduler is used to notify EventSchedulerStatus of database deletion,
	// so the events of this database in the scheduler will be removed.
	EventScheduler sql.EventScheduler
}

DropDB removes a databases from the Catalog and updates the active database if it gets removed itself.

func NewDropDatabase 

func NewDropDatabase(dbName string, ifExists bool) *DropDB

func (*DropDB) CheckPrivileges 

func (d *DropDB) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropDB) Children 

func (d *DropDB) Children() []sql.Node

func (*DropDB) CollationCoercibility 

func (*DropDB) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropDB) IsReadOnly 

func (d *DropDB) IsReadOnly() bool

func (*DropDB) Resolved 

func (d *DropDB) Resolved() bool

func (*DropDB) Schema 

func (d *DropDB) Schema() sql.Schema

func (*DropDB) String 

func (d *DropDB) String() string

func (*DropDB) WithChildren 

func (d *DropDB) WithChildren(children ...sql.Node) (sql.Node, error)

func (*DropDB) WithEventScheduler 

func (d *DropDB) WithEventScheduler(scheduler sql.EventScheduler) sql.Node

WithEventScheduler is used to drop all events from EventSchedulerStatus for DROP DATABASE.

type DropEvent 

type DropEvent struct {
	EventName string
	IfExists  bool
	// contains filtered or unexported fields
}

func NewDropEvent 

func NewDropEvent(db sql.Database, eventName string, ifExists bool) *DropEvent

NewDropEvent creates a new *DropEvent node.

func (*DropEvent) CheckPrivileges 

func (d *DropEvent) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropEvent) Children 

func (c *DropEvent) Children() []sql.Node

Children implements the Node interface.

func (*DropEvent) Database 

func (c *DropEvent) Database() sql.Database

Database implements the sql.Databaser interface.

func (*DropEvent) IsReadOnly 

func (d *DropEvent) IsReadOnly() bool

func (*DropEvent) Resolved 

func (c *DropEvent) Resolved() bool

Resolved implements the Resolvable interface.

func (*DropEvent) RowIter 

func (d *DropEvent) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*DropEvent) Schema 

func (d *DropEvent) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*DropEvent) String 

func (d *DropEvent) String() string

String implements the sql.Node interface.

func (*DropEvent) WithChildren 

func (d *DropEvent) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*DropEvent) WithDatabase 

func (d *DropEvent) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*DropEvent) WithEventScheduler 

func (d *DropEvent) WithEventScheduler(scheduler sql.EventScheduler) sql.Node

WithEventScheduler is used to notify EventSchedulerStatus to update the events list for DROP EVENT.

type DropForeignKey 

type DropForeignKey struct {
	// In the cases where we have multiple ALTER statements, we need to resolve the table at execution time rather than
	// during analysis. Otherwise, you could add a foreign key in the preceding alter and we may have analyzed to a
	// table that did not yet have that foreign key.
	DbProvider sql.DatabaseProvider

	Table string
	Name  string
	// contains filtered or unexported fields
}

func NewAlterDropForeignKey 

func NewAlterDropForeignKey(db, table, name string) *DropForeignKey

func (*DropForeignKey) CheckPrivileges 

func (p *DropForeignKey) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropForeignKey) Children 

func (p *DropForeignKey) Children() []sql.Node

Children implements the interface sql.Node.

func (*DropForeignKey) CollationCoercibility 

func (*DropForeignKey) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropForeignKey) Database 

func (p *DropForeignKey) Database() string

func (*DropForeignKey) DatabaseProvider 

func (p *DropForeignKey) DatabaseProvider() sql.DatabaseProvider

DatabaseProvider implements the interface sql.MultiDatabaser.

func (*DropForeignKey) IsReadOnly 

func (p *DropForeignKey) IsReadOnly() bool

func (*DropForeignKey) Resolved 

func (p *DropForeignKey) Resolved() bool

Resolved implements the interface sql.Node.

func (*DropForeignKey) Schema 

func (p *DropForeignKey) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DropForeignKey) String 

func (p *DropForeignKey) String() string

String implements the interface sql.Node.

func (*DropForeignKey) WithChildren 

func (p *DropForeignKey) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DropForeignKey) WithDatabaseProvider 

func (p *DropForeignKey) WithDatabaseProvider(provider sql.DatabaseProvider) (sql.Node, error)

WithDatabaseProvider implements the interface sql.MultiDatabaser.

type DropHistogram 

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

func NewDropHistogram 

func NewDropHistogram(db, table string, cols []string) *DropHistogram

func (*DropHistogram) CheckPrivileges 

func (d *DropHistogram) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*DropHistogram) Children 

func (d *DropHistogram) Children() []sql.Node

func (*DropHistogram) Cols 

func (d *DropHistogram) Cols() []string

func (*DropHistogram) Db 

func (d *DropHistogram) Db() string

func (*DropHistogram) IsReadOnly 

func (d *DropHistogram) IsReadOnly() bool

func (*DropHistogram) Resolved 

func (d *DropHistogram) Resolved() bool

func (*DropHistogram) Schema 

func (d *DropHistogram) Schema() sql.Schema

func (*DropHistogram) StatsProvider 

func (d *DropHistogram) StatsProvider() sql.StatsProvider

func (*DropHistogram) String 

func (d *DropHistogram) String() string

func (*DropHistogram) Table 

func (d *DropHistogram) Table() string

func (*DropHistogram) WithChildren 

func (d *DropHistogram) WithChildren(_ ...sql.Node) (sql.Node, error)

func (*DropHistogram) WithProvider 

func (d *DropHistogram) WithProvider(prov sql.StatsProvider) *DropHistogram

type DropIndex 

type DropIndex struct {
	Name            string
	Table           sql.Node
	Catalog         sql.Catalog
	CurrentDatabase string
}

DropIndex is a node to drop an index.

func NewDropIndex 

func NewDropIndex(name string, table sql.Node) *DropIndex

NewDropIndex creates a new DropIndex node.

func (*DropIndex) CheckPrivileges 

func (d *DropIndex) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropIndex) Children 

func (d *DropIndex) Children() []sql.Node

Children implements the Node interface.

func (*DropIndex) CollationCoercibility 

func (*DropIndex) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropIndex) Database 

func (d *DropIndex) Database() string

func (*DropIndex) IsReadOnly 

func (d *DropIndex) IsReadOnly() bool

func (*DropIndex) Resolved 

func (d *DropIndex) Resolved() bool

Resolved implements the Node interface.

func (*DropIndex) Schema 

func (d *DropIndex) Schema() sql.Schema

Schema implements the Node interface.

func (*DropIndex) String 

func (d *DropIndex) String() string

func (*DropIndex) WithChildren 

func (d *DropIndex) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type DropProcedure 

type DropProcedure struct {
	Db            sql.Database
	IfExists      bool
	ProcedureName string
}

func NewDropProcedure 

func NewDropProcedure(db sql.Database, procedureName string, ifExists bool) *DropProcedure

NewDropProcedure creates a new *DropProcedure node.

func (*DropProcedure) CheckPrivileges 

func (d *DropProcedure) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropProcedure) Children 

func (d *DropProcedure) Children() []sql.Node

Children implements the sql.Node interface.

func (*DropProcedure) CollationCoercibility 

func (*DropProcedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropProcedure) Database 

func (d *DropProcedure) Database() sql.Database

Database implements the sql.Databaser interface.

func (*DropProcedure) IsReadOnly 

func (d *DropProcedure) IsReadOnly() bool

func (*DropProcedure) Resolved 

func (d *DropProcedure) Resolved() bool

Resolved implements the sql.Node interface.

func (*DropProcedure) Schema 

func (d *DropProcedure) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*DropProcedure) String 

func (d *DropProcedure) String() string

String implements the sql.Node interface.

func (*DropProcedure) WithChildren 

func (d *DropProcedure) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*DropProcedure) WithDatabase 

func (d *DropProcedure) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type DropRole 

type DropRole struct {
	IfExists bool
	Roles    []UserName
	MySQLDb  sql.Database
}

DropRole represents the statement DROP ROLE.

func NewDropRole 

func NewDropRole(ifExists bool, roles []UserName) *DropRole

NewDropRole returns a new DropRole node.

func (*DropRole) CheckPrivileges 

func (n *DropRole) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropRole) Children 

func (n *DropRole) Children() []sql.Node

Children implements the interface sql.Node.

func (*DropRole) CollationCoercibility 

func (*DropRole) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropRole) Database 

func (n *DropRole) Database() sql.Database

Database implements the interface sql.Databaser.

func (*DropRole) IsReadOnly 

func (n *DropRole) IsReadOnly() bool

func (*DropRole) Resolved 

func (n *DropRole) Resolved() bool

Resolved implements the interface sql.Node.

func (*DropRole) RowIter 

func (n *DropRole) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*DropRole) Schema 

func (n *DropRole) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DropRole) String 

func (n *DropRole) String() string

String implements the interface sql.Node.

func (*DropRole) WithChildren 

func (n *DropRole) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DropRole) WithDatabase 

func (n *DropRole) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type DropTable 

type DropTable struct {
	Tables []sql.Node

	TriggerNames []string
	// contains filtered or unexported fields
}

DropTable is a node describing dropping one or more tables

func NewDropTable 

func NewDropTable(tbls []sql.Node, ifExists bool) *DropTable

NewDropTable creates a new DropTable node

func (*DropTable) CheckPrivileges 

func (d *DropTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropTable) Children 

func (d *DropTable) Children() []sql.Node

Children implements the Node interface.

func (*DropTable) CollationCoercibility 

func (*DropTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropTable) IfExists 

func (d *DropTable) IfExists() bool

IfExists returns ifExists variable.

func (*DropTable) IsReadOnly 

func (d *DropTable) IsReadOnly() bool

func (*DropTable) Resolved 

func (d *DropTable) Resolved() bool

Resolved implements the sql.Expression interface.

func (*DropTable) Schema 

func (d *DropTable) Schema() sql.Schema

Schema implements the sql.Expression interface.

func (*DropTable) String 

func (d *DropTable) String() string

String implements the sql.Node interface.

func (*DropTable) TableNames 

func (d *DropTable) TableNames() ([]string, error)

TableNames returns the names of the tables to drop.

func (*DropTable) WithChildren 

func (d *DropTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*DropTable) WithTriggers 

func (d *DropTable) WithTriggers(triggers []string) sql.Node

WithTriggers returns this node but with the given triggers.

type DropTrigger 

type DropTrigger struct {
	Db          sql.Database
	IfExists    bool
	TriggerName string
}

func NewDropTrigger 

func NewDropTrigger(db sql.Database, trigger string, ifExists bool) *DropTrigger

NewDropTrigger creates a new NewDropTrigger node for DROP TRIGGER statements.

func (*DropTrigger) CheckPrivileges 

func (d *DropTrigger) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropTrigger) Children 

func (d *DropTrigger) Children() []sql.Node

Children implements the sql.Node interface.

func (*DropTrigger) CollationCoercibility 

func (*DropTrigger) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropTrigger) Database 

func (d *DropTrigger) Database() sql.Database

Database implements the sql.Databaser interface.

func (*DropTrigger) IsReadOnly 

func (d *DropTrigger) IsReadOnly() bool

func (*DropTrigger) Resolved 

func (d *DropTrigger) Resolved() bool

Resolved implements the sql.Node interface.

func (*DropTrigger) Schema 

func (d *DropTrigger) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*DropTrigger) String 

func (d *DropTrigger) String() string

String implements the sql.Node interface.

func (*DropTrigger) WithChildren 

func (d *DropTrigger) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*DropTrigger) WithDatabase 

func (d *DropTrigger) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type DropUser 

type DropUser struct {
	IfExists bool
	Users    []UserName
	MySQLDb  sql.Database
}

DropUser represents the statement DROP USER.

func NewDropUser 

func NewDropUser(ifExists bool, users []UserName) *DropUser

NewDropUser returns a new DropUser node.

func (*DropUser) CheckPrivileges 

func (n *DropUser) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropUser) Children 

func (n *DropUser) Children() []sql.Node

Children implements the interface sql.Node.

func (*DropUser) CollationCoercibility 

func (*DropUser) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropUser) Database 

func (n *DropUser) Database() sql.Database

Database implements the interface sql.Databaser.

func (*DropUser) IsReadOnly 

func (n *DropUser) IsReadOnly() bool

func (*DropUser) Resolved 

func (n *DropUser) Resolved() bool

Resolved implements the interface sql.Node.

func (*DropUser) RowIter 

func (n *DropUser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*DropUser) Schema 

func (n *DropUser) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*DropUser) String 

func (n *DropUser) String() string

String implements the interface sql.Node.

func (*DropUser) WithChildren 

func (n *DropUser) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*DropUser) WithDatabase 

func (n *DropUser) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type DropView 

type DropView struct {
	IfExists bool
	// contains filtered or unexported fields
}

DropView is a node representing the removal of a list of views, defined by the children member. The flag ifExists represents whether the user wants the node to fail if any of the views in children does not exist.

func NewDropView 

func NewDropView(children []sql.Node, ifExists bool) *DropView

NewDropView creates a DropView node with the specified parameters, setting its catalog to nil.

func (*DropView) CheckPrivileges 

func (dvs *DropView) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*DropView) Children 

func (dvs *DropView) Children() []sql.Node

Children implements the Node interface. It returns the children of the CreateView node; i.e., all the views that will be dropped.

func (*DropView) CollationCoercibility 

func (*DropView) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*DropView) IsReadOnly 

func (dvs *DropView) IsReadOnly() bool

func (*DropView) Resolved 

func (dvs *DropView) Resolved() bool

Resolved implements the Node interface. This node is resolved if and only if all of its children are resolved.

func (*DropView) Schema 

func (dvs *DropView) Schema() sql.Schema

Schema implements the Node interface. It always returns nil.

func (*DropView) String 

func (dvs *DropView) String() string

String implements the fmt.Stringer interface, using sql.TreePrinter to generate the string.

func (*DropView) WithChildren 

func (dvs *DropView) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface. It always suceeds, returning a copy of this node with the new array of nodes as children.

type DummyResolvedDB 

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

DummyResolvedDB is a transient database useful only for instances where a database is not available but required. No tables are persisted, nor will be returned.

func NewDummyResolvedDB 

func NewDummyResolvedDB(name string) *DummyResolvedDB

NewDummyResolvedDB creates a new dummy database with the given name.

func (*DummyResolvedDB) AddTable 

func (d *DummyResolvedDB) AddTable(name string, t sql.Table)

func (*DummyResolvedDB) CreateTable 

func (d *DummyResolvedDB) CreateTable(ctx *sql.Context, name string, schema sql.PrimaryKeySchema, collation sql.CollationID, comment string) error

func (*DummyResolvedDB) DropTable 

func (d *DummyResolvedDB) DropTable(ctx *sql.Context, name string) error

func (*DummyResolvedDB) GetTableInsensitive 

func (d *DummyResolvedDB) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.Table, bool, error)

func (*DummyResolvedDB) GetTableNames 

func (d *DummyResolvedDB) GetTableNames(ctx *sql.Context) ([]string, error)

func (*DummyResolvedDB) Name 

func (d *DummyResolvedDB) Name() string

func (*DummyResolvedDB) RenameTable 

func (d *DummyResolvedDB) RenameTable(ctx *sql.Context, oldName, newName string) error

func (*DummyResolvedDB) Tables 

func (d *DummyResolvedDB) Tables() map[string]sql.Table

type ElseCaseError 

type ElseCaseError struct{}

func (ElseCaseError) CheckPrivileges 

func (e ElseCaseError) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (ElseCaseError) Children 

func (e ElseCaseError) Children() []sql.Node

Children implements the interface sql.Node.

func (ElseCaseError) CollationCoercibility 

func (e ElseCaseError) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (ElseCaseError) IsReadOnly 

func (e ElseCaseError) IsReadOnly() bool

func (ElseCaseError) Resolved 

func (e ElseCaseError) Resolved() bool

Resolved implements the interface sql.Node.

func (ElseCaseError) Schema 

func (e ElseCaseError) Schema() sql.Schema

Schema implements the interface sql.Node.

func (ElseCaseError) String 

func (e ElseCaseError) String() string

String implements the interface sql.Node.

func (ElseCaseError) WithChildren 

func (e ElseCaseError) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type EmptyTable 

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

func (*EmptyTable) CheckPrivileges 

func (e *EmptyTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*EmptyTable) Children 

func (*EmptyTable) Children() []sql.Node

func (*EmptyTable) Collation 

func (e *EmptyTable) Collation() sql.CollationID

Collation implements the sql.UpdatableTable interface.

func (*EmptyTable) CollationCoercibility 

func (*EmptyTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*EmptyTable) Columns 

func (e *EmptyTable) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*EmptyTable) Deleter 

func (e *EmptyTable) Deleter(context *sql.Context) sql.RowDeleter

Deleter implements the sql.DeletableTable interface.

func (*EmptyTable) Id 

func (e *EmptyTable) Id() sql.TableId

Id implements sql.TableIdNode

func (*EmptyTable) IsReadOnly 

func (*EmptyTable) IsReadOnly() bool

func (*EmptyTable) Name 

func (e *EmptyTable) Name() string

func (*EmptyTable) PartitionRows 

func (e *EmptyTable) PartitionRows(_ *sql.Context, _ sql.Partition) (sql.RowIter, error)

PartitionRows implements the sql.UpdatableTable interface.

func (*EmptyTable) Partitions 

func (e *EmptyTable) Partitions(_ *sql.Context) (sql.PartitionIter, error)

Partitions implements the sql.UpdatableTable interface.

func (*EmptyTable) Resolved 

func (*EmptyTable) Resolved() bool

func (*EmptyTable) RowIter 

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

RowIter implements the sql.Node interface.

func (*EmptyTable) Schema 

func (e *EmptyTable) Schema() sql.Schema

func (*EmptyTable) String 

func (e *EmptyTable) String() string

func (*EmptyTable) Updater 

func (e *EmptyTable) Updater(ctx *sql.Context) sql.RowUpdater

Updater implements the sql.UpdatableTable interface.

func (*EmptyTable) WithChildren 

func (e *EmptyTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*EmptyTable) WithColumns 

func (e *EmptyTable) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*EmptyTable) WithId 

func (e *EmptyTable) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*EmptyTable) WithName 

func (e *EmptyTable) WithName(s string) sql.Node

type Exchange 

type Exchange struct {
	UnaryNode
	Parallelism int
}

Exchange is a node that can parallelize the underlying tree iterating partitions concurrently.

func NewExchange 

func NewExchange(
	parallelism int,
	child sql.Node,
) *Exchange

NewExchange creates a new Exchange node.

func (*Exchange) CheckPrivileges 

func (e *Exchange) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Exchange) CollationCoercibility 

func (e *Exchange) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Exchange) DebugString 

func (e *Exchange) DebugString() string

func (*Exchange) IsReadOnly 

func (e *Exchange) IsReadOnly() bool

func (*Exchange) String 

func (e *Exchange) String() string

func (*Exchange) WithChildren 

func (e *Exchange) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ExchangePartition 

type ExchangePartition struct {
	sql.Partition
	Table sql.Table
}

func (*ExchangePartition) CheckPrivileges 

func (p *ExchangePartition) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (ExchangePartition) Children 

func (ExchangePartition) Children() []sql.Node

func (*ExchangePartition) CollationCoercibility 

func (p *ExchangePartition) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (ExchangePartition) IsReadOnly 

func (ExchangePartition) IsReadOnly() bool

func (ExchangePartition) Resolved 

func (ExchangePartition) Resolved() bool

func (*ExchangePartition) Schema 

func (p *ExchangePartition) Schema() sql.Schema

func (*ExchangePartition) String 

func (p *ExchangePartition) String() string

func (*ExchangePartition) WithChildren 

func (p *ExchangePartition) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ExecuteQuery 

type ExecuteQuery struct {
	Name     string
	BindVars []sql.Expression
}

ExecuteQuery is a node that prepares the query

func NewExecuteQuery 

func NewExecuteQuery(name string, bindVars ...sql.Expression) *ExecuteQuery

NewExecuteQuery executes a prepared statement

func (*ExecuteQuery) CheckPrivileges 

func (p *ExecuteQuery) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ExecuteQuery) Children 

func (p *ExecuteQuery) Children() []sql.Node

Children implements the Node interface.

func (*ExecuteQuery) CollationCoercibility 

func (*ExecuteQuery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ExecuteQuery) IsReadOnly 

func (p *ExecuteQuery) IsReadOnly() bool

func (*ExecuteQuery) Resolved 

func (p *ExecuteQuery) Resolved() bool

func (*ExecuteQuery) RowIter 

func (p *ExecuteQuery) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the Node interface.

func (*ExecuteQuery) Schema 

func (p *ExecuteQuery) Schema() sql.Schema

Schema implements the Node interface.

func (*ExecuteQuery) String 

func (p *ExecuteQuery) String() string

func (*ExecuteQuery) WithChildren 

func (p *ExecuteQuery) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ExistsSubquery 

type ExistsSubquery struct {
	Query *Subquery
}

ExistsSubquery is an expression that checks that a subquery returns a non-empty result set. It's in the plan package, instead of the expression package, because Subquery is itself in the plan package (because it functions more like a plan node than an expression in its evaluation).

func NewExistsSubquery 

func NewExistsSubquery(sq *Subquery) *ExistsSubquery

NewExistsSubquery created an ExistsSubquery expression.

func (*ExistsSubquery) Children 

func (e *ExistsSubquery) Children() []sql.Expression

Children implements the Expression interface.

func (*ExistsSubquery) CollationCoercibility 

func (*ExistsSubquery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ExistsSubquery) DebugString 

func (e *ExistsSubquery) DebugString() string

DebugString implements the Expression interface.

func (*ExistsSubquery) Eval 

func (e *ExistsSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

Eval implements the Expression interface.

func (*ExistsSubquery) IsNullable 

func (e *ExistsSubquery) IsNullable() bool

IsNullable implements the Expression interface.

func (*ExistsSubquery) Resolved 

func (e *ExistsSubquery) Resolved() bool

Resolved implements the Expression interface.

func (*ExistsSubquery) String 

func (e *ExistsSubquery) String() string

String implements the Expression interface.

func (*ExistsSubquery) Type 

func (e *ExistsSubquery) Type() sql.Type

Type implements the Expression interface.

func (*ExistsSubquery) WithChildren 

func (e *ExistsSubquery) WithChildren(children ...sql.Expression) (sql.Expression, error)

WithChildren implements the Expression interface.

type ExternalProcedure 

type ExternalProcedure struct {
	sql.ExternalStoredProcedureDetails
	ParamDefinitions []ProcedureParam
	Params           []*expression.ProcedureParam
}

ExternalProcedure is the sql.Node container for sql.ExternalStoredProcedureDetails.

func (*ExternalProcedure) CheckPrivileges 

func (n *ExternalProcedure) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ExternalProcedure) Children 

func (n *ExternalProcedure) Children() []sql.Node

Children implements the interface sql.Node.

func (*ExternalProcedure) CollationCoercibility 

func (*ExternalProcedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ExternalProcedure) Expressions 

func (n *ExternalProcedure) Expressions() []sql.Expression

Expressions implements the interface sql.Expressioner.

func (*ExternalProcedure) IsReadOnly 

func (n *ExternalProcedure) IsReadOnly() bool

func (*ExternalProcedure) ProcessParam 

func (n *ExternalProcedure) ProcessParam(ctx *sql.Context, funcParamType reflect.Type, exprParamVal interface{}) (reflect.Value, error)

func (*ExternalProcedure) Resolved 

func (n *ExternalProcedure) Resolved() bool

Resolved implements the interface sql.Node.

func (*ExternalProcedure) RowIter 

func (n *ExternalProcedure) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*ExternalProcedure) Schema 

func (n *ExternalProcedure) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*ExternalProcedure) String 

func (n *ExternalProcedure) String() string

String implements the interface sql.Node.

func (*ExternalProcedure) WithChildren 

func (n *ExternalProcedure) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*ExternalProcedure) WithExpressions 

func (n *ExternalProcedure) WithExpressions(expressions ...sql.Expression) (sql.Node, error)

WithExpressions implements the interface sql.Expressioner.

type Fetch 

type Fetch struct {
	Name     string
	InnerSet *Set
	ToSet    []sql.Expression
	Pref     *expression.ProcedureReference
	Sch      sql.Schema
}

Fetch represents the FETCH statement, which handles value acquisition from cursors.

func NewFetch 

func NewFetch(name string, toSet []sql.Expression) *Fetch

NewFetch returns a new *Fetch node.

func (*Fetch) CheckPrivileges 

func (f *Fetch) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Fetch) Children 

func (f *Fetch) Children() []sql.Node

Children implements the interface sql.Node.

func (*Fetch) CollationCoercibility 

func (*Fetch) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Fetch) DebugString 

func (f *Fetch) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*Fetch) Expressions 

func (f *Fetch) Expressions() []sql.Expression

func (*Fetch) IsReadOnly 

func (f *Fetch) IsReadOnly() bool

func (*Fetch) Resolved 

func (f *Fetch) Resolved() bool

Resolved implements the interface sql.Node.

func (*Fetch) Schema 

func (f *Fetch) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Fetch) String 

func (f *Fetch) String() string

String implements the interface sql.Node.

func (*Fetch) WithChildren 

func (f *Fetch) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Fetch) WithExpressions 

func (f *Fetch) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*Fetch) WithParamReference 

func (f *Fetch) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type Filter 

type Filter struct {
	UnaryNode
	Expression sql.Expression
}

Filter skips rows that don't match a certain expression.

func NewFilter 

func NewFilter(expression sql.Expression, child sql.Node) *Filter

NewFilter creates a new filter node.

func (*Filter) CheckPrivileges 

func (f *Filter) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Filter) CollationCoercibility 

func (f *Filter) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Filter) DebugString 

func (f *Filter) DebugString() string

DebugString implements the sql.DebugStringer interface

func (*Filter) Describe 

func (f *Filter) Describe(options sql.DescribeOptions) string

Describe implements the sql.Describable interface

func (*Filter) Expressions 

func (f *Filter) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*Filter) IsReadOnly 

func (f *Filter) IsReadOnly() bool

func (*Filter) Resolved 

func (f *Filter) Resolved() bool

Resolved implements the Resolvable interface.

func (*Filter) String 

func (f *Filter) String() string

String implements the fmt.Stringer interface

func (*Filter) WithChildren 

func (f *Filter) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Filter) WithExpressions 

func (f *Filter) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type FilterIter 

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

FilterIter is an iterator that filters another iterator and skips rows that don't match the given condition.

func NewFilterIter 

func NewFilterIter(
	cond sql.Expression,
	child sql.RowIter,
) *FilterIter

NewFilterIter creates a new FilterIter.

func (*FilterIter) Close 

func (i *FilterIter) Close(ctx *sql.Context) error

Close implements the RowIter interface.

func (*FilterIter) Next 

func (i *FilterIter) Next(ctx *sql.Context) (sql.Row, error)

Next implements the RowIter interface.

type FlushPrivileges 

type FlushPrivileges struct {
	MysqlDb sql.Database
	// contains filtered or unexported fields
}

FlushPrivileges reads privileges from mysql tables and registers any unregistered privileges found.

func NewFlushPrivileges 

func NewFlushPrivileges(ft bool) *FlushPrivileges

NewFlushPrivileges creates a new FlushPrivileges node.

func (*FlushPrivileges) CheckPrivileges 

func (f *FlushPrivileges) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*FlushPrivileges) Children 

func (*FlushPrivileges) Children() []sql.Node

Children implements the sql.Node interface.

func (*FlushPrivileges) CollationCoercibility 

func (*FlushPrivileges) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*FlushPrivileges) Database 

func (f *FlushPrivileges) Database() sql.Database

Database implements the sql.Databaser interface.

func (*FlushPrivileges) IsReadOnly 

func (*FlushPrivileges) IsReadOnly() bool

Semantically there is no reason to run this in a read-only context, so we say it is not read only.

func (*FlushPrivileges) Resolved 

func (f *FlushPrivileges) Resolved() bool

Resolved implements the interface sql.Node.

func (*FlushPrivileges) RowIter 

func (f *FlushPrivileges) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*FlushPrivileges) Schema 

func (*FlushPrivileges) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*FlushPrivileges) String 

func (*FlushPrivileges) String() string

String implements the interface sql.Node.

func (*FlushPrivileges) WithChildren 

func (f *FlushPrivileges) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*FlushPrivileges) WithDatabase 

func (f *FlushPrivileges) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ForeignKeyEditor 

type ForeignKeyEditor struct {
	Schema     sql.Schema
	Editor     sql.ForeignKeyEditor
	References []*ForeignKeyReferenceHandler
	RefActions []ForeignKeyRefActionData
	Cyclical   bool
}

ForeignKeyEditor handles update and delete operations, as they may have referential actions on other tables (such as cascading). If this editor is Cyclical, then that means that following the referential actions will eventually lead back to this same editor. Self-referential foreign keys are inherently cyclical.

func (*ForeignKeyEditor) Close 

func (fkEditor *ForeignKeyEditor) Close(ctx *sql.Context) error

Close closes this handler along with all child handlers.

func (*ForeignKeyEditor) ColumnsUpdated 

func (fkEditor *ForeignKeyEditor) ColumnsUpdated(refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row) (bool, error)

ColumnsUpdated returns whether the columns involved in the foreign key were updated. Some updates may only update columns that are not involved in a foreign key, and therefore we should ignore a CASCADE or SET NULL referential action in such cases.

func (*ForeignKeyEditor) Delete 

func (fkEditor *ForeignKeyEditor) Delete(ctx *sql.Context, row sql.Row, depth int) error

Delete handles both the standard DELETE statement and propagated referential actions from a parent table's ON DELETE.

func (*ForeignKeyEditor) IsInitialized 

func (fkEditor *ForeignKeyEditor) IsInitialized(editors map[*ForeignKeyEditor]struct{}) bool

IsInitialized returns whether this editor has been initialized. The given map is used to prevent cycles, as editors will reference themselves if a cycle is formed between foreign keys.

func (*ForeignKeyEditor) OnDeleteCascade 

func (fkEditor *ForeignKeyEditor) OnDeleteCascade(ctx *sql.Context, refActionData ForeignKeyRefActionData, row sql.Row, depth int) error

OnDeleteCascade handles the ON DELETE CASCADE referential action.

func (*ForeignKeyEditor) OnDeleteRestrict 

func (fkEditor *ForeignKeyEditor) OnDeleteRestrict(ctx *sql.Context, refActionData ForeignKeyRefActionData, row sql.Row) error

OnDeleteRestrict handles the ON DELETE RESTRICT referential action.

func (*ForeignKeyEditor) OnDeleteSetNull 

func (fkEditor *ForeignKeyEditor) OnDeleteSetNull(ctx *sql.Context, refActionData ForeignKeyRefActionData, row sql.Row, depth int) error

OnDeleteSetNull handles the ON DELETE SET NULL referential action.

func (*ForeignKeyEditor) OnUpdateCascade 

func (fkEditor *ForeignKeyEditor) OnUpdateCascade(ctx *sql.Context, refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row, depth int) error

OnUpdateCascade handles the ON UPDATE CASCADE referential action.

func (*ForeignKeyEditor) OnUpdateRestrict 

func (fkEditor *ForeignKeyEditor) OnUpdateRestrict(ctx *sql.Context, refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row) error

OnUpdateRestrict handles the ON UPDATE RESTRICT referential action.

func (*ForeignKeyEditor) OnUpdateSetNull 

func (fkEditor *ForeignKeyEditor) OnUpdateSetNull(ctx *sql.Context, refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row, depth int) error

OnUpdateSetNull handles the ON UPDATE SET NULL referential action.

func (*ForeignKeyEditor) Update 

func (fkEditor *ForeignKeyEditor) Update(ctx *sql.Context, old sql.Row, new sql.Row, depth int) error

Update handles both the standard UPDATE statement and propagated referential actions from a parent table's ON UPDATE.

type ForeignKeyHandler 

type ForeignKeyHandler struct {
	Table        sql.ForeignKeyTable
	Sch          sql.Schema
	OriginalNode sql.Node
	Editor       *ForeignKeyEditor
	AllUpdaters  []sql.ForeignKeyEditor
}

ForeignKeyHandler handles all referencing and cascading operations that would need to be executed for an operation on a table.

func (*ForeignKeyHandler) CheckPrivileges 

func (n *ForeignKeyHandler) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ForeignKeyHandler) Children 

func (n *ForeignKeyHandler) Children() []sql.Node

Children implements the interface sql.Node.

func (*ForeignKeyHandler) Close 

func (n *ForeignKeyHandler) Close(ctx *sql.Context) error

Close implements the interface sql.Closer.

func (*ForeignKeyHandler) Collation 

func (n *ForeignKeyHandler) Collation() sql.CollationID

Collation implements the interface sql.Node.

func (*ForeignKeyHandler) CollationCoercibility 

func (*ForeignKeyHandler) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ForeignKeyHandler) DebugString 

func (n *ForeignKeyHandler) DebugString() string

func (*ForeignKeyHandler) Delete 

func (n *ForeignKeyHandler) Delete(ctx *sql.Context, row sql.Row) error

Delete implements the interface sql.RowDeleter.

func (*ForeignKeyHandler) Deleter 

func (n *ForeignKeyHandler) Deleter(context *sql.Context) sql.RowDeleter

Deleter implements the interface sql.DeletableTable.

func (*ForeignKeyHandler) DiscardChanges 

func (n *ForeignKeyHandler) DiscardChanges(ctx *sql.Context, errorEncountered error) error

DiscardChanges implements the interface sql.TableEditor.

func (*ForeignKeyHandler) Insert 

func (n *ForeignKeyHandler) Insert(ctx *sql.Context, row sql.Row) error

Insert implements the interface sql.RowInserter.

func (*ForeignKeyHandler) Inserter 

func (n *ForeignKeyHandler) Inserter(context *sql.Context) sql.RowInserter

Inserter implements the interface sql.InsertableTable.

func (*ForeignKeyHandler) IsReadOnly 

func (n *ForeignKeyHandler) IsReadOnly() bool

func (*ForeignKeyHandler) Name 

func (n *ForeignKeyHandler) Name() string

Name implements the interface sql.Table.

func (*ForeignKeyHandler) PartitionRows 

func (n *ForeignKeyHandler) PartitionRows(ctx *sql.Context, partition sql.Partition) (sql.RowIter, error)

PartitionRows implements the interface sql.Table.

func (*ForeignKeyHandler) Partitions 

func (n *ForeignKeyHandler) Partitions(ctx *sql.Context) (sql.PartitionIter, error)

Partitions implements the interface sql.Table.

func (*ForeignKeyHandler) Replacer 

func (n *ForeignKeyHandler) Replacer(ctx *sql.Context) sql.RowReplacer

Replacer implements the interface sql.ReplaceableTable.

func (*ForeignKeyHandler) Resolved 

func (n *ForeignKeyHandler) Resolved() bool

Resolved implements the interface sql.Node.

func (*ForeignKeyHandler) Schema 

func (n *ForeignKeyHandler) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*ForeignKeyHandler) StatementBegin 

func (n *ForeignKeyHandler) StatementBegin(ctx *sql.Context)

StatementBegin implements the interface sql.TableEditor.

func (*ForeignKeyHandler) StatementComplete 

func (n *ForeignKeyHandler) StatementComplete(ctx *sql.Context) error

StatementComplete implements the interface sql.TableEditor.

func (*ForeignKeyHandler) String 

func (n *ForeignKeyHandler) String() string

String implements the interface sql.Node.

func (*ForeignKeyHandler) Update 

func (n *ForeignKeyHandler) Update(ctx *sql.Context, old sql.Row, new sql.Row) error

Update implements the interface sql.RowUpdater.

func (*ForeignKeyHandler) Updater 

func (n *ForeignKeyHandler) Updater(ctx *sql.Context) sql.RowUpdater

Updater implements the interface sql.UpdatableTable.

func (*ForeignKeyHandler) WithChildren 

func (n *ForeignKeyHandler) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type ForeignKeyRefActionData 

type ForeignKeyRefActionData struct {
	RowMapper          *ForeignKeyRowMapper
	Editor             *ForeignKeyEditor
	ForeignKey         sql.ForeignKeyConstraint
	ChildParentMapping ChildParentMapping
}

ForeignKeyRefActionData contains the mapper, editor, and child to parent mapping for processing referential actions.

type ForeignKeyReferenceHandler 

type ForeignKeyReferenceHandler struct {
	ForeignKey sql.ForeignKeyConstraint
	RowMapper  ForeignKeyRowMapper
	SelfCols   map[string]int // SelfCols are used for self-referential fks to refer to a col position given a col name
}

ForeignKeyReferenceHandler handles references to any parent rows to verify they exist.

func (*ForeignKeyReferenceHandler) CheckReference 

func (reference *ForeignKeyReferenceHandler) CheckReference(ctx *sql.Context, row sql.Row) error

CheckReference checks that the given row has an index entry in the referenced table.

func (*ForeignKeyReferenceHandler) CheckTable 

func (reference *ForeignKeyReferenceHandler) CheckTable(ctx *sql.Context, tbl sql.ForeignKeyTable) error

CheckTable checks that every row in the table has an index entry in the referenced table.

func (*ForeignKeyReferenceHandler) IsInitialized 

func (reference *ForeignKeyReferenceHandler) IsInitialized() bool

IsInitialized returns whether this reference handler has been initialized.

type ForeignKeyRowMapper 

type ForeignKeyRowMapper struct {
	Index     sql.Index
	Updater   sql.ForeignKeyEditor
	SourceSch sql.Schema
	// IndexPositions hold the mapping between an index's column position and the source row's column position. Given
	// an index (x1, x2) and a source row (y1, y2, y3) and the relation (x1->y3, x2->y1), this slice would contain
	// [2, 0]. The first index column "x1" maps to the third source column "y3" (so position 2 since it's zero-based),
	// and the second index column "x2" maps to the first source column "y1" (position 0).
	IndexPositions []int
	// AppendTypes hold any types that may be needed to complete an index range's generation. Foreign keys are allowed
	// to use an index's prefix, and indexes expect ranges to reference all of their columns (not just the prefix), so
	// we grab the types of the suffix index columns to append to the range after the prefix columns that we're
	// referencing.
	AppendTypes []sql.Type
}

ForeignKeyRowMapper takes a source row and returns all matching rows on the contained table according to the row mapping from the source columns to the contained index's columns.

func (*ForeignKeyRowMapper) GetIter 

func (mapper *ForeignKeyRowMapper) GetIter(ctx *sql.Context, row sql.Row, refCheck bool) (sql.RowIter, error)

GetIter returns a row iterator for all rows that match the given source row.

func (*ForeignKeyRowMapper) GetKeyString 

func (mapper *ForeignKeyRowMapper) GetKeyString(row sql.Row) string

GetKeyString returns a string representing the key used to access the index.

func (*ForeignKeyRowMapper) IsInitialized 

func (mapper *ForeignKeyRowMapper) IsInitialized() bool

IsInitialized returns whether this mapper has been initialized.

type Grant 

type Grant struct {
	Privileges      []Privilege
	ObjectType      ObjectType
	PrivilegeLevel  PrivilegeLevel
	Users           []UserName
	WithGrantOption bool
	As              *GrantUserAssumption
	MySQLDb         sql.Database
	Catalog         *sql.Catalog
}

Grant represents the statement GRANT [privilege...] ON [item] TO [user...].

func (*Grant) CheckPrivileges 

func (n *Grant) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Grant) Children 

func (n *Grant) Children() []sql.Node

Children implements the interface sql.Node.

func (*Grant) CollationCoercibility 

func (*Grant) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Grant) Database 

func (n *Grant) Database() sql.Database

Database implements the interface sql.Databaser.

func (*Grant) HandleDatabasePrivileges 

func (n *Grant) HandleDatabasePrivileges(user *mysql_db.User, dbName string) error

HandleDatabasePrivileges handles giving a user their database privileges.

func (*Grant) HandleGlobalPrivileges 

func (n *Grant) HandleGlobalPrivileges(user *mysql_db.User) error

HandleGlobalPrivileges handles giving a user their global privileges.

func (*Grant) HandleRoutinePrivileges 

func (n *Grant) HandleRoutinePrivileges(user *mysql_db.User, dbName string, routineName string, isProcedureType bool) error

func (*Grant) HandleTablePrivileges 

func (n *Grant) HandleTablePrivileges(user *mysql_db.User, dbName string, tblName string) error

HandleTablePrivileges handles giving a user their table privileges.

func (*Grant) IsReadOnly 

func (n *Grant) IsReadOnly() bool

func (*Grant) Resolved 

func (n *Grant) Resolved() bool

Resolved implements the interface sql.Node.

func (*Grant) Schema 

func (n *Grant) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Grant) String 

func (n *Grant) String() string

String implements the interface sql.Node.

func (*Grant) WithChildren 

func (n *Grant) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Grant) WithDatabase 

func (n *Grant) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type GrantProxy 

type GrantProxy struct {
	On              UserName
	To              []UserName
	WithGrantOption bool
}

GrantProxy represents the statement GRANT PROXY.

func NewGrantProxy 

func NewGrantProxy(on UserName, to []UserName, withGrant bool) *GrantProxy

NewGrantProxy returns a new GrantProxy node.

func (*GrantProxy) CheckPrivileges 

func (n *GrantProxy) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*GrantProxy) Children 

func (n *GrantProxy) Children() []sql.Node

Children implements the interface sql.Node.

func (*GrantProxy) CollationCoercibility 

func (*GrantProxy) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*GrantProxy) IsReadOnly 

func (n *GrantProxy) IsReadOnly() bool

func (*GrantProxy) Resolved 

func (n *GrantProxy) Resolved() bool

Resolved implements the interface sql.Node.

func (*GrantProxy) Schema 

func (n *GrantProxy) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*GrantProxy) String 

func (n *GrantProxy) String() string

String implements the interface sql.Node.

func (*GrantProxy) WithChildren 

func (n *GrantProxy) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type GrantRole 

type GrantRole struct {
	Roles           []UserName
	TargetUsers     []UserName
	WithAdminOption bool
	MySQLDb         sql.Database
}

GrantRole represents the statement GRANT [role...] TO [user...].

func NewGrantRole 

func NewGrantRole(roles []UserName, users []UserName, withAdmin bool) *GrantRole

NewGrantRole returns a new GrantRole node.

func (*GrantRole) CheckPrivileges 

func (n *GrantRole) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*GrantRole) Children 

func (n *GrantRole) Children() []sql.Node

Children implements the interface sql.Node.

func (*GrantRole) CollationCoercibility 

func (*GrantRole) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*GrantRole) Database 

func (n *GrantRole) Database() sql.Database

Database implements the interface sql.Databaser.

func (*GrantRole) IsReadOnly 

func (n *GrantRole) IsReadOnly() bool

func (*GrantRole) Resolved 

func (n *GrantRole) Resolved() bool

Resolved implements the interface sql.Node.

func (*GrantRole) Schema 

func (n *GrantRole) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*GrantRole) String 

func (n *GrantRole) String() string

String implements the interface sql.Node.

func (*GrantRole) WithChildren 

func (n *GrantRole) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*GrantRole) WithDatabase 

func (n *GrantRole) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type GrantUserAssumption 

type GrantUserAssumption struct {
	Type  GrantUserAssumptionType
	User  UserName
	Roles []UserName
}

GrantUserAssumption represents the target user that the user executing the GRANT statement will assume the identity of.

type GrantUserAssumptionType 

type GrantUserAssumptionType byte

GrantUserAssumptionType is the assumption type that the user executing the GRANT statement will use. 

const (
	GrantUserAssumptionType_Default GrantUserAssumptionType = iota
	GrantUserAssumptionType_None
	GrantUserAssumptionType_All
	GrantUserAssumptionType_AllExcept
	GrantUserAssumptionType_Roles
)

type GroupBy 

type GroupBy struct {
	UnaryNode
	SelectedExprs []sql.Expression
	GroupByExprs  []sql.Expression
}

GroupBy groups the rows by some expressions.

func NewGroupBy 

func NewGroupBy(selectedExprs, groupByExprs []sql.Expression, child sql.Node) *GroupBy

NewGroupBy creates a new GroupBy node. Like Project, GroupBy is a top-level node, and contains all the fields that will appear in the output of the query. Some of these fields may be aggregate functions, some may be columns or other expressions. Unlike a project, the GroupBy also has a list of group-by expressions, which usually also appear in the list of selected expressions.

func (*GroupBy) CheckPrivileges 

func (g *GroupBy) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*GroupBy) CollationCoercibility 

func (g *GroupBy) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*GroupBy) DebugString 

func (g *GroupBy) DebugString() string

func (*GroupBy) Expressions 

func (g *GroupBy) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*GroupBy) IsReadOnly 

func (g *GroupBy) IsReadOnly() bool

func (*GroupBy) ProjectedExprs 

func (g *GroupBy) ProjectedExprs() []sql.Expression

ProjectedExprs implements the sql.Projector interface

func (*GroupBy) Resolved 

func (g *GroupBy) Resolved() bool

Resolved implements the Resolvable interface.

func (*GroupBy) Schema 

func (g *GroupBy) Schema() sql.Schema

Schema implements the Node interface.

func (*GroupBy) String 

func (g *GroupBy) String() string

func (*GroupBy) WithChildren 

func (g *GroupBy) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*GroupBy) WithExpressions 

func (g *GroupBy) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Node interface.

type HashLookup 

type HashLookup struct {
	UnaryNode
	RightEntryKey sql.Expression
	LeftProbeKey  sql.Expression
	Mutex         *sync.Mutex
	Lookup        *map[interface{}][]sql.Row
	JoinType      JoinType
}

func NewHashLookup 

func NewHashLookup(n sql.Node, rightEntryKey sql.Expression, leftProbeKey sql.Expression, joinType JoinType) *HashLookup

NewHashLookup returns a node that performs an indexed hash lookup of cached rows for fulfilling RowIter() calls. In particular, this node sits directly on top of a `CachedResults` node and has two expressions: a projection for hashing the Child row results and another projection for hashing the parent row values when performing a lookup. When RowIter is called, if cached results are available, it fulfills the RowIter call by performing a hash lookup on the projected results. If cached results are not available, it simply delegates to the child.

func (*HashLookup) CheckPrivileges 

func (n *HashLookup) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*HashLookup) CollationCoercibility 

func (n *HashLookup) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*HashLookup) DebugString 

func (n *HashLookup) DebugString() string

func (*HashLookup) Dispose 

func (n *HashLookup) Dispose()

func (*HashLookup) Expressions 

func (n *HashLookup) Expressions() []sql.Expression

func (*HashLookup) GetHashKey 

func (n *HashLookup) GetHashKey(ctx *sql.Context, e sql.Expression, row sql.Row) (interface{}, error)

Convert a tuple expression returning []interface{} into something comparable. Fast paths a few smaller slices into fixed size arrays, puts everything else through string serialization and a hash for now. It is OK to hash lossy here as the join condition is still evaluated after the matching rows are returned.

func (*HashLookup) IsReadOnly 

func (n *HashLookup) IsReadOnly() bool

func (*HashLookup) String 

func (n *HashLookup) String() string

func (*HashLookup) WithChildren 

func (n *HashLookup) WithChildren(children ...sql.Node) (sql.Node, error)

func (*HashLookup) WithExpressions 

func (n *HashLookup) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

type Having 

type Having struct {
	UnaryNode
	Cond sql.Expression
}

Having node is a filter that supports aggregate expressions. A having node is identical to a filter node in behaviour. The difference is that some analyzer rules work specifically on having clauses and not filters. For that reason, Having is a completely new node instead of using just filter.

func NewHaving 

func NewHaving(cond sql.Expression, child sql.Node) *Having

NewHaving creates a new having node.

func (*Having) CheckPrivileges 

func (h *Having) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Having) CollationCoercibility 

func (h *Having) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Having) DebugString 

func (h *Having) DebugString() string

func (*Having) Expressions 

func (h *Having) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*Having) IsReadOnly 

func (h *Having) IsReadOnly() bool

func (*Having) Resolved 

func (h *Having) Resolved() bool

Resolved implements the sql.Node interface.

func (*Having) String 

func (h *Having) String() string

func (*Having) WithChildren 

func (h *Having) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Having) WithExpressions 

func (h *Having) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type IfConditional 

type IfConditional struct {
	Condition sql.Expression
	Body      sql.Node
}

IfConditional represents IF statements only.

func NewIfConditional 

func NewIfConditional(condition sql.Expression, body sql.Node) *IfConditional

NewIfConditional creates a new *IfConditional node.

func (*IfConditional) CheckPrivileges 

func (ic *IfConditional) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*IfConditional) Children 

func (ic *IfConditional) Children() []sql.Node

Children implements the sql.Node interface.

func (*IfConditional) CollationCoercibility 

func (ic *IfConditional) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*IfConditional) DebugString 

func (ic *IfConditional) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*IfConditional) Expressions 

func (ic *IfConditional) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*IfConditional) IsReadOnly 

func (ic *IfConditional) IsReadOnly() bool

func (*IfConditional) Resolved 

func (ic *IfConditional) Resolved() bool

Resolved implements the sql.Node interface.

func (*IfConditional) Schema 

func (ic *IfConditional) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*IfConditional) String 

func (ic *IfConditional) String() string

String implements the sql.Node interface.

func (*IfConditional) WithChildren 

func (ic *IfConditional) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*IfConditional) WithExpressions 

func (ic *IfConditional) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type IfElseBlock 

type IfElseBlock struct {
	IfConditionals []*IfConditional
	Else           sql.Node
}

IfElseBlock represents IF/ELSE IF/ELSE statements.

func NewIfElse 

func NewIfElse(ifConditionals []*IfConditional, elseStatement sql.Node) *IfElseBlock

NewIfElse creates a new *IfElseBlock node.

func (*IfElseBlock) CheckPrivileges 

func (ieb *IfElseBlock) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*IfElseBlock) Children 

func (ieb *IfElseBlock) Children() []sql.Node

Children implements the sql.Node interface.

func (*IfElseBlock) CollationCoercibility 

func (ieb *IfElseBlock) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*IfElseBlock) DebugString 

func (ieb *IfElseBlock) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*IfElseBlock) IsReadOnly 

func (ieb *IfElseBlock) IsReadOnly() bool

func (*IfElseBlock) Resolved 

func (ieb *IfElseBlock) Resolved() bool

Resolved implements the sql.Node interface.

func (*IfElseBlock) Schema 

func (ieb *IfElseBlock) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*IfElseBlock) String 

func (ieb *IfElseBlock) String() string

String implements the sql.Node interface.

func (*IfElseBlock) WithChildren 

func (ieb *IfElseBlock) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type InSubquery 

type InSubquery struct {
	expression.BinaryExpressionStub
}

InSubquery is an expression that checks an expression is in the result of a subquery. It's in the plan package, instead of the expression package, because Subquery is itself in the plan package (because it functions more like a plan node than an expression in its evaluation).

func NewInSubquery 

func NewInSubquery(left sql.Expression, right sql.Expression) *InSubquery

NewInSubquery creates an InSubquery expression.

func (*InSubquery) Children 

func (in *InSubquery) Children() []sql.Expression

Children implements the Expression interface.

func (*InSubquery) CollationCoercibility 

func (*InSubquery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*InSubquery) DebugString 

func (in *InSubquery) DebugString() string

DebugString implements the sql.DebugStringer interface

func (*InSubquery) Describe 

func (in *InSubquery) Describe(options sql.DescribeOptions) string

Describe implements the sql.Describable interface

func (*InSubquery) Dispose 

func (in *InSubquery) Dispose()

Dispose implements sql.Disposable

func (*InSubquery) Eval 

func (in *InSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

Eval implements the Expression interface.

func (*InSubquery) String 

func (in *InSubquery) String() string

String implements the fmt.Stringer interface

func (*InSubquery) Type 

func (in *InSubquery) Type() sql.Type

Type implements sql.Expression

func (*InSubquery) WithChildren 

func (in *InSubquery) WithChildren(children ...sql.Expression) (sql.Expression, error)

WithChildren implements the Expression interface.

type IndexAction 

type IndexAction byte
const (
	IndexAction_Create IndexAction = iota
	IndexAction_Drop
	IndexAction_Rename
	IndexAction_DisableEnableKeys
)

type IndexedTableAccess 

type IndexedTableAccess struct {
	TableNode sql.TableNode

	Table sql.IndexedTable
	Typ   itaType
	// contains filtered or unexported fields
}

IndexedTableAccess represents an indexed lookup of a particular plan.TableNode. The values for the key used to access the indexed table is provided in RowIter(), or during static analysis.

func NewIndexedAccessForTableNode 

func NewIndexedAccessForTableNode(node sql.TableNode, lb *LookupBuilder) (*IndexedTableAccess, error)

NewIndexedAccessForTableNode creates an IndexedTableAccess node if the resolved table embeds an IndexAddressableTable, otherwise returns an error.

func NewStaticIndexedAccessForFullTextTable 

func NewStaticIndexedAccessForFullTextTable(node sql.TableNode, lookup sql.IndexLookup, ftTable sql.IndexedTable) *IndexedTableAccess

NewStaticIndexedAccessForFullTextTable creates an IndexedTableAccess node for Full-Text tables, which have a different behavior compared to other indexed tables.

func NewStaticIndexedAccessForTableNode 

func NewStaticIndexedAccessForTableNode(node sql.TableNode, lookup sql.IndexLookup) (*IndexedTableAccess, error)

NewStaticIndexedAccessForTableNode creates an IndexedTableAccess node if the resolved table embeds an IndexAddressableTable, otherwise returns an error.

func (*IndexedTableAccess) CanBuildIndex 

func (i *IndexedTableAccess) CanBuildIndex(ctx *sql.Context) (bool, error)

CanBuildIndex returns whether an index lookup on this table can be successfully built for a zero-valued key. For a static lookup, no lookup needs to be built, so returns true.

func (*IndexedTableAccess) CheckPrivileges 

func (i *IndexedTableAccess) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*IndexedTableAccess) Children 

func (i *IndexedTableAccess) Children() []sql.Node

func (*IndexedTableAccess) Collation 

func (i *IndexedTableAccess) Collation() sql.CollationID

func (*IndexedTableAccess) CollationCoercibility 

func (i *IndexedTableAccess) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*IndexedTableAccess) Columns 

func (i *IndexedTableAccess) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*IndexedTableAccess) Comment 

func (i *IndexedTableAccess) Comment() string

func (*IndexedTableAccess) Database 

func (i *IndexedTableAccess) Database() sql.Database

func (*IndexedTableAccess) DebugString 

func (i *IndexedTableAccess) DebugString() string

func (*IndexedTableAccess) Expressions 

func (i *IndexedTableAccess) Expressions() []sql.Expression

Expressions implements sql.Expressioner

func (*IndexedTableAccess) GetLookup 

func (i *IndexedTableAccess) GetLookup(ctx *sql.Context, row sql.Row) (sql.IndexLookup, error)

func (*IndexedTableAccess) Id 

func (i *IndexedTableAccess) Id() sql.TableId

Id implements sql.TableIdNode

func (*IndexedTableAccess) Index 

func (i *IndexedTableAccess) Index() sql.Index

func (*IndexedTableAccess) IsReadOnly 

func (i *IndexedTableAccess) IsReadOnly() bool

func (*IndexedTableAccess) IsStatic 

func (i *IndexedTableAccess) IsStatic() bool

func (*IndexedTableAccess) Name 

func (i *IndexedTableAccess) Name() string

func (*IndexedTableAccess) NullMask 

func (i *IndexedTableAccess) NullMask() []bool

func (*IndexedTableAccess) PartitionRows 

func (i *IndexedTableAccess) PartitionRows(ctx *sql.Context, partition sql.Partition) (sql.RowIter, error)

PartitionRows implements sql.Table

func (*IndexedTableAccess) Partitions 

func (i *IndexedTableAccess) Partitions(ctx *sql.Context) (sql.PartitionIter, error)

Partitions implements sql.Table

func (*IndexedTableAccess) Resolved 

func (i *IndexedTableAccess) Resolved() bool

func (*IndexedTableAccess) Schema 

func (i *IndexedTableAccess) Schema() sql.Schema

func (*IndexedTableAccess) String 

func (i *IndexedTableAccess) String() string

func (*IndexedTableAccess) UnderlyingTable 

func (i *IndexedTableAccess) UnderlyingTable() sql.Table

func (*IndexedTableAccess) WithChildren 

func (i *IndexedTableAccess) WithChildren(children ...sql.Node) (sql.Node, error)

func (*IndexedTableAccess) WithColumns 

func (i *IndexedTableAccess) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*IndexedTableAccess) WithDatabase 

func (i *IndexedTableAccess) WithDatabase(database sql.Database) (sql.Node, error)

func (*IndexedTableAccess) WithExpressions 

func (i *IndexedTableAccess) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements sql.Expressioner

func (*IndexedTableAccess) WithId 

func (i *IndexedTableAccess) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*IndexedTableAccess) WithName 

func (i *IndexedTableAccess) WithName(s string) sql.Node

func (IndexedTableAccess) WithTable 

func (i IndexedTableAccess) WithTable(table sql.IndexedTable) (sql.Node, error)

type InsertDestination 

type InsertDestination struct {
	UnaryNode
	DestinationName string
	Sch             sql.Schema
}

InsertDestination is a wrapper for a table to be used with InsertInto.Destination that allows the schema to be overridden. This is useful when the table in question has late-resolving column defaults.

func NewInsertDestination 

func NewInsertDestination(schema sql.Schema, node sql.Node) *InsertDestination

func (*InsertDestination) CheckPrivileges 

func (id *InsertDestination) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*InsertDestination) CollationCoercibility 

func (id *InsertDestination) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*InsertDestination) DebugString 

func (id *InsertDestination) DebugString() string

func (*InsertDestination) Expressions 

func (id *InsertDestination) Expressions() []sql.Expression

func (*InsertDestination) IsReadOnly 

func (id *InsertDestination) IsReadOnly() bool

func (*InsertDestination) Name 

func (id *InsertDestination) Name() string

func (*InsertDestination) Resolved 

func (id *InsertDestination) Resolved() bool

func (*InsertDestination) Schema 

func (id *InsertDestination) Schema() sql.Schema

func (*InsertDestination) String 

func (id *InsertDestination) String() string

func (InsertDestination) WithChildren 

func (id InsertDestination) WithChildren(children ...sql.Node) (sql.Node, error)

func (InsertDestination) WithExpressions 

func (id InsertDestination) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

type InsertInto 

type InsertInto struct {
	Destination           sql.Node
	Source                sql.Node
	ColumnNames           []string
	IsReplace             bool
	HasUnspecifiedAutoInc bool
	OnDupExprs            []sql.Expression

	Ignore bool
	// contains filtered or unexported fields
}

InsertInto is the top level node for INSERT INTO statements. It has a source for rows and a destination to insert them into.

func NewInsertInto 

func NewInsertInto(db sql.Database, dst, src sql.Node, isReplace bool, cols []string, onDupExprs []sql.Expression, ignore bool) *InsertInto

NewInsertInto creates an InsertInto node.

func (*InsertInto) CheckPrivileges 

func (ii *InsertInto) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*InsertInto) Checks 

func (ii *InsertInto) Checks() sql.CheckConstraints

func (*InsertInto) Children 

func (ii *InsertInto) Children() []sql.Node

func (*InsertInto) CollationCoercibility 

func (*InsertInto) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*InsertInto) Database 

func (ii *InsertInto) Database() sql.Database

func (InsertInto) DebugString 

func (ii InsertInto) DebugString() string

func (*InsertInto) DisjointedChildren 

func (ii *InsertInto) DisjointedChildren() [][]sql.Node

DisjointedChildren implements the interface DisjointedChildrenNode.

func (*InsertInto) Dispose 

func (ii *InsertInto) Dispose()

func (*InsertInto) Expressions 

func (ii *InsertInto) Expressions() []sql.Expression

func (*InsertInto) IsReadOnly 

func (ii *InsertInto) IsReadOnly() bool

func (*InsertInto) Resolved 

func (ii *InsertInto) Resolved() bool

Resolved implements the Resolvable interface.

func (*InsertInto) Schema 

func (ii *InsertInto) Schema() sql.Schema

Schema implements the sql.Node interface. Insert nodes return rows that are inserted. Replaces return a concatenation of the deleted row and the inserted row. If no row was deleted, the value of those columns is nil.

func (InsertInto) String 

func (ii InsertInto) String() string

func (*InsertInto) WithChecks 

func (ii *InsertInto) WithChecks(checks sql.CheckConstraints) sql.Node

func (*InsertInto) WithChildren 

func (ii *InsertInto) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (InsertInto) WithColumnNames 

func (ii InsertInto) WithColumnNames(cols []string) *InsertInto

func (*InsertInto) WithDatabase 

func (ii *InsertInto) WithDatabase(database sql.Database) (sql.Node, error)

func (*InsertInto) WithDisjointedChildren 

func (ii *InsertInto) WithDisjointedChildren(children [][]sql.Node) (sql.Node, error)

WithDisjointedChildren implements the interface DisjointedChildrenNode.

func (InsertInto) WithExpressions 

func (ii InsertInto) WithExpressions(newExprs ...sql.Expression) (sql.Node, error)

func (*InsertInto) WithSource 

func (ii *InsertInto) WithSource(src sql.Node) *InsertInto

WithSource sets the source node for this insert, which is analyzed separately

func (*InsertInto) WithUnspecifiedAutoIncrement 

func (ii *InsertInto) WithUnspecifiedAutoIncrement(unspecifiedAutoIncrement bool) *InsertInto

WithUnspecifiedAutoIncrement sets the unspecified auto increment flag for this insert operation. Inserts with this property set the LAST_INSERT_ID session variable, whereas inserts that manually specify values for an auto-insert column do not.

type Into 

type Into struct {
	UnaryNode
	IntoVars []sql.Expression
	Dumpfile string
	Outfile  string

	Charset string

	FieldsTerminatedBy  string
	FieldsEnclosedBy    string
	FieldsEnclosedByOpt bool
	FieldsEscapedBy     string

	LinesStartingBy   string
	LinesTerminatedBy string
}

Into is a node to wrap the top-level node in a query plan so that any result will set user-defined or others variables given

func NewInto 

func NewInto(
	child sql.Node,
	variables []sql.Expression,
	outfile, dumpfile string) *Into

func (*Into) CheckPrivileges 

func (i *Into) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Into) CollationCoercibility 

func (i *Into) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Into) DebugString 

func (i *Into) DebugString() string

func (*Into) Expressions 

func (i *Into) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*Into) IsReadOnly 

func (i *Into) IsReadOnly() bool

func (*Into) Schema 

func (i *Into) Schema() sql.Schema

Schema implements the Node interface.

func (*Into) String 

func (i *Into) String() string

func (*Into) WithChildren 

func (i *Into) WithChildren(children ...sql.Node) (sql.Node, error)

func (*Into) WithExpressions 

func (i *Into) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type Iterate 

type Iterate struct {
	Label string
}

Iterate represents the ITERATE statement, which instructs a loop to continue to the next iteration. Equivalent to "continue" in Go.

func NewIterate 

func NewIterate(label string) *Iterate

NewIterate returns a new *Iterate node.

func (*Iterate) CheckPrivileges 

func (i *Iterate) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Iterate) Children 

func (i *Iterate) Children() []sql.Node

Children implements the interface sql.Node.

func (*Iterate) CollationCoercibility 

func (*Iterate) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Iterate) IsReadOnly 

func (i *Iterate) IsReadOnly() bool

func (*Iterate) Resolved 

func (i *Iterate) Resolved() bool

Resolved implements the interface sql.Node.

func (*Iterate) Schema 

func (i *Iterate) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Iterate) String 

func (i *Iterate) String() string

String implements the interface sql.Node.

func (*Iterate) WithChildren 

func (i *Iterate) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type JSONTable 

type JSONTable struct {
	DataExpr  sql.Expression
	TableName string
	RootPath  string
	Cols      []JSONTableCol
	// contains filtered or unexported fields
}

func NewJSONTable 

func NewJSONTable(dataExpr sql.Expression, path string, alias string, cols []JSONTableCol) (*JSONTable, error)

NewJSONTable creates a new in memory table from the JSON formatted data, a jsonpath path string, and table spec.

func (*JSONTable) CheckPrivileges 

func (t *JSONTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the sql.Node interface

func (*JSONTable) Children 

func (t *JSONTable) Children() []sql.Node

Children implements the sql.Node interface

func (*JSONTable) Collation 

func (t *JSONTable) Collation() sql.CollationID

Collation implements the sql.Table interface

func (*JSONTable) CollationCoercibility 

func (*JSONTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*JSONTable) Columns 

func (t *JSONTable) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*JSONTable) DebugString 

func (t *JSONTable) DebugString() string

DebugString implements the sql.Table interface

func (*JSONTable) Expressions 

func (t *JSONTable) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface

func (*JSONTable) FlattenSchema 

func (t *JSONTable) FlattenSchema(cols []JSONTableCol) sql.Schema

FlattenSchema returns the flattened schema of a JSONTableCol

func (*JSONTable) Id 

func (t *JSONTable) Id() sql.TableId

Id implements sql.TableIdNode

func (*JSONTable) IsReadOnly 

func (t *JSONTable) IsReadOnly() bool

func (*JSONTable) Name 

func (t *JSONTable) Name() string

Name implements the sql.Table interface

func (*JSONTable) PartitionRows 

func (t *JSONTable) PartitionRows(ctx *sql.Context, partition sql.Partition) (sql.RowIter, error)

PartitionRows implements the sql.Table interface

func (*JSONTable) Partitions 

func (t *JSONTable) Partitions(ctx *sql.Context) (sql.PartitionIter, error)

Partitions implements the sql.Table interface

func (*JSONTable) Resolved 

func (t *JSONTable) Resolved() bool

Resolved implements the sql.Resolvable interface

func (*JSONTable) Schema 

func (t *JSONTable) Schema() sql.Schema

Schema implements the sql.Table interface

func (*JSONTable) String 

func (t *JSONTable) String() string

String implements the sql.Table interface

func (*JSONTable) WithChildren 

func (t *JSONTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface

func (*JSONTable) WithColumns 

func (t *JSONTable) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*JSONTable) WithExpressions 

func (t *JSONTable) WithExpressions(expression ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface

func (*JSONTable) WithId 

func (t *JSONTable) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*JSONTable) WithName 

func (t *JSONTable) WithName(s string) sql.Node

type JSONTableCol 

type JSONTableCol struct {
	Path       string
	Opts       *JSONTableColOpts
	NestedCols []JSONTableCol
}

func (*JSONTableCol) Expressions 

func (c *JSONTableCol) Expressions() []sql.Expression

func (*JSONTableCol) Resolved 

func (c *JSONTableCol) Resolved() bool

func (*JSONTableCol) WithExpressions 

func (c *JSONTableCol) WithExpressions(exprs []sql.Expression, idx *int) error

type JSONTableColOpts 

type JSONTableColOpts struct {
	Name         string
	Type         sql.Type
	ForOrd       bool
	Exists       bool
	DefEmptyVal  sql.Expression
	DefErrorVal  sql.Expression
	ErrorOnError bool
	ErrorOnEmpty bool
}

type JoinNode 

type JoinNode struct {
	BinaryNode
	sql.DescribeStats
	Filter     sql.Expression
	Op         JoinType
	CommentStr string
	ScopeLen   int
	UsingCols  []string
}

JoinNode contains all the common data fields and implements the common sql.Node getters for all join types.

func NewAntiJoin 

func NewAntiJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewCrossJoin 

func NewCrossJoin(left, right sql.Node) *JoinNode

func NewFullOuterJoin 

func NewFullOuterJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewHashJoin 

func NewHashJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewInnerJoin 

func NewInnerJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewJoin 

func NewJoin(left, right sql.Node, op JoinType, cond sql.Expression) *JoinNode

func NewLeftOuterHashJoin 

func NewLeftOuterHashJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewLeftOuterJoin 

func NewLeftOuterJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewLeftOuterLookupJoin 

func NewLeftOuterLookupJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewLookupJoin 

func NewLookupJoin(left, right sql.Node, cond sql.Expression) *JoinNode

An LookupJoin is a join that uses index lookups for the secondary table.

func NewNaturalJoin 

func NewNaturalJoin(left, right sql.Node) *JoinNode

NaturalJoin is a join that automatically joins by all the columns with the same name. NaturalJoin is a placeholder node, it should be transformed into an INNER JOIN during analysis.

func NewRightOuterJoin 

func NewRightOuterJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewSemiJoin 

func NewSemiJoin(left, right sql.Node, cond sql.Expression) *JoinNode

func NewUsingJoin 

func NewUsingJoin(left, right sql.Node, op JoinType, cols []string) *JoinNode

NewUsingJoin creates a UsingJoin that joins on the specified columns with the same name. This is a placeholder node, and should be transformed into the appropriate join during analysis.

func (*JoinNode) CheckPrivileges 

func (j *JoinNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*JoinNode) CollationCoercibility 

func (*JoinNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*JoinNode) Comment 

func (j *JoinNode) Comment() string

Comment implements sql.CommentedNode

func (*JoinNode) DebugString 

func (j *JoinNode) DebugString() string

DebugString implements sql.DebugStringer

func (*JoinNode) Describe 

func (j *JoinNode) Describe(options sql.DescribeOptions) string

Describe implements sql.Describable

func (*JoinNode) Expressions 

func (j *JoinNode) Expressions() []sql.Expression

Expressions implements sql.Expression

func (*JoinNode) IsReadOnly 

func (j *JoinNode) IsReadOnly() bool

func (*JoinNode) JoinCond 

func (j *JoinNode) JoinCond() sql.Expression

func (*JoinNode) JoinType 

func (j *JoinNode) JoinType() JoinType

func (*JoinNode) Resolved 

func (j *JoinNode) Resolved() bool

Resolved implements the Resolvable interface.

func (*JoinNode) Schema 

func (j *JoinNode) Schema() sql.Schema

Schema implements the Node interface.

func (*JoinNode) String 

func (j *JoinNode) String() string

String implements fmt.Stringer

func (*JoinNode) WithChildren 

func (j *JoinNode) WithChildren(children ...sql.Node) (sql.Node, error)

func (*JoinNode) WithComment 

func (j *JoinNode) WithComment(comment string) sql.Node

WithComment implements sql.CommentedNode

func (*JoinNode) WithExpressions 

func (j *JoinNode) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*JoinNode) WithScopeLen 

func (j *JoinNode) WithScopeLen(i int) *JoinNode

type JoinType 

type JoinType uint16
const (
	JoinTypeUnknown                   JoinType = iota // UnknownJoin
	JoinTypeCross                                     // CrossJoin
	JoinTypeCrossHash                                 // CrossHashJoin
	JoinTypeInner                                     // InnerJoin
	JoinTypeSemi                                      // SemiJoin
	JoinTypeAnti                                      // AntiJoin
	JoinTypeLeftOuter                                 // LeftOuterJoin
	JoinTypeLeftOuterExcludeNulls                     // LeftOuterJoinExcludingNulls
	JoinTypeFullOuter                                 // FullOuterJoin
	JoinTypeGroupBy                                   // GroupByJoin
	JoinTypeRightOuter                                // RightJoin
	JoinTypeLookup                                    // LookupJoin
	JoinTypeLeftOuterLookup                           // LeftOuterLookupJoin
	JoinTypeHash                                      // HashJoin
	JoinTypeLeftOuterHash                             // LeftOuterHashJoin
	JoinTypeLeftOuterHashExcludeNulls                 // LeftOuterHashJoinExcludeNulls
	JoinTypeMerge                                     // MergeJoin
	JoinTypeLeftOuterMerge                            // LeftOuterMergeJoin
	JoinTypeRangeHeap                                 // RangeHeapJoin
	JoinTypeLeftOuterRangeHeap                        // LeftOuterRangeHeapJoin
	JoinTypeSemiHash                                  // SemiHashJoin
	JoinTypeAntiHash                                  // AntiHashJoin
	JoinTypeSemiLookup                                // SemiLookupJoin
	JoinTypeAntiLookup                                // AntiLookupJoin
	JoinTypeSemiMerge                                 // SemiMergeJoin
	JoinTypeAntiMerge                                 // AntiMergeJoin
	JoinTypeUsing                                     // NaturalJoin
	JoinTypeUsingLeft                                 // NaturalLeftJoin
	JoinTypeUsingRight                                // NaturalRightJoin

	// TODO: might be able to merge these with their respective join types
	JoinTypeLateralCross // LateralCrossJoin
	JoinTypeLateralInner // LateralInnerJoin
	JoinTypeLateralLeft  // LateralLeftJoin
	JoinTypeLateralRight // LateralLeftJoin
)

func (JoinType) AsHash 

func (i JoinType) AsHash() JoinType

func (JoinType) AsLateral 

func (i JoinType) AsLateral() JoinType

func (JoinType) AsLookup 

func (i JoinType) AsLookup() JoinType

func (JoinType) AsMerge 

func (i JoinType) AsMerge() JoinType

func (JoinType) AsRangeHeap 

func (i JoinType) AsRangeHeap() JoinType

func (JoinType) IsAnti 

func (i JoinType) IsAnti() bool

func (JoinType) IsCross 

func (i JoinType) IsCross() bool

func (JoinType) IsDegenerate 

func (i JoinType) IsDegenerate() bool

func (JoinType) IsExcludeNulls 

func (i JoinType) IsExcludeNulls() bool

IsExcludeNulls returns whether a join operation has the behavior that if a condition evaluates to NULL, that row is excluded from the result table.

func (JoinType) IsFullOuter 

func (i JoinType) IsFullOuter() bool

func (JoinType) IsHash 

func (i JoinType) IsHash() bool

func (JoinType) IsInner 

func (i JoinType) IsInner() bool

func (JoinType) IsLateral 

func (i JoinType) IsLateral() bool

func (JoinType) IsLeftOuter 

func (i JoinType) IsLeftOuter() bool

func (JoinType) IsLookup 

func (i JoinType) IsLookup() bool

func (JoinType) IsMerge 

func (i JoinType) IsMerge() bool

func (JoinType) IsPartial 

func (i JoinType) IsPartial() bool

func (JoinType) IsPhysical 

func (i JoinType) IsPhysical() bool

func (JoinType) IsPlaceholder 

func (i JoinType) IsPlaceholder() bool

func (JoinType) IsRange 

func (i JoinType) IsRange() bool

func (JoinType) IsRightOuter 

func (i JoinType) IsRightOuter() bool

func (JoinType) IsSemi 

func (i JoinType) IsSemi() bool

func (JoinType) IsUsing 

func (i JoinType) IsUsing() bool

func (JoinType) String 

func (i JoinType) String() string

type Kill 

type Kill struct {
	Kt     KillType
	ConnID uint32
}

func NewKill 

func NewKill(kt KillType, connID uint32) *Kill

func (*Kill) CheckPrivileges 

func (k *Kill) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Kill) Children 

func (k *Kill) Children() []sql.Node

func (*Kill) CollationCoercibility 

func (*Kill) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Kill) IsReadOnly 

func (k *Kill) IsReadOnly() bool

func (*Kill) Resolved 

func (k *Kill) Resolved() bool

func (*Kill) Schema 

func (k *Kill) Schema() sql.Schema

func (*Kill) String 

func (k *Kill) String() string

func (*Kill) WithChildren 

func (k *Kill) WithChildren(children ...sql.Node) (sql.Node, error)

type KillType 

type KillType int
const (
	KillType_Query      KillType = 0
	KillType_Connection KillType = 1
)

func (KillType) String 

func (kt KillType) String() string

type Leave 

type Leave struct {
	Label string
}

Leave represents the LEAVE statement, which instructs a loop to end. Equivalent to "break" in Go.

func NewLeave 

func NewLeave(label string) *Leave

NewLeave returns a new *Leave node.

func (*Leave) CheckPrivileges 

func (l *Leave) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Leave) Children 

func (l *Leave) Children() []sql.Node

Children implements the interface sql.Node.

func (*Leave) CollationCoercibility 

func (*Leave) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Leave) IsReadOnly 

func (l *Leave) IsReadOnly() bool

func (*Leave) Resolved 

func (l *Leave) Resolved() bool

Resolved implements the interface sql.Node.

func (*Leave) Schema 

func (l *Leave) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Leave) String 

func (l *Leave) String() string

String implements the interface sql.Node.

func (*Leave) WithChildren 

func (l *Leave) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type Limit 

type Limit struct {
	UnaryNode
	Limit         sql.Expression
	CalcFoundRows bool
}

Limit is a node that only allows up to N rows to be retrieved.

func NewLimit 

func NewLimit(size sql.Expression, child sql.Node) *Limit

NewLimit creates a new Limit node with the given size.

func (*Limit) CheckPrivileges 

func (l *Limit) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Limit) CollationCoercibility 

func (l *Limit) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Limit) DebugString 

func (l Limit) DebugString() string

func (*Limit) Expressions 

func (l *Limit) Expressions() []sql.Expression

Expressions implements sql.Expressioner

func (Limit) IsReadOnly 

func (l Limit) IsReadOnly() bool

func (*Limit) Resolved 

func (l *Limit) Resolved() bool

Resolved implements the Resolvable interface.

func (Limit) String 

func (l Limit) String() string

func (Limit) WithCalcFoundRows 

func (l Limit) WithCalcFoundRows(v bool) *Limit

func (*Limit) WithChildren 

func (l *Limit) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (Limit) WithExpressions 

func (l Limit) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements sql.Expressioner

type LoadData 

type LoadData struct {
	Local              bool
	File               string
	DestSch            sql.Schema
	ColumnNames        []string
	ResponsePacketSent bool
	IgnoreNum          int64
	IsIgnore           bool
	IsReplace          bool

	Charset string

	FieldsTerminatedBy  string
	FieldsEnclosedBy    string
	FieldsEnclosedByOpt bool
	FieldsEscapedBy     string

	LinesStartingBy   string
	LinesTerminatedBy string
}

func NewLoadData 

func NewLoadData(local bool, file string, destSch sql.Schema, cols []string, ignoreNum int64, ignoreOrReplace string) *LoadData

func (*LoadData) CheckPrivileges 

func (l *LoadData) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*LoadData) Children 

func (l *LoadData) Children() []sql.Node

func (*LoadData) CollationCoercibility 

func (*LoadData) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*LoadData) IsReadOnly 

func (l *LoadData) IsReadOnly() bool

func (*LoadData) Resolved 

func (l *LoadData) Resolved() bool

func (*LoadData) Schema 

func (l *LoadData) Schema() sql.Schema

func (*LoadData) SplitLines 

func (l *LoadData) SplitLines(data []byte, atEOF bool) (advance int, token []byte, err error)

func (*LoadData) String 

func (l *LoadData) String() string

func (*LoadData) WithChildren 

func (l *LoadData) WithChildren(children ...sql.Node) (sql.Node, error)

type LockTables 

type LockTables struct {
	Catalog sql.Catalog
	Locks   []*TableLock
}

LockTables will lock tables for the session in which it's executed.

func NewLockTables 

func NewLockTables(locks []*TableLock) *LockTables

NewLockTables creates a new LockTables node.

func (*LockTables) CheckPrivileges 

func (t *LockTables) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*LockTables) Children 

func (t *LockTables) Children() []sql.Node

Children implements the sql.Node interface.

func (*LockTables) CollationCoercibility 

func (*LockTables) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*LockTables) IsReadOnly 

func (t *LockTables) IsReadOnly() bool

MySQL allows these against read-only servers.

func (*LockTables) Resolved 

func (t *LockTables) Resolved() bool

Resolved implements the sql.Node interface.

func (*LockTables) Schema 

func (t *LockTables) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*LockTables) String 

func (t *LockTables) String() string

func (*LockTables) WithChildren 

func (t *LockTables) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type LookupBuilder 

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

LookupBuilder abstracts secondary table access for an LookupJoin. A row from the primary table is first evaluated on the secondary index's expressions (columns) to produce a lookupBuilderKey. Consider the query below, assuming B has an index `xy (x,y)`:

select * from A join B on a.x = b.x AND a.y = b.y

Assume we choose A as the primary row source and B as a secondary lookup on `xy`. For every row in A, we will produce a lookupBuilderKey on B using the join condition. For the A row (x=1,y=2), the lookup key into B will be (1,2) to reflect the B-xy index access.

Then we construct a sql.RangeCollection to represent the (1,2) point lookup into B-xy. The collection will always be a single range, because a point lookup cannot be a disjoint set of ranges. The range will also have the same dimension as the index itself. If the join condition is a partial prefix on the index (ex: INDEX x (x)), the unfiltered columns are padded.

The <=> filter is a special case for two reasons. 1) It is not a point lookup, the corresponding range will either be IsNull or IsNotNull depending on whether the primary row key column is nil or not, respectfully. 2) The format of the output range is variable, while equality ranges are identical except for bound values.

Currently the analyzer constructs one of these and uses it for the IndexedTableAccess nodes below an indexed join, for example. This struct is also used to implement Expressioner on the IndexedTableAccess node.

func NewLookupBuilder 

func NewLookupBuilder(index sql.Index, keyExprs []sql.Expression, matchesNullMask []bool) *LookupBuilder

func (*LookupBuilder) DebugString 

func (lb *LookupBuilder) DebugString() string

func (*LookupBuilder) Expressions 

func (lb *LookupBuilder) Expressions() []sql.Expression

func (*LookupBuilder) GetKey 

func (lb *LookupBuilder) GetKey(ctx *sql.Context, row sql.Row) (lookupBuilderKey, error)

func (*LookupBuilder) GetKey2 

func (lb *LookupBuilder) GetKey2(ctx *sql.Context, row sql.Row2) (lookupBuilderKey, error)

func (*LookupBuilder) GetLookup 

func (lb *LookupBuilder) GetLookup(key lookupBuilderKey) (sql.IndexLookup, error)

func (*LookupBuilder) GetZeroKey 

func (lb *LookupBuilder) GetZeroKey() lookupBuilderKey

func (*LookupBuilder) Index 

func (lb *LookupBuilder) Index() sql.Index

func (*LookupBuilder) WithExpressions 

func (lb *LookupBuilder) WithExpressions(node sql.Node, exprs ...sql.Expression) (*LookupBuilder, error)

type Loop 

type Loop struct {
	Label          string
	Condition      sql.Expression // We continue looping until the condition returns false
	OnceBeforeEval bool           // Whether to run through the statements first before evaluating the condition
	*Block
}

Loop represents the LOOP statement, which loops over a set of statements.

func NewLoop 

func NewLoop(label string, block *Block) *Loop

NewLoop returns a new *Loop node.

func (*Loop) CheckPrivileges 

func (l *Loop) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Loop) CollationCoercibility 

func (l *Loop) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Loop) DebugString 

func (l *Loop) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*Loop) Expressions 

func (l *Loop) Expressions() []sql.Expression

Expressions implements the interface sql.Node.

func (*Loop) GetBlockLabel 

func (l *Loop) GetBlockLabel(ctx *sql.Context) string

GetBlockLabel implements the interface RepresentsLabeledBlock.

func (*Loop) RepresentsLoop 

func (l *Loop) RepresentsLoop() bool

RepresentsLoop implements the interface RepresentsLabeledBlock.

func (*Loop) Resolved 

func (l *Loop) Resolved() bool

Resolved implements the interface sql.Node.

func (*Loop) String 

func (l *Loop) String() string

String implements the interface sql.Node.

func (*Loop) WithChildren 

func (l *Loop) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Loop) WithExpressions 

func (l *Loop) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the interface sql.Node.

type Max1Row 

type Max1Row struct {
	Child sql.Node

	Result      sql.Row
	Mu          *sync.Mutex
	EmptyResult bool
	// contains filtered or unexported fields
}

Max1Row throws a runtime error if its child (usually subquery) tries to return more than one row.

func NewMax1Row 

func NewMax1Row(n sql.Node, name string) *Max1Row

func (*Max1Row) CheckPrivileges 

func (m *Max1Row) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*Max1Row) Children 

func (m *Max1Row) Children() []sql.Node

func (*Max1Row) CollationCoercibility 

func (m *Max1Row) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Max1Row) DebugString 

func (m *Max1Row) DebugString() string

func (*Max1Row) HasResults 

func (m *Max1Row) HasResults() bool

HasResults returns true after a successful call to PopulateResults()

func (*Max1Row) IsReadOnly 

func (m *Max1Row) IsReadOnly() bool

func (*Max1Row) Name 

func (m *Max1Row) Name() string

func (*Max1Row) Resolved 

func (m *Max1Row) Resolved() bool

func (*Max1Row) Schema 

func (m *Max1Row) Schema() sql.Schema

func (*Max1Row) String 

func (m *Max1Row) String() string

func (*Max1Row) WithChildren 

func (m *Max1Row) WithChildren(children ...sql.Node) (sql.Node, error)

func (*Max1Row) WithName 

func (m *Max1Row) WithName(s string) sql.Node

type ModifyColumn 

type ModifyColumn struct {
	Table sql.Node
	// contains filtered or unexported fields
}

func NewModifyColumn 

func NewModifyColumn(database sql.Database, table *UnresolvedTable, columnName string, column *sql.Column, order *sql.ColumnOrder) *ModifyColumn

func NewModifyColumnResolved 

func NewModifyColumnResolved(table *ResolvedTable, columnName string, column sql.Column, order *sql.ColumnOrder) *ModifyColumn

func (*ModifyColumn) CheckPrivileges 

func (m *ModifyColumn) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ModifyColumn) Children 

func (m *ModifyColumn) Children() []sql.Node

func (*ModifyColumn) CollationCoercibility 

func (*ModifyColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ModifyColumn) Column 

func (m *ModifyColumn) Column() string

func (*ModifyColumn) Database 

func (c *ModifyColumn) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ModifyColumn) Expressions 

func (m *ModifyColumn) Expressions() []sql.Expression

func (*ModifyColumn) IsReadOnly 

func (m *ModifyColumn) IsReadOnly() bool

func (*ModifyColumn) NewColumn 

func (m *ModifyColumn) NewColumn() *sql.Column

func (*ModifyColumn) Order 

func (m *ModifyColumn) Order() *sql.ColumnOrder

func (*ModifyColumn) Resolved 

func (m *ModifyColumn) Resolved() bool

Resolved implements the Resolvable interface.

func (*ModifyColumn) Schema 

func (m *ModifyColumn) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*ModifyColumn) String 

func (m *ModifyColumn) String() string

func (*ModifyColumn) TargetSchema 

func (m *ModifyColumn) TargetSchema() sql.Schema

func (*ModifyColumn) ValidateDefaultPosition 

func (m *ModifyColumn) ValidateDefaultPosition(tblSch sql.Schema) error

func (*ModifyColumn) WithChildren 

func (m *ModifyColumn) WithChildren(children ...sql.Node) (sql.Node, error)

func (*ModifyColumn) WithDatabase 

func (m *ModifyColumn) WithDatabase(db sql.Database) (sql.Node, error)

func (*ModifyColumn) WithExpressions 

func (m *ModifyColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*ModifyColumn) WithTargetSchema 

func (m *ModifyColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type NamedNotifyFunc 

type NamedNotifyFunc func(name string)

NamedNotifyFunc is a function to notify about some event with a string argument.

type NamedWindows 

type NamedWindows struct {
	UnaryNode
	WindowDefs map[string]*sql.WindowDefinition
}

NamedWindows is a list of WINDOW clause definitions to be resolved and merged into OVER clause sql.Window nodes.

func NewNamedWindows 

func NewNamedWindows(windowDefs map[string]*sql.WindowDefinition, child sql.Node) *NamedWindows

func (*NamedWindows) CheckPrivileges 

func (n *NamedWindows) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements sql.Node

func (*NamedWindows) CollationCoercibility 

func (n *NamedWindows) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*NamedWindows) DebugString 

func (n *NamedWindows) DebugString() string

DebugString implements sql.Node

func (*NamedWindows) IsReadOnly 

func (n *NamedWindows) IsReadOnly() bool

func (*NamedWindows) RowIter 

func (n *NamedWindows) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements sql.Node

func (*NamedWindows) String 

func (n *NamedWindows) String() string

String implements sql.Node

func (*NamedWindows) WithChildren 

func (n *NamedWindows) WithChildren(nodes ...sql.Node) (sql.Node, error)

WithChildren implements sql.Node

type NoopTriggerRollback 

type NoopTriggerRollback struct {
	UnaryNode
}

func NewNoopTriggerRollback 

func NewNoopTriggerRollback(child sql.Node) *NoopTriggerRollback

func (*NoopTriggerRollback) CheckPrivileges 

func (t *NoopTriggerRollback) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*NoopTriggerRollback) CollationCoercibility 

func (t *NoopTriggerRollback) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*NoopTriggerRollback) DebugString 

func (t *NoopTriggerRollback) DebugString() string

func (*NoopTriggerRollback) IsReadOnly 

func (t *NoopTriggerRollback) IsReadOnly() bool

func (*NoopTriggerRollback) String 

func (t *NoopTriggerRollback) String() string

func (*NoopTriggerRollback) WithChildren 

func (t *NoopTriggerRollback) WithChildren(children ...sql.Node) (sql.Node, error)

type Nothing 

type Nothing struct{}
var NothingImpl Nothing

NothingImpl is a node that will return no rows.

func (Nothing) CheckPrivileges 

func (Nothing) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (Nothing) Children 

func (Nothing) Children() []sql.Node

func (Nothing) CollationCoercibility 

func (Nothing) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Nothing) IsReadOnly 

func (Nothing) IsReadOnly() bool

func (Nothing) Resolved 

func (Nothing) Resolved() bool

func (Nothing) RowIter 

func (Nothing) RowIter(*sql.Context, sql.Row) (sql.RowIter, error)

func (Nothing) Schema 

func (Nothing) Schema() sql.Schema

func (Nothing) String 

func (Nothing) String() string

func (Nothing) WithChildren 

func (n Nothing) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type NotifyFunc 

type NotifyFunc func()

NotifyFunc is a function to notify about some event.

type ObjectType 

type ObjectType byte

ObjectType represents the object type that the GRANT or REVOKE statement will apply to. 

const (
	ObjectType_Any ObjectType = iota
	ObjectType_Table
	ObjectType_Function
	ObjectType_Procedure
)

type Offset 

type Offset struct {
	UnaryNode
	Offset sql.Expression
}

Offset is a node that skips the first N rows.

func NewOffset 

func NewOffset(n sql.Expression, child sql.Node) *Offset

NewOffset creates a new Offset node.

func (*Offset) CheckPrivileges 

func (o *Offset) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Offset) CollationCoercibility 

func (o *Offset) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Offset) Expressions 

func (o *Offset) Expressions() []sql.Expression

Expressions implements sql.Expressioner

func (*Offset) IsReadOnly 

func (o *Offset) IsReadOnly() bool

func (*Offset) Resolved 

func (o *Offset) Resolved() bool

Resolved implements the Resolvable interface.

func (Offset) String 

func (o Offset) String() string

func (*Offset) WithChildren 

func (o *Offset) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Offset) WithExpressions 

func (o *Offset) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements sql.Expressioner

type OnScheduleTimestamp 

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

OnScheduleTimestamp is object used for EVENT ON SCHEDULE { AT / STARTS / ENDS } optional fields only.

func NewOnScheduleTimestamp 

func NewOnScheduleTimestamp(f string, ts sql.Expression, i []sql.Expression) *OnScheduleTimestamp

NewOnScheduleTimestamp creates OnScheduleTimestamp object used for EVENT ON SCHEDULE { AT / STARTS / ENDS } optional fields only.

func (*OnScheduleTimestamp) Children 

func (ost *OnScheduleTimestamp) Children() []sql.Expression

func (*OnScheduleTimestamp) Eval 

func (ost *OnScheduleTimestamp) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

func (*OnScheduleTimestamp) EvalTime 

func (ost *OnScheduleTimestamp) EvalTime(ctx *sql.Context, tz string) (time.Time, error)

EvalTime returns time.Time value converted to UTC evaluating given expressions as expected to be time value and optional interval values. The value returned is time.Time value from timestamp value plus all intervals given.

func (*OnScheduleTimestamp) IsNullable 

func (ost *OnScheduleTimestamp) IsNullable() bool

func (*OnScheduleTimestamp) IsReadOnly 

func (ost *OnScheduleTimestamp) IsReadOnly() bool

func (*OnScheduleTimestamp) Resolved 

func (ost *OnScheduleTimestamp) Resolved() bool

Resolved implements the sql.Node interface.

func (*OnScheduleTimestamp) String 

func (ost *OnScheduleTimestamp) String() string

String implements the sql.Node interface.

func (*OnScheduleTimestamp) Type 

func (ost *OnScheduleTimestamp) Type() sql.Type

func (*OnScheduleTimestamp) WithChildren 

func (ost *OnScheduleTimestamp) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Open 

type Open struct {
	Name string
	Pref *expression.ProcedureReference
}

Open represents the OPEN statement, which opens a cursor.

func NewOpen 

func NewOpen(name string) *Open

NewOpen returns a new *Open node.

func (*Open) CheckPrivileges 

func (o *Open) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Open) Children 

func (o *Open) Children() []sql.Node

Children implements the interface sql.Node.

func (*Open) CollationCoercibility 

func (*Open) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Open) IsReadOnly 

func (o *Open) IsReadOnly() bool

func (*Open) Resolved 

func (o *Open) Resolved() bool

Resolved implements the interface sql.Node.

func (*Open) Schema 

func (o *Open) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Open) String 

func (o *Open) String() string

String implements the interface sql.Node.

func (*Open) WithChildren 

func (o *Open) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Open) WithParamReference 

func (o *Open) WithParamReference(pRef *expression.ProcedureReference) sql.Node

WithParamReference implements the interface expression.ProcedureReferencable.

type OrderedDistinct 

type OrderedDistinct struct {
	UnaryNode
}

OrderedDistinct is a Distinct node optimized for sorted row sets. It's 2 orders of magnitude faster and uses 2 orders of magnitude less memory.

func NewOrderedDistinct 

func NewOrderedDistinct(child sql.Node) *OrderedDistinct

NewOrderedDistinct creates a new OrderedDistinct node.

func (*OrderedDistinct) CheckPrivileges 

func (d *OrderedDistinct) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*OrderedDistinct) CollationCoercibility 

func (d *OrderedDistinct) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (OrderedDistinct) DebugString 

func (d OrderedDistinct) DebugString() string

func (*OrderedDistinct) IsReadOnly 

func (d *OrderedDistinct) IsReadOnly() bool

func (*OrderedDistinct) Resolved 

func (d *OrderedDistinct) Resolved() bool

Resolved implements the Resolvable interface.

func (OrderedDistinct) String 

func (d OrderedDistinct) String() string

func (*OrderedDistinct) WithChildren 

func (d *OrderedDistinct) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type PKAction 

type PKAction byte
const (
	PrimaryKeyAction_Create PKAction = iota
	PrimaryKeyAction_Drop
)

type PasswordOptions 

type PasswordOptions struct {
	RequireCurrentOptional bool

	ExpirationTime *int64
	History        *int64
	ReuseInterval  *int64
	FailedAttempts *int64
	LockTime       *int64
}

PasswordOptions states how to handle a user's passwords.

type PrepareInfo 

type PrepareInfo struct {
}

PrepareInfo is the Info for OKResults returned by Update nodes.

func (PrepareInfo) String 

func (pi PrepareInfo) String() string

String implements fmt.Stringer

type PrepareQuery 

type PrepareQuery struct {
	Name  string
	Child sql.Node
}

PrepareQuery is a node that prepares the query

func NewPrepareQuery 

func NewPrepareQuery(name string, child sql.Node) *PrepareQuery

NewPrepareQuery creates a new PrepareQuery node.

func (*PrepareQuery) CheckPrivileges 

func (p *PrepareQuery) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*PrepareQuery) Children 

func (p *PrepareQuery) Children() []sql.Node

Children implements the Node interface.

func (*PrepareQuery) CollationCoercibility 

func (*PrepareQuery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*PrepareQuery) IsReadOnly 

func (p *PrepareQuery) IsReadOnly() bool

func (*PrepareQuery) Resolved 

func (p *PrepareQuery) Resolved() bool

func (*PrepareQuery) RowIter 

func (p *PrepareQuery) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the Node interface.

func (*PrepareQuery) Schema 

func (p *PrepareQuery) Schema() sql.Schema

Schema implements the Node interface.

func (*PrepareQuery) String 

func (p *PrepareQuery) String() string

func (*PrepareQuery) WithChildren 

func (p *PrepareQuery) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type PrependNode 

type PrependNode struct {
	UnaryNode
	Row sql.Row
}

PrependNode wraps its child by prepending column values onto any result rows

func (*PrependNode) CheckPrivileges 

func (p *PrependNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*PrependNode) CollationCoercibility 

func (p *PrependNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*PrependNode) DebugString 

func (p *PrependNode) DebugString() string

func (*PrependNode) IsReadOnly 

func (p *PrependNode) IsReadOnly() bool

func (*PrependNode) String 

func (p *PrependNode) String() string

func (*PrependNode) WithChildren 

func (p *PrependNode) WithChildren(children ...sql.Node) (sql.Node, error)

type Privilege 

type Privilege struct {
	Type    PrivilegeType
	Columns []string
	Dynamic string // PrivilegeType_Dynamic will set this string to the correct lowercased value
}

Privilege specifies a privilege to be used in a GRANT or REVOKE statement.

func (*Privilege) IsValidDynamic 

func (p *Privilege) IsValidDynamic() bool

IsValidDynamic returns whether the given dynamic privilege is valid. If the privilege is NOT dynamic, or the dynamic privilege is not supported, then this returns false.

func (*Privilege) String 

func (p *Privilege) String() string

String returns the Privilege as a formatted string.

type PrivilegeLevel 

type PrivilegeLevel struct {
	Database     string
	TableRoutine string
}

PrivilegeLevel defines the level that a privilege applies to.

func (*PrivilegeLevel) String 

func (p *PrivilegeLevel) String() string

String returns the PrivilegeLevel as a formatted string.

type PrivilegeType 

type PrivilegeType byte

PrivilegeType is the type of privilege that is being granted or revoked. 

const (
	PrivilegeType_All PrivilegeType = iota
	PrivilegeType_Alter
	PrivilegeType_AlterRoutine
	PrivilegeType_Create
	PrivilegeType_CreateRole
	PrivilegeType_CreateRoutine
	PrivilegeType_CreateTablespace
	PrivilegeType_CreateTemporaryTables
	PrivilegeType_CreateUser
	PrivilegeType_CreateView
	PrivilegeType_Delete
	PrivilegeType_Drop
	PrivilegeType_DropRole
	PrivilegeType_Event
	PrivilegeType_Execute
	PrivilegeType_File
	PrivilegeType_GrantOption
	PrivilegeType_Index
	PrivilegeType_Insert
	PrivilegeType_LockTables
	PrivilegeType_Process
	PrivilegeType_References
	PrivilegeType_Reload
	PrivilegeType_ReplicationClient
	PrivilegeType_ReplicationSlave
	PrivilegeType_Select
	PrivilegeType_ShowDatabases
	PrivilegeType_ShowView
	PrivilegeType_Shutdown
	PrivilegeType_Super
	PrivilegeType_Trigger
	PrivilegeType_Update
	PrivilegeType_Usage
	PrivilegeType_Dynamic
)

type Procedure 

type Procedure struct {
	Name                  string
	Definer               string
	Params                []ProcedureParam
	SecurityContext       ProcedureSecurityContext
	Comment               string
	Characteristics       []Characteristic
	CreateProcedureString string
	Body                  sql.Node
	CreatedAt             time.Time
	ModifiedAt            time.Time
	ValidationError       error
}

Procedure is a stored procedure that may be executed using the CALL statement.

func NewProcedure 

func NewProcedure(
	name string,
	definer string,
	params []ProcedureParam,
	securityContext ProcedureSecurityContext,
	comment string,
	characteristics []Characteristic,
	createProcedureString string,
	body sql.Node,
	createdAt time.Time,
	modifiedAt time.Time,
) *Procedure

NewProcedure returns a *Procedure. All names contained within are lowercase, and all methods are case-insensitive.

func (*Procedure) CheckPrivileges 

func (p *Procedure) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Procedure) Children 

func (p *Procedure) Children() []sql.Node

Children implements the sql.Node interface.

func (*Procedure) CollationCoercibility 

func (p *Procedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Procedure) DebugString 

func (p *Procedure) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*Procedure) ExtendVariadic 

func (p *Procedure) ExtendVariadic(ctx *sql.Context, length int) *Procedure

ExtendVariadic returns a new procedure that has the variadic parameter extended to match the CALL's parameter count.

func (*Procedure) HasVariadicParameter 

func (p *Procedure) HasVariadicParameter() bool

HasVariadicParameter returns if the last parameter is variadic.

func (*Procedure) IsExternal 

func (p *Procedure) IsExternal() bool

IsExternal returns whether the stored procedure is external.

func (*Procedure) IsReadOnly 

func (p *Procedure) IsReadOnly() bool

func (*Procedure) Resolved 

func (p *Procedure) Resolved() bool

Resolved implements the sql.Node interface.

func (*Procedure) Schema 

func (p *Procedure) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Procedure) String 

func (p *Procedure) String() string

String implements the sql.Node interface.

func (*Procedure) WithChildren 

func (p *Procedure) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type ProcedureCache 

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

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

func NewProcedureCache 

func NewProcedureCache() *ProcedureCache

NewProcedureCache returns a *ProcedureCache.

func (*ProcedureCache) AllForDatabase 

func (pc *ProcedureCache) AllForDatabase(dbName string) []*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 

func (pc *ProcedureCache) Get(dbName, procedureName string, numOfParams int) *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 

func (pc *ProcedureCache) Register(dbName string, procedure *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 ProcedureParam 

type ProcedureParam struct {
	Direction ProcedureParamDirection // Direction is the direction of the parameter.
	Name      string                  // Name is the name of the parameter.
	Type      sql.Type                // Type is the SQL type of the parameter.
	Variadic  bool                    // Variadic states whether the parameter is variadic.
}

ProcedureParam represents the parameter of a stored procedure.

func (ProcedureParam) String 

func (pp ProcedureParam) String() string

String returns the original SQL representation.

type ProcedureParamDirection 

type ProcedureParamDirection byte

ProcedureParamDirection represents the use case of the stored procedure parameter. 

const (
	// ProcedureParamDirection_In means the parameter passes its contained value to the stored procedure.
	ProcedureParamDirection_In ProcedureParamDirection = iota
	// ProcedureParamDirection_Inout means the parameter passes its contained value to the stored procedure, while also
	// modifying the given variable.
	ProcedureParamDirection_Inout
	// ProcedureParamDirection_Out means the parameter variable will be modified, but will not be read from within the
	// stored procedure.
	ProcedureParamDirection_Out
)

type ProcedureResolvedTable 

type ProcedureResolvedTable struct {
	ResolvedTable *ResolvedTable
}

ProcedureResolvedTable represents a resolved SQL Table inside of a stored procedure. These are initially resolved to verify that they exist, and are then reloaded when another statement accesses its data. Some integrators return a snapshot of a table during the analysis step as an internal optimization, which is incompatible with stored procedures as they require the latest data at each statement.

func NewProcedureResolvedTable 

func NewProcedureResolvedTable(rt *ResolvedTable) *ProcedureResolvedTable

NewProcedureResolvedTable returns a *ProcedureResolvedTable.

func (*ProcedureResolvedTable) CheckPrivileges 

func (t *ProcedureResolvedTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ProcedureResolvedTable) Children 

func (t *ProcedureResolvedTable) Children() []sql.Node

Children implements the sql.Node interface.

func (*ProcedureResolvedTable) Collation 

func (t *ProcedureResolvedTable) Collation() sql.CollationID

Collation implements the sql.Table interface.

func (*ProcedureResolvedTable) CollationCoercibility 

func (t *ProcedureResolvedTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ProcedureResolvedTable) Comment 

func (t *ProcedureResolvedTable) Comment() string

Comment implements the sql.CommentedTable interface.

func (*ProcedureResolvedTable) DebugString 

func (t *ProcedureResolvedTable) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*ProcedureResolvedTable) IsReadOnly 

func (t *ProcedureResolvedTable) IsReadOnly() bool

func (*ProcedureResolvedTable) Name 

func (t *ProcedureResolvedTable) Name() string

Name implements the sql.Table interface.

func (*ProcedureResolvedTable) NewestTable 

func (t *ProcedureResolvedTable) NewestTable(ctx *sql.Context) (*ResolvedTable, error)

NewestTable fetches the newest copy of the contained table from the database.

func (*ProcedureResolvedTable) PartitionRows 

func (t *ProcedureResolvedTable) PartitionRows(ctx *sql.Context, partition sql.Partition) (sql.RowIter, error)

PartitionRows implements the sql.Table interface.

func (*ProcedureResolvedTable) Partitions 

func (t *ProcedureResolvedTable) Partitions(ctx *sql.Context) (sql.PartitionIter, error)

Partitions implements the sql.Table interface.

func (*ProcedureResolvedTable) Resolved 

func (t *ProcedureResolvedTable) Resolved() bool

Resolved implements the sql.Node interface.

func (*ProcedureResolvedTable) Schema 

func (t *ProcedureResolvedTable) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*ProcedureResolvedTable) String 

func (t *ProcedureResolvedTable) String() string

String implements the sql.Node interface.

func (*ProcedureResolvedTable) Underlying 

func (t *ProcedureResolvedTable) Underlying() sql.Table

Underlying implements the sql.TableWrapper interface.

func (*ProcedureResolvedTable) WithChildren 

func (t *ProcedureResolvedTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type ProcedureSecurityContext 

type ProcedureSecurityContext byte

ProcedureSecurityContext determines whether the stored procedure is executed using the privileges of the definer or the invoker. 

const (
	// ProcedureSecurityContext_Definer uses the definer's security context.
	ProcedureSecurityContext_Definer ProcedureSecurityContext = iota
	// ProcedureSecurityContext_Invoker uses the invoker's security context.
	ProcedureSecurityContext_Invoker
)

func (ProcedureSecurityContext) String 

func (pst ProcedureSecurityContext) String() string

String returns the original SQL representation.

type ProcessIndexableTable 

type ProcessIndexableTable struct {
	sql.DriverIndexableTable
	OnPartitionDone  NamedNotifyFunc
	OnPartitionStart NamedNotifyFunc
	OnRowNext        NamedNotifyFunc
}

ProcessIndexableTable is a wrapper for sql.Tables inside a query process that support indexing. It notifies the process manager about the status of a query when a partition is processed.

func NewProcessIndexableTable 

func NewProcessIndexableTable(t sql.DriverIndexableTable, onPartitionDone, onPartitionStart, OnRowNext NamedNotifyFunc) *ProcessIndexableTable

NewProcessIndexableTable returns a new ProcessIndexableTable.

func (*ProcessIndexableTable) DebugString 

func (t *ProcessIndexableTable) DebugString() string

func (*ProcessIndexableTable) IndexKeyValues 

func (t *ProcessIndexableTable) IndexKeyValues(
	ctx *sql.Context,
	columns []string,
) (sql.PartitionIndexKeyValueIter, error)

IndexKeyValues implements the sql.IndexableTable interface.

func (*ProcessIndexableTable) PartitionRows 

func (t *ProcessIndexableTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.RowIter, error)

PartitionRows implements the sql.Table interface.

func (*ProcessIndexableTable) Underlying 

func (t *ProcessIndexableTable) Underlying() sql.Table

Underlying implements sql.TableWrapper interface.

type ProcessTable 

type ProcessTable struct {
	sql.Table
	OnPartitionDone  NamedNotifyFunc
	OnPartitionStart NamedNotifyFunc
	OnRowNext        NamedNotifyFunc
}

ProcessTable is a wrapper for sql.Tables inside a query process. It notifies the process manager about the status of a query when a partition is processed.

func NewProcessTable 

func NewProcessTable(t sql.Table, onPartitionDone, onPartitionStart, OnRowNext NamedNotifyFunc) *ProcessTable

NewProcessTable returns a new ProcessTable.

func (*ProcessTable) Comment 

func (t *ProcessTable) Comment() string

Comment implements sql.CommentedTable interface.

func (*ProcessTable) DebugString 

func (t *ProcessTable) DebugString() string

func (*ProcessTable) PartitionRows 

func (t *ProcessTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.RowIter, error)

PartitionRows implements the sql.Table interface.

func (*ProcessTable) Underlying 

func (t *ProcessTable) Underlying() sql.Table

Underlying implements sql.TableWrapper interface.

type Project 

type Project struct {
	UnaryNode
	// Expression projected.
	Projections []sql.Expression
}

Project is a projection of certain expression from the children node.

func NewProject 

func NewProject(expressions []sql.Expression, child sql.Node) *Project

NewProject creates a new projection.

func (*Project) CheckPrivileges 

func (p *Project) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Project) CollationCoercibility 

func (p *Project) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Project) DebugString 

func (p *Project) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*Project) Describe 

func (p *Project) Describe(options sql.DescribeOptions) string

Describe implements the sql.Describable interface.

func (*Project) Expressions 

func (p *Project) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*Project) IsReadOnly 

func (p *Project) IsReadOnly() bool

func (*Project) ProjectedExprs 

func (p *Project) ProjectedExprs() []sql.Expression

ProjectedExprs implements sql.Projector

func (*Project) Resolved 

func (p *Project) Resolved() bool

Resolved implements the Resolvable interface.

func (*Project) Schema 

func (p *Project) Schema() sql.Schema

Schema implements the Node interface.

func (*Project) String 

func (p *Project) String() string

String implements the fmt.Stringer interface.

func (*Project) WithChildren 

func (p *Project) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Project) WithExpressions 

func (p *Project) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type QueryProcess 

type QueryProcess struct {
	UnaryNode
	Notify NotifyFunc
}

QueryProcess represents a running query process node. It will use a callback to notify when it has finished running. TODO: QueryProcess -> trackedRowIter is required to dispose certain iter caches. Make a proper scheduler interface to perform lifecycle management, caching, and scan attaching

func NewQueryProcess 

func NewQueryProcess(node sql.Node, notify NotifyFunc) *QueryProcess

NewQueryProcess creates a new QueryProcess node.

func (*QueryProcess) CheckPrivileges 

func (p *QueryProcess) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*QueryProcess) Child 

func (p *QueryProcess) Child() sql.Node

func (*QueryProcess) CollationCoercibility 

func (p *QueryProcess) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*QueryProcess) DebugString 

func (p *QueryProcess) DebugString() string

func (*QueryProcess) IsReadOnly 

func (p *QueryProcess) IsReadOnly() bool

func (*QueryProcess) ShouldSetFoundRows 

func (p *QueryProcess) ShouldSetFoundRows() bool

ShouldSetFoundRows returns whether the query process should set the FOUND_ROWS query variable. It should do this for any select except a Limit with a SQL_CALC_FOUND_ROWS modifier, which is handled in the Limit node itself.

func (*QueryProcess) String 

func (p *QueryProcess) String() string

func (*QueryProcess) WithChildren 

func (p *QueryProcess) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type RangeCurrentRowToCurrentRowFrame 

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

func NewRangeCurrentRowToCurrentRowFrame 

func NewRangeCurrentRowToCurrentRowFrame() *RangeCurrentRowToCurrentRowFrame

func (*RangeCurrentRowToCurrentRowFrame) DebugString 

func (f *RangeCurrentRowToCurrentRowFrame) DebugString() string

func (*RangeCurrentRowToCurrentRowFrame) EndCurrentRow 

func (f *RangeCurrentRowToCurrentRowFrame) EndCurrentRow() bool

func (*RangeCurrentRowToCurrentRowFrame) EndNFollowing 

func (f *RangeCurrentRowToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RangeCurrentRowToCurrentRowFrame) EndNPreceding 

func (f *RangeCurrentRowToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RangeCurrentRowToCurrentRowFrame) NewFramer 

func (f *RangeCurrentRowToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeCurrentRowToCurrentRowFrame) StartCurrentRow 

func (f *RangeCurrentRowToCurrentRowFrame) StartCurrentRow() bool

func (*RangeCurrentRowToCurrentRowFrame) StartNFollowing 

func (f *RangeCurrentRowToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RangeCurrentRowToCurrentRowFrame) StartNPreceding 

func (f *RangeCurrentRowToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RangeCurrentRowToCurrentRowFrame) String 

func (f *RangeCurrentRowToCurrentRowFrame) String() string

func (*RangeCurrentRowToCurrentRowFrame) UnboundedFollowing 

func (f *RangeCurrentRowToCurrentRowFrame) UnboundedFollowing() bool

func (*RangeCurrentRowToCurrentRowFrame) UnboundedPreceding 

func (f *RangeCurrentRowToCurrentRowFrame) UnboundedPreceding() bool

type RangeCurrentRowToNFollowingFrame 

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

func NewRangeCurrentRowToNFollowingFrame 

func NewRangeCurrentRowToNFollowingFrame(endNFollowing sql.Expression) *RangeCurrentRowToNFollowingFrame

func (*RangeCurrentRowToNFollowingFrame) DebugString 

func (f *RangeCurrentRowToNFollowingFrame) DebugString() string

func (*RangeCurrentRowToNFollowingFrame) EndCurrentRow 

func (f *RangeCurrentRowToNFollowingFrame) EndCurrentRow() bool

func (*RangeCurrentRowToNFollowingFrame) EndNFollowing 

func (f *RangeCurrentRowToNFollowingFrame) EndNFollowing() sql.Expression

func (*RangeCurrentRowToNFollowingFrame) EndNPreceding 

func (f *RangeCurrentRowToNFollowingFrame) EndNPreceding() sql.Expression

func (*RangeCurrentRowToNFollowingFrame) NewFramer 

func (f *RangeCurrentRowToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeCurrentRowToNFollowingFrame) StartCurrentRow 

func (f *RangeCurrentRowToNFollowingFrame) StartCurrentRow() bool

func (*RangeCurrentRowToNFollowingFrame) StartNFollowing 

func (f *RangeCurrentRowToNFollowingFrame) StartNFollowing() sql.Expression

func (*RangeCurrentRowToNFollowingFrame) StartNPreceding 

func (f *RangeCurrentRowToNFollowingFrame) StartNPreceding() sql.Expression

func (*RangeCurrentRowToNFollowingFrame) String 

func (f *RangeCurrentRowToNFollowingFrame) String() string

func (*RangeCurrentRowToNFollowingFrame) UnboundedFollowing 

func (f *RangeCurrentRowToNFollowingFrame) UnboundedFollowing() bool

func (*RangeCurrentRowToNFollowingFrame) UnboundedPreceding 

func (f *RangeCurrentRowToNFollowingFrame) UnboundedPreceding() bool

type RangeCurrentRowToNPrecedingFrame 

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

func NewRangeCurrentRowToNPrecedingFrame 

func NewRangeCurrentRowToNPrecedingFrame(endNPreceding sql.Expression) *RangeCurrentRowToNPrecedingFrame

func (*RangeCurrentRowToNPrecedingFrame) DebugString 

func (f *RangeCurrentRowToNPrecedingFrame) DebugString() string

func (*RangeCurrentRowToNPrecedingFrame) EndCurrentRow 

func (f *RangeCurrentRowToNPrecedingFrame) EndCurrentRow() bool

func (*RangeCurrentRowToNPrecedingFrame) EndNFollowing 

func (f *RangeCurrentRowToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RangeCurrentRowToNPrecedingFrame) EndNPreceding 

func (f *RangeCurrentRowToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RangeCurrentRowToNPrecedingFrame) NewFramer 

func (f *RangeCurrentRowToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeCurrentRowToNPrecedingFrame) StartCurrentRow 

func (f *RangeCurrentRowToNPrecedingFrame) StartCurrentRow() bool

func (*RangeCurrentRowToNPrecedingFrame) StartNFollowing 

func (f *RangeCurrentRowToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RangeCurrentRowToNPrecedingFrame) StartNPreceding 

func (f *RangeCurrentRowToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RangeCurrentRowToNPrecedingFrame) String 

func (f *RangeCurrentRowToNPrecedingFrame) String() string

func (*RangeCurrentRowToNPrecedingFrame) UnboundedFollowing 

func (f *RangeCurrentRowToNPrecedingFrame) UnboundedFollowing() bool

func (*RangeCurrentRowToNPrecedingFrame) UnboundedPreceding 

func (f *RangeCurrentRowToNPrecedingFrame) UnboundedPreceding() bool

type RangeCurrentRowToUnboundedFollowingFrame 

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

func NewRangeCurrentRowToUnboundedFollowingFrame 

func NewRangeCurrentRowToUnboundedFollowingFrame() *RangeCurrentRowToUnboundedFollowingFrame

func (*RangeCurrentRowToUnboundedFollowingFrame) DebugString 

func (f *RangeCurrentRowToUnboundedFollowingFrame) DebugString() string

func (*RangeCurrentRowToUnboundedFollowingFrame) EndCurrentRow 

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RangeCurrentRowToUnboundedFollowingFrame) EndNFollowing 

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RangeCurrentRowToUnboundedFollowingFrame) EndNPreceding 

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RangeCurrentRowToUnboundedFollowingFrame) NewFramer 

func (f *RangeCurrentRowToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeCurrentRowToUnboundedFollowingFrame) StartCurrentRow 

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RangeCurrentRowToUnboundedFollowingFrame) StartNFollowing 

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RangeCurrentRowToUnboundedFollowingFrame) StartNPreceding 

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RangeCurrentRowToUnboundedFollowingFrame) String 

func (f *RangeCurrentRowToUnboundedFollowingFrame) String() string

func (*RangeCurrentRowToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RangeCurrentRowToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RangeCurrentRowToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RangeCurrentRowToUnboundedFollowingFrame) UnboundedPreceding() bool

type RangeHeap 

type RangeHeap struct {
	UnaryNode
	ValueColumnIndex   int
	MinColumnIndex     int
	MaxColumnIndex     int
	ValueColumnGf      sql.Expression
	MinColumnGf        sql.Expression
	MaxColumnGf        sql.Expression
	ComparisonType     sql.Type
	RangeIsClosedBelow bool
	RangeIsClosedAbove bool
}

RangeHeap is a Node that wraps a table with min and max range columns. When used as a secondary provider in Join operations, it can efficiently compute the rows whose ranges bound the value from the other table. When the ranges don't overlap, the amortized complexity is O(1) for each result row.

func NewRangeHeap 

func NewRangeHeap(child sql.Node, value, min, max *expression.GetField, rangeIsClosedBelow, rangeIsClosedAbove bool) (*RangeHeap, error)

func (*RangeHeap) CheckPrivileges 

func (s *RangeHeap) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*RangeHeap) DebugString 

func (s *RangeHeap) DebugString() string

func (*RangeHeap) IsReadOnly 

func (s *RangeHeap) IsReadOnly() bool

func (*RangeHeap) String 

func (s *RangeHeap) String() string

func (*RangeHeap) WithChildren 

func (s *RangeHeap) WithChildren(children ...sql.Node) (sql.Node, error)

type RangeNFollowingToCurrentRowFrame 

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

func NewRangeNFollowingToCurrentRowFrame 

func NewRangeNFollowingToCurrentRowFrame(startNFollowing sql.Expression) *RangeNFollowingToCurrentRowFrame

func (*RangeNFollowingToCurrentRowFrame) DebugString 

func (f *RangeNFollowingToCurrentRowFrame) DebugString() string

func (*RangeNFollowingToCurrentRowFrame) EndCurrentRow 

func (f *RangeNFollowingToCurrentRowFrame) EndCurrentRow() bool

func (*RangeNFollowingToCurrentRowFrame) EndNFollowing 

func (f *RangeNFollowingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RangeNFollowingToCurrentRowFrame) EndNPreceding 

func (f *RangeNFollowingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RangeNFollowingToCurrentRowFrame) NewFramer 

func (f *RangeNFollowingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNFollowingToCurrentRowFrame) StartCurrentRow 

func (f *RangeNFollowingToCurrentRowFrame) StartCurrentRow() bool

func (*RangeNFollowingToCurrentRowFrame) StartNFollowing 

func (f *RangeNFollowingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RangeNFollowingToCurrentRowFrame) StartNPreceding 

func (f *RangeNFollowingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RangeNFollowingToCurrentRowFrame) String 

func (f *RangeNFollowingToCurrentRowFrame) String() string

func (*RangeNFollowingToCurrentRowFrame) UnboundedFollowing 

func (f *RangeNFollowingToCurrentRowFrame) UnboundedFollowing() bool

func (*RangeNFollowingToCurrentRowFrame) UnboundedPreceding 

func (f *RangeNFollowingToCurrentRowFrame) UnboundedPreceding() bool

type RangeNFollowingToNFollowingFrame 

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

func NewRangeNFollowingToNFollowingFrame 

func NewRangeNFollowingToNFollowingFrame(startNFollowing sql.Expression, endNFollowing sql.Expression) *RangeNFollowingToNFollowingFrame

func (*RangeNFollowingToNFollowingFrame) DebugString 

func (f *RangeNFollowingToNFollowingFrame) DebugString() string

func (*RangeNFollowingToNFollowingFrame) EndCurrentRow 

func (f *RangeNFollowingToNFollowingFrame) EndCurrentRow() bool

func (*RangeNFollowingToNFollowingFrame) EndNFollowing 

func (f *RangeNFollowingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RangeNFollowingToNFollowingFrame) EndNPreceding 

func (f *RangeNFollowingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RangeNFollowingToNFollowingFrame) NewFramer 

func (f *RangeNFollowingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNFollowingToNFollowingFrame) StartCurrentRow 

func (f *RangeNFollowingToNFollowingFrame) StartCurrentRow() bool

func (*RangeNFollowingToNFollowingFrame) StartNFollowing 

func (f *RangeNFollowingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RangeNFollowingToNFollowingFrame) StartNPreceding 

func (f *RangeNFollowingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RangeNFollowingToNFollowingFrame) String 

func (f *RangeNFollowingToNFollowingFrame) String() string

func (*RangeNFollowingToNFollowingFrame) UnboundedFollowing 

func (f *RangeNFollowingToNFollowingFrame) UnboundedFollowing() bool

func (*RangeNFollowingToNFollowingFrame) UnboundedPreceding 

func (f *RangeNFollowingToNFollowingFrame) UnboundedPreceding() bool

type RangeNFollowingToNPrecedingFrame 

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

func NewRangeNFollowingToNPrecedingFrame 

func NewRangeNFollowingToNPrecedingFrame(startNFollowing sql.Expression, endNPreceding sql.Expression) *RangeNFollowingToNPrecedingFrame

func (*RangeNFollowingToNPrecedingFrame) DebugString 

func (f *RangeNFollowingToNPrecedingFrame) DebugString() string

func (*RangeNFollowingToNPrecedingFrame) EndCurrentRow 

func (f *RangeNFollowingToNPrecedingFrame) EndCurrentRow() bool

func (*RangeNFollowingToNPrecedingFrame) EndNFollowing 

func (f *RangeNFollowingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RangeNFollowingToNPrecedingFrame) EndNPreceding 

func (f *RangeNFollowingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RangeNFollowingToNPrecedingFrame) NewFramer 

func (f *RangeNFollowingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNFollowingToNPrecedingFrame) StartCurrentRow 

func (f *RangeNFollowingToNPrecedingFrame) StartCurrentRow() bool

func (*RangeNFollowingToNPrecedingFrame) StartNFollowing 

func (f *RangeNFollowingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RangeNFollowingToNPrecedingFrame) StartNPreceding 

func (f *RangeNFollowingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RangeNFollowingToNPrecedingFrame) String 

func (f *RangeNFollowingToNPrecedingFrame) String() string

func (*RangeNFollowingToNPrecedingFrame) UnboundedFollowing 

func (f *RangeNFollowingToNPrecedingFrame) UnboundedFollowing() bool

func (*RangeNFollowingToNPrecedingFrame) UnboundedPreceding 

func (f *RangeNFollowingToNPrecedingFrame) UnboundedPreceding() bool

type RangeNFollowingToUnboundedFollowingFrame 

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

func NewRangeNFollowingToUnboundedFollowingFrame 

func NewRangeNFollowingToUnboundedFollowingFrame(startNFollowing sql.Expression) *RangeNFollowingToUnboundedFollowingFrame

func (*RangeNFollowingToUnboundedFollowingFrame) DebugString 

func (f *RangeNFollowingToUnboundedFollowingFrame) DebugString() string

func (*RangeNFollowingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RangeNFollowingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RangeNFollowingToUnboundedFollowingFrame) EndNFollowing 

func (f *RangeNFollowingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RangeNFollowingToUnboundedFollowingFrame) EndNPreceding 

func (f *RangeNFollowingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RangeNFollowingToUnboundedFollowingFrame) NewFramer 

func (f *RangeNFollowingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNFollowingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RangeNFollowingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RangeNFollowingToUnboundedFollowingFrame) StartNFollowing 

func (f *RangeNFollowingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RangeNFollowingToUnboundedFollowingFrame) StartNPreceding 

func (f *RangeNFollowingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RangeNFollowingToUnboundedFollowingFrame) String 

func (f *RangeNFollowingToUnboundedFollowingFrame) String() string

func (*RangeNFollowingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RangeNFollowingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RangeNFollowingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RangeNFollowingToUnboundedFollowingFrame) UnboundedPreceding() bool

type RangeNPrecedingToCurrentRowFrame 

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

func NewRangeNPrecedingToCurrentRowFrame 

func NewRangeNPrecedingToCurrentRowFrame(startNPreceding sql.Expression) *RangeNPrecedingToCurrentRowFrame

func (*RangeNPrecedingToCurrentRowFrame) DebugString 

func (f *RangeNPrecedingToCurrentRowFrame) DebugString() string

func (*RangeNPrecedingToCurrentRowFrame) EndCurrentRow 

func (f *RangeNPrecedingToCurrentRowFrame) EndCurrentRow() bool

func (*RangeNPrecedingToCurrentRowFrame) EndNFollowing 

func (f *RangeNPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RangeNPrecedingToCurrentRowFrame) EndNPreceding 

func (f *RangeNPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RangeNPrecedingToCurrentRowFrame) NewFramer 

func (f *RangeNPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNPrecedingToCurrentRowFrame) StartCurrentRow 

func (f *RangeNPrecedingToCurrentRowFrame) StartCurrentRow() bool

func (*RangeNPrecedingToCurrentRowFrame) StartNFollowing 

func (f *RangeNPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RangeNPrecedingToCurrentRowFrame) StartNPreceding 

func (f *RangeNPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RangeNPrecedingToCurrentRowFrame) String 

func (f *RangeNPrecedingToCurrentRowFrame) String() string

func (*RangeNPrecedingToCurrentRowFrame) UnboundedFollowing 

func (f *RangeNPrecedingToCurrentRowFrame) UnboundedFollowing() bool

func (*RangeNPrecedingToCurrentRowFrame) UnboundedPreceding 

func (f *RangeNPrecedingToCurrentRowFrame) UnboundedPreceding() bool

type RangeNPrecedingToNFollowingFrame 

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

func NewRangeNPrecedingToNFollowingFrame 

func NewRangeNPrecedingToNFollowingFrame(startNPreceding sql.Expression, endNFollowing sql.Expression) *RangeNPrecedingToNFollowingFrame

func (*RangeNPrecedingToNFollowingFrame) DebugString 

func (f *RangeNPrecedingToNFollowingFrame) DebugString() string

func (*RangeNPrecedingToNFollowingFrame) EndCurrentRow 

func (f *RangeNPrecedingToNFollowingFrame) EndCurrentRow() bool

func (*RangeNPrecedingToNFollowingFrame) EndNFollowing 

func (f *RangeNPrecedingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RangeNPrecedingToNFollowingFrame) EndNPreceding 

func (f *RangeNPrecedingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RangeNPrecedingToNFollowingFrame) NewFramer 

func (f *RangeNPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNPrecedingToNFollowingFrame) StartCurrentRow 

func (f *RangeNPrecedingToNFollowingFrame) StartCurrentRow() bool

func (*RangeNPrecedingToNFollowingFrame) StartNFollowing 

func (f *RangeNPrecedingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RangeNPrecedingToNFollowingFrame) StartNPreceding 

func (f *RangeNPrecedingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RangeNPrecedingToNFollowingFrame) String 

func (f *RangeNPrecedingToNFollowingFrame) String() string

func (*RangeNPrecedingToNFollowingFrame) UnboundedFollowing 

func (f *RangeNPrecedingToNFollowingFrame) UnboundedFollowing() bool

func (*RangeNPrecedingToNFollowingFrame) UnboundedPreceding 

func (f *RangeNPrecedingToNFollowingFrame) UnboundedPreceding() bool

type RangeNPrecedingToNPrecedingFrame 

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

func NewRangeNPrecedingToNPrecedingFrame 

func NewRangeNPrecedingToNPrecedingFrame(startNPreceding sql.Expression, endNPreceding sql.Expression) *RangeNPrecedingToNPrecedingFrame

func (*RangeNPrecedingToNPrecedingFrame) DebugString 

func (f *RangeNPrecedingToNPrecedingFrame) DebugString() string

func (*RangeNPrecedingToNPrecedingFrame) EndCurrentRow 

func (f *RangeNPrecedingToNPrecedingFrame) EndCurrentRow() bool

func (*RangeNPrecedingToNPrecedingFrame) EndNFollowing 

func (f *RangeNPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RangeNPrecedingToNPrecedingFrame) EndNPreceding 

func (f *RangeNPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RangeNPrecedingToNPrecedingFrame) NewFramer 

func (f *RangeNPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNPrecedingToNPrecedingFrame) StartCurrentRow 

func (f *RangeNPrecedingToNPrecedingFrame) StartCurrentRow() bool

func (*RangeNPrecedingToNPrecedingFrame) StartNFollowing 

func (f *RangeNPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RangeNPrecedingToNPrecedingFrame) StartNPreceding 

func (f *RangeNPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RangeNPrecedingToNPrecedingFrame) String 

func (f *RangeNPrecedingToNPrecedingFrame) String() string

func (*RangeNPrecedingToNPrecedingFrame) UnboundedFollowing 

func (f *RangeNPrecedingToNPrecedingFrame) UnboundedFollowing() bool

func (*RangeNPrecedingToNPrecedingFrame) UnboundedPreceding 

func (f *RangeNPrecedingToNPrecedingFrame) UnboundedPreceding() bool

type RangeNPrecedingToUnboundedFollowingFrame 

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

func NewRangeNPrecedingToUnboundedFollowingFrame 

func NewRangeNPrecedingToUnboundedFollowingFrame(startNPreceding sql.Expression) *RangeNPrecedingToUnboundedFollowingFrame

func (*RangeNPrecedingToUnboundedFollowingFrame) DebugString 

func (f *RangeNPrecedingToUnboundedFollowingFrame) DebugString() string

func (*RangeNPrecedingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RangeNPrecedingToUnboundedFollowingFrame) EndNFollowing 

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RangeNPrecedingToUnboundedFollowingFrame) EndNPreceding 

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RangeNPrecedingToUnboundedFollowingFrame) NewFramer 

func (f *RangeNPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeNPrecedingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RangeNPrecedingToUnboundedFollowingFrame) StartNFollowing 

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RangeNPrecedingToUnboundedFollowingFrame) StartNPreceding 

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RangeNPrecedingToUnboundedFollowingFrame) String 

func (f *RangeNPrecedingToUnboundedFollowingFrame) String() string

func (*RangeNPrecedingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RangeNPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RangeNPrecedingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RangeNPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool

type RangeUnboundedPrecedingToCurrentRowFrame 

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

func NewRangeUnboundedPrecedingToCurrentRowFrame 

func NewRangeUnboundedPrecedingToCurrentRowFrame() *RangeUnboundedPrecedingToCurrentRowFrame

func (*RangeUnboundedPrecedingToCurrentRowFrame) DebugString 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) DebugString() string

func (*RangeUnboundedPrecedingToCurrentRowFrame) EndCurrentRow 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndCurrentRow() bool

func (*RangeUnboundedPrecedingToCurrentRowFrame) EndNFollowing 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToCurrentRowFrame) EndNPreceding 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToCurrentRowFrame) NewFramer 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeUnboundedPrecedingToCurrentRowFrame) StartCurrentRow 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartCurrentRow() bool

func (*RangeUnboundedPrecedingToCurrentRowFrame) StartNFollowing 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToCurrentRowFrame) StartNPreceding 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToCurrentRowFrame) String 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) String() string

func (*RangeUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing() bool

func (*RangeUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding 

func (f *RangeUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding() bool

type RangeUnboundedPrecedingToNFollowingFrame 

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

func NewRangeUnboundedPrecedingToNFollowingFrame 

func NewRangeUnboundedPrecedingToNFollowingFrame(endNFollowing sql.Expression) *RangeUnboundedPrecedingToNFollowingFrame

func (*RangeUnboundedPrecedingToNFollowingFrame) DebugString 

func (f *RangeUnboundedPrecedingToNFollowingFrame) DebugString() string

func (*RangeUnboundedPrecedingToNFollowingFrame) EndCurrentRow 

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndCurrentRow() bool

func (*RangeUnboundedPrecedingToNFollowingFrame) EndNFollowing 

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToNFollowingFrame) EndNPreceding 

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToNFollowingFrame) NewFramer 

func (f *RangeUnboundedPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeUnboundedPrecedingToNFollowingFrame) StartCurrentRow 

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartCurrentRow() bool

func (*RangeUnboundedPrecedingToNFollowingFrame) StartNFollowing 

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToNFollowingFrame) StartNPreceding 

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToNFollowingFrame) String 

func (f *RangeUnboundedPrecedingToNFollowingFrame) String() string

func (*RangeUnboundedPrecedingToNFollowingFrame) UnboundedFollowing 

func (f *RangeUnboundedPrecedingToNFollowingFrame) UnboundedFollowing() bool

func (*RangeUnboundedPrecedingToNFollowingFrame) UnboundedPreceding 

func (f *RangeUnboundedPrecedingToNFollowingFrame) UnboundedPreceding() bool

type RangeUnboundedPrecedingToNPrecedingFrame 

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

func NewRangeUnboundedPrecedingToNPrecedingFrame 

func NewRangeUnboundedPrecedingToNPrecedingFrame(endNPreceding sql.Expression) *RangeUnboundedPrecedingToNPrecedingFrame

func (*RangeUnboundedPrecedingToNPrecedingFrame) DebugString 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) DebugString() string

func (*RangeUnboundedPrecedingToNPrecedingFrame) EndCurrentRow 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndCurrentRow() bool

func (*RangeUnboundedPrecedingToNPrecedingFrame) EndNFollowing 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToNPrecedingFrame) EndNPreceding 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToNPrecedingFrame) NewFramer 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeUnboundedPrecedingToNPrecedingFrame) StartCurrentRow 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartCurrentRow() bool

func (*RangeUnboundedPrecedingToNPrecedingFrame) StartNFollowing 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToNPrecedingFrame) StartNPreceding 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToNPrecedingFrame) String 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) String() string

func (*RangeUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing() bool

func (*RangeUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding 

func (f *RangeUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding() bool

type RangeUnboundedPrecedingToUnboundedFollowingFrame 

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

func NewRangeUnboundedPrecedingToUnboundedFollowingFrame 

func NewRangeUnboundedPrecedingToUnboundedFollowingFrame() *RangeUnboundedPrecedingToUnboundedFollowingFrame

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) DebugString 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) DebugString() string

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) NewFramer 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) String 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) String() string

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool

type RecursiveCte 

type RecursiveCte struct {

	// ColumnNames used to name lazily-loaded schema fields
	ColumnNames []string

	// Working is a handle to our refreshable intermediate table
	Working *RecursiveTable
	// contains filtered or unexported fields
}

RecursiveCte is defined by two subqueries connected with a union: 

ex => WITH RECURSIVE [name]([Columns]) as ([Init] UNION [Rec]) ...

[Init] is a non-recursive select statement, and [Rec] selects from the recursive relation [name] until exhaustion. Note that if [Rec] is not recursive, the optimizer will fold the RecursiveCte into a SubqueryAlias.

The node is executed as follows:

  1. First, iterate the [Init] subquery.
  2. Collect the outputs of [Init] in a [temporary] buffer.
  3. When the iterator is exhausted, populate the recursive [working] table with the [temporary] buffer.
  4. Iterate [Rec], collecting outputs in the [temporary] buffer.
  5. Repeat steps (3) and (4) until [temporary] is empty.

A RecursiveCte, its [Init], and its [Rec] have the same projection count and types. [Init] will be resolved before [Rec] or RecursiveCte to share schema types.

func NewRecursiveCte 

func NewRecursiveCte(initial, recursive sql.Node, name string, outputCols []string, deduplicate bool, l sql.Expression, sf sql.SortFields) *RecursiveCte

func (*RecursiveCte) CheckPrivileges 

func (r *RecursiveCte) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*RecursiveCte) Children 

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

func (*RecursiveCte) CollationCoercibility 

func (*RecursiveCte) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RecursiveCte) Columns 

func (r *RecursiveCte) Columns() sql.ColSet

ColumnNames implements sql.TableIdNode

func (*RecursiveCte) DebugString 

func (r *RecursiveCte) DebugString() string

DebugString implements sql.Node

func (*RecursiveCte) Expressions 

func (r *RecursiveCte) Expressions() []sql.Expression

func (*RecursiveCte) Id 

func (r *RecursiveCte) Id() sql.TableId

Id implements sql.TableIdNode

func (*RecursiveCte) IsNullable 

func (r *RecursiveCte) IsNullable() bool

IsNullable implements sql.Node

func (*RecursiveCte) IsReadOnly 

func (r *RecursiveCte) IsReadOnly() bool

func (*RecursiveCte) Left 

func (r *RecursiveCte) Left() sql.Node

Left implements sql.BinaryNode

func (*RecursiveCte) Name 

func (r *RecursiveCte) Name() string

Name implements sql.Nameable

func (*RecursiveCte) Opaque 

func (r *RecursiveCte) Opaque() bool

func (*RecursiveCte) Resolved 

func (r *RecursiveCte) Resolved() bool

func (*RecursiveCte) Right 

func (r *RecursiveCte) Right() sql.Node

Right implements sql.BinaryNode

func (*RecursiveCte) Schema 

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

Schema implements sql.Node

func (*RecursiveCte) String 

func (r *RecursiveCte) String() string

String implements sql.Node

func (*RecursiveCte) Type 

func (r *RecursiveCte) Type() sql.Type

Type implements sql.Node

func (*RecursiveCte) Union 

func (r *RecursiveCte) Union() *SetOp

func (*RecursiveCte) WithChildren 

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

WithChildren implements sql.Node

func (*RecursiveCte) WithColumns 

func (r *RecursiveCte) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*RecursiveCte) WithExpressions 

func (r *RecursiveCte) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*RecursiveCte) WithId 

func (r *RecursiveCte) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*RecursiveCte) WithName 

func (r *RecursiveCte) WithName(s string) sql.Node

func (*RecursiveCte) WithSchema 

func (r *RecursiveCte) WithSchema(s sql.Schema) *RecursiveCte

WithSchema inherits [Init]'s schema at resolve time

func (*RecursiveCte) WithWorking 

func (r *RecursiveCte) WithWorking(t *RecursiveTable) *RecursiveCte

WithWorking populates the [working] table with a common schema

type RecursiveTable 

type RecursiveTable struct {
	Buf []sql.Row
	// contains filtered or unexported fields
}

RecursiveTable is a thin wrapper around an in memory buffer for use with recursiveCteIter.

func NewRecursiveTable 

func NewRecursiveTable(n string, s sql.Schema) *RecursiveTable

func (*RecursiveTable) CheckPrivileges 

func (r *RecursiveTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RecursiveTable) Children 

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

func (*RecursiveTable) CollationCoercibility 

func (*RecursiveTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RecursiveTable) Columns 

func (r *RecursiveTable) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*RecursiveTable) Id 

func (r *RecursiveTable) Id() sql.TableId

Id implements sql.TableIdNode

func (*RecursiveTable) IsReadOnly 

func (r *RecursiveTable) IsReadOnly() bool

func (*RecursiveTable) Name 

func (r *RecursiveTable) Name() string

func (*RecursiveTable) Resolved 

func (r *RecursiveTable) Resolved() bool

func (*RecursiveTable) Schema 

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

func (*RecursiveTable) String 

func (r *RecursiveTable) String() string

func (*RecursiveTable) WithChildren 

func (r *RecursiveTable) WithChildren(node ...sql.Node) (sql.Node, error)

func (*RecursiveTable) WithColumns 

func (r *RecursiveTable) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*RecursiveTable) WithId 

func (r *RecursiveTable) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*RecursiveTable) WithName 

func (r *RecursiveTable) WithName(s string) sql.Node

type ReleaseSavepoint 

type ReleaseSavepoint struct {
	Name string
	// contains filtered or unexported fields
}

ReleaseSavepoint releases the given savepoint. For sessions that don't implement sql.TransactionSession, this is a no-op.

func NewReleaseSavepoint 

func NewReleaseSavepoint(name string) *ReleaseSavepoint

NewReleaseSavepoint creates a new ReleaseSavepoint node.

func (ReleaseSavepoint) CheckPrivileges 

func (ReleaseSavepoint) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (ReleaseSavepoint) Children 

func (ReleaseSavepoint) Children() []sql.Node

func (*ReleaseSavepoint) CollationCoercibility 

func (*ReleaseSavepoint) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (ReleaseSavepoint) IsReadOnly 

func (ReleaseSavepoint) IsReadOnly() bool

func (ReleaseSavepoint) Resolved 

func (ReleaseSavepoint) Resolved() bool

Resolved implements the sql.Node interface.

func (*ReleaseSavepoint) RowIter 

func (r *ReleaseSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (ReleaseSavepoint) Schema 

func (ReleaseSavepoint) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*ReleaseSavepoint) String 

func (r *ReleaseSavepoint) String() string

func (*ReleaseSavepoint) WithChildren 

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

WithChildren implements the Node interface.

type Releaser 

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

func (*Releaser) CheckPrivileges 

func (r *Releaser) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Releaser) Children 

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

func (*Releaser) CollationCoercibility 

func (r *Releaser) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Releaser) Equal 

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

func (*Releaser) IsReadOnly 

func (r *Releaser) IsReadOnly() bool

func (*Releaser) Resolved 

func (r *Releaser) Resolved() bool

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 RenameColumn 

type RenameColumn struct {
	Table         sql.Node
	ColumnName    string
	NewColumnName string
	// contains filtered or unexported fields
}

func NewRenameColumn 

func NewRenameColumn(database sql.Database, table *UnresolvedTable, columnName string, newColumnName string) *RenameColumn

func NewRenameColumnResolved 

func NewRenameColumnResolved(table *ResolvedTable, columnName string, newColumnName string) *RenameColumn

func (*RenameColumn) CheckPrivileges 

func (r *RenameColumn) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RenameColumn) Checks 

func (r *RenameColumn) Checks() sql.CheckConstraints

func (*RenameColumn) Children 

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

func (*RenameColumn) CollationCoercibility 

func (*RenameColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RenameColumn) Database 

func (c *RenameColumn) Database() sql.Database

Database implements the sql.Databaser interface.

func (*RenameColumn) DebugString 

func (r *RenameColumn) DebugString() string

func (*RenameColumn) Expressions 

func (r *RenameColumn) Expressions() []sql.Expression

func (*RenameColumn) IsReadOnly 

func (r *RenameColumn) IsReadOnly() bool

func (*RenameColumn) Resolved 

func (r *RenameColumn) Resolved() bool

func (*RenameColumn) Schema 

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

func (*RenameColumn) String 

func (r *RenameColumn) String() string

func (*RenameColumn) TargetSchema 

func (r *RenameColumn) TargetSchema() sql.Schema

func (*RenameColumn) WithChecks 

func (r *RenameColumn) WithChecks(checks sql.CheckConstraints) sql.Node

func (RenameColumn) WithChildren 

func (r RenameColumn) WithChildren(children ...sql.Node) (sql.Node, error)

func (*RenameColumn) WithDatabase 

func (r *RenameColumn) WithDatabase(db sql.Database) (sql.Node, error)

func (RenameColumn) WithExpressions 

func (r RenameColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (RenameColumn) WithTargetSchema 

func (r RenameColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type RenameTable 

type RenameTable struct {
	OldNames []string
	NewNames []string
	// contains filtered or unexported fields
}

func NewRenameTable 

func NewRenameTable(db sql.Database, oldNames, newNames []string, alterTbl bool) *RenameTable

NewRenameTable creates a new RenameTable node

func (*RenameTable) CheckPrivileges 

func (r *RenameTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RenameTable) Children 

func (c *RenameTable) Children() []sql.Node

Children implements the Node interface.

func (*RenameTable) CollationCoercibility 

func (*RenameTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RenameTable) Database 

func (c *RenameTable) Database() sql.Database

Database implements the sql.Databaser interface.

func (*RenameTable) IsReadOnly 

func (r *RenameTable) IsReadOnly() bool

func (*RenameTable) Resolved 

func (c *RenameTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*RenameTable) RowIter 

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

func (*RenameTable) Schema 

func (*RenameTable) Schema() sql.Schema

Schema implements the Node interface.

func (*RenameTable) String 

func (r *RenameTable) String() string

func (*RenameTable) WithChildren 

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

func (*RenameTable) WithDatabase 

func (r *RenameTable) WithDatabase(db sql.Database) (sql.Node, error)

type RenameUser 

type RenameUser struct {
	OldName []UserName
	NewName []UserName
}

RenameUser represents the statement RENAME USER.

func NewRenameUser 

func NewRenameUser(oldNames []UserName, newNames []UserName) *RenameUser

NewRenameUser returns a new RenameUser node.

func (*RenameUser) CheckPrivileges 

func (n *RenameUser) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RenameUser) Children 

func (n *RenameUser) Children() []sql.Node

Children implements the interface sql.Node.

func (*RenameUser) CollationCoercibility 

func (*RenameUser) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RenameUser) IsReadOnly 

func (n *RenameUser) IsReadOnly() bool

func (*RenameUser) Resolved 

func (n *RenameUser) Resolved() bool

Resolved implements the interface sql.Node.

func (*RenameUser) RowIter 

func (n *RenameUser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*RenameUser) Schema 

func (n *RenameUser) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*RenameUser) String 

func (n *RenameUser) String() string

String implements the interface sql.Node.

func (*RenameUser) WithChildren 

func (n *RenameUser) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type Repeat 

type Repeat struct {
	*Loop
}

Repeat represents the REPEAT statement, which loops over a set of statements until the condition is true.

func NewRepeat 

func NewRepeat(label string, condition sql.Expression, block *Block) *Repeat

NewRepeat returns a new *Repeat node.

func (*Repeat) DebugString 

func (r *Repeat) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*Repeat) String 

func (r *Repeat) String() string

String implements the interface sql.Node.

func (*Repeat) WithChildren 

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

WithChildren implements the interface sql.Node.

func (*Repeat) WithExpressions 

func (r *Repeat) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the interface sql.Node.

type RepresentsBlock 

type RepresentsBlock interface {
	sql.Node
	// contains filtered or unexported methods
}

RepresentsBlock is an interface that defines whether a node contains a Block node, or contains multiple child statements similar to a block node. As a rule of thumb, if a parent node depends upon a child node, either explicitly or implicitly, then it does not represent a Block.

type RepresentsLabeledBlock 

type RepresentsLabeledBlock interface {
	RepresentsBlock
	GetBlockLabel(ctx *sql.Context) string
	RepresentsLoop() bool
}

RepresentsLabeledBlock is an interface that defines whether a node represents a Block node, while also carrying a label that may be referenced by statements within the block (such as LEAVE, ITERATE, etc.). Some statements that use labels only look for labels on statements that loop (such as LOOP and REPEAT), so there's an additional function to check whether this also represents a loop.

type RepresentsScope 

type RepresentsScope interface {
	RepresentsBlock
	// contains filtered or unexported methods
}

RepresentsScope is an interface that defines whether a node represents a new scope. Scopes define boundaries that are used for variable resolution and control flow modification (via condition handling, etc.).

type ResetReplica 

type ResetReplica struct {
	ReplicaController binlogreplication.BinlogReplicaController
	All               bool
}

ResetReplica is a plan node for the "RESET REPLICA" statement. https://dev.mysql.com/doc/refman/8.0/en/reset-replica.html

func NewResetReplica 

func NewResetReplica(all bool) *ResetReplica

func (*ResetReplica) CheckPrivileges 

func (r *ResetReplica) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*ResetReplica) Children 

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

func (*ResetReplica) CollationCoercibility 

func (*ResetReplica) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ResetReplica) IsReadOnly 

func (r *ResetReplica) IsReadOnly() bool

func (*ResetReplica) Resolved 

func (r *ResetReplica) Resolved() bool

func (*ResetReplica) Schema 

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

func (*ResetReplica) String 

func (r *ResetReplica) String() string

func (*ResetReplica) WithBinlogReplicaController 

func (r *ResetReplica) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*ResetReplica) WithChildren 

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

type ResolvedTable 

type ResolvedTable struct {
	sql.Table
	SqlDatabase sql.Database
	AsOf        interface{}
	// contains filtered or unexported fields
}

ResolvedTable represents a resolved SQL Table.

func NewResolvedDualTable 

func NewResolvedDualTable() *ResolvedTable

NewResolvedDualTable creates a new instance of ResolvedTable.

func NewResolvedTable 

func NewResolvedTable(table sql.Table, db sql.Database, asOf interface{}) *ResolvedTable

NewResolvedTable creates a new instance of ResolvedTable.

func (*ResolvedTable) CheckPrivileges 

func (t *ResolvedTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ResolvedTable) Children 

func (*ResolvedTable) Children() []sql.Node

Children implements the Node interface.

func (*ResolvedTable) CollationCoercibility 

func (*ResolvedTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ResolvedTable) Columns 

func (t *ResolvedTable) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*ResolvedTable) Comment 

func (t *ResolvedTable) Comment() string

func (*ResolvedTable) Database 

func (t *ResolvedTable) Database() sql.Database

func (*ResolvedTable) DebugString 

func (t *ResolvedTable) DebugString() string

func (*ResolvedTable) Id 

func (t *ResolvedTable) Id() sql.TableId

Id implements sql.TableIdNode

func (*ResolvedTable) IsReadOnly 

func (*ResolvedTable) IsReadOnly() bool

func (ResolvedTable) ReplaceTable 

func (t ResolvedTable) ReplaceTable(table sql.Table) (sql.MutableTableNode, error)

ReplaceTable returns this Node with the given table without performing any re-wrapping of any MutableTableWrapper

func (*ResolvedTable) Resolved 

func (*ResolvedTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*ResolvedTable) String 

func (t *ResolvedTable) String() string

func (*ResolvedTable) UnderlyingTable 

func (t *ResolvedTable) UnderlyingTable() sql.Table

UnderlyingTable returns the table wrapped by the ResolvedTable.

func (*ResolvedTable) UnwrappedDatabase 

func (t *ResolvedTable) UnwrappedDatabase() sql.Database

func (*ResolvedTable) WithChildren 

func (t *ResolvedTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*ResolvedTable) WithColumns 

func (t *ResolvedTable) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*ResolvedTable) WithComment 

func (t *ResolvedTable) WithComment(s string) sql.Node

func (*ResolvedTable) WithDatabase 

func (t *ResolvedTable) WithDatabase(database sql.Database) (sql.Node, error)

func (*ResolvedTable) WithId 

func (t *ResolvedTable) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*ResolvedTable) WithName 

func (t *ResolvedTable) WithName(s string) sql.Node

func (ResolvedTable) WithTable 

func (t ResolvedTable) WithTable(table sql.Table) (sql.MutableTableNode, error)

WithTable returns this Node with the given table, re-wrapping it with any MutableTableWrapper that was wrapping it prior to this call.

func (*ResolvedTable) WrappedTable 

func (t *ResolvedTable) WrappedTable() sql.Table

type Revoke 

type Revoke struct {
	Privileges     []Privilege
	ObjectType     ObjectType
	PrivilegeLevel PrivilegeLevel
	Users          []UserName
	MySQLDb        sql.Database
}

Revoke represents the statement REVOKE [privilege...] ON [item] FROM [user...].

func (*Revoke) CheckPrivileges 

func (n *Revoke) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Revoke) Children 

func (n *Revoke) Children() []sql.Node

Children implements the interface sql.Node.

func (*Revoke) CollationCoercibility 

func (*Revoke) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Revoke) Database 

func (n *Revoke) Database() sql.Database

Database implements the interface sql.Databaser.

func (*Revoke) HandleDatabasePrivileges 

func (n *Revoke) HandleDatabasePrivileges(user *mysql_db.User, dbName string) error

HandleDatabasePrivileges handles removing database privileges from a user.

func (*Revoke) HandleGlobalPrivileges 

func (n *Revoke) HandleGlobalPrivileges(user *mysql_db.User) error

HandleGlobalPrivileges handles removing global privileges from a user.

func (*Revoke) HandleRoutinePrivileges 

func (n *Revoke) HandleRoutinePrivileges(user *mysql_db.User, dbName string, routineName string, isProcedureType bool) error

func (*Revoke) HandleTablePrivileges 

func (n *Revoke) HandleTablePrivileges(user *mysql_db.User, dbName string, tblName string) error

HandleTablePrivileges handles removing table privileges from a user.

func (*Revoke) IsReadOnly 

func (n *Revoke) IsReadOnly() bool

func (*Revoke) Resolved 

func (n *Revoke) Resolved() bool

Resolved implements the interface sql.Node.

func (*Revoke) Schema 

func (n *Revoke) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*Revoke) String 

func (n *Revoke) String() string

String implements the interface sql.Node.

func (*Revoke) WithChildren 

func (n *Revoke) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*Revoke) WithDatabase 

func (n *Revoke) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type RevokeAll 

type RevokeAll struct {
	Users []UserName
}

RevokeAll represents the statement REVOKE ALL PRIVILEGES.

func NewRevokeAll 

func NewRevokeAll(users []UserName) *RevokeAll

NewRevokeAll returns a new RevokeAll node.

func (*RevokeAll) CheckPrivileges 

func (n *RevokeAll) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RevokeAll) Children 

func (n *RevokeAll) Children() []sql.Node

Children implements the interface sql.Node.

func (*RevokeAll) CollationCoercibility 

func (*RevokeAll) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RevokeAll) IsReadOnly 

func (n *RevokeAll) IsReadOnly() bool

func (*RevokeAll) Resolved 

func (n *RevokeAll) Resolved() bool

Resolved implements the interface sql.Node.

func (*RevokeAll) Schema 

func (n *RevokeAll) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*RevokeAll) String 

func (n *RevokeAll) String() string

String implements the interface sql.Node.

func (*RevokeAll) WithChildren 

func (n *RevokeAll) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type RevokeProxy 

type RevokeProxy struct {
	On   UserName
	From []UserName
}

RevokeProxy represents the statement REVOKE PROXY.

func NewRevokeProxy 

func NewRevokeProxy(on UserName, from []UserName) *RevokeProxy

NewRevokeProxy returns a new RevokeProxy node.

func (*RevokeProxy) CheckPrivileges 

func (n *RevokeProxy) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RevokeProxy) Children 

func (n *RevokeProxy) Children() []sql.Node

Children implements the interface sql.Node.

func (*RevokeProxy) CollationCoercibility 

func (*RevokeProxy) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RevokeProxy) IsReadOnly 

func (n *RevokeProxy) IsReadOnly() bool

func (*RevokeProxy) Resolved 

func (n *RevokeProxy) Resolved() bool

Resolved implements the interface sql.Node.

func (*RevokeProxy) RowIter 

func (n *RevokeProxy) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*RevokeProxy) Schema 

func (n *RevokeProxy) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*RevokeProxy) String 

func (n *RevokeProxy) String() string

String implements the interface sql.Node.

func (*RevokeProxy) WithChildren 

func (n *RevokeProxy) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type RevokeRole 

type RevokeRole struct {
	Roles       []UserName
	TargetUsers []UserName
	MySQLDb     sql.Database
}

RevokeRole represents the statement REVOKE [role...] FROM [user...].

func NewRevokeRole 

func NewRevokeRole(roles []UserName, users []UserName) *RevokeRole

NewRevokeRole returns a new RevokeRole node.

func (*RevokeRole) CheckPrivileges 

func (n *RevokeRole) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*RevokeRole) Children 

func (n *RevokeRole) Children() []sql.Node

Children implements the interface sql.Node.

func (*RevokeRole) CollationCoercibility 

func (*RevokeRole) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*RevokeRole) Database 

func (n *RevokeRole) Database() sql.Database

Database implements the interface sql.Databaser.

func (*RevokeRole) IsReadOnly 

func (n *RevokeRole) IsReadOnly() bool

func (*RevokeRole) Resolved 

func (n *RevokeRole) Resolved() bool

Resolved implements the interface sql.Node.

func (*RevokeRole) Schema 

func (n *RevokeRole) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*RevokeRole) String 

func (n *RevokeRole) String() string

String implements the interface sql.Node.

func (*RevokeRole) WithChildren 

func (n *RevokeRole) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*RevokeRole) WithDatabase 

func (n *RevokeRole) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type Rollback 

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

Rollback undoes the changes performed in the current transaction. For compatibility, sessions that don't implement sql.TransactionSession treat this as a no-op.

func NewRollback 

func NewRollback() *Rollback

NewRollback creates a new Rollback node.

func (Rollback) CheckPrivileges 

func (Rollback) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (Rollback) Children 

func (Rollback) Children() []sql.Node

func (*Rollback) CollationCoercibility 

func (*Rollback) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (Rollback) IsReadOnly 

func (Rollback) IsReadOnly() bool

func (Rollback) Resolved 

func (Rollback) Resolved() bool

Resolved implements the sql.Node interface.

func (*Rollback) RowIter 

func (r *Rollback) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (Rollback) Schema 

func (Rollback) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Rollback) String 

func (*Rollback) String() string

func (*Rollback) WithChildren 

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

WithChildren implements the Node interface.

type RollbackSavepoint 

type RollbackSavepoint struct {
	Name string
	// contains filtered or unexported fields
}

RollbackSavepoint rolls back the current transaction to the given savepoint. For sessions that don't implement sql.TransactionSession, this is a no-op.

func NewRollbackSavepoint 

func NewRollbackSavepoint(name string) *RollbackSavepoint

NewRollbackSavepoint creates a new RollbackSavepoint node.

func (RollbackSavepoint) CheckPrivileges 

func (RollbackSavepoint) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (RollbackSavepoint) Children 

func (RollbackSavepoint) Children() []sql.Node

func (*RollbackSavepoint) CollationCoercibility 

func (*RollbackSavepoint) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (RollbackSavepoint) IsReadOnly 

func (RollbackSavepoint) IsReadOnly() bool

func (RollbackSavepoint) Resolved 

func (RollbackSavepoint) Resolved() bool

Resolved implements the sql.Node interface.

func (*RollbackSavepoint) RowIter 

func (r *RollbackSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (RollbackSavepoint) Schema 

func (RollbackSavepoint) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*RollbackSavepoint) String 

func (r *RollbackSavepoint) String() string

func (*RollbackSavepoint) WithChildren 

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

WithChildren implements the Node interface.

type RowUpdateAccumulator 

type RowUpdateAccumulator struct {
	UnaryNode
	RowUpdateType
}

RowUpdateAccumulator wraps other nodes that update tables, and returns their results as OKResults with the appropriate fields set.

func NewRowUpdateAccumulator 

func NewRowUpdateAccumulator(n sql.Node, updateType RowUpdateType) *RowUpdateAccumulator

NewRowUpdateResult returns a new RowUpdateResult with the given node to wrap.

func (RowUpdateAccumulator) CheckPrivileges 

func (r RowUpdateAccumulator) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (RowUpdateAccumulator) Child 

func (r RowUpdateAccumulator) Child() sql.Node

func (RowUpdateAccumulator) CollationCoercibility 

func (r RowUpdateAccumulator) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (RowUpdateAccumulator) DebugString 

func (r RowUpdateAccumulator) DebugString() string

func (RowUpdateAccumulator) IsReadOnly 

func (r RowUpdateAccumulator) IsReadOnly() bool

func (RowUpdateAccumulator) Schema 

func (r RowUpdateAccumulator) Schema() sql.Schema

func (RowUpdateAccumulator) String 

func (r RowUpdateAccumulator) String() string

func (RowUpdateAccumulator) WithChildren 

func (r RowUpdateAccumulator) WithChildren(children ...sql.Node) (sql.Node, error)

type RowUpdateType 

type RowUpdateType int
const (
	UpdateTypeInsert RowUpdateType = iota
	UpdateTypeReplace
	UpdateTypeDuplicateKeyUpdate
	UpdateTypeUpdate
	UpdateTypeDelete
	UpdateTypeJoinUpdate
)

type RowsCurrentRowToCurrentRowFrame 

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

func NewRowsCurrentRowToCurrentRowFrame 

func NewRowsCurrentRowToCurrentRowFrame() *RowsCurrentRowToCurrentRowFrame

func (*RowsCurrentRowToCurrentRowFrame) DebugString 

func (f *RowsCurrentRowToCurrentRowFrame) DebugString() string

func (*RowsCurrentRowToCurrentRowFrame) EndCurrentRow 

func (f *RowsCurrentRowToCurrentRowFrame) EndCurrentRow() bool

func (*RowsCurrentRowToCurrentRowFrame) EndNFollowing 

func (f *RowsCurrentRowToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RowsCurrentRowToCurrentRowFrame) EndNPreceding 

func (f *RowsCurrentRowToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RowsCurrentRowToCurrentRowFrame) NewFramer 

func (f *RowsCurrentRowToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsCurrentRowToCurrentRowFrame) StartCurrentRow 

func (f *RowsCurrentRowToCurrentRowFrame) StartCurrentRow() bool

func (*RowsCurrentRowToCurrentRowFrame) StartNFollowing 

func (f *RowsCurrentRowToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RowsCurrentRowToCurrentRowFrame) StartNPreceding 

func (f *RowsCurrentRowToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RowsCurrentRowToCurrentRowFrame) String 

func (f *RowsCurrentRowToCurrentRowFrame) String() string

func (*RowsCurrentRowToCurrentRowFrame) UnboundedFollowing 

func (f *RowsCurrentRowToCurrentRowFrame) UnboundedFollowing() bool

func (*RowsCurrentRowToCurrentRowFrame) UnboundedPreceding 

func (f *RowsCurrentRowToCurrentRowFrame) UnboundedPreceding() bool

type RowsCurrentRowToNFollowingFrame 

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

func NewRowsCurrentRowToNFollowingFrame 

func NewRowsCurrentRowToNFollowingFrame(endNFollowing sql.Expression) *RowsCurrentRowToNFollowingFrame

func (*RowsCurrentRowToNFollowingFrame) DebugString 

func (f *RowsCurrentRowToNFollowingFrame) DebugString() string

func (*RowsCurrentRowToNFollowingFrame) EndCurrentRow 

func (f *RowsCurrentRowToNFollowingFrame) EndCurrentRow() bool

func (*RowsCurrentRowToNFollowingFrame) EndNFollowing 

func (f *RowsCurrentRowToNFollowingFrame) EndNFollowing() sql.Expression

func (*RowsCurrentRowToNFollowingFrame) EndNPreceding 

func (f *RowsCurrentRowToNFollowingFrame) EndNPreceding() sql.Expression

func (*RowsCurrentRowToNFollowingFrame) NewFramer 

func (f *RowsCurrentRowToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsCurrentRowToNFollowingFrame) StartCurrentRow 

func (f *RowsCurrentRowToNFollowingFrame) StartCurrentRow() bool

func (*RowsCurrentRowToNFollowingFrame) StartNFollowing 

func (f *RowsCurrentRowToNFollowingFrame) StartNFollowing() sql.Expression

func (*RowsCurrentRowToNFollowingFrame) StartNPreceding 

func (f *RowsCurrentRowToNFollowingFrame) StartNPreceding() sql.Expression

func (*RowsCurrentRowToNFollowingFrame) String 

func (f *RowsCurrentRowToNFollowingFrame) String() string

func (*RowsCurrentRowToNFollowingFrame) UnboundedFollowing 

func (f *RowsCurrentRowToNFollowingFrame) UnboundedFollowing() bool

func (*RowsCurrentRowToNFollowingFrame) UnboundedPreceding 

func (f *RowsCurrentRowToNFollowingFrame) UnboundedPreceding() bool

type RowsCurrentRowToNPrecedingFrame 

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

func NewRowsCurrentRowToNPrecedingFrame 

func NewRowsCurrentRowToNPrecedingFrame(endNPreceding sql.Expression) *RowsCurrentRowToNPrecedingFrame

func (*RowsCurrentRowToNPrecedingFrame) DebugString 

func (f *RowsCurrentRowToNPrecedingFrame) DebugString() string

func (*RowsCurrentRowToNPrecedingFrame) EndCurrentRow 

func (f *RowsCurrentRowToNPrecedingFrame) EndCurrentRow() bool

func (*RowsCurrentRowToNPrecedingFrame) EndNFollowing 

func (f *RowsCurrentRowToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RowsCurrentRowToNPrecedingFrame) EndNPreceding 

func (f *RowsCurrentRowToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RowsCurrentRowToNPrecedingFrame) NewFramer 

func (f *RowsCurrentRowToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsCurrentRowToNPrecedingFrame) StartCurrentRow 

func (f *RowsCurrentRowToNPrecedingFrame) StartCurrentRow() bool

func (*RowsCurrentRowToNPrecedingFrame) StartNFollowing 

func (f *RowsCurrentRowToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RowsCurrentRowToNPrecedingFrame) StartNPreceding 

func (f *RowsCurrentRowToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RowsCurrentRowToNPrecedingFrame) String 

func (f *RowsCurrentRowToNPrecedingFrame) String() string

func (*RowsCurrentRowToNPrecedingFrame) UnboundedFollowing 

func (f *RowsCurrentRowToNPrecedingFrame) UnboundedFollowing() bool

func (*RowsCurrentRowToNPrecedingFrame) UnboundedPreceding 

func (f *RowsCurrentRowToNPrecedingFrame) UnboundedPreceding() bool

type RowsCurrentRowToUnboundedFollowingFrame 

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

func NewRowsCurrentRowToUnboundedFollowingFrame 

func NewRowsCurrentRowToUnboundedFollowingFrame() *RowsCurrentRowToUnboundedFollowingFrame

func (*RowsCurrentRowToUnboundedFollowingFrame) DebugString 

func (f *RowsCurrentRowToUnboundedFollowingFrame) DebugString() string

func (*RowsCurrentRowToUnboundedFollowingFrame) EndCurrentRow 

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RowsCurrentRowToUnboundedFollowingFrame) EndNFollowing 

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RowsCurrentRowToUnboundedFollowingFrame) EndNPreceding 

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RowsCurrentRowToUnboundedFollowingFrame) NewFramer 

func (f *RowsCurrentRowToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsCurrentRowToUnboundedFollowingFrame) StartCurrentRow 

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RowsCurrentRowToUnboundedFollowingFrame) StartNFollowing 

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RowsCurrentRowToUnboundedFollowingFrame) StartNPreceding 

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RowsCurrentRowToUnboundedFollowingFrame) String 

func (f *RowsCurrentRowToUnboundedFollowingFrame) String() string

func (*RowsCurrentRowToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RowsCurrentRowToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RowsCurrentRowToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RowsCurrentRowToUnboundedFollowingFrame) UnboundedPreceding() bool

type RowsNFollowingToCurrentRowFrame 

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

func NewRowsNFollowingToCurrentRowFrame 

func NewRowsNFollowingToCurrentRowFrame(startNFollowing sql.Expression) *RowsNFollowingToCurrentRowFrame

func (*RowsNFollowingToCurrentRowFrame) DebugString 

func (f *RowsNFollowingToCurrentRowFrame) DebugString() string

func (*RowsNFollowingToCurrentRowFrame) EndCurrentRow 

func (f *RowsNFollowingToCurrentRowFrame) EndCurrentRow() bool

func (*RowsNFollowingToCurrentRowFrame) EndNFollowing 

func (f *RowsNFollowingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RowsNFollowingToCurrentRowFrame) EndNPreceding 

func (f *RowsNFollowingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RowsNFollowingToCurrentRowFrame) NewFramer 

func (f *RowsNFollowingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNFollowingToCurrentRowFrame) StartCurrentRow 

func (f *RowsNFollowingToCurrentRowFrame) StartCurrentRow() bool

func (*RowsNFollowingToCurrentRowFrame) StartNFollowing 

func (f *RowsNFollowingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RowsNFollowingToCurrentRowFrame) StartNPreceding 

func (f *RowsNFollowingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RowsNFollowingToCurrentRowFrame) String 

func (f *RowsNFollowingToCurrentRowFrame) String() string

func (*RowsNFollowingToCurrentRowFrame) UnboundedFollowing 

func (f *RowsNFollowingToCurrentRowFrame) UnboundedFollowing() bool

func (*RowsNFollowingToCurrentRowFrame) UnboundedPreceding 

func (f *RowsNFollowingToCurrentRowFrame) UnboundedPreceding() bool

type RowsNFollowingToNFollowingFrame 

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

func NewRowsNFollowingToNFollowingFrame 

func NewRowsNFollowingToNFollowingFrame(startNFollowing sql.Expression, endNFollowing sql.Expression) *RowsNFollowingToNFollowingFrame

func (*RowsNFollowingToNFollowingFrame) DebugString 

func (f *RowsNFollowingToNFollowingFrame) DebugString() string

func (*RowsNFollowingToNFollowingFrame) EndCurrentRow 

func (f *RowsNFollowingToNFollowingFrame) EndCurrentRow() bool

func (*RowsNFollowingToNFollowingFrame) EndNFollowing 

func (f *RowsNFollowingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RowsNFollowingToNFollowingFrame) EndNPreceding 

func (f *RowsNFollowingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RowsNFollowingToNFollowingFrame) NewFramer 

func (f *RowsNFollowingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNFollowingToNFollowingFrame) StartCurrentRow 

func (f *RowsNFollowingToNFollowingFrame) StartCurrentRow() bool

func (*RowsNFollowingToNFollowingFrame) StartNFollowing 

func (f *RowsNFollowingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RowsNFollowingToNFollowingFrame) StartNPreceding 

func (f *RowsNFollowingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RowsNFollowingToNFollowingFrame) String 

func (f *RowsNFollowingToNFollowingFrame) String() string

func (*RowsNFollowingToNFollowingFrame) UnboundedFollowing 

func (f *RowsNFollowingToNFollowingFrame) UnboundedFollowing() bool

func (*RowsNFollowingToNFollowingFrame) UnboundedPreceding 

func (f *RowsNFollowingToNFollowingFrame) UnboundedPreceding() bool

type RowsNFollowingToNPrecedingFrame 

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

func NewRowsNFollowingToNPrecedingFrame 

func NewRowsNFollowingToNPrecedingFrame(startNFollowing sql.Expression, endNPreceding sql.Expression) *RowsNFollowingToNPrecedingFrame

func (*RowsNFollowingToNPrecedingFrame) DebugString 

func (f *RowsNFollowingToNPrecedingFrame) DebugString() string

func (*RowsNFollowingToNPrecedingFrame) EndCurrentRow 

func (f *RowsNFollowingToNPrecedingFrame) EndCurrentRow() bool

func (*RowsNFollowingToNPrecedingFrame) EndNFollowing 

func (f *RowsNFollowingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RowsNFollowingToNPrecedingFrame) EndNPreceding 

func (f *RowsNFollowingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RowsNFollowingToNPrecedingFrame) NewFramer 

func (f *RowsNFollowingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNFollowingToNPrecedingFrame) StartCurrentRow 

func (f *RowsNFollowingToNPrecedingFrame) StartCurrentRow() bool

func (*RowsNFollowingToNPrecedingFrame) StartNFollowing 

func (f *RowsNFollowingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RowsNFollowingToNPrecedingFrame) StartNPreceding 

func (f *RowsNFollowingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RowsNFollowingToNPrecedingFrame) String 

func (f *RowsNFollowingToNPrecedingFrame) String() string

func (*RowsNFollowingToNPrecedingFrame) UnboundedFollowing 

func (f *RowsNFollowingToNPrecedingFrame) UnboundedFollowing() bool

func (*RowsNFollowingToNPrecedingFrame) UnboundedPreceding 

func (f *RowsNFollowingToNPrecedingFrame) UnboundedPreceding() bool

type RowsNFollowingToUnboundedFollowingFrame 

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

func NewRowsNFollowingToUnboundedFollowingFrame 

func NewRowsNFollowingToUnboundedFollowingFrame(startNFollowing sql.Expression) *RowsNFollowingToUnboundedFollowingFrame

func (*RowsNFollowingToUnboundedFollowingFrame) DebugString 

func (f *RowsNFollowingToUnboundedFollowingFrame) DebugString() string

func (*RowsNFollowingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RowsNFollowingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RowsNFollowingToUnboundedFollowingFrame) EndNFollowing 

func (f *RowsNFollowingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RowsNFollowingToUnboundedFollowingFrame) EndNPreceding 

func (f *RowsNFollowingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RowsNFollowingToUnboundedFollowingFrame) NewFramer 

func (f *RowsNFollowingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNFollowingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RowsNFollowingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RowsNFollowingToUnboundedFollowingFrame) StartNFollowing 

func (f *RowsNFollowingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RowsNFollowingToUnboundedFollowingFrame) StartNPreceding 

func (f *RowsNFollowingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RowsNFollowingToUnboundedFollowingFrame) String 

func (f *RowsNFollowingToUnboundedFollowingFrame) String() string

func (*RowsNFollowingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RowsNFollowingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RowsNFollowingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RowsNFollowingToUnboundedFollowingFrame) UnboundedPreceding() bool

type RowsNPrecedingToCurrentRowFrame 

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

func NewRowsNPrecedingToCurrentRowFrame 

func NewRowsNPrecedingToCurrentRowFrame(startNPreceding sql.Expression) *RowsNPrecedingToCurrentRowFrame

func (*RowsNPrecedingToCurrentRowFrame) DebugString 

func (f *RowsNPrecedingToCurrentRowFrame) DebugString() string

func (*RowsNPrecedingToCurrentRowFrame) EndCurrentRow 

func (f *RowsNPrecedingToCurrentRowFrame) EndCurrentRow() bool

func (*RowsNPrecedingToCurrentRowFrame) EndNFollowing 

func (f *RowsNPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RowsNPrecedingToCurrentRowFrame) EndNPreceding 

func (f *RowsNPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RowsNPrecedingToCurrentRowFrame) NewFramer 

func (f *RowsNPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNPrecedingToCurrentRowFrame) StartCurrentRow 

func (f *RowsNPrecedingToCurrentRowFrame) StartCurrentRow() bool

func (*RowsNPrecedingToCurrentRowFrame) StartNFollowing 

func (f *RowsNPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RowsNPrecedingToCurrentRowFrame) StartNPreceding 

func (f *RowsNPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RowsNPrecedingToCurrentRowFrame) String 

func (f *RowsNPrecedingToCurrentRowFrame) String() string

func (*RowsNPrecedingToCurrentRowFrame) UnboundedFollowing 

func (f *RowsNPrecedingToCurrentRowFrame) UnboundedFollowing() bool

func (*RowsNPrecedingToCurrentRowFrame) UnboundedPreceding 

func (f *RowsNPrecedingToCurrentRowFrame) UnboundedPreceding() bool

type RowsNPrecedingToNFollowingFrame 

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

func NewRowsNPrecedingToNFollowingFrame 

func NewRowsNPrecedingToNFollowingFrame(startNPreceding sql.Expression, endNFollowing sql.Expression) *RowsNPrecedingToNFollowingFrame

func (*RowsNPrecedingToNFollowingFrame) DebugString 

func (f *RowsNPrecedingToNFollowingFrame) DebugString() string

func (*RowsNPrecedingToNFollowingFrame) EndCurrentRow 

func (f *RowsNPrecedingToNFollowingFrame) EndCurrentRow() bool

func (*RowsNPrecedingToNFollowingFrame) EndNFollowing 

func (f *RowsNPrecedingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RowsNPrecedingToNFollowingFrame) EndNPreceding 

func (f *RowsNPrecedingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RowsNPrecedingToNFollowingFrame) NewFramer 

func (f *RowsNPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNPrecedingToNFollowingFrame) StartCurrentRow 

func (f *RowsNPrecedingToNFollowingFrame) StartCurrentRow() bool

func (*RowsNPrecedingToNFollowingFrame) StartNFollowing 

func (f *RowsNPrecedingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RowsNPrecedingToNFollowingFrame) StartNPreceding 

func (f *RowsNPrecedingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RowsNPrecedingToNFollowingFrame) String 

func (f *RowsNPrecedingToNFollowingFrame) String() string

func (*RowsNPrecedingToNFollowingFrame) UnboundedFollowing 

func (f *RowsNPrecedingToNFollowingFrame) UnboundedFollowing() bool

func (*RowsNPrecedingToNFollowingFrame) UnboundedPreceding 

func (f *RowsNPrecedingToNFollowingFrame) UnboundedPreceding() bool

type RowsNPrecedingToNPrecedingFrame 

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

func NewRowsNPrecedingToNPrecedingFrame 

func NewRowsNPrecedingToNPrecedingFrame(startNPreceding sql.Expression, endNPreceding sql.Expression) *RowsNPrecedingToNPrecedingFrame

func (*RowsNPrecedingToNPrecedingFrame) DebugString 

func (f *RowsNPrecedingToNPrecedingFrame) DebugString() string

func (*RowsNPrecedingToNPrecedingFrame) EndCurrentRow 

func (f *RowsNPrecedingToNPrecedingFrame) EndCurrentRow() bool

func (*RowsNPrecedingToNPrecedingFrame) EndNFollowing 

func (f *RowsNPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RowsNPrecedingToNPrecedingFrame) EndNPreceding 

func (f *RowsNPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RowsNPrecedingToNPrecedingFrame) NewFramer 

func (f *RowsNPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNPrecedingToNPrecedingFrame) StartCurrentRow 

func (f *RowsNPrecedingToNPrecedingFrame) StartCurrentRow() bool

func (*RowsNPrecedingToNPrecedingFrame) StartNFollowing 

func (f *RowsNPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RowsNPrecedingToNPrecedingFrame) StartNPreceding 

func (f *RowsNPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RowsNPrecedingToNPrecedingFrame) String 

func (f *RowsNPrecedingToNPrecedingFrame) String() string

func (*RowsNPrecedingToNPrecedingFrame) UnboundedFollowing 

func (f *RowsNPrecedingToNPrecedingFrame) UnboundedFollowing() bool

func (*RowsNPrecedingToNPrecedingFrame) UnboundedPreceding 

func (f *RowsNPrecedingToNPrecedingFrame) UnboundedPreceding() bool

type RowsNPrecedingToUnboundedFollowingFrame 

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

func NewRowsNPrecedingToUnboundedFollowingFrame 

func NewRowsNPrecedingToUnboundedFollowingFrame(startNPreceding sql.Expression) *RowsNPrecedingToUnboundedFollowingFrame

func (*RowsNPrecedingToUnboundedFollowingFrame) DebugString 

func (f *RowsNPrecedingToUnboundedFollowingFrame) DebugString() string

func (*RowsNPrecedingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RowsNPrecedingToUnboundedFollowingFrame) EndNFollowing 

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RowsNPrecedingToUnboundedFollowingFrame) EndNPreceding 

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RowsNPrecedingToUnboundedFollowingFrame) NewFramer 

func (f *RowsNPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsNPrecedingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RowsNPrecedingToUnboundedFollowingFrame) StartNFollowing 

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RowsNPrecedingToUnboundedFollowingFrame) StartNPreceding 

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RowsNPrecedingToUnboundedFollowingFrame) String 

func (f *RowsNPrecedingToUnboundedFollowingFrame) String() string

func (*RowsNPrecedingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RowsNPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RowsNPrecedingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RowsNPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool

type RowsUnboundedPrecedingToCurrentRowFrame 

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

func NewRowsUnboundedPrecedingToCurrentRowFrame 

func NewRowsUnboundedPrecedingToCurrentRowFrame() *RowsUnboundedPrecedingToCurrentRowFrame

func (*RowsUnboundedPrecedingToCurrentRowFrame) DebugString 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) DebugString() string

func (*RowsUnboundedPrecedingToCurrentRowFrame) EndCurrentRow 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndCurrentRow() bool

func (*RowsUnboundedPrecedingToCurrentRowFrame) EndNFollowing 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToCurrentRowFrame) EndNPreceding 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToCurrentRowFrame) NewFramer 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsUnboundedPrecedingToCurrentRowFrame) StartCurrentRow 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartCurrentRow() bool

func (*RowsUnboundedPrecedingToCurrentRowFrame) StartNFollowing 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToCurrentRowFrame) StartNPreceding 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToCurrentRowFrame) String 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) String() string

func (*RowsUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing() bool

func (*RowsUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding 

func (f *RowsUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding() bool

type RowsUnboundedPrecedingToNFollowingFrame 

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

func NewRowsUnboundedPrecedingToNFollowingFrame 

func NewRowsUnboundedPrecedingToNFollowingFrame(endNFollowing sql.Expression) *RowsUnboundedPrecedingToNFollowingFrame

func (*RowsUnboundedPrecedingToNFollowingFrame) DebugString 

func (f *RowsUnboundedPrecedingToNFollowingFrame) DebugString() string

func (*RowsUnboundedPrecedingToNFollowingFrame) EndCurrentRow 

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndCurrentRow() bool

func (*RowsUnboundedPrecedingToNFollowingFrame) EndNFollowing 

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToNFollowingFrame) EndNPreceding 

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToNFollowingFrame) NewFramer 

func (f *RowsUnboundedPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsUnboundedPrecedingToNFollowingFrame) StartCurrentRow 

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartCurrentRow() bool

func (*RowsUnboundedPrecedingToNFollowingFrame) StartNFollowing 

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToNFollowingFrame) StartNPreceding 

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToNFollowingFrame) String 

func (f *RowsUnboundedPrecedingToNFollowingFrame) String() string

func (*RowsUnboundedPrecedingToNFollowingFrame) UnboundedFollowing 

func (f *RowsUnboundedPrecedingToNFollowingFrame) UnboundedFollowing() bool

func (*RowsUnboundedPrecedingToNFollowingFrame) UnboundedPreceding 

func (f *RowsUnboundedPrecedingToNFollowingFrame) UnboundedPreceding() bool

type RowsUnboundedPrecedingToNPrecedingFrame 

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

func NewRowsUnboundedPrecedingToNPrecedingFrame 

func NewRowsUnboundedPrecedingToNPrecedingFrame(endNPreceding sql.Expression) *RowsUnboundedPrecedingToNPrecedingFrame

func (*RowsUnboundedPrecedingToNPrecedingFrame) DebugString 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) DebugString() string

func (*RowsUnboundedPrecedingToNPrecedingFrame) EndCurrentRow 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndCurrentRow() bool

func (*RowsUnboundedPrecedingToNPrecedingFrame) EndNFollowing 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToNPrecedingFrame) EndNPreceding 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToNPrecedingFrame) NewFramer 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsUnboundedPrecedingToNPrecedingFrame) StartCurrentRow 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartCurrentRow() bool

func (*RowsUnboundedPrecedingToNPrecedingFrame) StartNFollowing 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToNPrecedingFrame) StartNPreceding 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToNPrecedingFrame) String 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) String() string

func (*RowsUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing() bool

func (*RowsUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding 

func (f *RowsUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding() bool

type RowsUnboundedPrecedingToUnboundedFollowingFrame 

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

func NewRowsUnboundedPrecedingToUnboundedFollowingFrame 

func NewRowsUnboundedPrecedingToUnboundedFollowingFrame() *RowsUnboundedPrecedingToUnboundedFollowingFrame

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) DebugString 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) DebugString() string

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) NewFramer 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error)

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) String 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) String() string

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool

func (*RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding 

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool

type Scope 

type Scope struct {

	// Memo nodes are nodes in the execution context that shouldn't be considered for name resolution, but are still
	// important for analysis.
	Memos []sql.Node

	// CurrentNodeIsFromSubqueryExpression is true when the last scope (i.e. the most inner of the outer scope levels) has been
	// created by a subquery expression. This is needed in order to calculate outer scope visibility for derived tables.
	CurrentNodeIsFromSubqueryExpression bool
	// EnforceReadOnly causes analysis to block all modification operations, as though a database is read only.
	EnforceReadOnly bool

	Procedures *ProcedureCache
	// 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) Correlated 

func (s *Scope) Correlated() sql.ColSet

func (*Scope) EnforcesReadOnly 

func (s *Scope) EnforcesReadOnly() bool

func (*Scope) InJoin 

func (s *Scope) InJoin() bool

func (*Scope) InLateralJoin 

func (s *Scope) InLateralJoin() 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 

func (s *Scope) IsEmpty() bool

func (*Scope) JoinSiblings 

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

func (*Scope) Memo 

func (s *Scope) Memo(node sql.Node) *Scope

Memo creates a new Scope object with the Memo node given. Memo nodes don't affect name resolution, but are used in other parts of analysis, such as error handling for trigger / procedure execution.

func (*Scope) MemoNodes 

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

func (*Scope) NewScope 

func (s *Scope) NewScope(node sql.Node) *Scope

NewScope creates a new Scope object with the additional innermost Node context. When constructing with a subquery, the Node given should be the sibling Node of the subquery.

func (*Scope) NewScopeFromSubqueryAlias 

func (s *Scope) NewScopeFromSubqueryAlias(sqa *SubqueryAlias) *Scope

NewScopeFromSubqueryAlias returns a new subscope created from the specified SubqueryAlias. Subquery aliases, or derived tables, generally do NOT have any visibility to outer scopes, but when they are nested inside a subquery expression, they may reference tables from the scopes outside the subquery expression's scope.

func (*Scope) NewScopeFromSubqueryExpression 

func (s *Scope) NewScopeFromSubqueryExpression(node sql.Node, corr sql.ColSet) *Scope

NewScopeFromSubqueryExpression returns a new subscope created from a subquery expression contained by the specified node. |corr| is the set of correlated columns referenced in this subquery, which is only implicit here because the subquery is distanced from its parent |node|.

func (*Scope) NewScopeInJoin 

func (s *Scope) NewScopeInJoin(node sql.Node) *Scope

NewScopeFromSubqueryExpression returns a new subscope created from a subquery expression contained by the specified node.

func (*Scope) NewScopeNoJoin 

func (s *Scope) NewScopeNoJoin() *Scope

newScopeFromSubqueryExpression returns a new subscope created from a subquery expression contained by the specified node.

func (*Scope) OuterRelUnresolved 

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) ProcedureCache 

func (s *Scope) ProcedureCache() *ProcedureCache

func (*Scope) ProceduresPopulating 

func (s *Scope) ProceduresPopulating() bool

func (*Scope) RecursionDepth 

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.

func (*Scope) SetJoin 

func (s *Scope) SetJoin(b bool)

func (*Scope) SetLateralJoin 

func (s *Scope) SetLateralJoin(b bool)

func (*Scope) WithMemos 

func (s *Scope) WithMemos(memoNodes []sql.Node) *Scope

WithMemos returns a new scope object identical to the receiver, but with its memos replaced with the ones given.

func (*Scope) WithProcedureCache 

func (s *Scope) WithProcedureCache(cache *ProcedureCache) *Scope

type Set 

type Set struct {
	Exprs []sql.Expression
}

Set represents a set statement. This can be variables, but in some instances can also refer to row values.

func NewSet 

func NewSet(vars []sql.Expression) *Set

NewSet creates a new Set node.

func (*Set) CheckPrivileges 

func (s *Set) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Set) Children 

func (s *Set) Children() []sql.Node

Children implements the sql.Node interface.

func (*Set) CollationCoercibility 

func (*Set) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Set) DebugString 

func (s *Set) DebugString() string

func (*Set) Expressions 

func (s *Set) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*Set) IsReadOnly 

func (s *Set) IsReadOnly() bool

func (*Set) Resolved 

func (s *Set) Resolved() bool

Resolved implements the sql.Node interface.

func (*Set) Schema 

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

Schema implements the sql.Node interface.

func (*Set) String 

func (s *Set) String() string

func (*Set) WithChildren 

func (s *Set) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*Set) WithExpressions 

func (s *Set) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type SetOp 

type SetOp struct {
	BinaryNode
	SetOpType  int
	Distinct   bool
	Limit      sql.Expression
	Offset     sql.Expression
	SortFields sql.SortFields
	// contains filtered or unexported fields
}

SetOp is a node that returns everything in Left and then everything in Right

func NewSetOp 

func NewSetOp(setOpType int, left, right sql.Node, distinct bool, limit, offset sql.Expression, sortFields sql.SortFields) *SetOp

NewSetOp creates a new SetOp node with the given children.

func (*SetOp) AddDispose 

func (s *SetOp) AddDispose(f sql.DisposeFunc)

func (*SetOp) CheckPrivileges 

func (s *SetOp) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*SetOp) CollationCoercibility 

func (*SetOp) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*SetOp) Columns 

func (s *SetOp) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*SetOp) DebugString 

func (s *SetOp) DebugString() string

func (*SetOp) Dispose 

func (s *SetOp) Dispose()

func (*SetOp) Expressions 

func (s *SetOp) Expressions() []sql.Expression

func (*SetOp) Id 

func (s *SetOp) Id() sql.TableId

Id implements sql.TableIdNode

func (*SetOp) IsReadOnly 

func (s *SetOp) IsReadOnly() bool

func (*SetOp) Name 

func (s *SetOp) Name() string

func (*SetOp) Opaque 

func (s *SetOp) Opaque() bool

Opaque implements the sql.OpaqueNode interface. Like SubqueryAlias, the selects in a SetOp must be evaluated in isolation.

func (*SetOp) Resolved 

func (s *SetOp) Resolved() bool

func (*SetOp) Schema 

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

func (*SetOp) String 

func (s *SetOp) String() string

func (*SetOp) WithChildren 

func (s *SetOp) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*SetOp) WithColumns 

func (s *SetOp) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*SetOp) WithDistinct 

func (s *SetOp) WithDistinct(b bool) *SetOp

func (*SetOp) WithExpressions 

func (s *SetOp) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*SetOp) WithId 

func (s *SetOp) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*SetOp) WithLimit 

func (s *SetOp) WithLimit(e sql.Expression) *SetOp

func (*SetOp) WithOffset 

func (s *SetOp) WithOffset(e sql.Expression) *SetOp

type ShowCharset 

type ShowCharset struct {
	CharacterSetTable sql.Node
}

func NewShowCharset 

func NewShowCharset() *ShowCharset

NewShowCharset returns a new ShowCharset reference.

func (*ShowCharset) CheckPrivileges 

func (sc *ShowCharset) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCharset) Children 

func (sc *ShowCharset) Children() []sql.Node

func (*ShowCharset) CollationCoercibility 

func (*ShowCharset) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCharset) IsReadOnly 

func (sc *ShowCharset) IsReadOnly() bool

func (*ShowCharset) Resolved 

func (sc *ShowCharset) Resolved() bool

Resolved implements sql.Node interface. The function always returns true.

func (*ShowCharset) RowIter 

func (sc *ShowCharset) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

func (*ShowCharset) Schema 

func (sc *ShowCharset) Schema() sql.Schema

Note how this Schema differs in order from the information_schema.character_sets table.

func (*ShowCharset) String 

func (sc *ShowCharset) String() string

func (*ShowCharset) WithChildren 

func (sc *ShowCharset) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ShowColumns 

type ShowColumns struct {
	UnaryNode
	Full    bool
	Indexes []sql.Index
	// contains filtered or unexported fields
}

ShowColumns shows the columns details of a table.

func NewShowColumns 

func NewShowColumns(full bool, child sql.Node) *ShowColumns

NewShowColumns creates a new ShowColumns node.

func (*ShowColumns) CheckPrivileges 

func (s *ShowColumns) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowColumns) CollationCoercibility 

func (*ShowColumns) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowColumns) DebugString 

func (s *ShowColumns) DebugString() string

func (*ShowColumns) Expressions 

func (s *ShowColumns) Expressions() []sql.Expression

func (*ShowColumns) IsReadOnly 

func (s *ShowColumns) IsReadOnly() bool

func (*ShowColumns) Resolved 

func (s *ShowColumns) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowColumns) Schema 

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

Schema implements the sql.Node interface.

func (*ShowColumns) String 

func (s *ShowColumns) String() string

func (*ShowColumns) TargetSchema 

func (s *ShowColumns) TargetSchema() sql.Schema

func (*ShowColumns) WithChildren 

func (s *ShowColumns) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (ShowColumns) WithExpressions 

func (s ShowColumns) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (*ShowColumns) WithTargetSchema 

func (s *ShowColumns) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type ShowCreateDatabase 

type ShowCreateDatabase struct {
	IfNotExists bool
	// contains filtered or unexported fields
}

ShowCreateDatabase returns the SQL for creating a database.

func NewShowCreateDatabase 

func NewShowCreateDatabase(db sql.Database, ifNotExists bool) *ShowCreateDatabase

NewShowCreateDatabase creates a new ShowCreateDatabase node.

func (*ShowCreateDatabase) CheckPrivileges 

func (s *ShowCreateDatabase) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCreateDatabase) Children 

func (s *ShowCreateDatabase) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowCreateDatabase) CollationCoercibility 

func (*ShowCreateDatabase) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCreateDatabase) Database 

func (s *ShowCreateDatabase) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowCreateDatabase) IsReadOnly 

func (s *ShowCreateDatabase) IsReadOnly() bool

func (*ShowCreateDatabase) Resolved 

func (s *ShowCreateDatabase) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowCreateDatabase) Schema 

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

Schema implements the sql.Node interface.

func (*ShowCreateDatabase) String 

func (s *ShowCreateDatabase) String() string

func (*ShowCreateDatabase) WithChildren 

func (s *ShowCreateDatabase) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*ShowCreateDatabase) WithDatabase 

func (s *ShowCreateDatabase) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ShowCreateEvent 

type ShowCreateEvent struct {
	Event sql.EventDefinition
	// contains filtered or unexported fields
}

func NewShowCreateEvent 

func NewShowCreateEvent(db sql.Database, event sql.EventDefinition) *ShowCreateEvent

NewShowCreateEvent creates a new ShowCreateEvent node for SHOW CREATE EVENT statements.

func (*ShowCreateEvent) CheckPrivileges 

func (s *ShowCreateEvent) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCreateEvent) Children 

func (s *ShowCreateEvent) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowCreateEvent) CollationCoercibility 

func (*ShowCreateEvent) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCreateEvent) Database 

func (s *ShowCreateEvent) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowCreateEvent) IsReadOnly 

func (s *ShowCreateEvent) IsReadOnly() bool

func (*ShowCreateEvent) Resolved 

func (s *ShowCreateEvent) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowCreateEvent) Schema 

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

Schema implements the sql.Node interface.

func (*ShowCreateEvent) String 

func (s *ShowCreateEvent) String() string

String implements the sql.Node interface.

func (*ShowCreateEvent) WithChildren 

func (s *ShowCreateEvent) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*ShowCreateEvent) WithDatabase 

func (s *ShowCreateEvent) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ShowCreateProcedure 

type ShowCreateProcedure struct {
	ProcedureName           string
	ExternalStoredProcedure *sql.ExternalStoredProcedureDetails
	// contains filtered or unexported fields
}

func NewShowCreateProcedure 

func NewShowCreateProcedure(db sql.Database, procedure string) *ShowCreateProcedure

NewShowCreateProcedure creates a new ShowCreateProcedure node for SHOW CREATE PROCEDURE statements.

func (*ShowCreateProcedure) CheckPrivileges 

func (s *ShowCreateProcedure) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCreateProcedure) Children 

func (s *ShowCreateProcedure) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowCreateProcedure) CollationCoercibility 

func (*ShowCreateProcedure) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCreateProcedure) Database 

func (s *ShowCreateProcedure) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowCreateProcedure) IsReadOnly 

func (s *ShowCreateProcedure) IsReadOnly() bool

func (*ShowCreateProcedure) Resolved 

func (s *ShowCreateProcedure) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowCreateProcedure) RowIter 

func (s *ShowCreateProcedure) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*ShowCreateProcedure) Schema 

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

Schema implements the sql.Node interface.

func (*ShowCreateProcedure) String 

func (s *ShowCreateProcedure) String() string

String implements the sql.Node interface.

func (*ShowCreateProcedure) WithChildren 

func (s *ShowCreateProcedure) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*ShowCreateProcedure) WithDatabase 

func (s *ShowCreateProcedure) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*ShowCreateProcedure) WithExternalStoredProcedure 

func (s *ShowCreateProcedure) WithExternalStoredProcedure(procedure sql.ExternalStoredProcedureDetails) sql.Node

WithExternalStoredProcedure returns a new ShowCreateProcedure node with the specified external stored procedure set as the procedure to be shown.

type ShowCreateTable 

type ShowCreateTable struct {
	*UnaryNode
	IsView  bool
	Indexes []sql.Index

	PrimaryKeySchema sql.PrimaryKeySchema
	// contains filtered or unexported fields
}

ShowCreateTable is a node that shows the CREATE TABLE statement for a table.

func NewShowCreateTable 

func NewShowCreateTable(table sql.Node, isView bool) *ShowCreateTable

NewShowCreateTable creates a new ShowCreateTable node.

func NewShowCreateTableWithAsOf 

func NewShowCreateTableWithAsOf(table sql.Node, isView bool, asOf sql.Expression) *ShowCreateTable

NewShowCreateTableWithAsOf creates a new ShowCreateTable node for a specific version of a table.

func (*ShowCreateTable) AsOf 

func (sc *ShowCreateTable) AsOf() sql.Expression

AsOf implements the Versionable interface.

func (*ShowCreateTable) CheckPrivileges 

func (sc *ShowCreateTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCreateTable) Checks 

func (sc *ShowCreateTable) Checks() sql.CheckConstraints

func (*ShowCreateTable) CollationCoercibility 

func (*ShowCreateTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCreateTable) Expressions 

func (sc *ShowCreateTable) Expressions() []sql.Expression

func (*ShowCreateTable) GetTargetSchema 

func (sc *ShowCreateTable) GetTargetSchema() sql.Schema

GetTargetSchema returns the final resolved target schema of show create table.

func (*ShowCreateTable) IsReadOnly 

func (sc *ShowCreateTable) IsReadOnly() bool

func (*ShowCreateTable) Resolved 

func (sc *ShowCreateTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*ShowCreateTable) Schema 

func (sc *ShowCreateTable) Schema() sql.Schema

Schema implements the Node interface.

func (*ShowCreateTable) String 

func (sc *ShowCreateTable) String() string

String implements the fmt.Stringer interface.

func (*ShowCreateTable) TargetSchema 

func (sc *ShowCreateTable) TargetSchema() sql.Schema

func (*ShowCreateTable) WithAsOf 

func (sc *ShowCreateTable) WithAsOf(asOf sql.Expression) (sql.Node, error)

WithAsOf implements the Versionable interface.

func (*ShowCreateTable) WithChecks 

func (sc *ShowCreateTable) WithChecks(checks sql.CheckConstraints) sql.Node

func (ShowCreateTable) WithChildren 

func (sc ShowCreateTable) WithChildren(children ...sql.Node) (sql.Node, error)

func (ShowCreateTable) WithExpressions 

func (sc ShowCreateTable) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

func (ShowCreateTable) WithPrimaryKeySchema 

func (sc ShowCreateTable) WithPrimaryKeySchema(schema sql.PrimaryKeySchema) (sql.Node, error)

func (ShowCreateTable) WithTargetSchema 

func (sc ShowCreateTable) WithTargetSchema(schema sql.Schema) (sql.Node, error)

type ShowCreateTrigger 

type ShowCreateTrigger struct {
	TriggerName string
	// contains filtered or unexported fields
}

func NewShowCreateTrigger 

func NewShowCreateTrigger(db sql.Database, trigger string) *ShowCreateTrigger

NewShowCreateTrigger creates a new ShowCreateTrigger node for SHOW CREATE TRIGGER statements.

func (*ShowCreateTrigger) CheckPrivileges 

func (s *ShowCreateTrigger) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowCreateTrigger) Children 

func (s *ShowCreateTrigger) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowCreateTrigger) CollationCoercibility 

func (*ShowCreateTrigger) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowCreateTrigger) Database 

func (s *ShowCreateTrigger) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowCreateTrigger) IsReadOnly 

func (s *ShowCreateTrigger) IsReadOnly() bool

func (*ShowCreateTrigger) Resolved 

func (s *ShowCreateTrigger) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowCreateTrigger) Schema 

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

Schema implements the sql.Node interface.

func (*ShowCreateTrigger) String 

func (s *ShowCreateTrigger) String() string

String implements the sql.Node interface.

func (*ShowCreateTrigger) WithChildren 

func (s *ShowCreateTrigger) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*ShowCreateTrigger) WithDatabase 

func (s *ShowCreateTrigger) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ShowDatabases 

type ShowDatabases struct {
	Catalog sql.Catalog
}

ShowDatabases is a node that shows the databases.

func NewShowDatabases 

func NewShowDatabases() *ShowDatabases

NewShowDatabases creates a new show databases node.

func (*ShowDatabases) CheckPrivileges 

func (p *ShowDatabases) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowDatabases) Children 

func (*ShowDatabases) Children() []sql.Node

Children implements the Node interface.

func (*ShowDatabases) CollationCoercibility 

func (*ShowDatabases) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowDatabases) IsReadOnly 

func (*ShowDatabases) IsReadOnly() bool

func (*ShowDatabases) Resolved 

func (p *ShowDatabases) Resolved() bool

Resolved implements the Resolvable interface.

func (*ShowDatabases) Schema 

func (*ShowDatabases) Schema() sql.Schema

Schema implements the Node interface.

func (ShowDatabases) String 

func (p ShowDatabases) String() string

func (*ShowDatabases) WithChildren 

func (p *ShowDatabases) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ShowEvents 

type ShowEvents struct {
	Events []sql.EventDefinition
	// contains filtered or unexported fields
}

func NewShowEvents 

func NewShowEvents(db sql.Database) *ShowEvents

NewShowEvents creates a new ShowEvents node for SHOW EVENTS statements.

func (*ShowEvents) CheckPrivileges 

func (s *ShowEvents) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowEvents) Children 

func (s *ShowEvents) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowEvents) CollationCoercibility 

func (*ShowEvents) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowEvents) Database 

func (s *ShowEvents) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowEvents) IsReadOnly 

func (s *ShowEvents) IsReadOnly() bool

func (*ShowEvents) Resolved 

func (s *ShowEvents) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowEvents) RowIter 

func (s *ShowEvents) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*ShowEvents) Schema 

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

Schema implements the sql.Node interface.

func (*ShowEvents) String 

func (s *ShowEvents) String() string

String implements the sql.Node interface.

func (*ShowEvents) WithChildren 

func (s *ShowEvents) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*ShowEvents) WithDatabase 

func (s *ShowEvents) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ShowGrants 

type ShowGrants struct {
	CurrentUser bool
	For         *UserName
	Using       []UserName
	MySQLDb     sql.Database
}

ShowGrants represents the statement SHOW GRANTS.

func (*ShowGrants) CheckPrivileges 

func (n *ShowGrants) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowGrants) Children 

func (n *ShowGrants) Children() []sql.Node

Children implements the interface sql.Node.

func (*ShowGrants) CollationCoercibility 

func (*ShowGrants) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowGrants) Database 

func (n *ShowGrants) Database() sql.Database

Database implements the interface sql.Databaser.

func (*ShowGrants) IsReadOnly 

func (n *ShowGrants) IsReadOnly() bool

func (*ShowGrants) Resolved 

func (n *ShowGrants) Resolved() bool

Resolved implements the interface sql.Node.

func (*ShowGrants) Schema 

func (n *ShowGrants) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*ShowGrants) String 

func (n *ShowGrants) String() string

String implements the interface sql.Node.

func (*ShowGrants) WithChildren 

func (n *ShowGrants) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*ShowGrants) WithDatabase 

func (n *ShowGrants) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the interface sql.Databaser.

type ShowIndexes 

type ShowIndexes struct {
	UnaryNode
	IndexesToShow []sql.Index
}

ShowIndexes is a node that shows the indexes on a table.

func NewShowIndexes 

func NewShowIndexes(table sql.Node) *ShowIndexes

NewShowIndexes creates a new ShowIndexes node. The node must represent a table.

func (*ShowIndexes) CheckPrivileges 

func (n *ShowIndexes) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowIndexes) CollationCoercibility 

func (*ShowIndexes) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowIndexes) IsReadOnly 

func (n *ShowIndexes) IsReadOnly() bool

func (*ShowIndexes) Schema 

func (n *ShowIndexes) Schema() sql.Schema

Schema implements the Node interface.

func (*ShowIndexes) String 

func (n *ShowIndexes) String() string

String implements the fmt.Stringer interface.

func (*ShowIndexes) WithChildren 

func (n *ShowIndexes) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ShowPrivileges 

type ShowPrivileges struct{}

ShowPrivileges represents the statement SHOW PRIVILEGES.

func NewShowPrivileges 

func NewShowPrivileges() *ShowPrivileges

NewShowPrivileges returns a new ShowPrivileges node.

func (*ShowPrivileges) CheckPrivileges 

func (n *ShowPrivileges) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowPrivileges) Children 

func (n *ShowPrivileges) Children() []sql.Node

Children implements the interface sql.Node.

func (*ShowPrivileges) CollationCoercibility 

func (*ShowPrivileges) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowPrivileges) IsReadOnly 

func (n *ShowPrivileges) IsReadOnly() bool

func (*ShowPrivileges) Resolved 

func (n *ShowPrivileges) Resolved() bool

Resolved implements the interface sql.Node.

func (*ShowPrivileges) RowIter 

func (n *ShowPrivileges) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the interface sql.Node.

func (*ShowPrivileges) Schema 

func (n *ShowPrivileges) Schema() sql.Schema

Schema implements the interface sql.Node.

func (*ShowPrivileges) String 

func (n *ShowPrivileges) String() string

String implements the interface sql.Node.

func (*ShowPrivileges) WithChildren 

func (n *ShowPrivileges) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

type ShowProcessList 

type ShowProcessList struct {
	Database string
}

ShowProcessList shows a list of all current running processes.

func NewShowProcessList 

func NewShowProcessList() *ShowProcessList

NewShowProcessList creates a new ProcessList node.

func (*ShowProcessList) CheckPrivileges 

func (p *ShowProcessList) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowProcessList) Children 

func (p *ShowProcessList) Children() []sql.Node

Children implements the Node interface.

func (*ShowProcessList) CollationCoercibility 

func (*ShowProcessList) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowProcessList) IsReadOnly 

func (p *ShowProcessList) IsReadOnly() bool

func (*ShowProcessList) Resolved 

func (p *ShowProcessList) Resolved() bool

Resolved implements the Node interface.

func (*ShowProcessList) Schema 

func (p *ShowProcessList) Schema() sql.Schema

Schema implements the Node interface.

func (*ShowProcessList) String 

func (p *ShowProcessList) String() string

func (*ShowProcessList) WithChildren 

func (p *ShowProcessList) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type ShowReplicaStatus 

type ShowReplicaStatus struct {
	ReplicaController binlogreplication.BinlogReplicaController
}

ShowReplicaStatus is the plan node for the "SHOW REPLICA STATUS" statement. https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html

func NewShowReplicaStatus 

func NewShowReplicaStatus() *ShowReplicaStatus

func (*ShowReplicaStatus) CheckPrivileges 

func (s *ShowReplicaStatus) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*ShowReplicaStatus) Children 

func (s *ShowReplicaStatus) Children() []sql.Node

func (*ShowReplicaStatus) CollationCoercibility 

func (*ShowReplicaStatus) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowReplicaStatus) IsReadOnly 

func (s *ShowReplicaStatus) IsReadOnly() bool

func (*ShowReplicaStatus) Resolved 

func (s *ShowReplicaStatus) Resolved() bool

func (*ShowReplicaStatus) Schema 

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

func (*ShowReplicaStatus) String 

func (s *ShowReplicaStatus) String() string

func (*ShowReplicaStatus) WithBinlogReplicaController 

func (s *ShowReplicaStatus) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*ShowReplicaStatus) WithChildren 

func (s *ShowReplicaStatus) WithChildren(children ...sql.Node) (sql.Node, error)

type ShowStatus 

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

ShowStatus implements the SHOW STATUS MySQL command.

func NewShowStatus 

func NewShowStatus(isGlobal bool) *ShowStatus

NewShowStatus returns a new ShowStatus reference.

func (*ShowStatus) CheckPrivileges 

func (s *ShowStatus) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowStatus) Children 

func (s *ShowStatus) Children() []sql.Node

Children implements sql.Node interface.

func (*ShowStatus) CollationCoercibility 

func (*ShowStatus) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowStatus) IsReadOnly 

func (s *ShowStatus) IsReadOnly() bool

IsReadOnly implements sql.Node interface.

func (*ShowStatus) Resolved 

func (s *ShowStatus) Resolved() bool

Resolved implements sql.Node interface.

func (*ShowStatus) RowIter 

func (s *ShowStatus) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error)

RowIter implements sql.Node interface.

func (*ShowStatus) Schema 

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

Schema implements sql.Node interface.

func (*ShowStatus) String 

func (s *ShowStatus) String() string

String implements sql.Node interface.

func (*ShowStatus) WithChildren 

func (s *ShowStatus) WithChildren(node ...sql.Node) (sql.Node, error)

WithChildren implements sql.Node interface.

type ShowTableStatus 

type ShowTableStatus struct {
	Catalog sql.Catalog
	// contains filtered or unexported fields
}

ShowTableStatus returns the status of the tables in a database.

func NewShowTableStatus 

func NewShowTableStatus(db sql.Database) *ShowTableStatus

NewShowTableStatus creates a new ShowTableStatus node.

func (*ShowTableStatus) CheckPrivileges 

func (s *ShowTableStatus) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowTableStatus) Children 

func (s *ShowTableStatus) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowTableStatus) CollationCoercibility 

func (*ShowTableStatus) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowTableStatus) Database 

func (s *ShowTableStatus) Database() sql.Database

func (*ShowTableStatus) IsReadOnly 

func (s *ShowTableStatus) IsReadOnly() bool

func (*ShowTableStatus) Resolved 

func (s *ShowTableStatus) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowTableStatus) Schema 

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

Schema implements the sql.Node interface.

func (*ShowTableStatus) String 

func (s *ShowTableStatus) String() string

func (*ShowTableStatus) WithChildren 

func (s *ShowTableStatus) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*ShowTableStatus) WithDatabase 

func (s *ShowTableStatus) WithDatabase(db sql.Database) (sql.Node, error)

type ShowTables 

type ShowTables struct {
	Full bool
	// contains filtered or unexported fields
}

ShowTables is a node that shows the database tables.

func NewShowTables 

func NewShowTables(database sql.Database, full bool, asOf sql.Expression) *ShowTables

NewShowTables creates a new show tables node given a database.

func (*ShowTables) AsOf 

func (p *ShowTables) AsOf() sql.Expression

AsOf implements the Versionable interface.

func (*ShowTables) CheckPrivileges 

func (p *ShowTables) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowTables) Children 

func (*ShowTables) Children() []sql.Node

Children implements the Node interface.

func (*ShowTables) CollationCoercibility 

func (*ShowTables) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowTables) Database 

func (p *ShowTables) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowTables) Expressions 

func (p *ShowTables) Expressions() []sql.Expression

Expressions implements sql.Expressioner

func (*ShowTables) IsReadOnly 

func (p *ShowTables) IsReadOnly() bool

func (*ShowTables) Resolved 

func (p *ShowTables) Resolved() bool

Resolved implements the Resolvable interface.

func (*ShowTables) Schema 

func (p *ShowTables) Schema() sql.Schema

Schema implements the Node interface.

func (ShowTables) String 

func (p ShowTables) String() string

func (*ShowTables) WithAsOf 

func (p *ShowTables) WithAsOf(asOf sql.Expression) (sql.Node, error)

WithAsOf implements the Versionable interface.

func (*ShowTables) WithChildren 

func (p *ShowTables) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*ShowTables) WithDatabase 

func (p *ShowTables) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

func (*ShowTables) WithExpressions 

func (p *ShowTables) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements sql.Expressioner

type ShowTriggers 

type ShowTriggers struct {
	Triggers []*CreateTrigger
	// contains filtered or unexported fields
}

func NewShowTriggers 

func NewShowTriggers(db sql.Database) *ShowTriggers

NewShowCreateTrigger creates a new ShowCreateTrigger node for SHOW TRIGGER statements.

func (*ShowTriggers) CheckPrivileges 

func (s *ShowTriggers) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowTriggers) Children 

func (s *ShowTriggers) Children() []sql.Node

Children implements the sql.Node interface.

func (*ShowTriggers) CollationCoercibility 

func (*ShowTriggers) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowTriggers) Database 

func (s *ShowTriggers) Database() sql.Database

Database implements the sql.Databaser interface.

func (*ShowTriggers) IsReadOnly 

func (s *ShowTriggers) IsReadOnly() bool

func (*ShowTriggers) Resolved 

func (s *ShowTriggers) Resolved() bool

Resolved implements the sql.Node interface.

func (*ShowTriggers) Schema 

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

Schema implements the sql.Node interface.

func (*ShowTriggers) String 

func (s *ShowTriggers) String() string

String implements the sql.Node interface.

func (*ShowTriggers) WithChildren 

func (s *ShowTriggers) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (*ShowTriggers) WithDatabase 

func (s *ShowTriggers) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type ShowVariables 

type ShowVariables struct {
	Filter sql.Expression
	Global bool
}

ShowVariables is a node that shows the global and session variables

func NewShowVariables 

func NewShowVariables(filter sql.Expression, isGlobal bool) *ShowVariables

NewShowVariables returns a new ShowVariables reference.

func (*ShowVariables) CheckPrivileges 

func (sv *ShowVariables) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*ShowVariables) Children 

func (*ShowVariables) Children() []sql.Node

Children implements sql.Node interface. The function always returns nil.

func (*ShowVariables) CollationCoercibility 

func (*ShowVariables) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*ShowVariables) Expressions 

func (sv *ShowVariables) Expressions() []sql.Expression

func (*ShowVariables) IsReadOnly 

func (sv *ShowVariables) IsReadOnly() bool

func (*ShowVariables) Resolved 

func (sv *ShowVariables) Resolved() bool

Resolved implements sql.Node interface. The function always returns true.

func (*ShowVariables) Schema 

func (*ShowVariables) Schema() sql.Schema

Schema returns a new Schema reference for "SHOW VARIABLES" query.

func (*ShowVariables) String 

func (sv *ShowVariables) String() string

String implements the fmt.Stringer interface.

func (*ShowVariables) WithChildren 

func (sv *ShowVariables) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*ShowVariables) WithExpressions 

func (sv *ShowVariables) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

type ShowWarnings 

type ShowWarnings []*sql.Warning

ShowWarnings is a node that shows the session warnings

func (ShowWarnings) CheckPrivileges 

func (sw ShowWarnings) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (ShowWarnings) Children 

func (ShowWarnings) Children() []sql.Node

Children implements sql.Node interface. The function always returns nil.

func (ShowWarnings) CollationCoercibility 

func (ShowWarnings) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (ShowWarnings) IsReadOnly 

func (ShowWarnings) IsReadOnly() bool

func (ShowWarnings) Resolved 

func (ShowWarnings) Resolved() bool

Resolved implements sql.Node interface. The function always returns true.

func (ShowWarnings) Schema 

func (ShowWarnings) Schema() sql.Schema

Schema returns a new Schema reference for "SHOW VARIABLES" query.

func (ShowWarnings) String 

func (ShowWarnings) String() string

String implements the fmt.Stringer interface.

func (ShowWarnings) WithChildren 

func (sw ShowWarnings) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type Signal 

type Signal struct {
	SqlStateValue string // Will always be a string with length 5
	Info          map[SignalConditionItemName]SignalInfo
}

Signal represents the SIGNAL statement with a set SQLSTATE.

func NewSignal 

func NewSignal(sqlstate string, info map[SignalConditionItemName]SignalInfo) *Signal

NewSignal returns a *Signal node.

func (*Signal) CheckPrivileges 

func (s *Signal) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Signal) Children 

func (s *Signal) Children() []sql.Node

Children implements the sql.Node interface.

func (*Signal) CollationCoercibility 

func (*Signal) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Signal) DebugString 

func (s *Signal) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*Signal) Expressions 

func (s *Signal) Expressions() []sql.Expression

func (*Signal) IsReadOnly 

func (s *Signal) IsReadOnly() bool

func (*Signal) Resolved 

func (s *Signal) Resolved() bool

Resolved implements the sql.Node interface.

func (*Signal) RowIter 

func (s *Signal) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*Signal) Schema 

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

Schema implements the sql.Node interface.

func (*Signal) String 

func (s *Signal) String() string

String implements the sql.Node interface.

func (*Signal) WithChildren 

func (s *Signal) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

func (Signal) WithExpressions 

func (s Signal) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

type SignalConditionItemName 

type SignalConditionItemName string

SignalConditionItemName represents the item name for the set conditions of a SIGNAL statement. 

const (
	SignalConditionItemName_Unknown           SignalConditionItemName = ""
	SignalConditionItemName_ClassOrigin       SignalConditionItemName = "class_origin"
	SignalConditionItemName_SubclassOrigin    SignalConditionItemName = "subclass_origin"
	SignalConditionItemName_MessageText       SignalConditionItemName = "message_text"
	SignalConditionItemName_MysqlErrno        SignalConditionItemName = "mysql_errno"
	SignalConditionItemName_ConstraintCatalog SignalConditionItemName = "constraint_catalog"
	SignalConditionItemName_ConstraintSchema  SignalConditionItemName = "constraint_schema"
	SignalConditionItemName_ConstraintName    SignalConditionItemName = "constraint_name"
	SignalConditionItemName_CatalogName       SignalConditionItemName = "catalog_name"
	SignalConditionItemName_SchemaName        SignalConditionItemName = "schema_name"
	SignalConditionItemName_TableName         SignalConditionItemName = "table_name"
	SignalConditionItemName_ColumnName        SignalConditionItemName = "column_name"
	SignalConditionItemName_CursorName        SignalConditionItemName = "cursor_name"
)

type SignalInfo 

type SignalInfo struct {
	ConditionItemName SignalConditionItemName
	IntValue          int64
	StrValue          string
	ExprVal           sql.Expression
}

SignalInfo represents a piece of information for a SIGNAL statement.

func (SignalInfo) DebugString 

func (s SignalInfo) DebugString() string

func (SignalInfo) IsReadOnly 

func (s SignalInfo) IsReadOnly() bool

func (SignalInfo) String 

func (s SignalInfo) String() string

type SignalName 

type SignalName struct {
	Signal *Signal
	Name   string
}

SignalName represents the SIGNAL statement with a condition name.

func NewSignalName 

func NewSignalName(name string, info map[SignalConditionItemName]SignalInfo) *SignalName

NewSignalName returns a *SignalName node.

func (*SignalName) CheckPrivileges 

func (s *SignalName) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*SignalName) Children 

func (s *SignalName) Children() []sql.Node

Children implements the sql.Node interface.

func (*SignalName) CollationCoercibility 

func (*SignalName) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*SignalName) IsReadOnly 

func (s *SignalName) IsReadOnly() bool

func (*SignalName) Resolved 

func (s *SignalName) Resolved() bool

Resolved implements the sql.Node interface.

func (*SignalName) RowIter 

func (s *SignalName) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*SignalName) Schema 

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

Schema implements the sql.Node interface.

func (*SignalName) String 

func (s *SignalName) String() string

String implements the sql.Node interface.

func (*SignalName) WithChildren 

func (s *SignalName) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type SingleDropView 

type SingleDropView struct {
	ViewName string
	// contains filtered or unexported fields
}

func NewSingleDropView 

func NewSingleDropView(
	database sql.Database,
	viewName string,
) *SingleDropView

NewSingleDropView creates a SingleDropView.

func (*SingleDropView) CheckPrivileges 

func (dv *SingleDropView) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*SingleDropView) Children 

func (dv *SingleDropView) Children() []sql.Node

Children implements the Node interface. It always returns nil.

func (*SingleDropView) CollationCoercibility 

func (*SingleDropView) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*SingleDropView) Database 

func (dv *SingleDropView) Database() sql.Database

Database implements the sql.Databaser interface. It returns the node's database.

func (*SingleDropView) IsReadOnly 

func (dv *SingleDropView) IsReadOnly() bool

func (*SingleDropView) Resolved 

func (dv *SingleDropView) Resolved() bool

Resolved implements the Node interface. This node is resolved if and only if its database is resolved.

func (*SingleDropView) RowIter 

func (dv *SingleDropView) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the Node interface. It always returns an empty iterator.

func (*SingleDropView) Schema 

func (dv *SingleDropView) Schema() sql.Schema

Schema implements the Node interface. It always returns nil.

func (*SingleDropView) String 

func (dv *SingleDropView) String() string

String implements the fmt.Stringer interface, using sql.TreePrinter to generate the string.

func (*SingleDropView) WithChildren 

func (dv *SingleDropView) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface. It only succeeds if the length of the specified children equals 0.

func (*SingleDropView) WithDatabase 

func (dv *SingleDropView) WithDatabase(database sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface, and it returns a copy of this node with the specified database.

type Sort 

type Sort struct {
	UnaryNode
	SortFields sql.SortFields
}

Sort is the sort node.

func NewSort 

func NewSort(sortFields []sql.SortField, child sql.Node) *Sort

NewSort creates a new Sort node.

func (*Sort) CheckPrivileges 

func (s *Sort) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Sort) CollationCoercibility 

func (s *Sort) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Sort) DebugString 

func (s *Sort) DebugString() string

func (*Sort) Expressions 

func (s *Sort) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*Sort) IsReadOnly 

func (s *Sort) IsReadOnly() bool

func (*Sort) Resolved 

func (s *Sort) Resolved() bool

Resolved implements the Resolvable interface.

func (*Sort) String 

func (s *Sort) String() string

func (*Sort) WithChildren 

func (s *Sort) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Sort) WithExpressions 

func (s *Sort) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type SrsAttribute 

type SrsAttribute struct {
	Name         string
	Definition   string
	Organization string
	OrgID        uint32
	Description  string
}

type StartReplica 

type StartReplica struct {
	ReplicaController binlogreplication.BinlogReplicaController
}

StartReplica is a plan node for the "START REPLICA" statement. https://dev.mysql.com/doc/refman/8.0/en/start-replica.html

func NewStartReplica 

func NewStartReplica() *StartReplica

func (*StartReplica) CheckPrivileges 

func (s *StartReplica) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*StartReplica) Children 

func (s *StartReplica) Children() []sql.Node

func (*StartReplica) CollationCoercibility 

func (*StartReplica) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*StartReplica) IsReadOnly 

func (s *StartReplica) IsReadOnly() bool

func (*StartReplica) Resolved 

func (s *StartReplica) Resolved() bool

func (*StartReplica) Schema 

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

func (*StartReplica) String 

func (s *StartReplica) String() string

func (*StartReplica) WithBinlogReplicaController 

func (s *StartReplica) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*StartReplica) WithChildren 

func (s *StartReplica) WithChildren(children ...sql.Node) (sql.Node, error)

type StartTransaction 

type StartTransaction struct {
	TransChar sql.TransactionCharacteristic
	// contains filtered or unexported fields
}

StartTransaction explicitly starts a transaction. Transactions also start before any statement execution that doesn't have a transaction. Starting a transaction implicitly commits any in-progress one.

func NewStartTransaction 

func NewStartTransaction(transactionChar sql.TransactionCharacteristic) *StartTransaction

NewStartTransaction creates a new StartTransaction node.

func (StartTransaction) CheckPrivileges 

func (StartTransaction) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (StartTransaction) Children 

func (StartTransaction) Children() []sql.Node

func (*StartTransaction) CollationCoercibility 

func (*StartTransaction) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (StartTransaction) IsReadOnly 

func (StartTransaction) IsReadOnly() bool

func (StartTransaction) Resolved 

func (StartTransaction) Resolved() bool

Resolved implements the sql.Node interface.

func (*StartTransaction) RowIter 

func (s *StartTransaction) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (StartTransaction) Schema 

func (StartTransaction) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*StartTransaction) String 

func (s *StartTransaction) String() string

func (*StartTransaction) WithChildren 

func (s *StartTransaction) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type StopReplica 

type StopReplica struct {
	ReplicaController binlogreplication.BinlogReplicaController
}

StopReplica is the plan node for the "STOP REPLICA" statement. https://dev.mysql.com/doc/refman/8.0/en/stop-replica.html

func NewStopReplica 

func NewStopReplica() *StopReplica

func (*StopReplica) CheckPrivileges 

func (s *StopReplica) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*StopReplica) Children 

func (s *StopReplica) Children() []sql.Node

func (*StopReplica) CollationCoercibility 

func (*StopReplica) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*StopReplica) IsReadOnly 

func (s *StopReplica) IsReadOnly() bool

func (*StopReplica) Resolved 

func (s *StopReplica) Resolved() bool

func (*StopReplica) Schema 

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

func (*StopReplica) String 

func (s *StopReplica) String() string

func (*StopReplica) WithBinlogReplicaController 

func (s *StopReplica) WithBinlogReplicaController(controller binlogreplication.BinlogReplicaController) sql.Node

WithBinlogReplicaController implements the BinlogReplicaControllerCommand interface.

func (*StopReplica) WithChildren 

func (s *StopReplica) WithChildren(children ...sql.Node) (sql.Node, error)

type StrExpr 

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

StrExpr is used exclusively for overriding the .String() method of a node.

func NewStrExpr 

func NewStrExpr(s string) *StrExpr

func (*StrExpr) CheckPrivileges 

func (s *StrExpr) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*StrExpr) Children 

func (s *StrExpr) Children() []sql.Node

func (*StrExpr) Eval 

func (s *StrExpr) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

func (*StrExpr) IsNullable 

func (s *StrExpr) IsNullable() bool

func (*StrExpr) IsReadOnly 

func (s *StrExpr) IsReadOnly() bool

func (*StrExpr) Resolved 

func (s *StrExpr) Resolved() bool

func (*StrExpr) Schema 

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

func (*StrExpr) String 

func (s *StrExpr) String() string

func (*StrExpr) Type 

func (s *StrExpr) Type() sql.Type

func (*StrExpr) WithChildren 

func (s *StrExpr) WithChildren(children ...sql.Node) (sql.Node, error)

type StripRowNode 

type StripRowNode struct {
	UnaryNode
	NumCols int
}

func (*StripRowNode) CheckPrivileges 

func (srn *StripRowNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*StripRowNode) CollationCoercibility 

func (srn *StripRowNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*StripRowNode) DebugString 

func (srn *StripRowNode) DebugString() string

DebugString implements the sql.DebugStringer interface

func (*StripRowNode) Describe 

func (srn *StripRowNode) Describe(options sql.DescribeOptions) string

Describe implements the sql.Describable interface

func (*StripRowNode) IsReadOnly 

func (srn *StripRowNode) IsReadOnly() bool

func (*StripRowNode) String 

func (srn *StripRowNode) String() string

String implements the fmt.Stringer interface

func (*StripRowNode) WithChildren 

func (srn *StripRowNode) WithChildren(children ...sql.Node) (sql.Node, error)

type Subquery 

type Subquery struct {
	// The subquery to execute for each row in the outer result set
	Query sql.Node
	// The original verbatim select statement for this subquery
	QueryString string
	// contains filtered or unexported fields
}

Subquery is as an expression whose value is derived by executing a subquery. It must be executed for every row in the outer result set. It's in the plan package instead of the expression package because it functions more like a plan Node than an expression.

func NewSubquery 

func NewSubquery(node sql.Node, queryString string) *Subquery

NewSubquery returns a new subquery expression.

func (*Subquery) CanCacheResults 

func (s *Subquery) CanCacheResults() bool

func (*Subquery) Children 

func (s *Subquery) Children() []sql.Expression

Children implements the Expression interface.

func (*Subquery) CollationCoercibility 

func (s *Subquery) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Subquery) Correlated 

func (s *Subquery) Correlated() sql.ColSet

func (*Subquery) DebugString 

func (s *Subquery) DebugString() string

func (*Subquery) Dispose 

func (s *Subquery) Dispose()

Dispose implements sql.Disposable

func (*Subquery) Eval 

func (s *Subquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

Eval implements the Expression interface.

func (*Subquery) EvalMultiple 

func (s *Subquery) EvalMultiple(ctx *sql.Context, row sql.Row) ([]interface{}, error)

EvalMultiple returns all rows returned by a subquery.

func (*Subquery) HasResultRow 

func (s *Subquery) HasResultRow(ctx *sql.Context, row sql.Row) (bool, error)

HasResultRow returns whether the subquery has a result set > 0.

func (*Subquery) HashMultiple 

func (s *Subquery) HashMultiple(ctx *sql.Context, row sql.Row) (sql.KeyValueCache, error)

HashMultiple returns all rows returned by a subquery, backed by a sql.KeyValueCache. Keys are constructed using the 64-bit hash of the values stored.

func (*Subquery) IsNonDeterministic 

func (s *Subquery) IsNonDeterministic() bool

func (*Subquery) IsNullable 

func (s *Subquery) IsNullable() bool

IsNullable implements the Expression interface.

func (*Subquery) NodeChildren 

func (s *Subquery) NodeChildren() []sql.Node

NodeChildren implements the sql.ExpressionWithNodes interface.

func (*Subquery) Resolved 

func (s *Subquery) Resolved() bool

Resolved implements the Expression interface.

func (*Subquery) String 

func (s *Subquery) String() string

func (*Subquery) Type 

func (s *Subquery) Type() sql.Type

Type implements the Expression interface.

func (*Subquery) Volatile 

func (s *Subquery) Volatile() bool

func (*Subquery) WithChildren 

func (s *Subquery) WithChildren(children ...sql.Expression) (sql.Expression, error)

WithChildren implements the Expression interface.

func (*Subquery) WithCorrelated 

func (s *Subquery) WithCorrelated(cols sql.ColSet) *Subquery

func (*Subquery) WithExecBuilder 

func (s *Subquery) WithExecBuilder(b sql.NodeExecBuilder) *Subquery

WithExecBuilder returns the subquery with a recursive execution builder.

func (*Subquery) WithNodeChildren 

func (s *Subquery) WithNodeChildren(children ...sql.Node) (sql.ExpressionWithNodes, error)

WithNodeChildren implements the sql.ExpressionWithNodes interface.

func (*Subquery) WithQuery 

func (s *Subquery) WithQuery(node sql.Node) *Subquery

WithQuery returns the subquery with the query node changed.

func (*Subquery) WithVolatile 

func (s *Subquery) WithVolatile() *Subquery

type SubqueryAlias 

type SubqueryAlias struct {
	UnaryNode
	ColumnNames []string

	TextDefinition string
	// OuterScopeVisibility is true when a SubqueryAlias (i.e. derived table) is contained in a subquery
	// expression and is eligible to have visibility to outer scopes of the query.
	OuterScopeVisibility bool
	Correlated           sql.ColSet
	Volatile             bool
	CacheableCTESource   bool
	IsLateral            bool
	ScopeMapping         map[sql.ColumnId]sql.Expression
	// contains filtered or unexported fields
}

SubqueryAlias is a node that gives a subquery a name.

func NewSubqueryAlias 

func NewSubqueryAlias(name, textDefinition string, node sql.Node) *SubqueryAlias

NewSubqueryAlias creates a new SubqueryAlias node.

func (*SubqueryAlias) AsView 

func (sq *SubqueryAlias) AsView(createViewStmt string) *sql.View

AsView returns the view wrapper for this subquery

func (*SubqueryAlias) CanCacheResults 

func (sq *SubqueryAlias) CanCacheResults() bool

func (*SubqueryAlias) CheckPrivileges 

func (sq *SubqueryAlias) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*SubqueryAlias) CollationCoercibility 

func (sq *SubqueryAlias) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*SubqueryAlias) Columns 

func (sq *SubqueryAlias) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*SubqueryAlias) DebugString 

func (sq *SubqueryAlias) DebugString() string

func (*SubqueryAlias) Id 

func (sq *SubqueryAlias) Id() sql.TableId

Id implements sql.TableIdNode

func (*SubqueryAlias) IsReadOnly 

func (sq *SubqueryAlias) IsReadOnly() bool

func (*SubqueryAlias) Name 

func (sq *SubqueryAlias) Name() string

Name implements the Table interface.

func (*SubqueryAlias) Opaque 

func (sq *SubqueryAlias) Opaque() bool

Opaque implements the OpaqueNode interface.

func (*SubqueryAlias) Schema 

func (sq *SubqueryAlias) Schema() sql.Schema

Schema implements the Node interface.

func (*SubqueryAlias) String 

func (sq *SubqueryAlias) String() string

func (*SubqueryAlias) WithChild 

func (sq *SubqueryAlias) WithChild(n sql.Node) *SubqueryAlias

func (*SubqueryAlias) WithChildren 

func (sq *SubqueryAlias) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*SubqueryAlias) WithColumnNames 

func (sq *SubqueryAlias) WithColumnNames(columns []string) *SubqueryAlias

func (*SubqueryAlias) WithColumns 

func (sq *SubqueryAlias) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*SubqueryAlias) WithCorrelated 

func (sq *SubqueryAlias) WithCorrelated(cols sql.ColSet) *SubqueryAlias

func (*SubqueryAlias) WithId 

func (sq *SubqueryAlias) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (*SubqueryAlias) WithName 

func (sq *SubqueryAlias) WithName(n string) sql.Node

func (*SubqueryAlias) WithScopeMapping 

func (sq *SubqueryAlias) WithScopeMapping(cols map[sql.ColumnId]sql.Expression) *SubqueryAlias

func (*SubqueryAlias) WithVolatile 

func (sq *SubqueryAlias) WithVolatile(v bool) *SubqueryAlias

type TLSOptions 

type TLSOptions struct {
	SSL     bool
	X509    bool
	Cipher  string
	Issuer  string
	Subject string
}

TLSOptions represents a user's TLS options.

type TableAlias 

type TableAlias struct {
	*UnaryNode
	// contains filtered or unexported fields
}

TableAlias is a node that acts as a table with a given name.

func NewTableAlias 

func NewTableAlias(name string, node sql.Node) *TableAlias

NewTableAlias returns a new Table alias node.

func (*TableAlias) CheckPrivileges 

func (t *TableAlias) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TableAlias) CollationCoercibility 

func (t *TableAlias) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TableAlias) Columns 

func (t *TableAlias) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*TableAlias) Comment 

func (t *TableAlias) Comment() string

func (TableAlias) DebugString 

func (t TableAlias) DebugString() string

func (*TableAlias) Id 

func (t *TableAlias) Id() sql.TableId

Id implements sql.TableIdNode

func (*TableAlias) IsReadOnly 

func (t *TableAlias) IsReadOnly() bool

func (*TableAlias) Name 

func (t *TableAlias) Name() string

Name implements the Nameable interface.

func (*TableAlias) Schema 

func (t *TableAlias) Schema() sql.Schema

Schema implements the Node interface. TableAlias alters the schema of its child element to rename the source of columns to the alias.

func (TableAlias) String 

func (t TableAlias) String() string

func (*TableAlias) WithChildren 

func (t *TableAlias) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*TableAlias) WithColumns 

func (t *TableAlias) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*TableAlias) WithComment 

func (t *TableAlias) WithComment(s string) sql.Node

func (*TableAlias) WithId 

func (t *TableAlias) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

func (TableAlias) WithName 

func (t TableAlias) WithName(name string) sql.Node

type TableCopier 

type TableCopier struct {
	Source      sql.Node
	Destination sql.Node
	// contains filtered or unexported fields
}

TableCopier is a supporting node that allows for the optimization of copying tables. It should be used in two cases. 1) CREATE TABLE SELECT * 2) INSERT INTO SELECT * where the inserted table is empty. // TODO: Implement this optimization

func NewTableCopier 

func NewTableCopier(db sql.Database, createTableNode sql.Node, source sql.Node, prop CopierProps) *TableCopier

func (*TableCopier) CheckPrivileges 

func (tc *TableCopier) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TableCopier) Children 

func (tc *TableCopier) Children() []sql.Node

func (*TableCopier) CollationCoercibility 

func (*TableCopier) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TableCopier) CopyTableOver 

func (tc *TableCopier) CopyTableOver(ctx *sql.Context, sourceTable string, destinationTable string) (sql.RowIter, error)

CopyTableOver is used when we can guarantee the Destination table will have the same data as the source table.

func (*TableCopier) Database 

func (tc *TableCopier) Database() sql.Database

func (*TableCopier) IsReadOnly 

func (tc *TableCopier) IsReadOnly() bool

func (*TableCopier) ProcessCreateTable 

func (tc *TableCopier) ProcessCreateTable(ctx *sql.Context, b sql.NodeExecBuilder, row sql.Row) (sql.RowIter, error)

func (*TableCopier) Resolved 

func (tc *TableCopier) Resolved() bool

func (*TableCopier) Schema 

func (tc *TableCopier) Schema() sql.Schema

func (*TableCopier) String 

func (tc *TableCopier) String() string

func (*TableCopier) WithChildren 

func (tc *TableCopier) WithChildren(...sql.Node) (sql.Node, error)

func (*TableCopier) WithDatabase 

func (tc *TableCopier) WithDatabase(db sql.Database) (sql.Node, error)

type TableCountLookup 

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

TableCountLookup short-circuits `select count(*) from table` using the sql.StatisticsTable interface.

func (*TableCountLookup) CheckPrivileges 

func (t *TableCountLookup) CheckPrivileges(_ *sql.Context, _ sql.PrivilegedOperationChecker) bool

func (*TableCountLookup) Children 

func (t *TableCountLookup) Children() []sql.Node

func (*TableCountLookup) Count 

func (t *TableCountLookup) Count() uint64

func (*TableCountLookup) Db 

func (t *TableCountLookup) Db() sql.Database

func (*TableCountLookup) Id 

func (t *TableCountLookup) Id() sql.ColumnId

func (*TableCountLookup) IsReadOnly 

func (t *TableCountLookup) IsReadOnly() bool

func (*TableCountLookup) Name 

func (t *TableCountLookup) Name() string

func (*TableCountLookup) Resolved 

func (t *TableCountLookup) Resolved() bool

func (*TableCountLookup) Schema 

func (t *TableCountLookup) Schema() sql.Schema

func (*TableCountLookup) String 

func (t *TableCountLookup) String() string

func (*TableCountLookup) Table 

func (t *TableCountLookup) Table() sql.Table

func (*TableCountLookup) WithChildren 

func (t *TableCountLookup) WithChildren(_ ...sql.Node) (sql.Node, error)

func (*TableCountLookup) WithId 

func (t *TableCountLookup) WithId(id sql.ColumnId) *TableCountLookup

type TableEditorIter 

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

TableEditorIter wraps the given iterator and calls the Begin and Complete functions on the given table.

func (*TableEditorIter) Close 

func (s *TableEditorIter) Close(ctx *sql.Context) error

Close implements the interface sql.RowIter.

func (*TableEditorIter) InnerIter 

func (s *TableEditorIter) InnerIter() sql.RowIter

func (*TableEditorIter) Next 

func (s *TableEditorIter) Next(ctx *sql.Context) (sql.Row, error)

Next implements the interface sql.RowIter.

type TableIdNode 

type TableIdNode interface {
	sql.NameableNode
	WithId(id sql.TableId) TableIdNode
	Id() sql.TableId
	WithColumns(sql.ColSet) TableIdNode
	Columns() sql.ColSet
}

TableIdNode is a distinct source of rows associated with a table identifier and set of column identifiers.

type TableLock 

type TableLock struct {
	Table sql.Node
	// Write if it's true, read if it's false.
	Write bool
}

TableLock is a read or write lock on a table.

type TableSpec 

type TableSpec struct {
	Schema    sql.PrimaryKeySchema
	FkDefs    sql.ForeignKeyConstraints
	ChDefs    sql.CheckConstraints
	IdxDefs   sql.IndexDefs
	Collation sql.CollationID
	TableOpts map[string]interface{}
	Comment   string
}

TableSpec is a node describing the schema of a table.

type TopN 

type TopN struct {
	UnaryNode
	Limit         sql.Expression
	Fields        sql.SortFields
	CalcFoundRows bool
}

TopN was a sort node that has a limit. It doesn't need to buffer everything, but can calculate the top n on the fly.

func NewTopN 

func NewTopN(fields sql.SortFields, limit sql.Expression, child sql.Node) *TopN

NewTopN creates a new TopN node.

func (*TopN) CheckPrivileges 

func (n *TopN) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TopN) CollationCoercibility 

func (n *TopN) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TopN) DebugString 

func (n *TopN) DebugString() string

func (*TopN) Expressions 

func (n *TopN) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*TopN) IsReadOnly 

func (n *TopN) IsReadOnly() bool

func (*TopN) Resolved 

func (n *TopN) Resolved() bool

Resolved implements the Resolvable interface.

func (*TopN) String 

func (n *TopN) String() string

func (TopN) WithCalcFoundRows 

func (n TopN) WithCalcFoundRows(v bool) *TopN

func (*TopN) WithChildren 

func (n *TopN) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*TopN) WithExpressions 

func (n *TopN) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type TransactionCommittingNode 

type TransactionCommittingNode struct {
	UnaryNode
}

TransactionCommittingNode implements autocommit logic. It wraps relevant queries and ensures the database commits the transaction.

func NewTransactionCommittingNode 

func NewTransactionCommittingNode(child sql.Node) *TransactionCommittingNode

NewTransactionCommittingNode returns a TransactionCommittingNode.

func (*TransactionCommittingNode) CheckPrivileges 

func (t *TransactionCommittingNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the sql.Node interface.

func (*TransactionCommittingNode) Child 

func (t *TransactionCommittingNode) Child() sql.Node

Child implements the sql.UnaryNode interface.

func (*TransactionCommittingNode) CollationCoercibility 

func (*TransactionCommittingNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TransactionCommittingNode) DebugString 

func (t *TransactionCommittingNode) DebugString() string

DebugString implements the sql.DebugStringer interface.

func (*TransactionCommittingNode) Describe 

func (t *TransactionCommittingNode) Describe(options sql.DescribeOptions) string

Describe implements the sql.Describable interface.

func (*TransactionCommittingNode) IsReadOnly 

func (t *TransactionCommittingNode) IsReadOnly() bool

func (*TransactionCommittingNode) String 

func (t *TransactionCommittingNode) String() string

String implements the sql.Node interface.

func (*TransactionCommittingNode) WithChildren 

func (t *TransactionCommittingNode) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type TransformedNamedNode 

type TransformedNamedNode struct {
	UnaryNode
	// contains filtered or unexported fields
}

func NewTransformedNamedNode 

func NewTransformedNamedNode(child sql.Node, name string) *TransformedNamedNode

TransformedNamedNode is a wrapper for arbitrary logic to represent a table factor assembled from other nodes at some point in by the analyzer. See e.g., Concat.

func (*TransformedNamedNode) CheckPrivileges 

func (n *TransformedNamedNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TransformedNamedNode) CollationCoercibility 

func (n *TransformedNamedNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TransformedNamedNode) DebugString 

func (n *TransformedNamedNode) DebugString() string

func (*TransformedNamedNode) IsReadOnly 

func (n *TransformedNamedNode) IsReadOnly() bool

func (*TransformedNamedNode) Name 

func (n *TransformedNamedNode) Name() string

func (*TransformedNamedNode) Schema 

func (n *TransformedNamedNode) Schema() sql.Schema

func (*TransformedNamedNode) String 

func (n *TransformedNamedNode) String() string

func (*TransformedNamedNode) WithChildren 

func (n *TransformedNamedNode) WithChildren(children ...sql.Node) (sql.Node, error)

type TriggerBeginEndBlock 

type TriggerBeginEndBlock struct {
	*BeginEndBlock
}

TriggerBeginEndBlock represents a BEGIN/END block specific to TRIGGER execution, which has special considerations regarding logic execution through the RowIter function.

func NewTriggerBeginEndBlock 

func NewTriggerBeginEndBlock(block *BeginEndBlock) *TriggerBeginEndBlock

NewTriggerBeginEndBlock creates a new *TriggerBeginEndBlock node.

func (*TriggerBeginEndBlock) CheckPrivileges 

func (b *TriggerBeginEndBlock) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TriggerBeginEndBlock) WithChildren 

func (b *TriggerBeginEndBlock) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type TriggerEvent 

type TriggerEvent string

type TriggerExecutor 

type TriggerExecutor struct {
	BinaryNode        // Left = wrapped node, Right = trigger execution logic
	TriggerEvent      TriggerEvent
	TriggerTime       TriggerTime
	TriggerDefinition sql.TriggerDefinition
}

TriggerExecutor is node that wraps, or is wrapped by, an INSERT, UPDATE, or DELETE node to execute defined trigger logic either before or after that operation. When a table has multiple triggers defined, TriggerExecutor nodes can wrap each other as well.

func NewTriggerExecutor 

func NewTriggerExecutor(child, triggerLogic sql.Node, triggerEvent TriggerEvent, triggerTime TriggerTime, triggerDefinition sql.TriggerDefinition) *TriggerExecutor

func (*TriggerExecutor) CheckPrivileges 

func (t *TriggerExecutor) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TriggerExecutor) CollationCoercibility 

func (t *TriggerExecutor) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TriggerExecutor) DebugString 

func (t *TriggerExecutor) DebugString() string

func (*TriggerExecutor) IsReadOnly 

func (t *TriggerExecutor) IsReadOnly() bool

func (*TriggerExecutor) Schema 

func (t *TriggerExecutor) Schema() sql.Schema

func (*TriggerExecutor) String 

func (t *TriggerExecutor) String() string

func (*TriggerExecutor) WithChildren 

func (t *TriggerExecutor) WithChildren(children ...sql.Node) (sql.Node, error)

type TriggerOrder 

type TriggerOrder struct {
	PrecedesOrFollows string // PrecedesStr, FollowsStr
	OtherTriggerName  string
}

type TriggerRollback 

type TriggerRollback struct {
	UnaryNode
}

TriggerRollback is a node that wraps the entire tree iff it contains a trigger, creates a savepoint, and performs a rollback if something went wrong during execution

func NewTriggerRollback 

func NewTriggerRollback(child sql.Node) *TriggerRollback

func (*TriggerRollback) CheckPrivileges 

func (t *TriggerRollback) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*TriggerRollback) CollationCoercibility 

func (t *TriggerRollback) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*TriggerRollback) DebugString 

func (t *TriggerRollback) DebugString() string

func (*TriggerRollback) IsReadOnly 

func (t *TriggerRollback) IsReadOnly() bool

func (*TriggerRollback) String 

func (t *TriggerRollback) String() string

func (*TriggerRollback) WithChildren 

func (t *TriggerRollback) WithChildren(children ...sql.Node) (sql.Node, error)

type TriggerTime 

type TriggerTime string
const (
	BeforeTrigger TriggerTime = "before"
	AfterTrigger              = "after"
)

type Truncate 

type Truncate struct {
	UnaryNode
	// contains filtered or unexported fields
}

Truncate is a node describing the deletion of all rows from some table.

func NewTruncate 

func NewTruncate(db string, table sql.Node) *Truncate

NewTruncate creates a Truncate node.

func (*Truncate) CheckPrivileges 

func (p *Truncate) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Truncate) CollationCoercibility 

func (*Truncate) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Truncate) DatabaseName 

func (p *Truncate) DatabaseName() string

DatabaseName returns the name of the database that this operation is being performed in.

func (Truncate) DebugString 

func (p Truncate) DebugString() string

DebugString implements the DebugStringer interface.

func (*Truncate) IsReadOnly 

func (*Truncate) IsReadOnly() bool

func (*Truncate) Schema 

func (p *Truncate) Schema() sql.Schema

Schema implements the Node interface.

func (Truncate) String 

func (p Truncate) String() string

String implements the Node interface.

func (*Truncate) WithChildren 

func (p *Truncate) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type UnaryNode 

type UnaryNode struct {
	Child sql.Node
}

UnaryNode is a node that has only one child.

func (UnaryNode) Children 

func (n UnaryNode) Children() []sql.Node

Children implements the Node interface.

func (UnaryNode) Resolved 

func (n UnaryNode) Resolved() bool

Resolved implements the Resolvable interface.

func (*UnaryNode) Schema 

func (n *UnaryNode) Schema() sql.Schema

Schema implements the Node interface.

type UnlockTables 

type UnlockTables struct {
	Catalog sql.Catalog
}

UnlockTables will release all locks for the current session.

func NewUnlockTables 

func NewUnlockTables() *UnlockTables

NewUnlockTables returns a new UnlockTables node.

func (*UnlockTables) CheckPrivileges 

func (t *UnlockTables) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*UnlockTables) Children 

func (t *UnlockTables) Children() []sql.Node

Children implements the sql.Node interface.

func (*UnlockTables) CollationCoercibility 

func (*UnlockTables) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*UnlockTables) IsReadOnly 

func (t *UnlockTables) IsReadOnly() bool

MySQL allows these against read-only servers.

func (*UnlockTables) Resolved 

func (t *UnlockTables) Resolved() bool

Resolved implements the sql.Node interface.

func (*UnlockTables) RowIter 

func (t *UnlockTables) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (*UnlockTables) Schema 

func (t *UnlockTables) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*UnlockTables) String 

func (t *UnlockTables) String() string

func (*UnlockTables) WithChildren 

func (t *UnlockTables) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

type UnresolvedTable 

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

UnresolvedTable is a table that has not been resolved yet but whose name is known.

func NewUnresolvedTable 

func NewUnresolvedTable(name, db string) *UnresolvedTable

NewUnresolvedTable creates a new Unresolved table.

func NewUnresolvedTableAsOf 

func NewUnresolvedTableAsOf(name, db string, asOf sql.Expression) *UnresolvedTable

NewUnresolvedTableAsOf creates a new Unresolved table with an AS OF expression.

func NewUnresolvedTableAsOfWithDatabase 

func NewUnresolvedTableAsOfWithDatabase(name string, db sql.Database, asOf sql.Expression) *UnresolvedTable

NewUnresolvedTableAsOfWithDatabase creates a new Unresolved table with an AS OF expression and the database provided.

func NewUnresolvedTableWithDatabase 

func NewUnresolvedTableWithDatabase(name string, db sql.Database) *UnresolvedTable

NewUnresolvedTableWithDatabase creates a new Unresolved table with a database provided.

func (*UnresolvedTable) AsOf 

func (t *UnresolvedTable) AsOf() sql.Expression

AsOf implements sql.UnresolvedTable

func (*UnresolvedTable) CheckPrivileges 

func (t *UnresolvedTable) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*UnresolvedTable) Children 

func (*UnresolvedTable) Children() []sql.Node

Children implements the Node interface.

func (*UnresolvedTable) CollationCoercibility 

func (*UnresolvedTable) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*UnresolvedTable) Comment 

func (t *UnresolvedTable) Comment() string

func (*UnresolvedTable) Database 

func (t *UnresolvedTable) Database() sql.Database

Database implements sql.UnresolvedTable

func (*UnresolvedTable) Expressions 

func (t *UnresolvedTable) Expressions() []sql.Expression

func (*UnresolvedTable) IsReadOnly 

func (t *UnresolvedTable) IsReadOnly() bool

func (*UnresolvedTable) Name 

func (t *UnresolvedTable) Name() string

Name implements the Nameable interface.

func (*UnresolvedTable) Resolved 

func (*UnresolvedTable) Resolved() bool

Resolved implements the Resolvable interface.

func (*UnresolvedTable) RowIter 

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

RowIter implements the RowIter interface.

func (*UnresolvedTable) Schema 

func (*UnresolvedTable) Schema() sql.Schema

Schema implements the Node interface.

func (UnresolvedTable) String 

func (t UnresolvedTable) String() string

func (*UnresolvedTable) WithAsOf 

func (t *UnresolvedTable) WithAsOf(asOf sql.Expression) (sql.Node, error)

WithAsOf implements sql.UnresolvedTable

func (*UnresolvedTable) WithChildren 

func (t *UnresolvedTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*UnresolvedTable) WithComment 

func (t *UnresolvedTable) WithComment(s string) sql.Node

func (*UnresolvedTable) WithDatabase 

func (t *UnresolvedTable) WithDatabase(database string) (*UnresolvedTable, error)

WithDatabase returns a copy of this unresolved table with its Database field set to the given value. Analagous to WithChildren.

func (*UnresolvedTable) WithExpressions 

func (t *UnresolvedTable) WithExpressions(expressions ...sql.Expression) (sql.Node, error)

type Update 

type Update struct {
	UnaryNode

	Ignore bool
	// contains filtered or unexported fields
}

Update is a node for updating rows on tables.

func NewUpdate 

func NewUpdate(n sql.Node, ignore bool, updateExprs []sql.Expression) *Update

NewUpdate creates an Update node.

func (*Update) CheckPrivileges 

func (u *Update) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Update) Checks 

func (u *Update) Checks() sql.CheckConstraints

func (*Update) CollationCoercibility 

func (*Update) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Update) DB 

func (u *Update) DB() sql.Database

DB returns the database being updated. |Database| is already used by another interface we implement.

func (*Update) Database 

func (u *Update) Database() string

func (*Update) DebugString 

func (u *Update) DebugString() string

func (*Update) Expressions 

func (u *Update) Expressions() []sql.Expression

func (*Update) IsReadOnly 

func (u *Update) IsReadOnly() bool

func (*Update) Resolved 

func (u *Update) Resolved() bool

func (*Update) String 

func (u *Update) String() string

func (*Update) WithChecks 

func (u *Update) WithChecks(checks sql.CheckConstraints) sql.Node

func (*Update) WithChildren 

func (u *Update) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (Update) WithExpressions 

func (u Update) WithExpressions(newExprs ...sql.Expression) (sql.Node, error)

type UpdateHistogram 

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

func NewUpdateHistogram 

func NewUpdateHistogram(db, table, index string, cols []string, stats sql.Statistic) *UpdateHistogram

func (*UpdateHistogram) CheckPrivileges 

func (u *UpdateHistogram) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

func (*UpdateHistogram) Children 

func (u *UpdateHistogram) Children() []sql.Node

func (*UpdateHistogram) Cols 

func (u *UpdateHistogram) Cols() []string

func (*UpdateHistogram) Db 

func (u *UpdateHistogram) Db() string

func (*UpdateHistogram) Index 

func (u *UpdateHistogram) Index() string

func (*UpdateHistogram) IsReadOnly 

func (u *UpdateHistogram) IsReadOnly() bool

func (*UpdateHistogram) Resolved 

func (u *UpdateHistogram) Resolved() bool

func (*UpdateHistogram) Schema 

func (u *UpdateHistogram) Schema() sql.Schema

func (*UpdateHistogram) Stats 

func (u *UpdateHistogram) Stats() sql.Statistic

func (*UpdateHistogram) StatsProvider 

func (u *UpdateHistogram) StatsProvider() sql.StatsProvider

func (*UpdateHistogram) String 

func (u *UpdateHistogram) String() string

func (*UpdateHistogram) Table 

func (u *UpdateHistogram) Table() string

func (*UpdateHistogram) WithChildren 

func (u *UpdateHistogram) WithChildren(children ...sql.Node) (sql.Node, error)

func (*UpdateHistogram) WithProvider 

func (u *UpdateHistogram) WithProvider(prov sql.StatsProvider) *UpdateHistogram

type UpdateInfo 

type UpdateInfo struct {
	Matched, Updated, Warnings int
}

UpdateInfo is the Info for OKResults returned by Update nodes.

func (UpdateInfo) String 

func (ui UpdateInfo) String() string

String implements fmt.Stringer

type UpdateJoin 

type UpdateJoin struct {
	Updaters map[string]sql.RowUpdater
	UnaryNode
}

func NewUpdateJoin 

func NewUpdateJoin(editorMap map[string]sql.RowUpdater, child sql.Node) *UpdateJoin

NewUpdateJoin returns an *UpdateJoin node.

func (*UpdateJoin) CheckPrivileges 

func (u *UpdateJoin) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*UpdateJoin) CollationCoercibility 

func (u *UpdateJoin) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*UpdateJoin) DebugString 

func (u *UpdateJoin) DebugString() string

DebugString implements the sql.Node interface.

func (*UpdateJoin) GetUpdatable 

func (u *UpdateJoin) GetUpdatable() sql.UpdatableTable

GetUpdatable returns an updateJoinTable which implements sql.UpdatableTable.

func (*UpdateJoin) IsReadOnly 

func (u *UpdateJoin) IsReadOnly() bool

func (*UpdateJoin) String 

func (u *UpdateJoin) String() string

String implements the sql.Node interface.

func (*UpdateJoin) WithChildren 

func (u *UpdateJoin) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the sql.Node interface.

type UpdateSource 

type UpdateSource struct {
	UnaryNode
	UpdateExprs []sql.Expression
	Ignore      bool
}

UpdateSource is the source of updates for an Update node. Its schema is the concatenation of the old and new rows, before and after being updated.

func NewUpdateSource 

func NewUpdateSource(node sql.Node, ignore bool, updateExprs []sql.Expression) *UpdateSource

NewUpdateSource returns a new UpdateSource from the node and expressions given.

func (*UpdateSource) CheckPrivileges 

func (u *UpdateSource) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*UpdateSource) CollationCoercibility 

func (u *UpdateSource) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*UpdateSource) DebugString 

func (u *UpdateSource) DebugString() string

func (*UpdateSource) Expressions 

func (u *UpdateSource) Expressions() []sql.Expression

Expressions implements the sql.Expressioner interface.

func (*UpdateSource) GetChildSchema 

func (u *UpdateSource) GetChildSchema() (sql.Schema, error)

func (*UpdateSource) IsReadOnly 

func (u *UpdateSource) IsReadOnly() bool

func (*UpdateSource) Resolved 

func (u *UpdateSource) Resolved() bool

Resolved implements the Resolvable interface.

func (*UpdateSource) Schema 

func (u *UpdateSource) Schema() sql.Schema

Schema implements sql.Node. The schema of an update is a concatenation of the old and new rows.

func (*UpdateSource) String 

func (u *UpdateSource) String() string

func (*UpdateSource) WithChildren 

func (u *UpdateSource) WithChildren(children ...sql.Node) (sql.Node, error)

func (*UpdateSource) WithExpressions 

func (u *UpdateSource) WithExpressions(newExprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the sql.Expressioner interface.

type Use 

type Use struct {
	Catalog sql.Catalog
	// contains filtered or unexported fields
}

Use changes the current database.

func NewUse 

func NewUse(db sql.Database) *Use

NewUse creates a new Use node.

func (*Use) CheckPrivileges 

func (u *Use) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (Use) Children 

func (Use) Children() []sql.Node

Children implements the sql.Node interface.

func (*Use) CollationCoercibility 

func (*Use) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Use) Database 

func (u *Use) Database() sql.Database

Database implements the sql.Databaser interface.

func (*Use) IsReadOnly 

func (u *Use) IsReadOnly() bool

func (*Use) Resolved 

func (u *Use) Resolved() bool

Resolved implements the sql.Node interface.

func (*Use) RowIter 

func (u *Use) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the sql.Node interface.

func (Use) Schema 

func (Use) Schema() sql.Schema

Schema implements the sql.Node interface.

func (*Use) String 

func (u *Use) String() string

String implements the sql.Node interface.

func (*Use) WithChildren 

func (u *Use) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Use) WithDatabase 

func (u *Use) WithDatabase(db sql.Database) (sql.Node, error)

WithDatabase implements the sql.Databaser interface.

type UserName 

type UserName struct {
	Name    string
	Host    string
	AnyHost bool
}

UserName represents either a user or role name.

func (*UserName) String 

func (un *UserName) String(quote string) string

String returns the UserName as a formatted string using the quotes given. Using the default root account with the backtick as the quote, root@localhost would become `root`@`localhost`. Different quotes are used in different places in MySQL. In addition, if the quote is used in a section as part of the name, it is escaped by doubling the quote (which also mimics MySQL behavior).

type ValueDerivedTable 

type ValueDerivedTable struct {
	*Values
	// contains filtered or unexported fields
}

func NewValueDerivedTable 

func NewValueDerivedTable(values *Values, name string) *ValueDerivedTable

func (*ValueDerivedTable) Columns 

func (v *ValueDerivedTable) Columns() sql.ColSet

Columns implements sql.TableIdNode

func (*ValueDerivedTable) DebugString 

func (v *ValueDerivedTable) DebugString() string

func (*ValueDerivedTable) Id 

func (v *ValueDerivedTable) Id() sql.TableId

Id implements sql.TableIdNode

func (*ValueDerivedTable) Name 

func (v *ValueDerivedTable) Name() string

Name implements sql.Nameable

func (*ValueDerivedTable) Schema 

func (v *ValueDerivedTable) Schema() sql.Schema

Schema implements the Node interface.

func (*ValueDerivedTable) String 

func (v *ValueDerivedTable) String() string

func (*ValueDerivedTable) WithChildren 

func (v *ValueDerivedTable) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (ValueDerivedTable) WithColumNames 

func (v ValueDerivedTable) WithColumNames(columns []string) *ValueDerivedTable

func (*ValueDerivedTable) WithColumns 

func (v *ValueDerivedTable) WithColumns(set sql.ColSet) TableIdNode

WithColumns implements sql.TableIdNode

func (*ValueDerivedTable) WithExpressions 

func (v *ValueDerivedTable) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

func (*ValueDerivedTable) WithId 

func (v *ValueDerivedTable) WithId(id sql.TableId) TableIdNode

WithId implements sql.TableIdNode

type Values 

type Values struct {
	ExpressionTuples [][]sql.Expression
}

Values represents a set of tuples of expressions.

func NewValues 

func NewValues(tuples [][]sql.Expression) *Values

NewValues creates a Values node with the given tuples.

func (*Values) CheckPrivileges 

func (p *Values) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Values) Children 

func (p *Values) Children() []sql.Node

Children implements the Node interface.

func (*Values) CollationCoercibility 

func (*Values) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Values) DebugString 

func (p *Values) DebugString() string

func (*Values) Expressions 

func (p *Values) Expressions() []sql.Expression

Expressions implements the Expressioner interface.

func (*Values) IsReadOnly 

func (p *Values) IsReadOnly() bool

func (*Values) Resolved 

func (p *Values) Resolved() bool

Resolved implements the Resolvable interface.

func (*Values) RowIter 

func (p *Values) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

RowIter implements the Node interface.

func (*Values) Schema 

func (p *Values) Schema() sql.Schema

Schema implements the Node interface.

func (*Values) String 

func (p *Values) String() string

func (*Values) WithChildren 

func (p *Values) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the Node interface.

func (*Values) WithExpressions 

func (p *Values) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the Expressioner interface.

type Versionable 

type Versionable interface {
	sql.Node
	// AsOf returns this table's asof expression.
	AsOf() sql.Expression
	// WithAsOf returns a copy of this versioned table with its AsOf
	// field set to the given value. Analogous to WithChildren.
	WithAsOf(asOf sql.Expression) (sql.Node, error)
}

Versionable represents a plan that contains an AsOf expression.

type VirtualColumnTable 

type VirtualColumnTable struct {
	sql.Table
	Projections []sql.Expression
}

VirtualColumnTable is a sql.TableNode that combines a ResolvedTable with a Project, the latter of which is used to add the values of virtual columns to the table.

func FindVirtualColumnTable 

func FindVirtualColumnTable(table sql.Table) (*VirtualColumnTable, bool)

FindVirtualColumnTable returns the plan.VirtualTableColumn being wrapped by the given table, if any.

func NewVirtualColumnTable 

func NewVirtualColumnTable(table sql.Table, projections []sql.Expression) *VirtualColumnTable

NewVirtualColumnTable creates a new VirtualColumnTable.

func (*VirtualColumnTable) DebugString 

func (v *VirtualColumnTable) DebugString() string

func (*VirtualColumnTable) LookupPartitions 

func (v *VirtualColumnTable) LookupPartitions(context *sql.Context, lookup sql.IndexLookup) (sql.PartitionIter, error)

func (*VirtualColumnTable) String 

func (v *VirtualColumnTable) String() string

func (*VirtualColumnTable) Underlying 

func (v *VirtualColumnTable) Underlying() sql.Table

func (VirtualColumnTable) WithUnderlying 

func (v VirtualColumnTable) WithUnderlying(table sql.Table) sql.Table

type While 

type While struct {
	*Loop
}

While represents the WHILE statement, which loops over a set of statements while the condition is true.

func NewWhile 

func NewWhile(label string, condition sql.Expression, block *Block) *While

NewWhile returns a new *While node.

func (*While) DebugString 

func (w *While) DebugString() string

DebugString implements the interface sql.DebugStringer.

func (*While) String 

func (w *While) String() string

String implements the interface sql.Node.

func (*While) WithChildren 

func (w *While) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements the interface sql.Node.

func (*While) WithExpressions 

func (w *While) WithExpressions(exprs ...sql.Expression) (sql.Node, error)

WithExpressions implements the interface sql.Node.

type Window 

type Window struct {
	SelectExprs []sql.Expression
	UnaryNode
}

func NewWindow 

func NewWindow(selectExprs []sql.Expression, node sql.Node) *Window

func (*Window) CheckPrivileges 

func (w *Window) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*Window) CollationCoercibility 

func (w *Window) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*Window) DebugString 

func (w *Window) DebugString() string

func (*Window) Expressions 

func (w *Window) Expressions() []sql.Expression

Expressions implements sql.Expressioner

func (*Window) IsReadOnly 

func (w *Window) IsReadOnly() bool

func (*Window) ProjectedExprs 

func (w *Window) ProjectedExprs() []sql.Expression

ProjectedExprs implements sql.Projector

func (*Window) Resolved 

func (w *Window) Resolved() bool

Resolved implements sql.Node

func (*Window) Schema 

func (w *Window) Schema() sql.Schema

Schema implements sql.Node

func (*Window) String 

func (w *Window) String() string

func (*Window) WithChildren 

func (w *Window) WithChildren(children ...sql.Node) (sql.Node, error)

WithChildren implements sql.Node

func (*Window) WithExpressions 

func (w *Window) WithExpressions(e ...sql.Expression) (sql.Node, error)

WithExpressions implements sql.Expressioner

type With 

type With struct {
	UnaryNode
	CTEs      []*CommonTableExpression
	Recursive bool
}

With is a node to wrap the top-level node in a query plan so that any common table expressions can be applied in analysis. It is removed during analysis.

func NewWith 

func NewWith(child sql.Node, ctes []*CommonTableExpression, recursive bool) *With

func (*With) CheckPrivileges 

func (w *With) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

CheckPrivileges implements the interface sql.Node.

func (*With) CollationCoercibility 

func (w *With) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

CollationCoercibility implements the interface sql.CollationCoercible.

func (*With) DebugString 

func (w *With) DebugString() string

func (*With) DisjointedChildren 

func (w *With) DisjointedChildren() [][]sql.Node

DisjointedChildren implements the interface DisjointedChildrenNode.

func (*With) IsReadOnly 

func (w *With) IsReadOnly() bool

func (*With) RowIter 

func (w *With) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

func (*With) String 

func (w *With) String() string

func (*With) WithChildren 

func (w *With) WithChildren(children ...sql.Node) (sql.Node, error)

func (*With) WithDisjointedChildren 

func (w *With) WithDisjointedChildren(children [][]sql.Node) (sql.Node, error)

WithDisjointedChildren implements the interface DisjointedChildrenNode.

Source Files

View all Source files

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.