Versions in this module Expand all Collapse all v0 v0.1.1 Jan 2, 2022 Changes in this version + const DeleteTrigger + const InsertTrigger + const UpdateTrigger + var DescribeSchema = sql.Schema + var EmptyTable = new(emptyTable) + var ErrAddForeignKeyDuplicateColumn = errors.NewKind("cannot have duplicates of columns in a foreign key: `%v`") + var ErrAlterTableNotSupported = errors.NewKind("table %s cannot be altered on database %s") + var ErrAutoIncrementNotSupported = errors.NewKind("table doesn't support AUTO_INCREMENT") + var ErrCheckFailed = errors.NewKind("check constraint %s is violated.") + var ErrCreateIndexDuplicateColumn = errors.NewKind("cannot have duplicates of columns in an index: `%v`") + var ErrCreateIndexMissingColumns = errors.NewKind("cannot create an index without columns") + var ErrCreateIndexNonExistentColumn = errors.NewKind("column `%v` does not exist in the table") + var ErrCreateTableNotSupported = errors.NewKind("tables cannot be created on database %s") + var ErrDeleteFromNotSupported = errors.NewKind("table doesn't support DELETE FROM") + var ErrDropTableNotSupported = errors.NewKind("tables cannot be dropped on database %s") + var ErrExprTypeNotIndexable = errors.NewKind("expression %q with type %s cannot be indexed") + var ErrForeignKeyMissingColumns = errors.NewKind("cannot create a foreign key without columns") + var ErrGroupBy = errors.NewKind("group by aggregation '%v' not supported") + var ErrIndexActionNotImplemented = errors.NewKind("alter table index action is not implemented: %v") + var ErrIndexNotAvailable = errors.NewKind("index %q is still not ready for usage and can't be deleted") + var ErrIndexNotFound = errors.NewKind("unable to find index %q on table %q of database %q") + var ErrInsertIntoDuplicateColumn = errors.NewKind("duplicate column name %v") + var ErrInsertIntoIncompatibleTypes = errors.NewKind("cannot convert type %s to %s") + var ErrInsertIntoMismatchValueCount = errors.NewKind("number of values does not match number of columns provided") + var ErrInsertIntoNonexistentColumn = errors.NewKind("invalid column name %v") + var ErrInsertIntoNotSupported = errors.NewKind("table doesn't support INSERT INTO") + var ErrInsertIntoUnsupportedValues = errors.NewKind("%T is unsupported for inserts") + var ErrInvalidIndexDriver = errors.NewKind("invalid driver index %q") + var ErrNoCheckConstraintSupport = errors.NewKind("the table does not support check constraint operations: %s") + var ErrNoForeignKeySupport = errors.NewKind("the table does not support foreign key operations: %s") + var ErrNoIndexableTable = errors.NewKind("expected an IndexableTable, couldn't find one in %v") + var ErrNoIndexedTableAccess = errors.NewKind("expected an IndexedTableAccess, couldn't find one in %v") + var ErrNoPartitionable = errors.NewKind("no partitionable node found in exchange tree") + var ErrNotIndexable = errors.NewKind("the table is not indexable") + var ErrNotPrimaryKeyAlterable = errors.NewKind("error: table is not primary key alterable") + var ErrNotView = errors.NewKind("'%' is not VIEW") + var ErrNullDefault = errors.NewKind("column declared not null must have a non-null default value") + var ErrOnDuplicateKeyUpdateNotSupported = errors.NewKind("table doesn't support ON DUPLICATE KEY UPDATE") + var ErrRenameTableNotSupported = errors.NewKind("tables cannot be renamed on database %s") + var ErrReplaceIntoNotSupported = errors.NewKind("table doesn't support REPLACE INTO") + var ErrTableCreatedNotFound = errors.NewKind("table was created but could not be found") + var ErrTableNotLockable = errors.NewKind("table %s is not lockable") + var ErrTableNotNameable = errors.NewKind("can't get name from table") + var ErrTableNotValid = errors.NewKind("table is not valid") + var ErrTemporaryTablesForeignKeySupport = errors.NewKind("temporary tables do not support foreign keys") + var ErrTruncateNotSupported = errors.NewKind("table doesn't support TRUNCATE") + var ErrUnresolvedTable = errors.NewKind("unresolved table") + var ErrUpdateNotSupported = errors.NewKind("table doesn't support UPDATE") + var ErrUpdateUnexpectedSetResult = errors.NewKind("attempted to set field but expression returned %T") + var IgnorableErrors = []*errors.Kind + var Nothing nothing + func ApplyBindings(ctx *sql.Context, n sql.Node, bindings map[string]sql.Expression) (sql.Node, error) + func GetColumnFromIndexExpr(expr string, table sql.Table) *sql.Column + func GetColumnsAndPrepareExpressions(ctx *sql.Context, exprs []sql.Expression) ([]string, []sql.Expression, error) + func GetIndexLookup(ita *IndexedTableAccess) sql.IndexLookup + func GetInsertable(node sql.Node) (sql.InsertableTable, error) + func GetTruncatable(node sql.Node) (sql.TruncateableTable, error) + func Inspect(node sql.Node, f func(sql.Node) bool) + func InspectExpressions(node sql.Node, f func(sql.Expression) bool) + func InspectExpressionsWithNode(node sql.Node, f func(sql.Node, sql.Expression) bool) + func IsBinary(node sql.Node) bool + func IsDDLNode(node sql.Node) bool + func IsNoRowNode(node sql.Node) bool + func IsShowNode(node sql.Node) bool + func IsUnary(node sql.Node) bool + func NewCheckDefinition(ctx *sql.Context, check *sql.CheckConstraint) (*sql.CheckDefinition, error) + func NewIndexedInSubqueryFilter(subquery *Subquery, child sql.Node, padding int, ...) sql.Node + func NewNotInSubquery(left sql.Expression, right sql.Expression) sql.Expression + func NewShowCreateTable(table sql.Node, isView bool) sql.Node + func NewShowIndexes(table sql.Node) sql.Node + func NewStripRowNode(child sql.Node, numCols int) sql.Node + func NewTableEditorIter(table sql.TableEditor, wrappedIter sql.RowIter) sql.RowIter + func NillaryWithChildren(node sql.Node, children ...sql.Node) (sql.Node, error) + func ProjectRow(s *sql.Context, projections []sql.Expression, row sql.Row) (sql.Row, error) + func TransformExpressions(node sql.Node, f sql.TransformExprFunc) (sql.Node, error) + func TransformExpressionsUp(node sql.Node, f sql.TransformExprFunc) (sql.Node, error) + func TransformExpressionsUpWithNode(node sql.Node, f expression.TransformExprWithNodeFunc) (sql.Node, error) + func TransformExpressionsWithNode(n sql.Node, f expression.TransformExprWithNodeFunc) (sql.Node, error) + func TransformUp(node sql.Node, f sql.TransformNodeFunc) (sql.Node, error) + func TransformUpCtx(n sql.Node, s TransformSelector, f Transformer) (sql.Node, error) + func Walk(v Visitor, node sql.Node) + func WalkExpressions(v sql.Visitor, node sql.Node) + func WalkExpressionsWithNode(v sql.NodeVisitor, n sql.Node) + type AccountLimits struct + MaxConnectionsPerHour *int64 + MaxQueriesPerHour *int64 + MaxUpdatesPerHour *int64 + MaxUserConnections *int64 + type AddColumn struct + func NewAddColumn(db sql.Database, table *UnresolvedTable, column *sql.Column, ...) *AddColumn + func (a *AddColumn) Children() []sql.Node + func (a *AddColumn) Column() *sql.Column + func (a *AddColumn) Expressions() []sql.Expression + func (a *AddColumn) Order() *sql.ColumnOrder + func (a *AddColumn) Resolved() bool + func (a *AddColumn) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (a *AddColumn) Schema() sql.Schema + func (a *AddColumn) String() string + func (a *AddColumn) WithDatabase(db sql.Database) (sql.Node, error) + func (a *AddColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (a AddColumn) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *AddColumn) Database() sql.Database + type AlterAutoIncrement struct + func NewAlterAutoIncrement(table sql.Node, autoVal int64) *AlterAutoIncrement + func (p *AlterAutoIncrement) Execute(ctx *sql.Context) error + func (p *AlterAutoIncrement) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (p *AlterAutoIncrement) Schema() sql.Schema + func (p *AlterAutoIncrement) WithChildren(children ...sql.Node) (sql.Node, error) + func (p AlterAutoIncrement) String() string + type AlterDefaultDrop struct + ColumnName string + func NewAlterDefaultDrop(table sql.Node, columnName string) *AlterDefaultDrop + func (d *AlterDefaultDrop) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *AlterDefaultDrop) String() string + func (d *AlterDefaultDrop) WithChildren(children ...sql.Node) (sql.Node, error) + type AlterDefaultSet struct + ColumnName string + Default *sql.ColumnDefaultValue + func NewAlterDefaultSet(table sql.Node, columnName string, defVal *sql.ColumnDefaultValue) *AlterDefaultSet + func (d *AlterDefaultSet) Expressions() []sql.Expression + func (d *AlterDefaultSet) Resolved() bool + func (d *AlterDefaultSet) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *AlterDefaultSet) String() string + func (d *AlterDefaultSet) WithChildren(children ...sql.Node) (sql.Node, error) + func (d *AlterDefaultSet) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type AlterIndex struct + Action IndexAction + Columns []sql.IndexColumn + Comment string + Constraint sql.IndexConstraint + IndexName string + PreviousIndexName string + Table sql.Node + Using sql.IndexUsing + func NewAlterCreateIndex(table sql.Node, indexName string, using sql.IndexUsing, ...) *AlterIndex + func NewAlterDropIndex(table sql.Node, indexName string) *AlterIndex + func NewAlterRenameIndex(table sql.Node, fromIndexName, toIndexName string) *AlterIndex + func (p *AlterIndex) Children() []sql.Node + func (p *AlterIndex) Execute(ctx *sql.Context) error + func (p *AlterIndex) Resolved() bool + func (p *AlterIndex) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *AlterIndex) Schema() sql.Schema + func (p *AlterIndex) WithChildren(children ...sql.Node) (sql.Node, error) + func (p AlterIndex) String() string + type AlterPK struct + Action PKAction + Columns []sql.IndexColumn + Table sql.Node + func NewAlterCreatePk(table sql.Node, columns []sql.IndexColumn) *AlterPK + func NewAlterDropPk(table sql.Node) *AlterPK + func (a AlterPK) Children() []sql.Node + func (a AlterPK) Resolved() bool + func (a AlterPK) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (a AlterPK) Schema() sql.Schema + func (a AlterPK) String() string + func (a AlterPK) WithChildren(children ...sql.Node) (sql.Node, error) + type AuthenticatedUser struct + Auth1 Authentication + Auth2 Authentication + Auth3 Authentication + AuthInitial Authentication + type Authentication interface + type BeginEndBlock struct + func NewBeginEndBlock(block *Block) *BeginEndBlock + func (b *BeginEndBlock) DebugString() string + func (b *BeginEndBlock) String() string + func (b *BeginEndBlock) WithChildren(children ...sql.Node) (sql.Node, error) + type BinaryNode struct + func (n BinaryNode) Children() []sql.Node + func (n BinaryNode) Left() sql.Node + func (n BinaryNode) Resolved() bool + func (n BinaryNode) Right() sql.Node + type Block struct + func NewBlock(statements []sql.Node) *Block + func (b *Block) Children() []sql.Node + func (b *Block) DebugString() string + func (b *Block) Resolved() bool + func (b *Block) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (b *Block) Schema() sql.Schema + func (b *Block) String() string + func (b *Block) WithChildren(children ...sql.Node) (sql.Node, error) + type BlockRowIter interface + RepresentingNode func() sql.Node + Schema func() sql.Schema + type CachedResults struct + func NewCachedResults(n sql.Node) *CachedResults + func (n *CachedResults) DebugString() string + func (n *CachedResults) Dispose() + func (n *CachedResults) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) + func (n *CachedResults) String() string + func (n *CachedResults) WithChildren(children ...sql.Node) (sql.Node, error) + type Call struct + Name string + Params []sql.Expression + func NewCall(name string, params []sql.Expression) *Call + func (c *Call) Children() []sql.Node + func (c *Call) Expressions() []sql.Expression + func (c *Call) HasProcedure() bool + func (c *Call) Resolved() bool + func (c *Call) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *Call) Schema() sql.Schema + func (c *Call) String() string + func (c *Call) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *Call) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (c *Call) WithParamReference(pRef *expression.ProcedureParamReference) *Call + func (c *Call) WithProcedure(proc *Procedure) *Call + type Characteristic byte + const Characteristic_ContainsSql + const Characteristic_Deterministic + const Characteristic_LanguageSql + const Characteristic_ModifiesSqlData + const Characteristic_NoSql + const Characteristic_NotDeterministic + const Characteristic_ReadsSqlData + func (c Characteristic) String() string + type Commit struct + func NewCommit(db sql.UnresolvedDatabase) *Commit + func (*Commit) Children() []sql.Node + func (*Commit) Schema() sql.Schema + func (*Commit) String() string + func (c *Commit) Database() sql.Database + func (c *Commit) Resolved() bool + func (c *Commit) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (c *Commit) WithChildren(children ...sql.Node) (sql.Node, error) + func (c Commit) WithDatabase(database sql.Database) (sql.Node, error) + type CommonTableExpression struct + Columns []string + Subquery *SubqueryAlias + func NewCommonTableExpression(subquery *SubqueryAlias, columns []string) *CommonTableExpression + func (e *CommonTableExpression) DebugString() string + func (e *CommonTableExpression) String() string + type Concat struct + func NewConcat(left, right sql.Node) *Concat + func (c *Concat) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *Concat) Schema() sql.Schema + func (c *Concat) WithChildren(children ...sql.Node) (sql.Node, error) + func (c Concat) DebugString() string + func (c Concat) String() string + type CopierProps struct + type CreateCheck struct + Check *sql.CheckConstraint + func NewAlterAddCheck(table sql.Node, check *sql.CheckConstraint) *CreateCheck + func (c *CreateCheck) Execute(ctx *sql.Context) error + func (c *CreateCheck) Expressions() []sql.Expression + func (c *CreateCheck) Resolved() bool + func (c *CreateCheck) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *CreateCheck) Schema() sql.Schema + func (c *CreateCheck) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *CreateCheck) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (c CreateCheck) String() string + type CreateDB struct + Catalog sql.Catalog + IfNotExists bool + func NewCreateDatabase(dbName string, ifNotExists bool) *CreateDB + func (c CreateDB) Children() []sql.Node + func (c CreateDB) Resolved() bool + func (c CreateDB) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c CreateDB) Schema() sql.Schema + func (c CreateDB) String() string + func (c CreateDB) WithChildren(children ...sql.Node) (sql.Node, error) + type CreateForeignKey struct + FkDef *sql.ForeignKeyConstraint + ReferencedTable string + Table string + func NewAlterAddForeignKey(db sql.Database, table, refTable string, fkDef *sql.ForeignKeyConstraint) *CreateForeignKey + func (c *CreateForeignKey) Children() []sql.Node + func (c *CreateForeignKey) Database() sql.Database + func (c *CreateForeignKey) Resolved() bool + func (p *CreateForeignKey) Execute(ctx *sql.Context) error + func (p *CreateForeignKey) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *CreateForeignKey) Schema() sql.Schema + func (p *CreateForeignKey) WithChildren(children ...sql.Node) (sql.Node, error) + func (p *CreateForeignKey) WithDatabase(db sql.Database) (sql.Node, error) + func (p CreateForeignKey) String() string + type CreateIndex struct + Catalog sql.Catalog + Config map[string]string + CurrentDatabase string + Driver string + Exprs []sql.Expression + Name string + Table sql.Node + func NewCreateIndex(name string, table sql.Node, exprs []sql.Expression, driver string, ...) *CreateIndex + func (c *CreateIndex) Children() []sql.Node + func (c *CreateIndex) Expressions() []sql.Expression + func (c *CreateIndex) Resolved() bool + func (c *CreateIndex) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *CreateIndex) Schema() sql.Schema + func (c *CreateIndex) String() string + func (c *CreateIndex) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *CreateIndex) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type CreateProcedure struct + BodyString string + Db sql.Database + func NewCreateProcedure(name, definer string, params []ProcedureParam, createdAt, modifiedAt time.Time, ...) *CreateProcedure + func (c *CreateProcedure) Children() []sql.Node + func (c *CreateProcedure) Database() sql.Database + func (c *CreateProcedure) DebugString() string + func (c *CreateProcedure) Resolved() bool + func (c *CreateProcedure) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *CreateProcedure) Schema() sql.Schema + func (c *CreateProcedure) String() string + func (c *CreateProcedure) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *CreateProcedure) WithDatabase(database sql.Database) (sql.Node, error) + type CreateRole struct + IfNotExists bool + Roles []UserName + func NewCreateRole(ifNotExists bool, roles []UserName) *CreateRole + func (n *CreateRole) Children() []sql.Node + func (n *CreateRole) Resolved() bool + func (n *CreateRole) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *CreateRole) Schema() sql.Schema + func (n *CreateRole) String() string + func (n *CreateRole) WithChildren(children ...sql.Node) (sql.Node, error) + type CreateSavepoint struct + func NewCreateSavepoint(db sql.UnresolvedDatabase, name string) *CreateSavepoint + func (*CreateSavepoint) Children() []sql.Node + func (*CreateSavepoint) Schema() sql.Schema + func (c *CreateSavepoint) Database() sql.Database + func (c *CreateSavepoint) Resolved() bool + func (c *CreateSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (c *CreateSavepoint) String() string + func (c *CreateSavepoint) WithChildren(children ...sql.Node) (sql.Node, error) + func (c CreateSavepoint) WithDatabase(database sql.Database) (sql.Node, error) + type CreateTable struct + CreateSchema sql.PrimaryKeySchema + func NewCreateTable(db sql.Database, name string, ifn IfNotExistsOption, temp TempTableOption, ...) *CreateTable + func NewCreateTableLike(db sql.Database, name string, likeTable sql.Node, ifn IfNotExistsOption, ...) *CreateTable + func NewCreateTableSelect(db sql.Database, name string, selectNode sql.Node, tableSpec *TableSpec, ...) *CreateTable + func (c *CreateTable) Children() []sql.Node + func (c *CreateTable) Database() sql.Database + func (c *CreateTable) DebugString() string + func (c *CreateTable) Expressions() []sql.Expression + func (c *CreateTable) IfNotExists() IfNotExistsOption + func (c *CreateTable) Like() sql.Node + func (c *CreateTable) Name() string + func (c *CreateTable) PkSchema() sql.PrimaryKeySchema + func (c *CreateTable) Resolved() bool + func (c *CreateTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *CreateTable) Schema() sql.Schema + func (c *CreateTable) Select() sql.Node + func (c *CreateTable) String() string + func (c *CreateTable) TableSpec() *TableSpec + func (c *CreateTable) Temporary() TempTableOption + func (c *CreateTable) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *CreateTable) WithDatabase(db sql.Database) (sql.Node, error) + func (c *CreateTable) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type CreateTrigger struct + Body sql.Node + BodyString string + CreateDatabase sql.Database + CreateTriggerString string + Table sql.Node + TriggerEvent string + TriggerName string + TriggerOrder *TriggerOrder + TriggerTime string + func NewCreateTrigger(triggerName, triggerTime, triggerEvent string, triggerOrder *TriggerOrder, ...) *CreateTrigger + func (c *CreateTrigger) Children() []sql.Node + func (c *CreateTrigger) Database() sql.Database + func (c *CreateTrigger) DebugString() string + func (c *CreateTrigger) Resolved() bool + func (c *CreateTrigger) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (c *CreateTrigger) Schema() sql.Schema + func (c *CreateTrigger) String() string + func (c *CreateTrigger) WithChildren(children ...sql.Node) (sql.Node, error) + func (c *CreateTrigger) WithDatabase(database sql.Database) (sql.Node, error) + type CreateUser struct + AccountLimits *AccountLimits + Attribute string + DefaultRoles []UserName + IfNotExists bool + Locked bool + PasswordOptions *PasswordOptions + TLSOptions *TLSOptions + Users []AuthenticatedUser + func (n *CreateUser) Children() []sql.Node + func (n *CreateUser) Resolved() bool + func (n *CreateUser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *CreateUser) Schema() sql.Schema + func (n *CreateUser) String() string + func (n *CreateUser) WithChildren(children ...sql.Node) (sql.Node, error) + type CreateView struct + Columns []string + Definition *SubqueryAlias + IsReplace bool + Name string + func NewCreateView(database sql.Database, name string, columns []string, ...) *CreateView + func (cv *CreateView) Children() []sql.Node + func (cv *CreateView) Database() sql.Database + func (cv *CreateView) Resolved() bool + func (cv *CreateView) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (cv *CreateView) Schema() sql.Schema + func (cv *CreateView) String() string + func (cv *CreateView) View() *sql.View + func (cv *CreateView) WithChildren(children ...sql.Node) (sql.Node, error) + func (cv *CreateView) WithDatabase(database sql.Database) (sql.Node, error) + type CrossJoin struct + func NewCrossJoin(left sql.Node, right sql.Node) *CrossJoin + func (p *CrossJoin) DebugString() string + func (p *CrossJoin) Resolved() bool + func (p *CrossJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *CrossJoin) Schema() sql.Schema + func (p *CrossJoin) String() string + func (p *CrossJoin) WithChildren(children ...sql.Node) (sql.Node, error) + type DeclareCondition struct + MysqlErrCode int64 + Name string + SqlStateValue string + func NewDeclareCondition(name string, errCode int64, sqlStateValue string) *DeclareCondition + func (d *DeclareCondition) Children() []sql.Node + func (d *DeclareCondition) Resolved() bool + func (d *DeclareCondition) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DeclareCondition) Schema() sql.Schema + func (d *DeclareCondition) String() string + func (d *DeclareCondition) WithChildren(children ...sql.Node) (sql.Node, error) + type DecoratedNode struct + func NewDecoratedNode(decoration string, node sql.Node) *DecoratedNode + func (n *DecoratedNode) DebugString() string + func (n *DecoratedNode) RowIter(context *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *DecoratedNode) String() string + func (n *DecoratedNode) WithChildren(children ...sql.Node) (sql.Node, error) + type DecorationType byte + type DeleteFrom struct + func NewDeleteFrom(n sql.Node) *DeleteFrom + func (p *DeleteFrom) Database() string + func (p *DeleteFrom) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *DeleteFrom) WithChildren(children ...sql.Node) (sql.Node, error) + func (p DeleteFrom) DebugString() string + func (p DeleteFrom) String() string + type Describe struct + func NewDescribe(child sql.Node) *Describe + func (d *Describe) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *Describe) Schema() sql.Schema + func (d *Describe) WithChildren(children ...sql.Node) (sql.Node, error) + func (d Describe) String() string + type DescribeQuery struct + Format string + func NewDescribeQuery(format string, child sql.Node) *DescribeQuery + func (d *DescribeQuery) Children() []sql.Node + func (d *DescribeQuery) DebugString() string + func (d *DescribeQuery) Query() sql.Node + func (d *DescribeQuery) Resolved() bool + func (d *DescribeQuery) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DescribeQuery) Schema() sql.Schema + func (d *DescribeQuery) String() string + func (d *DescribeQuery) WithChildren(node ...sql.Node) (sql.Node, error) + func (d *DescribeQuery) WithQuery(child sql.Node) sql.Node + type Distinct struct + func NewDistinct(child sql.Node) *Distinct + func (d *Distinct) Resolved() bool + func (d *Distinct) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *Distinct) WithChildren(children ...sql.Node) (sql.Node, error) + func (d Distinct) DebugString() string + func (d Distinct) String() string + type DropCheck struct + Name string + func NewAlterDropCheck(table sql.Node, name string) *DropCheck + func (p *DropCheck) Execute(ctx *sql.Context) error + func (p *DropCheck) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *DropCheck) Schema() sql.Schema + func (p *DropCheck) WithChildren(children ...sql.Node) (sql.Node, error) + func (p DropCheck) String() string + type DropColumn struct + func NewDropColumn(db sql.Database, table *UnresolvedTable, column string) *DropColumn + func (c *DropColumn) Database() sql.Database + func (d *DropColumn) Children() []sql.Node + func (d *DropColumn) Resolved() bool + func (d *DropColumn) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropColumn) Schema() sql.Schema + func (d *DropColumn) String() string + func (d *DropColumn) WithDatabase(db sql.Database) (sql.Node, error) + func (d DropColumn) WithChildren(children ...sql.Node) (sql.Node, error) + type DropConstraint struct + Name string + func NewDropConstraint(table *UnresolvedTable, name string) *DropConstraint + func (d *DropConstraint) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropConstraint) String() string + func (d DropConstraint) WithChildren(children ...sql.Node) (sql.Node, error) + type DropDB struct + Catalog sql.Catalog + IfExists bool + func NewDropDatabase(dbName string, ifExists bool) *DropDB + func (d DropDB) Children() []sql.Node + func (d DropDB) Resolved() bool + func (d DropDB) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d DropDB) Schema() sql.Schema + func (d DropDB) String() string + func (d DropDB) WithChildren(children ...sql.Node) (sql.Node, error) + type DropForeignKey struct + Name string + func NewAlterDropForeignKey(table sql.Node, name string) *DropForeignKey + func (p *DropForeignKey) Execute(ctx *sql.Context) error + func (p *DropForeignKey) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *DropForeignKey) Schema() sql.Schema + func (p *DropForeignKey) WithChildren(children ...sql.Node) (sql.Node, error) + func (p DropForeignKey) String() string + type DropIndex struct + Catalog sql.Catalog + CurrentDatabase string + Name string + Table sql.Node + func NewDropIndex(name string, table sql.Node) *DropIndex + func (d *DropIndex) Children() []sql.Node + func (d *DropIndex) Resolved() bool + func (d *DropIndex) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropIndex) Schema() sql.Schema + func (d *DropIndex) String() string + func (d *DropIndex) WithChildren(children ...sql.Node) (sql.Node, error) + type DropProcedure struct + IfExists bool + ProcedureName string + func NewDropProcedure(db sql.Database, procedureName string, ifExists bool) *DropProcedure + func (d *DropProcedure) Children() []sql.Node + func (d *DropProcedure) Database() sql.Database + func (d *DropProcedure) Resolved() bool + func (d *DropProcedure) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropProcedure) Schema() sql.Schema + func (d *DropProcedure) String() string + func (d *DropProcedure) WithChildren(children ...sql.Node) (sql.Node, error) + func (d *DropProcedure) WithDatabase(db sql.Database) (sql.Node, error) + type DropRole struct + IfExists bool + Roles []UserName + func NewDropRole(ifExists bool, roles []UserName) *DropRole + func (n *DropRole) Children() []sql.Node + func (n *DropRole) Resolved() bool + func (n *DropRole) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *DropRole) Schema() sql.Schema + func (n *DropRole) String() string + func (n *DropRole) WithChildren(children ...sql.Node) (sql.Node, error) + type DropTable struct + func NewDropTable(db sql.Database, ifExists bool, tableNames ...string) *DropTable + func (*DropTable) Schema() sql.Schema + func (c *DropTable) Children() []sql.Node + func (c *DropTable) Database() sql.Database + func (c *DropTable) Resolved() bool + func (d *DropTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropTable) String() string + func (d *DropTable) TableNames() []string + func (d *DropTable) WithChildren(children ...sql.Node) (sql.Node, error) + func (d *DropTable) WithDatabase(db sql.Database) (sql.Node, error) + func (d *DropTable) WithTriggers(triggers []string) sql.Node + type DropTrigger struct + IfExists bool + TriggerName string + func NewDropTrigger(db sql.Database, trigger string, ifExists bool) *DropTrigger + func (d *DropTrigger) Children() []sql.Node + func (d *DropTrigger) Database() sql.Database + func (d *DropTrigger) Resolved() bool + func (d *DropTrigger) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *DropTrigger) Schema() sql.Schema + func (d *DropTrigger) String() string + func (d *DropTrigger) WithChildren(children ...sql.Node) (sql.Node, error) + func (d *DropTrigger) WithDatabase(db sql.Database) (sql.Node, error) + type DropUser struct + IfExists bool + Users []UserName + func NewDropUser(ifExists bool, users []UserName) *DropUser + func (n *DropUser) Children() []sql.Node + func (n *DropUser) Resolved() bool + func (n *DropUser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *DropUser) Schema() sql.Schema + func (n *DropUser) String() string + func (n *DropUser) WithChildren(children ...sql.Node) (sql.Node, error) + type DropView struct + func NewDropView(children []sql.Node, ifExists bool) *DropView + func (dvs *DropView) Children() []sql.Node + func (dvs *DropView) Resolved() bool + func (dvs *DropView) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (dvs *DropView) Schema() sql.Schema + func (dvs *DropView) String() string + func (dvs *DropView) WithChildren(children ...sql.Node) (sql.Node, error) + type DummyResolvedDB struct + func NewDummyResolvedDB(name string) *DummyResolvedDB + func (d *DummyResolvedDB) AddTable(name string, t sql.Table) + func (d *DummyResolvedDB) CreateTable(ctx *sql.Context, name string, schema sql.PrimaryKeySchema) error + func (d *DummyResolvedDB) DropTable(ctx *sql.Context, name string) error + func (d *DummyResolvedDB) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.Table, bool, error) + func (d *DummyResolvedDB) GetTableNames(ctx *sql.Context) ([]string, error) + func (d *DummyResolvedDB) Name() string + func (d *DummyResolvedDB) RenameTable(ctx *sql.Context, oldName, newName string) error + func (d *DummyResolvedDB) Tables() map[string]sql.Table + type EvalPartitionKeyValueIter struct + func NewEvalPartitionKeyValueIter(iter sql.PartitionIndexKeyValueIter, columns []string, exprs []sql.Expression) *EvalPartitionKeyValueIter + func (i *EvalPartitionKeyValueIter) Close(ctx *sql.Context) error + func (i *EvalPartitionKeyValueIter) Next(ctx *sql.Context) (sql.Partition, sql.IndexKeyValueIter, error) + type Exchange struct + Parallelism int + func NewExchange(parallelism int, child sql.Node) *Exchange + func (e *Exchange) DebugString() string + func (e *Exchange) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (e *Exchange) String() string + func (e *Exchange) WithChildren(children ...sql.Node) (sql.Node, error) + type ExistsSubquery struct + func NewExistsSubquery(query sql.Expression) *ExistsSubquery + func (e *ExistsSubquery) Children() []sql.Expression + func (e *ExistsSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) + func (e *ExistsSubquery) IsNullable() bool + func (e *ExistsSubquery) Resolved() bool + func (e *ExistsSubquery) String() string + func (e *ExistsSubquery) Type() sql.Type + func (e *ExistsSubquery) WithChildren(children ...sql.Expression) (sql.Expression, error) + type Filter struct + Expression sql.Expression + func NewFilter(expression sql.Expression, child sql.Node) *Filter + func (f *Filter) DebugString() string + func (f *Filter) Expressions() []sql.Expression + func (f *Filter) Resolved() bool + func (f *Filter) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (f *Filter) String() string + func (f *Filter) WithChildren(children ...sql.Node) (sql.Node, error) + func (f *Filter) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type FilterIter struct + func NewFilterIter(cond sql.Expression, child sql.RowIter) *FilterIter + func (i *FilterIter) Close(ctx *sql.Context) error + func (i *FilterIter) Next(ctx *sql.Context) (sql.Row, error) + type Generate struct + Column *expression.GetField + func NewGenerate(child sql.Node, col *expression.GetField) *Generate + func (g *Generate) Expressions() []sql.Expression + func (g *Generate) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (g *Generate) Schema() sql.Schema + func (g *Generate) String() string + func (g *Generate) WithChildren(children ...sql.Node) (sql.Node, error) + func (g *Generate) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type Grant struct + As *GrantUserAssumption + ObjectType ObjectType + PrivilegeLevel PrivilegeLevel + Privileges []Privilege + Users []UserName + WithGrantOption bool + func NewGrant(privileges []Privilege, objType ObjectType, level PrivilegeLevel, ...) *Grant + func (n *Grant) Children() []sql.Node + func (n *Grant) Resolved() bool + func (n *Grant) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *Grant) Schema() sql.Schema + func (n *Grant) String() string + func (n *Grant) WithChildren(children ...sql.Node) (sql.Node, error) + type GrantProxy struct + On UserName + To []UserName + WithGrantOption bool + func NewGrantProxy(on UserName, to []UserName, withGrant bool) *GrantProxy + func (n *GrantProxy) Children() []sql.Node + func (n *GrantProxy) Resolved() bool + func (n *GrantProxy) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *GrantProxy) Schema() sql.Schema + func (n *GrantProxy) String() string + func (n *GrantProxy) WithChildren(children ...sql.Node) (sql.Node, error) + type GrantRole struct + Roles []UserName + TargetUsers []UserName + WithAdminOption bool + func NewGrantRole(roles []UserName, users []UserName, withAdmin bool) *GrantRole + func (n *GrantRole) Children() []sql.Node + func (n *GrantRole) Resolved() bool + func (n *GrantRole) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *GrantRole) Schema() sql.Schema + func (n *GrantRole) String() string + func (n *GrantRole) WithChildren(children ...sql.Node) (sql.Node, error) + type GrantUserAssumption struct + Roles []UserName + Type GrantUserAssumptionType + User UserName + type GrantUserAssumptionType byte + const GrantUserAssumptionType_All + const GrantUserAssumptionType_AllExcept + const GrantUserAssumptionType_Default + const GrantUserAssumptionType_None + const GrantUserAssumptionType_Roles + type GroupBy struct + GroupByExprs []sql.Expression + SelectedExprs []sql.Expression + func NewGroupBy(selectedExprs, groupByExprs []sql.Expression, child sql.Node) *GroupBy + func (g *GroupBy) DebugString() string + func (g *GroupBy) Expressions() []sql.Expression + func (g *GroupBy) Resolved() bool + func (g *GroupBy) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (g *GroupBy) Schema() sql.Schema + func (g *GroupBy) String() string + func (g *GroupBy) WithChildren(children ...sql.Node) (sql.Node, error) + func (g *GroupBy) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type HashLookup struct + func NewHashLookup(n *CachedResults, childProjection sql.Expression, ...) *HashLookup + func (n *HashLookup) DebugString() string + func (n *HashLookup) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) + func (n *HashLookup) String() string + func (n *HashLookup) WithChildren(children ...sql.Node) (sql.Node, error) + type Having struct + Cond sql.Expression + func NewHaving(cond sql.Expression, child sql.Node) *Having + func (h *Having) DebugString() string + func (h *Having) Expressions() []sql.Expression + func (h *Having) Resolved() bool + func (h *Having) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (h *Having) String() string + func (h *Having) WithChildren(children ...sql.Node) (sql.Node, error) + func (h *Having) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type IfConditional struct + Body sql.Node + Condition sql.Expression + func NewIfConditional(condition sql.Expression, body sql.Node) *IfConditional + func (ic *IfConditional) Children() []sql.Node + func (ic *IfConditional) DebugString() string + func (ic *IfConditional) Expressions() []sql.Expression + func (ic *IfConditional) Resolved() bool + func (ic *IfConditional) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (ic *IfConditional) Schema() sql.Schema + func (ic *IfConditional) String() string + func (ic *IfConditional) WithChildren(children ...sql.Node) (sql.Node, error) + func (ic *IfConditional) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type IfElseBlock struct + Else sql.Node + IfConditionals []*IfConditional + func NewIfElse(ifConditionals []*IfConditional, elseStatement sql.Node) *IfElseBlock + func (ieb *IfElseBlock) Children() []sql.Node + func (ieb *IfElseBlock) DebugString() string + func (ieb *IfElseBlock) Resolved() bool + func (ieb *IfElseBlock) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (ieb *IfElseBlock) Schema() sql.Schema + func (ieb *IfElseBlock) String() string + func (ieb *IfElseBlock) WithChildren(children ...sql.Node) (sql.Node, error) + type IfNotExistsOption bool + const IfNotExists + const IfNotExistsAbsent + type InSubquery struct + func NewInSubquery(left sql.Expression, right sql.Expression) *InSubquery + func (in *InSubquery) Children() []sql.Expression + func (in *InSubquery) DebugString() string + func (in *InSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) + func (in *InSubquery) String() string + func (in *InSubquery) Type() sql.Type + func (in *InSubquery) WithChildren(children ...sql.Expression) (sql.Expression, error) + type IndexAction byte + const IndexAction_Create + const IndexAction_Drop + const IndexAction_Rename + type IndexDefinition struct + Columns []sql.IndexColumn + Comment string + Constraint sql.IndexConstraint + IndexName string + Using sql.IndexUsing + func (i *IndexDefinition) String() string + type IndexedInSubqueryFilter struct + func (i *IndexedInSubqueryFilter) Children() []sql.Node + func (i *IndexedInSubqueryFilter) DebugString() string + func (i *IndexedInSubqueryFilter) Resolved() bool + func (i *IndexedInSubqueryFilter) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (i *IndexedInSubqueryFilter) Schema() sql.Schema + func (i *IndexedInSubqueryFilter) String() string + func (i *IndexedInSubqueryFilter) WithChildren(children ...sql.Node) (sql.Node, error) + type IndexedJoin struct + Cond sql.Expression + func NewIndexedJoin(left, right sql.Node, joinType JoinType, cond sql.Expression, scopeLen int) *IndexedJoin + func (ij *IndexedJoin) DebugString() string + func (ij *IndexedJoin) JoinType() JoinType + func (ij *IndexedJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (ij *IndexedJoin) Schema() sql.Schema + func (ij *IndexedJoin) String() string + func (ij *IndexedJoin) WithChildren(children ...sql.Node) (sql.Node, error) + type IndexedTableAccess struct + func NewIndexedTableAccess(resolvedTable *ResolvedTable, index sql.Index, keyExprs []sql.Expression) *IndexedTableAccess + func NewStaticIndexedTableAccess(resolvedTable *ResolvedTable, lookup sql.IndexLookup, index sql.Index, ...) *IndexedTableAccess + func (i *IndexedTableAccess) CanBuildIndex(ctx *sql.Context) (bool, error) + func (i *IndexedTableAccess) DebugString() string + func (i *IndexedTableAccess) Expressions() []sql.Expression + func (i *IndexedTableAccess) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (i *IndexedTableAccess) String() string + func (i *IndexedTableAccess) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type InnerJoin struct + func NewInnerJoin(left, right sql.Node, cond sql.Expression) *InnerJoin + func (j *InnerJoin) DebugString() string + func (j *InnerJoin) JoinType() JoinType + func (j *InnerJoin) Resolved() bool + func (j *InnerJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (j *InnerJoin) Schema() sql.Schema + func (j *InnerJoin) String() string + func (j *InnerJoin) WithChildren(children ...sql.Node) (sql.Node, error) + func (j *InnerJoin) WithComment(comment string) sql.Node + func (j *InnerJoin) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (j *InnerJoin) WithScopeLen(i int) JoinNode + func (j InnerJoin) Comment() string + func (j InnerJoin) Expressions() []sql.Expression + func (j InnerJoin) JoinCond() sql.Expression + func (j InnerJoin) WithMultipassMode() JoinNode + type InsertInto struct + Checks sql.CheckConstraints + ColumnNames []string + Destination sql.Node + Ignore bool + IsReplace bool + OnDupExprs []sql.Expression + Source sql.Node + func NewInsertInto(db sql.Database, dst, src sql.Node, isReplace bool, cols []string, ...) *InsertInto + func (ii *InsertInto) Children() []sql.Node + func (ii *InsertInto) Database() sql.Database + func (ii *InsertInto) Expressions() []sql.Expression + func (ii *InsertInto) Resolved() bool + func (ii *InsertInto) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (ii *InsertInto) Schema() sql.Schema + func (ii *InsertInto) WithChildren(children ...sql.Node) (sql.Node, error) + func (ii *InsertInto) WithDatabase(database sql.Database) (sql.Node, error) + func (ii *InsertInto) WithSource(src sql.Node) sql.Node + func (ii InsertInto) DebugString() string + func (ii InsertInto) String() string + func (ii InsertInto) WithExpressions(newExprs ...sql.Expression) (sql.Node, error) + type JoinNode interface + Comment func() string + JoinCond func() sql.Expression + JoinType func() JoinType + Left func() sql.Node + Right func() sql.Node + WithMultipassMode func() JoinNode + WithScopeLen func(int) JoinNode + type JoinType byte + const JoinTypeInner + const JoinTypeLeft + const JoinTypeRight + func (t JoinType) String() string + type Kill struct + func NewKill(kt KillType, connID uint32) *Kill + func (k *Kill) Children() []sql.Node + func (k *Kill) Resolved() bool + func (k *Kill) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (k *Kill) Schema() sql.Schema + func (k *Kill) String() string + func (k *Kill) WithChildren(children ...sql.Node) (sql.Node, error) + type KillType int + const KillType_Connection + const KillType_Query + func (kt KillType) String() string + type LeftJoin struct + func NewLeftJoin(left, right sql.Node, cond sql.Expression) *LeftJoin + func (j *LeftJoin) DebugString() string + func (j *LeftJoin) JoinType() JoinType + func (j *LeftJoin) Resolved() bool + func (j *LeftJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (j *LeftJoin) Schema() sql.Schema + func (j *LeftJoin) String() string + func (j *LeftJoin) WithChildren(children ...sql.Node) (sql.Node, error) + func (j *LeftJoin) WithComment(comment string) sql.Node + func (j *LeftJoin) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (j *LeftJoin) WithScopeLen(i int) JoinNode + func (j LeftJoin) Comment() string + func (j LeftJoin) Expressions() []sql.Expression + func (j LeftJoin) JoinCond() sql.Expression + func (j LeftJoin) WithMultipassMode() JoinNode + type Limit struct + CalcFoundRows bool + Limit sql.Expression + func NewLimit(size sql.Expression, child sql.Node) *Limit + func (l *Limit) Expressions() []sql.Expression + func (l *Limit) Resolved() bool + func (l *Limit) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (l *Limit) WithChildren(children ...sql.Node) (sql.Node, error) + func (l Limit) DebugString() string + func (l Limit) String() string + func (l Limit) WithCalcFoundRows(v bool) *Limit + func (l Limit) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type LoadData struct + ColumnNames []string + Destination sql.Node + Fields *sqlparser.Fields + File string + IgnoreNum int64 + Lines *sqlparser.Lines + Local bool + ResponsePacketSent bool + func NewLoadData(local bool, file string, destination sql.Node, cols []string, ...) *LoadData + func (l *LoadData) Children() []sql.Node + func (l *LoadData) Resolved() bool + func (l *LoadData) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (l *LoadData) Schema() sql.Schema + func (l *LoadData) String() string + func (l *LoadData) WithChildren(children ...sql.Node) (sql.Node, error) + type LockTables struct + Catalog sql.Catalog + Locks []*TableLock + func NewLockTables(locks []*TableLock) *LockTables + func (t *LockTables) Children() []sql.Node + func (t *LockTables) Resolved() bool + func (t *LockTables) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *LockTables) Schema() sql.Schema + func (t *LockTables) String() string + func (t *LockTables) WithChildren(children ...sql.Node) (sql.Node, error) + type ModifyColumn struct + func NewModifyColumn(db sql.Database, table *UnresolvedTable, columnName string, column *sql.Column, ...) *ModifyColumn + func (c *ModifyColumn) Database() sql.Database + func (m *ModifyColumn) Children() []sql.Node + func (m *ModifyColumn) Column() string + func (m *ModifyColumn) Expressions() []sql.Expression + func (m *ModifyColumn) NewColumn() *sql.Column + func (m *ModifyColumn) Order() *sql.ColumnOrder + func (m *ModifyColumn) Resolved() bool + func (m *ModifyColumn) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (m *ModifyColumn) Schema() sql.Schema + func (m *ModifyColumn) String() string + func (m *ModifyColumn) WithDatabase(db sql.Database) (sql.Node, error) + func (m *ModifyColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (m ModifyColumn) WithChildren(children ...sql.Node) (sql.Node, error) + type NameAndSchema interface + Schema func() sql.Schema + type NamedNotifyFunc func(name string) + type NaturalJoin struct + func NewNaturalJoin(left, right sql.Node) *NaturalJoin + func (NaturalJoin) Resolved() bool + func (NaturalJoin) RowIter(*sql.Context, sql.Row) (sql.RowIter, error) + func (NaturalJoin) Schema() sql.Schema + func (j *NaturalJoin) WithChildren(children ...sql.Node) (sql.Node, error) + func (j NaturalJoin) String() string + type NotifyFunc func() + type ObjectType byte + const ObjectType_Any + const ObjectType_Function + const ObjectType_Procedure + const ObjectType_Table + type Offset struct + Offset sql.Expression + func NewOffset(n sql.Expression, child sql.Node) *Offset + func (o *Offset) Expressions() []sql.Expression + func (o *Offset) Resolved() bool + func (o *Offset) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (o *Offset) WithChildren(children ...sql.Node) (sql.Node, error) + func (o *Offset) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (o Offset) String() string + type OrderedDistinct struct + func NewOrderedDistinct(child sql.Node) *OrderedDistinct + func (d *OrderedDistinct) Resolved() bool + func (d *OrderedDistinct) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (d *OrderedDistinct) WithChildren(children ...sql.Node) (sql.Node, error) + func (d OrderedDistinct) String() string + type PKAction byte + const PrimaryKeyAction_Create + const PrimaryKeyAction_Drop + type PasswordOptions struct + ExpirationTime *int64 + FailedAttempts *int64 + History *int64 + LockTime *int64 + RequireCurrentOptional bool + ReuseInterval *int64 + type Privilege struct + Columns []string + Type PrivilegeType + func (p *Privilege) String() string + type PrivilegeLevel struct + Database string + TableRoutine string + func (p *PrivilegeLevel) String() string + type PrivilegeType byte + const PrivilegeType_All + const PrivilegeType_Insert + const PrivilegeType_References + const PrivilegeType_Select + const PrivilegeType_Update + type Procedure struct + Body sql.Node + Characteristics []Characteristic + Comment string + CreateProcedureString string + CreatedAt time.Time + Definer string + ModifiedAt time.Time + Name string + Params []ProcedureParam + SecurityContext ProcedureSecurityContext + func NewProcedure(name string, definer string, params []ProcedureParam, ...) *Procedure + func (p *Procedure) Children() []sql.Node + func (p *Procedure) DebugString() string + func (p *Procedure) Resolved() bool + func (p *Procedure) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *Procedure) Schema() sql.Schema + func (p *Procedure) String() string + func (p *Procedure) WithChildren(children ...sql.Node) (sql.Node, error) + type ProcedureParam struct + Direction ProcedureParamDirection + Name string + Type sql.Type + func (pp ProcedureParam) String() string + type ProcedureParamDirection byte + const ProcedureParamDirection_In + const ProcedureParamDirection_Inout + const ProcedureParamDirection_Out + type ProcedureResolvedTable struct + ResolvedTable *ResolvedTable + func NewProcedureResolvedTable(rt *ResolvedTable) *ProcedureResolvedTable + func (t *ProcedureResolvedTable) Children() []sql.Node + func (t *ProcedureResolvedTable) DebugString() string + func (t *ProcedureResolvedTable) Name() string + func (t *ProcedureResolvedTable) PartitionRows(ctx *sql.Context, partition sql.Partition) (sql.RowIter, error) + func (t *ProcedureResolvedTable) Partitions(ctx *sql.Context) (sql.PartitionIter, error) + func (t *ProcedureResolvedTable) Resolved() bool + func (t *ProcedureResolvedTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *ProcedureResolvedTable) Schema() sql.Schema + func (t *ProcedureResolvedTable) String() string + func (t *ProcedureResolvedTable) Underlying() sql.Table + func (t *ProcedureResolvedTable) WithChildren(children ...sql.Node) (sql.Node, error) + type ProcedureSecurityContext byte + const ProcedureSecurityContext_Definer + const ProcedureSecurityContext_Invoker + func (pst ProcedureSecurityContext) String() string + type ProcessIndexableTable struct + OnPartitionDone NamedNotifyFunc + OnPartitionStart NamedNotifyFunc + OnRowNext NamedNotifyFunc + func NewProcessIndexableTable(t sql.DriverIndexableTable, ...) *ProcessIndexableTable + func (t *ProcessIndexableTable) DebugString() string + func (t *ProcessIndexableTable) IndexKeyValues(ctx *sql.Context, columns []string) (sql.PartitionIndexKeyValueIter, error) + func (t *ProcessIndexableTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.RowIter, error) + func (t *ProcessIndexableTable) Underlying() sql.Table + type ProcessTable struct + OnPartitionDone NamedNotifyFunc + OnPartitionStart NamedNotifyFunc + OnRowNext NamedNotifyFunc + func NewProcessTable(t sql.Table, onPartitionDone, onPartitionStart, OnRowNext NamedNotifyFunc) *ProcessTable + func (t *ProcessTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.RowIter, error) + func (t *ProcessTable) Underlying() sql.Table + type Project struct + Projections []sql.Expression + func NewProject(expressions []sql.Expression, child sql.Node) *Project + func (p *Project) DebugString() string + func (p *Project) Expressions() []sql.Expression + func (p *Project) Resolved() bool + func (p *Project) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *Project) Schema() sql.Schema + func (p *Project) String() string + func (p *Project) WithChildren(children ...sql.Node) (sql.Node, error) + func (p *Project) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type QueryProcess struct + Notify NotifyFunc + func NewQueryProcess(node sql.Node, notify NotifyFunc) *QueryProcess + func (p *QueryProcess) DebugString() string + func (p *QueryProcess) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *QueryProcess) String() string + func (p *QueryProcess) WithChildren(children ...sql.Node) (sql.Node, error) + type ReleaseSavepoint struct + func NewReleaseSavepoint(db sql.UnresolvedDatabase, name string) *ReleaseSavepoint + func (*ReleaseSavepoint) Children() []sql.Node + func (*ReleaseSavepoint) Schema() sql.Schema + func (r *ReleaseSavepoint) Database() sql.Database + func (r *ReleaseSavepoint) Resolved() bool + func (r *ReleaseSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (r *ReleaseSavepoint) String() string + func (r *ReleaseSavepoint) WithChildren(children ...sql.Node) (sql.Node, error) + func (r ReleaseSavepoint) WithDatabase(database sql.Database) (sql.Node, error) + type RenameColumn struct + ColumnName string + NewColumnName string + func NewRenameColumn(db sql.Database, table *UnresolvedTable, columnName string, ...) *RenameColumn + func (c *RenameColumn) Database() sql.Database + func (r *RenameColumn) Children() []sql.Node + func (r *RenameColumn) Resolved() bool + func (r *RenameColumn) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (r *RenameColumn) Schema() sql.Schema + func (r *RenameColumn) String() string + func (r *RenameColumn) WithDatabase(db sql.Database) (sql.Node, error) + func (r RenameColumn) WithChildren(children ...sql.Node) (sql.Node, error) + type RenameTable struct + func NewRenameTable(db sql.Database, oldNames, newNames []string) *RenameTable + func (*RenameTable) Schema() sql.Schema + func (c *RenameTable) Children() []sql.Node + func (c *RenameTable) Database() sql.Database + func (c *RenameTable) Resolved() bool + func (r *RenameTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (r *RenameTable) String() string + func (r *RenameTable) WithChildren(children ...sql.Node) (sql.Node, error) + func (r *RenameTable) WithDatabase(db sql.Database) (sql.Node, error) + type RenameUser struct + NewName []UserName + OldName []UserName + func NewRenameUser(oldNames []UserName, newNames []UserName) *RenameUser + func (n *RenameUser) Children() []sql.Node + func (n *RenameUser) Resolved() bool + func (n *RenameUser) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *RenameUser) Schema() sql.Schema + func (n *RenameUser) String() string + func (n *RenameUser) WithChildren(children ...sql.Node) (sql.Node, error) + type ResolvedTable struct + AsOf interface{} + Database sql.Database + func NewResolvedTable(table sql.Table, db sql.Database, asOf interface{}) *ResolvedTable + func (*ResolvedTable) Children() []sql.Node + func (*ResolvedTable) Resolved() bool + func (t *ResolvedTable) DebugString() string + func (t *ResolvedTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *ResolvedTable) String() string + func (t *ResolvedTable) WithChildren(children ...sql.Node) (sql.Node, error) + func (t *ResolvedTable) WithTable(table sql.Table) (*ResolvedTable, error) + type Revoke struct + ObjectType ObjectType + PrivilegeLevel PrivilegeLevel + Privileges []Privilege + Users []UserName + func NewRevoke(privileges []Privilege, objType ObjectType, level PrivilegeLevel, ...) *Revoke + func (n *Revoke) Children() []sql.Node + func (n *Revoke) Resolved() bool + func (n *Revoke) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *Revoke) Schema() sql.Schema + func (n *Revoke) String() string + func (n *Revoke) WithChildren(children ...sql.Node) (sql.Node, error) + type RevokeAll struct + Users []UserName + func NewRevokeAll(users []UserName) *RevokeAll + func (n *RevokeAll) Children() []sql.Node + func (n *RevokeAll) Resolved() bool + func (n *RevokeAll) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *RevokeAll) Schema() sql.Schema + func (n *RevokeAll) String() string + func (n *RevokeAll) WithChildren(children ...sql.Node) (sql.Node, error) + type RevokeProxy struct + From []UserName + On UserName + func NewRevokeProxy(on UserName, from []UserName) *RevokeProxy + func (n *RevokeProxy) Children() []sql.Node + func (n *RevokeProxy) Resolved() bool + func (n *RevokeProxy) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *RevokeProxy) Schema() sql.Schema + func (n *RevokeProxy) String() string + func (n *RevokeProxy) WithChildren(children ...sql.Node) (sql.Node, error) + type RevokeRole struct + Roles []UserName + TargetUsers []UserName + func NewRevokeRole(roles []UserName, users []UserName) *RevokeRole + func (n *RevokeRole) Children() []sql.Node + func (n *RevokeRole) Resolved() bool + func (n *RevokeRole) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *RevokeRole) Schema() sql.Schema + func (n *RevokeRole) String() string + func (n *RevokeRole) WithChildren(children ...sql.Node) (sql.Node, error) + type RightJoin struct + func NewRightJoin(left, right sql.Node, cond sql.Expression) *RightJoin + func (j *RightJoin) DebugString() string + func (j *RightJoin) JoinType() JoinType + func (j *RightJoin) Resolved() bool + func (j *RightJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (j *RightJoin) Schema() sql.Schema + func (j *RightJoin) String() string + func (j *RightJoin) WithChildren(children ...sql.Node) (sql.Node, error) + func (j *RightJoin) WithComment(comment string) sql.Node + func (j *RightJoin) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (j *RightJoin) WithScopeLen(i int) JoinNode + func (j RightJoin) Comment() string + func (j RightJoin) Expressions() []sql.Expression + func (j RightJoin) JoinCond() sql.Expression + func (j RightJoin) WithMultipassMode() JoinNode + type Rollback struct + func NewRollback(db sql.UnresolvedDatabase) *Rollback + func (*Rollback) Children() []sql.Node + func (*Rollback) Schema() sql.Schema + func (*Rollback) String() string + func (r *Rollback) Database() sql.Database + func (r *Rollback) Resolved() bool + func (r *Rollback) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (r *Rollback) WithChildren(children ...sql.Node) (sql.Node, error) + func (r Rollback) WithDatabase(database sql.Database) (sql.Node, error) + type RollbackSavepoint struct + func NewRollbackSavepoint(db sql.UnresolvedDatabase, name string) *RollbackSavepoint + func (*RollbackSavepoint) Children() []sql.Node + func (*RollbackSavepoint) Schema() sql.Schema + func (r *RollbackSavepoint) Database() sql.Database + func (r *RollbackSavepoint) Resolved() bool + func (r *RollbackSavepoint) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (r *RollbackSavepoint) String() string + func (r *RollbackSavepoint) WithChildren(children ...sql.Node) (sql.Node, error) + func (r RollbackSavepoint) WithDatabase(database sql.Database) (sql.Node, error) + type RowUpdateAccumulator struct + func NewRowUpdateAccumulator(n sql.Node, updateType RowUpdateType) *RowUpdateAccumulator + func (r RowUpdateAccumulator) DebugString() string + func (r RowUpdateAccumulator) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (r RowUpdateAccumulator) Schema() sql.Schema + func (r RowUpdateAccumulator) String() string + func (r RowUpdateAccumulator) WithChildren(children ...sql.Node) (sql.Node, error) + type RowUpdateType int + const UpdateTypeDelete + const UpdateTypeDuplicateKeyUpdate + const UpdateTypeInsert + const UpdateTypeJoinUpdate + const UpdateTypeReplace + const UpdateTypeUpdate + type Set struct + Exprs []sql.Expression + func NewSet(vars []sql.Expression) *Set + func (s *Set) Children() []sql.Node + func (s *Set) DebugString() string + func (s *Set) Expressions() []sql.Expression + func (s *Set) Resolved() bool + func (s *Set) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *Set) Schema() sql.Schema + func (s *Set) String() string + func (s *Set) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *Set) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type ShowCharset struct + CharacterSetTable sql.Node + func NewShowCharset() *ShowCharset + func (sc *ShowCharset) Children() []sql.Node + func (sc *ShowCharset) Resolved() bool + func (sc *ShowCharset) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (sc *ShowCharset) Schema() sql.Schema + func (sc *ShowCharset) String() string + func (sc *ShowCharset) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowColumns struct + Full bool + Indexes []sql.Index + func NewShowColumns(full bool, child sql.Node) *ShowColumns + func (s *ShowColumns) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowColumns) Schema() sql.Schema + func (s *ShowColumns) String() string + func (s *ShowColumns) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowCreateDatabase struct + IfNotExists bool + func NewShowCreateDatabase(db sql.Database, ifNotExists bool) *ShowCreateDatabase + func (s *ShowCreateDatabase) Children() []sql.Node + func (s *ShowCreateDatabase) Database() sql.Database + func (s *ShowCreateDatabase) Resolved() bool + func (s *ShowCreateDatabase) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowCreateDatabase) Schema() sql.Schema + func (s *ShowCreateDatabase) String() string + func (s *ShowCreateDatabase) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *ShowCreateDatabase) WithDatabase(db sql.Database) (sql.Node, error) + type ShowCreateTable struct + Checks sql.CheckConstraints + Indexes []sql.Index + IsView bool + func (n *ShowCreateTable) Resolved() bool + func (n *ShowCreateTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *ShowCreateTable) Schema() sql.Schema + func (n *ShowCreateTable) String() string + func (n *ShowCreateTable) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowCreateTrigger struct + TriggerName string + func NewShowCreateTrigger(db sql.Database, trigger string) *ShowCreateTrigger + func (s *ShowCreateTrigger) Children() []sql.Node + func (s *ShowCreateTrigger) Database() sql.Database + func (s *ShowCreateTrigger) Resolved() bool + func (s *ShowCreateTrigger) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowCreateTrigger) Schema() sql.Schema + func (s *ShowCreateTrigger) String() string + func (s *ShowCreateTrigger) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *ShowCreateTrigger) WithDatabase(db sql.Database) (sql.Node, error) + type ShowDatabases struct + Catalog sql.Catalog + func NewShowDatabases() *ShowDatabases + func (*ShowDatabases) Children() []sql.Node + func (*ShowDatabases) Schema() sql.Schema + func (p *ShowDatabases) Resolved() bool + func (p *ShowDatabases) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *ShowDatabases) WithChildren(children ...sql.Node) (sql.Node, error) + func (p ShowDatabases) String() string + type ShowGrants struct + CurrentUser bool + For *UserName + Using []UserName + func NewShowGrants(currentUser bool, targetUser *UserName, using []UserName) *ShowGrants + func (n *ShowGrants) Children() []sql.Node + func (n *ShowGrants) Resolved() bool + func (n *ShowGrants) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *ShowGrants) Schema() sql.Schema + func (n *ShowGrants) String() string + func (n *ShowGrants) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowIndexes struct + IndexesToShow []sql.Index + func (n *ShowIndexes) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *ShowIndexes) Schema() sql.Schema + func (n *ShowIndexes) String() string + func (n *ShowIndexes) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowPrivileges struct + func NewShowPrivileges() *ShowPrivileges + func (n *ShowPrivileges) Children() []sql.Node + func (n *ShowPrivileges) Resolved() bool + func (n *ShowPrivileges) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *ShowPrivileges) Schema() sql.Schema + func (n *ShowPrivileges) String() string + func (n *ShowPrivileges) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowProcedureStatus struct + Procedures []*Procedure + func NewShowProcedureStatus(db sql.Database) *ShowProcedureStatus + func (s *ShowProcedureStatus) Children() []sql.Node + func (s *ShowProcedureStatus) Database() sql.Database + func (s *ShowProcedureStatus) Resolved() bool + func (s *ShowProcedureStatus) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowProcedureStatus) Schema() sql.Schema + func (s *ShowProcedureStatus) String() string + func (s *ShowProcedureStatus) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *ShowProcedureStatus) WithDatabase(db sql.Database) (sql.Node, error) + type ShowProcessList struct + Database string + func NewShowProcessList() *ShowProcessList + func (p *ShowProcessList) Children() []sql.Node + func (p *ShowProcessList) Resolved() bool + func (p *ShowProcessList) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *ShowProcessList) Schema() sql.Schema + func (p *ShowProcessList) String() string + func (p *ShowProcessList) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowStatus struct + func NewShowStatus(modifier ShowStatusModifier) *ShowStatus + func (s *ShowStatus) Children() []sql.Node + func (s *ShowStatus) Resolved() bool + func (s *ShowStatus) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowStatus) Schema() sql.Schema + func (s *ShowStatus) String() string + func (s *ShowStatus) WithChildren(node ...sql.Node) (sql.Node, error) + type ShowStatusModifier byte + const ShowStatusModifier_Global + const ShowStatusModifier_Session + type ShowTableStatus struct + Catalog sql.Catalog + func NewShowTableStatus(db sql.Database) *ShowTableStatus + func (s *ShowTableStatus) Children() []sql.Node + func (s *ShowTableStatus) Database() sql.Database + func (s *ShowTableStatus) Resolved() bool + func (s *ShowTableStatus) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowTableStatus) Schema() sql.Schema + func (s *ShowTableStatus) String() string + func (s *ShowTableStatus) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *ShowTableStatus) WithDatabase(db sql.Database) (sql.Node, error) + type ShowTables struct + AsOf sql.Expression + Full bool + func NewShowTables(database sql.Database, full bool, asOf sql.Expression) *ShowTables + func (*ShowTables) Children() []sql.Node + func (p *ShowTables) Database() sql.Database + func (p *ShowTables) Expressions() []sql.Expression + func (p *ShowTables) Resolved() bool + func (p *ShowTables) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *ShowTables) Schema() sql.Schema + func (p *ShowTables) WithChildren(children ...sql.Node) (sql.Node, error) + func (p *ShowTables) WithDatabase(db sql.Database) (sql.Node, error) + func (p *ShowTables) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (p ShowTables) String() string + type ShowTriggers struct + Triggers []*CreateTrigger + func NewShowTriggers(db sql.Database) *ShowTriggers + func (s *ShowTriggers) Children() []sql.Node + func (s *ShowTriggers) Database() sql.Database + func (s *ShowTriggers) Resolved() bool + func (s *ShowTriggers) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *ShowTriggers) Schema() sql.Schema + func (s *ShowTriggers) String() string + func (s *ShowTriggers) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *ShowTriggers) WithDatabase(db sql.Database) (sql.Node, error) + type ShowVariables struct + func NewShowVariables(like string) *ShowVariables + func (*ShowVariables) Children() []sql.Node + func (*ShowVariables) Schema() sql.Schema + func (sv *ShowVariables) Resolved() bool + func (sv *ShowVariables) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (sv *ShowVariables) String() string + func (sv *ShowVariables) WithChildren(children ...sql.Node) (sql.Node, error) + type ShowWarnings []*sql.Warning + func (ShowWarnings) Children() []sql.Node + func (ShowWarnings) Resolved() bool + func (ShowWarnings) Schema() sql.Schema + func (ShowWarnings) String() string + func (sw ShowWarnings) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (sw ShowWarnings) WithChildren(children ...sql.Node) (sql.Node, error) + type Signal struct + Info map[SignalConditionItemName]SignalInfo + SqlStateValue string + func NewSignal(sqlstate string, info map[SignalConditionItemName]SignalInfo) *Signal + func (s *Signal) Children() []sql.Node + func (s *Signal) Resolved() bool + func (s *Signal) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *Signal) Schema() sql.Schema + func (s *Signal) String() string + func (s *Signal) WithChildren(children ...sql.Node) (sql.Node, error) + type SignalConditionItemName string + const SignalConditionItemName_CatalogName + const SignalConditionItemName_ClassOrigin + const SignalConditionItemName_ColumnName + const SignalConditionItemName_ConstraintCatalog + const SignalConditionItemName_ConstraintName + const SignalConditionItemName_ConstraintSchema + const SignalConditionItemName_CursorName + const SignalConditionItemName_MessageText + const SignalConditionItemName_MysqlErrno + const SignalConditionItemName_SchemaName + const SignalConditionItemName_SubclassOrigin + const SignalConditionItemName_TableName + type SignalInfo struct + ConditionItemName SignalConditionItemName + IntValue int64 + StrValue string + func (s SignalInfo) String() string + type SignalName struct + Name string + Signal *Signal + func NewSignalName(name string, info map[SignalConditionItemName]SignalInfo) *SignalName + func (s *SignalName) Children() []sql.Node + func (s *SignalName) Resolved() bool + func (s *SignalName) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *SignalName) Schema() sql.Schema + func (s *SignalName) String() string + func (s *SignalName) WithChildren(children ...sql.Node) (sql.Node, error) + type SingleDropView struct + func NewSingleDropView(database sql.Database, viewName string) *SingleDropView + func (dv *SingleDropView) Children() []sql.Node + func (dv *SingleDropView) Database() sql.Database + func (dv *SingleDropView) Resolved() bool + func (dv *SingleDropView) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (dv *SingleDropView) Schema() sql.Schema + func (dv *SingleDropView) String() string + func (dv *SingleDropView) WithChildren(children ...sql.Node) (sql.Node, error) + func (dv *SingleDropView) WithDatabase(database sql.Database) (sql.Node, error) + type Sort struct + SortFields []sql.SortField + func NewSort(sortFields []sql.SortField, child sql.Node) *Sort + func (s *Sort) DebugString() string + func (s *Sort) Expressions() []sql.Expression + func (s *Sort) Resolved() bool + func (s *Sort) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *Sort) String() string + func (s *Sort) WithChildren(children ...sql.Node) (sql.Node, error) + func (s *Sort) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type StartTransaction struct + func NewStartTransaction(db sql.UnresolvedDatabase, transactionChar sql.TransactionCharacteristic) *StartTransaction + func (s *StartTransaction) Children() []sql.Node + func (s *StartTransaction) Database() sql.Database + func (s *StartTransaction) DebugString() string + func (s *StartTransaction) Resolved() bool + func (s *StartTransaction) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (s *StartTransaction) Schema() sql.Schema + func (s *StartTransaction) String() string + func (s StartTransaction) WithChildren(children ...sql.Node) (sql.Node, error) + func (s StartTransaction) WithDatabase(database sql.Database) (sql.Node, error) + type StripRowNode struct + func (srn *StripRowNode) DebugString() string + func (srn *StripRowNode) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (srn *StripRowNode) String() string + func (srn *StripRowNode) WithChildren(children ...sql.Node) (sql.Node, error) + type Subquery struct + Query sql.Node + QueryString string + func NewSubquery(node sql.Node, queryString string) *Subquery + func (s *Subquery) Children() []sql.Expression + func (s *Subquery) DebugString() string + func (s *Subquery) Dispose() + func (s *Subquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) + func (s *Subquery) EvalMultiple(ctx *sql.Context, row sql.Row) ([]interface{}, error) + func (s *Subquery) HasResultRow(ctx *sql.Context, row sql.Row) (bool, error) + func (s *Subquery) HashMultiple(ctx *sql.Context, row sql.Row) (sql.KeyValueCache, error) + func (s *Subquery) IsNonDeterministic() bool + func (s *Subquery) IsNullable() bool + func (s *Subquery) Resolved() bool + func (s *Subquery) String() string + func (s *Subquery) Type() sql.Type + func (s *Subquery) WithCachedResults() *Subquery + func (s *Subquery) WithChildren(children ...sql.Expression) (sql.Expression, error) + func (s *Subquery) WithQuery(node sql.Node) *Subquery + type SubqueryAlias struct + Columns []string + TextDefinition string + func NewSubqueryAlias(name, textDefinition string, node sql.Node) *SubqueryAlias + func (sq *SubqueryAlias) AsView() *sql.View + func (sq *SubqueryAlias) Name() string + func (sq *SubqueryAlias) Opaque() bool + func (sq *SubqueryAlias) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (sq *SubqueryAlias) Schema() sql.Schema + func (sq *SubqueryAlias) WithChildren(children ...sql.Node) (sql.Node, error) + func (sq SubqueryAlias) DebugString() string + func (sq SubqueryAlias) String() string + func (sq SubqueryAlias) WithColumns(columns []string) *SubqueryAlias + func (sq SubqueryAlias) WithName(name string) *SubqueryAlias + type TLSOptions struct + Cipher string + Issuer string + SSL bool + Subject string + X509 bool + type TableAlias struct + func NewTableAlias(name string, node sql.Node) *TableAlias + func (t *TableAlias) Name() string + func (t *TableAlias) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *TableAlias) Schema() sql.Schema + func (t *TableAlias) WithChildren(children ...sql.Node) (sql.Node, error) + func (t TableAlias) DebugString() string + func (t TableAlias) String() string + func (t TableAlias) WithName(name string) *TableAlias + type TableCopier struct + func NewTableCopier(db sql.Database, createTableNode sql.Node, source sql.Node, prop CopierProps) *TableCopier + func (tc *TableCopier) Children() []sql.Node + func (tc *TableCopier) Database() sql.Database + func (tc *TableCopier) Resolved() bool + func (tc *TableCopier) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (tc *TableCopier) Schema() sql.Schema + func (tc *TableCopier) String() string + func (tc *TableCopier) WithChildren(...sql.Node) (sql.Node, error) + func (tc *TableCopier) WithDatabase(db sql.Database) (sql.Node, error) + type TableLock struct + Table sql.Node + Write bool + type TableSpec struct + ChDefs []*sql.CheckConstraint + FkDefs []*sql.ForeignKeyConstraint + IdxDefs []*IndexDefinition + Schema sql.PrimaryKeySchema + func (c *TableSpec) WithCheckConstraints(chDefs []*sql.CheckConstraint) *TableSpec + func (c *TableSpec) WithForeignKeys(fkDefs []*sql.ForeignKeyConstraint) *TableSpec + func (c *TableSpec) WithIndices(idxDefs []*IndexDefinition) *TableSpec + func (c *TableSpec) WithSchema(schema sql.PrimaryKeySchema) *TableSpec + type TempTableOption bool + const IsTempTable + const IsTempTableAbsent + type TopN struct + CalcFoundRows bool + Fields sql.SortFields + Limit sql.Expression + func NewTopN(fields sql.SortFields, limit sql.Expression, child sql.Node) *TopN + func (n *TopN) DebugString() string + func (n *TopN) Expressions() []sql.Expression + func (n *TopN) Resolved() bool + func (n *TopN) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *TopN) String() string + func (n *TopN) WithChildren(children ...sql.Node) (sql.Node, error) + func (n *TopN) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (n TopN) WithCalcFoundRows(v bool) *TopN + type TransformContext struct + ChildNum int + Node sql.Node + Parent sql.Node + SchemaPrefix sql.Schema + type TransformSelector func(TransformContext) bool + type TransformedNamedNode struct + func NewTransformedNamedNode(child sql.Node, name string) *TransformedNamedNode + func (n *TransformedNamedNode) DebugString() string + func (n *TransformedNamedNode) Name() string + func (n *TransformedNamedNode) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (n *TransformedNamedNode) Schema() sql.Schema + func (n *TransformedNamedNode) String() string + func (n *TransformedNamedNode) WithChildren(children ...sql.Node) (sql.Node, error) + type Transformer func(TransformContext) (sql.Node, error) + type TriggerBeginEndBlock struct + func NewTriggerBeginEndBlock(block *BeginEndBlock) *TriggerBeginEndBlock + func (b *TriggerBeginEndBlock) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (b *TriggerBeginEndBlock) WithChildren(children ...sql.Node) (sql.Node, error) + type TriggerEvent string + type TriggerExecutor struct + TriggerDefinition sql.TriggerDefinition + TriggerEvent TriggerEvent + TriggerTime TriggerTime + func NewTriggerExecutor(child, triggerLogic sql.Node, triggerEvent TriggerEvent, ...) *TriggerExecutor + func (t *TriggerExecutor) DebugString() string + func (t *TriggerExecutor) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *TriggerExecutor) Schema() sql.Schema + func (t *TriggerExecutor) String() string + func (t *TriggerExecutor) WithChildren(children ...sql.Node) (sql.Node, error) + type TriggerOrder struct + OtherTriggerName string + PrecedesOrFollows string + type TriggerTime string + const AfterTrigger + const BeforeTrigger + type Truncate struct + func NewTruncate(db string, table sql.Node) *Truncate + func (p *Truncate) DatabaseName() string + func (p *Truncate) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) + func (p *Truncate) Schema() sql.Schema + func (p *Truncate) WithChildren(children ...sql.Node) (sql.Node, error) + func (p Truncate) DebugString() string + func (p Truncate) String() string + type UnaryNode struct + Child sql.Node + func (n *UnaryNode) Schema() sql.Schema + func (n UnaryNode) Children() []sql.Node + func (n UnaryNode) Resolved() bool + type Union struct + func NewUnion(left, right sql.Node) *Union + func (u *Union) Opaque() bool + func (u *Union) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (u *Union) Schema() sql.Schema + func (u *Union) WithChildren(children ...sql.Node) (sql.Node, error) + func (u Union) DebugString() string + func (u Union) String() string + type UnlockTables struct + Catalog sql.Catalog + func NewUnlockTables() *UnlockTables + func (t *UnlockTables) Children() []sql.Node + func (t *UnlockTables) Resolved() bool + func (t *UnlockTables) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (t *UnlockTables) Schema() sql.Schema + func (t *UnlockTables) String() string + func (t *UnlockTables) WithChildren(children ...sql.Node) (sql.Node, error) + type UnresolvedTable struct + AsOf sql.Expression + Database string + func NewUnresolvedTable(name, db string) *UnresolvedTable + func NewUnresolvedTableAsOf(name, db string, asOf sql.Expression) *UnresolvedTable + func (*UnresolvedTable) Children() []sql.Node + func (*UnresolvedTable) Resolved() bool + func (*UnresolvedTable) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (*UnresolvedTable) Schema() sql.Schema + func (t *UnresolvedTable) Expressions() []sql.Expression + func (t *UnresolvedTable) Name() string + func (t *UnresolvedTable) WithAsOf(asOf sql.Expression) (*UnresolvedTable, error) + func (t *UnresolvedTable) WithChildren(children ...sql.Node) (sql.Node, error) + func (t *UnresolvedTable) WithDatabase(database string) (*UnresolvedTable, error) + func (t *UnresolvedTable) WithExpressions(expressions ...sql.Expression) (sql.Node, error) + func (t UnresolvedTable) String() string + type Update struct + Checks sql.CheckConstraints + func NewUpdate(n sql.Node, updateExprs []sql.Expression) *Update + func (u *Update) Database() string + func (u *Update) DebugString() string + func (u *Update) Expressions() []sql.Expression + func (u *Update) Resolved() bool + func (u *Update) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (u *Update) String() string + func (u *Update) WithChildren(children ...sql.Node) (sql.Node, error) + func (u Update) WithExpressions(newExprs ...sql.Expression) (sql.Node, error) + type UpdateInfo struct + Matched int + Updated int + Warnings int + func (ui UpdateInfo) String() string + type UpdateJoin struct + func NewUpdateJoin(editorMap map[string]sql.RowUpdater, child sql.Node) *UpdateJoin + func (u *UpdateJoin) GetUpdatable() sql.UpdatableTable + func (u *UpdateJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (u *UpdateJoin) String() string + func (u *UpdateJoin) WithChildren(children ...sql.Node) (sql.Node, error) + type UpdateSource struct + UpdateExprs []sql.Expression + func NewUpdateSource(node sql.Node, updateExprs []sql.Expression) *UpdateSource + func (u *UpdateSource) DebugString() string + func (u *UpdateSource) Expressions() []sql.Expression + func (u *UpdateSource) Resolved() bool + func (u *UpdateSource) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (u *UpdateSource) Schema() sql.Schema + func (u *UpdateSource) String() string + func (u *UpdateSource) WithChildren(children ...sql.Node) (sql.Node, error) + func (u *UpdateSource) WithExpressions(newExprs ...sql.Expression) (sql.Node, error) + type Use struct + Catalog sql.Catalog + func NewUse(db sql.Database) *Use + func (Use) Children() []sql.Node + func (Use) Schema() sql.Schema + func (u *Use) Database() sql.Database + func (u *Use) Resolved() bool + func (u *Use) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (u *Use) String() string + func (u *Use) WithChildren(children ...sql.Node) (sql.Node, error) + func (u *Use) WithDatabase(db sql.Database) (sql.Node, error) + type UserName struct + AnyHost bool + Host string + Name string + func (un *UserName) String() string + func (un *UserName) StringWithQuote(quote string, replacement string) string + type ValueDerivedTable struct + func NewValueDerivedTable(values *Values, name string) *ValueDerivedTable + func (v *ValueDerivedTable) DebugString() string + func (v *ValueDerivedTable) Name() string + func (v *ValueDerivedTable) Schema() sql.Schema + func (v *ValueDerivedTable) String() string + func (v *ValueDerivedTable) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + func (v ValueDerivedTable) WithColumns(columns []string) *ValueDerivedTable + type Values struct + ExpressionTuples [][]sql.Expression + func NewValues(tuples [][]sql.Expression) *Values + func (p *Values) Children() []sql.Node + func (p *Values) DebugString() string + func (p *Values) Expressions() []sql.Expression + func (p *Values) Resolved() bool + func (p *Values) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (p *Values) Schema() sql.Schema + func (p *Values) String() string + func (p *Values) WithChildren(children ...sql.Node) (sql.Node, error) + func (p *Values) WithExpressions(exprs ...sql.Expression) (sql.Node, error) + type Visitor interface + Visit func(node sql.Node) Visitor + type Window struct + SelectExprs []sql.Expression + func NewWindow(selectExprs []sql.Expression, node sql.Node) *Window + func (w *Window) DebugString() string + func (w *Window) Expressions() []sql.Expression + func (w *Window) Resolved() bool + func (w *Window) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (w *Window) Schema() sql.Schema + func (w *Window) String() string + func (w *Window) WithChildren(children ...sql.Node) (sql.Node, error) + func (w *Window) WithExpressions(e ...sql.Expression) (sql.Node, error) + type With struct + CTEs []*CommonTableExpression + func NewWith(child sql.Node, ctes []*CommonTableExpression) *With + func (w *With) DebugString() string + func (w *With) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) + func (w *With) String() string + func (w *With) WithChildren(children ...sql.Node) (sql.Node, error)