github.com/team-ide/go-dialect@v1.9.20/vitess/sqlparser/ast_rewrite.go

/*
Copyright 2021 The Vitess Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by ASTHelperGen. DO NOT EDIT.

package sqlparser

func (a *application) rewriteSQLNode(parent SQLNode, node SQLNode, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case AccessMode:
		return a.rewriteAccessMode(parent, node, replacer)
	case *AddColumns:
		return a.rewriteRefOfAddColumns(parent, node, replacer)
	case *AddConstraintDefinition:
		return a.rewriteRefOfAddConstraintDefinition(parent, node, replacer)
	case *AddIndexDefinition:
		return a.rewriteRefOfAddIndexDefinition(parent, node, replacer)
	case AlgorithmValue:
		return a.rewriteAlgorithmValue(parent, node, replacer)
	case *AliasedExpr:
		return a.rewriteRefOfAliasedExpr(parent, node, replacer)
	case *AliasedTableExpr:
		return a.rewriteRefOfAliasedTableExpr(parent, node, replacer)
	case *AlterCharset:
		return a.rewriteRefOfAlterCharset(parent, node, replacer)
	case *AlterColumn:
		return a.rewriteRefOfAlterColumn(parent, node, replacer)
	case *AlterDatabase:
		return a.rewriteRefOfAlterDatabase(parent, node, replacer)
	case *AlterMigration:
		return a.rewriteRefOfAlterMigration(parent, node, replacer)
	case *AlterTable:
		return a.rewriteRefOfAlterTable(parent, node, replacer)
	case *AlterView:
		return a.rewriteRefOfAlterView(parent, node, replacer)
	case *AlterVschema:
		return a.rewriteRefOfAlterVschema(parent, node, replacer)
	case *AndExpr:
		return a.rewriteRefOfAndExpr(parent, node, replacer)
	case Argument:
		return a.rewriteArgument(parent, node, replacer)
	case *AutoIncSpec:
		return a.rewriteRefOfAutoIncSpec(parent, node, replacer)
	case *Begin:
		return a.rewriteRefOfBegin(parent, node, replacer)
	case *BetweenExpr:
		return a.rewriteRefOfBetweenExpr(parent, node, replacer)
	case *BinaryExpr:
		return a.rewriteRefOfBinaryExpr(parent, node, replacer)
	case BoolVal:
		return a.rewriteBoolVal(parent, node, replacer)
	case *CallProc:
		return a.rewriteRefOfCallProc(parent, node, replacer)
	case *CaseExpr:
		return a.rewriteRefOfCaseExpr(parent, node, replacer)
	case *ChangeColumn:
		return a.rewriteRefOfChangeColumn(parent, node, replacer)
	case *CheckConstraintDefinition:
		return a.rewriteRefOfCheckConstraintDefinition(parent, node, replacer)
	case ColIdent:
		return a.rewriteColIdent(parent, node, replacer)
	case *ColName:
		return a.rewriteRefOfColName(parent, node, replacer)
	case *CollateExpr:
		return a.rewriteRefOfCollateExpr(parent, node, replacer)
	case *ColumnDefinition:
		return a.rewriteRefOfColumnDefinition(parent, node, replacer)
	case *ColumnType:
		return a.rewriteRefOfColumnType(parent, node, replacer)
	case Columns:
		return a.rewriteColumns(parent, node, replacer)
	case Comments:
		return a.rewriteComments(parent, node, replacer)
	case *Commit:
		return a.rewriteRefOfCommit(parent, node, replacer)
	case *CommonTableExpr:
		return a.rewriteRefOfCommonTableExpr(parent, node, replacer)
	case *ComparisonExpr:
		return a.rewriteRefOfComparisonExpr(parent, node, replacer)
	case *ConstraintDefinition:
		return a.rewriteRefOfConstraintDefinition(parent, node, replacer)
	case *ConvertExpr:
		return a.rewriteRefOfConvertExpr(parent, node, replacer)
	case *ConvertType:
		return a.rewriteRefOfConvertType(parent, node, replacer)
	case *ConvertUsingExpr:
		return a.rewriteRefOfConvertUsingExpr(parent, node, replacer)
	case *CreateDatabase:
		return a.rewriteRefOfCreateDatabase(parent, node, replacer)
	case *CreateTable:
		return a.rewriteRefOfCreateTable(parent, node, replacer)
	case *CreateView:
		return a.rewriteRefOfCreateView(parent, node, replacer)
	case *CurTimeFuncExpr:
		return a.rewriteRefOfCurTimeFuncExpr(parent, node, replacer)
	case *Default:
		return a.rewriteRefOfDefault(parent, node, replacer)
	case *Delete:
		return a.rewriteRefOfDelete(parent, node, replacer)
	case *DerivedTable:
		return a.rewriteRefOfDerivedTable(parent, node, replacer)
	case *DropColumn:
		return a.rewriteRefOfDropColumn(parent, node, replacer)
	case *DropDatabase:
		return a.rewriteRefOfDropDatabase(parent, node, replacer)
	case *DropKey:
		return a.rewriteRefOfDropKey(parent, node, replacer)
	case *DropTable:
		return a.rewriteRefOfDropTable(parent, node, replacer)
	case *DropView:
		return a.rewriteRefOfDropView(parent, node, replacer)
	case *ExistsExpr:
		return a.rewriteRefOfExistsExpr(parent, node, replacer)
	case *ExplainStmt:
		return a.rewriteRefOfExplainStmt(parent, node, replacer)
	case *ExplainTab:
		return a.rewriteRefOfExplainTab(parent, node, replacer)
	case *ExprOrColumns:
		return a.rewriteRefOfExprOrColumns(parent, node, replacer)
	case Exprs:
		return a.rewriteExprs(parent, node, replacer)
	case *ExtractFuncExpr:
		return a.rewriteRefOfExtractFuncExpr(parent, node, replacer)
	case *ExtractedSubquery:
		return a.rewriteRefOfExtractedSubquery(parent, node, replacer)
	case *Flush:
		return a.rewriteRefOfFlush(parent, node, replacer)
	case *Force:
		return a.rewriteRefOfForce(parent, node, replacer)
	case *ForeignKeyDefinition:
		return a.rewriteRefOfForeignKeyDefinition(parent, node, replacer)
	case *FuncExpr:
		return a.rewriteRefOfFuncExpr(parent, node, replacer)
	case GroupBy:
		return a.rewriteGroupBy(parent, node, replacer)
	case *GroupConcatExpr:
		return a.rewriteRefOfGroupConcatExpr(parent, node, replacer)
	case *IndexDefinition:
		return a.rewriteRefOfIndexDefinition(parent, node, replacer)
	case *IndexHints:
		return a.rewriteRefOfIndexHints(parent, node, replacer)
	case *IndexInfo:
		return a.rewriteRefOfIndexInfo(parent, node, replacer)
	case *Insert:
		return a.rewriteRefOfInsert(parent, node, replacer)
	case *IntervalExpr:
		return a.rewriteRefOfIntervalExpr(parent, node, replacer)
	case *IntroducerExpr:
		return a.rewriteRefOfIntroducerExpr(parent, node, replacer)
	case *IsExpr:
		return a.rewriteRefOfIsExpr(parent, node, replacer)
	case IsolationLevel:
		return a.rewriteIsolationLevel(parent, node, replacer)
	case *JoinCondition:
		return a.rewriteRefOfJoinCondition(parent, node, replacer)
	case *JoinTableExpr:
		return a.rewriteRefOfJoinTableExpr(parent, node, replacer)
	case *KeyState:
		return a.rewriteRefOfKeyState(parent, node, replacer)
	case *Limit:
		return a.rewriteRefOfLimit(parent, node, replacer)
	case ListArg:
		return a.rewriteListArg(parent, node, replacer)
	case *Literal:
		return a.rewriteRefOfLiteral(parent, node, replacer)
	case *Load:
		return a.rewriteRefOfLoad(parent, node, replacer)
	case *LockOption:
		return a.rewriteRefOfLockOption(parent, node, replacer)
	case *LockTables:
		return a.rewriteRefOfLockTables(parent, node, replacer)
	case *MatchExpr:
		return a.rewriteRefOfMatchExpr(parent, node, replacer)
	case *ModifyColumn:
		return a.rewriteRefOfModifyColumn(parent, node, replacer)
	case *Nextval:
		return a.rewriteRefOfNextval(parent, node, replacer)
	case *NotExpr:
		return a.rewriteRefOfNotExpr(parent, node, replacer)
	case *NullVal:
		return a.rewriteRefOfNullVal(parent, node, replacer)
	case OnDup:
		return a.rewriteOnDup(parent, node, replacer)
	case *OptLike:
		return a.rewriteRefOfOptLike(parent, node, replacer)
	case *OrExpr:
		return a.rewriteRefOfOrExpr(parent, node, replacer)
	case *Order:
		return a.rewriteRefOfOrder(parent, node, replacer)
	case OrderBy:
		return a.rewriteOrderBy(parent, node, replacer)
	case *OrderByOption:
		return a.rewriteRefOfOrderByOption(parent, node, replacer)
	case *OtherAdmin:
		return a.rewriteRefOfOtherAdmin(parent, node, replacer)
	case *OtherRead:
		return a.rewriteRefOfOtherRead(parent, node, replacer)
	case *ParenTableExpr:
		return a.rewriteRefOfParenTableExpr(parent, node, replacer)
	case *PartitionDefinition:
		return a.rewriteRefOfPartitionDefinition(parent, node, replacer)
	case *PartitionOption:
		return a.rewriteRefOfPartitionOption(parent, node, replacer)
	case *PartitionSpec:
		return a.rewriteRefOfPartitionSpec(parent, node, replacer)
	case Partitions:
		return a.rewritePartitions(parent, node, replacer)
	case ReferenceAction:
		return a.rewriteReferenceAction(parent, node, replacer)
	case *ReferenceDefinition:
		return a.rewriteRefOfReferenceDefinition(parent, node, replacer)
	case *Release:
		return a.rewriteRefOfRelease(parent, node, replacer)
	case *RenameIndex:
		return a.rewriteRefOfRenameIndex(parent, node, replacer)
	case *RenameTable:
		return a.rewriteRefOfRenameTable(parent, node, replacer)
	case *RenameTableName:
		return a.rewriteRefOfRenameTableName(parent, node, replacer)
	case *RevertMigration:
		return a.rewriteRefOfRevertMigration(parent, node, replacer)
	case *Rollback:
		return a.rewriteRefOfRollback(parent, node, replacer)
	case RootNode:
		return a.rewriteRootNode(parent, node, replacer)
	case *SRollback:
		return a.rewriteRefOfSRollback(parent, node, replacer)
	case *Savepoint:
		return a.rewriteRefOfSavepoint(parent, node, replacer)
	case *Select:
		return a.rewriteRefOfSelect(parent, node, replacer)
	case SelectExprs:
		return a.rewriteSelectExprs(parent, node, replacer)
	case *SelectInto:
		return a.rewriteRefOfSelectInto(parent, node, replacer)
	case *Set:
		return a.rewriteRefOfSet(parent, node, replacer)
	case *SetExpr:
		return a.rewriteRefOfSetExpr(parent, node, replacer)
	case SetExprs:
		return a.rewriteSetExprs(parent, node, replacer)
	case *SetTransaction:
		return a.rewriteRefOfSetTransaction(parent, node, replacer)
	case *Show:
		return a.rewriteRefOfShow(parent, node, replacer)
	case *ShowBasic:
		return a.rewriteRefOfShowBasic(parent, node, replacer)
	case *ShowCreate:
		return a.rewriteRefOfShowCreate(parent, node, replacer)
	case *ShowFilter:
		return a.rewriteRefOfShowFilter(parent, node, replacer)
	case *ShowLegacy:
		return a.rewriteRefOfShowLegacy(parent, node, replacer)
	case *ShowMigrationLogs:
		return a.rewriteRefOfShowMigrationLogs(parent, node, replacer)
	case *StarExpr:
		return a.rewriteRefOfStarExpr(parent, node, replacer)
	case *Stream:
		return a.rewriteRefOfStream(parent, node, replacer)
	case *SubPartition:
		return a.rewriteRefOfSubPartition(parent, node, replacer)
	case *Subquery:
		return a.rewriteRefOfSubquery(parent, node, replacer)
	case *SubstrExpr:
		return a.rewriteRefOfSubstrExpr(parent, node, replacer)
	case TableExprs:
		return a.rewriteTableExprs(parent, node, replacer)
	case TableIdent:
		return a.rewriteTableIdent(parent, node, replacer)
	case TableName:
		return a.rewriteTableName(parent, node, replacer)
	case TableNames:
		return a.rewriteTableNames(parent, node, replacer)
	case TableOptions:
		return a.rewriteTableOptions(parent, node, replacer)
	case *TableSpec:
		return a.rewriteRefOfTableSpec(parent, node, replacer)
	case *TablespaceOperation:
		return a.rewriteRefOfTablespaceOperation(parent, node, replacer)
	case *TimestampFuncExpr:
		return a.rewriteRefOfTimestampFuncExpr(parent, node, replacer)
	case *TruncateTable:
		return a.rewriteRefOfTruncateTable(parent, node, replacer)
	case *UnaryExpr:
		return a.rewriteRefOfUnaryExpr(parent, node, replacer)
	case *Union:
		return a.rewriteRefOfUnion(parent, node, replacer)
	case *UnlockTables:
		return a.rewriteRefOfUnlockTables(parent, node, replacer)
	case *Update:
		return a.rewriteRefOfUpdate(parent, node, replacer)
	case *UpdateExpr:
		return a.rewriteRefOfUpdateExpr(parent, node, replacer)
	case UpdateExprs:
		return a.rewriteUpdateExprs(parent, node, replacer)
	case *Use:
		return a.rewriteRefOfUse(parent, node, replacer)
	case *VStream:
		return a.rewriteRefOfVStream(parent, node, replacer)
	case ValTuple:
		return a.rewriteValTuple(parent, node, replacer)
	case *Validation:
		return a.rewriteRefOfValidation(parent, node, replacer)
	case Values:
		return a.rewriteValues(parent, node, replacer)
	case *ValuesFuncExpr:
		return a.rewriteRefOfValuesFuncExpr(parent, node, replacer)
	case VindexParam:
		return a.rewriteVindexParam(parent, node, replacer)
	case *VindexSpec:
		return a.rewriteRefOfVindexSpec(parent, node, replacer)
	case *When:
		return a.rewriteRefOfWhen(parent, node, replacer)
	case *Where:
		return a.rewriteRefOfWhere(parent, node, replacer)
	case *With:
		return a.rewriteRefOfWith(parent, node, replacer)
	case *XorExpr:
		return a.rewriteRefOfXorExpr(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteRefOfAddColumns(parent SQLNode, node *AddColumns, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	for x, el := range node.Columns {
		if !a.rewriteRefOfColumnDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*AddColumns).Columns[idx] = newNode.(*ColumnDefinition)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteRefOfColName(node, node.After, func(newNode, parent SQLNode) {
		parent.(*AddColumns).After = newNode.(*ColName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAddConstraintDefinition(parent SQLNode, node *AddConstraintDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfConstraintDefinition(node, node.ConstraintDefinition, func(newNode, parent SQLNode) {
		parent.(*AddConstraintDefinition).ConstraintDefinition = newNode.(*ConstraintDefinition)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAddIndexDefinition(parent SQLNode, node *AddIndexDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfIndexDefinition(node, node.IndexDefinition, func(newNode, parent SQLNode) {
		parent.(*AddIndexDefinition).IndexDefinition = newNode.(*IndexDefinition)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAliasedExpr(parent SQLNode, node *AliasedExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*AliasedExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.As, func(newNode, parent SQLNode) {
		parent.(*AliasedExpr).As = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAliasedTableExpr(parent SQLNode, node *AliasedTableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSimpleTableExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*AliasedTableExpr).Expr = newNode.(SimpleTableExpr)
	}) {
		return false
	}
	if !a.rewritePartitions(node, node.Partitions, func(newNode, parent SQLNode) {
		parent.(*AliasedTableExpr).Partitions = newNode.(Partitions)
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.As, func(newNode, parent SQLNode) {
		parent.(*AliasedTableExpr).As = newNode.(TableIdent)
	}) {
		return false
	}
	if !a.rewriteRefOfIndexHints(node, node.Hints, func(newNode, parent SQLNode) {
		parent.(*AliasedTableExpr).Hints = newNode.(*IndexHints)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*AliasedTableExpr).Columns = newNode.(Columns)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterCharset(parent SQLNode, node *AlterCharset, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterColumn(parent SQLNode, node *AlterColumn, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColName(node, node.Column, func(newNode, parent SQLNode) {
		parent.(*AlterColumn).Column = newNode.(*ColName)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.DefaultVal, func(newNode, parent SQLNode) {
		parent.(*AlterColumn).DefaultVal = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterDatabase(parent SQLNode, node *AlterDatabase, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.DBName, func(newNode, parent SQLNode) {
		parent.(*AlterDatabase).DBName = newNode.(TableIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterMigration(parent SQLNode, node *AlterMigration, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterTable(parent SQLNode, node *AlterTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*AlterTable).Table = newNode.(TableName)
	}) {
		return false
	}
	for x, el := range node.AlterOptions {
		if !a.rewriteAlterOption(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*AlterTable).AlterOptions[idx] = newNode.(AlterOption)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteRefOfPartitionSpec(node, node.PartitionSpec, func(newNode, parent SQLNode) {
		parent.(*AlterTable).PartitionSpec = newNode.(*PartitionSpec)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*AlterTable).Comments = newNode.(Comments)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterView(parent SQLNode, node *AlterView, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.ViewName, func(newNode, parent SQLNode) {
		parent.(*AlterView).ViewName = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*AlterView).Columns = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteSelectStatement(node, node.Select, func(newNode, parent SQLNode) {
		parent.(*AlterView).Select = newNode.(SelectStatement)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAlterVschema(parent SQLNode, node *AlterVschema, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*AlterVschema).Table = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteRefOfVindexSpec(node, node.VindexSpec, func(newNode, parent SQLNode) {
		parent.(*AlterVschema).VindexSpec = newNode.(*VindexSpec)
	}) {
		return false
	}
	for x, el := range node.VindexCols {
		if !a.rewriteColIdent(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*AlterVschema).VindexCols[idx] = newNode.(ColIdent)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteRefOfAutoIncSpec(node, node.AutoIncSpec, func(newNode, parent SQLNode) {
		parent.(*AlterVschema).AutoIncSpec = newNode.(*AutoIncSpec)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAndExpr(parent SQLNode, node *AndExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*AndExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*AndExpr).Right = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfAutoIncSpec(parent SQLNode, node *AutoIncSpec, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Column, func(newNode, parent SQLNode) {
		parent.(*AutoIncSpec).Column = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Sequence, func(newNode, parent SQLNode) {
		parent.(*AutoIncSpec).Sequence = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfBegin(parent SQLNode, node *Begin, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfBetweenExpr(parent SQLNode, node *BetweenExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*BetweenExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.From, func(newNode, parent SQLNode) {
		parent.(*BetweenExpr).From = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.To, func(newNode, parent SQLNode) {
		parent.(*BetweenExpr).To = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfBinaryExpr(parent SQLNode, node *BinaryExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*BinaryExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*BinaryExpr).Right = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCallProc(parent SQLNode, node *CallProc, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*CallProc).Name = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteExprs(node, node.Params, func(newNode, parent SQLNode) {
		parent.(*CallProc).Params = newNode.(Exprs)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCaseExpr(parent SQLNode, node *CaseExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*CaseExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	for x, el := range node.Whens {
		if !a.rewriteRefOfWhen(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*CaseExpr).Whens[idx] = newNode.(*When)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteExpr(node, node.Else, func(newNode, parent SQLNode) {
		parent.(*CaseExpr).Else = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfChangeColumn(parent SQLNode, node *ChangeColumn, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColName(node, node.OldColumn, func(newNode, parent SQLNode) {
		parent.(*ChangeColumn).OldColumn = newNode.(*ColName)
	}) {
		return false
	}
	if !a.rewriteRefOfColumnDefinition(node, node.NewColDefinition, func(newNode, parent SQLNode) {
		parent.(*ChangeColumn).NewColDefinition = newNode.(*ColumnDefinition)
	}) {
		return false
	}
	if !a.rewriteRefOfColName(node, node.After, func(newNode, parent SQLNode) {
		parent.(*ChangeColumn).After = newNode.(*ColName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCheckConstraintDefinition(parent SQLNode, node *CheckConstraintDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*CheckConstraintDefinition).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteColIdent(parent SQLNode, node ColIdent, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfColName(parent SQLNode, node *ColName, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*ColName).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Qualifier, func(newNode, parent SQLNode) {
		parent.(*ColName).Qualifier = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCollateExpr(parent SQLNode, node *CollateExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*CollateExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfColumnDefinition(parent SQLNode, node *ColumnDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*ColumnDefinition).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfColumnType(parent SQLNode, node *ColumnType, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfLiteral(node, node.Length, func(newNode, parent SQLNode) {
		parent.(*ColumnType).Length = newNode.(*Literal)
	}) {
		return false
	}
	if !a.rewriteRefOfLiteral(node, node.Scale, func(newNode, parent SQLNode) {
		parent.(*ColumnType).Scale = newNode.(*Literal)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteColumns(parent SQLNode, node Columns, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(Columns)
			a.cur.revisit = false
			return a.rewriteColumns(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteColIdent(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(Columns)[idx] = newNode.(ColIdent)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteComments(parent SQLNode, node Comments, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(Comments)
			a.cur.revisit = false
			return a.rewriteComments(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCommit(parent SQLNode, node *Commit, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCommonTableExpr(parent SQLNode, node *CommonTableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.TableID, func(newNode, parent SQLNode) {
		parent.(*CommonTableExpr).TableID = newNode.(TableIdent)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*CommonTableExpr).Columns = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteRefOfSubquery(node, node.Subquery, func(newNode, parent SQLNode) {
		parent.(*CommonTableExpr).Subquery = newNode.(*Subquery)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfComparisonExpr(parent SQLNode, node *ComparisonExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*ComparisonExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*ComparisonExpr).Right = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Escape, func(newNode, parent SQLNode) {
		parent.(*ComparisonExpr).Escape = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfConstraintDefinition(parent SQLNode, node *ConstraintDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*ConstraintDefinition).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteConstraintInfo(node, node.Details, func(newNode, parent SQLNode) {
		parent.(*ConstraintDefinition).Details = newNode.(ConstraintInfo)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfConvertExpr(parent SQLNode, node *ConvertExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*ConvertExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteRefOfConvertType(node, node.Type, func(newNode, parent SQLNode) {
		parent.(*ConvertExpr).Type = newNode.(*ConvertType)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfConvertType(parent SQLNode, node *ConvertType, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfLiteral(node, node.Length, func(newNode, parent SQLNode) {
		parent.(*ConvertType).Length = newNode.(*Literal)
	}) {
		return false
	}
	if !a.rewriteRefOfLiteral(node, node.Scale, func(newNode, parent SQLNode) {
		parent.(*ConvertType).Scale = newNode.(*Literal)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfConvertUsingExpr(parent SQLNode, node *ConvertUsingExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*ConvertUsingExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCreateDatabase(parent SQLNode, node *CreateDatabase, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*CreateDatabase).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.DBName, func(newNode, parent SQLNode) {
		parent.(*CreateDatabase).DBName = newNode.(TableIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCreateTable(parent SQLNode, node *CreateTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*CreateTable).Table = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteRefOfTableSpec(node, node.TableSpec, func(newNode, parent SQLNode) {
		parent.(*CreateTable).TableSpec = newNode.(*TableSpec)
	}) {
		return false
	}
	if !a.rewriteRefOfOptLike(node, node.OptLike, func(newNode, parent SQLNode) {
		parent.(*CreateTable).OptLike = newNode.(*OptLike)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*CreateTable).Comments = newNode.(Comments)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCreateView(parent SQLNode, node *CreateView, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.ViewName, func(newNode, parent SQLNode) {
		parent.(*CreateView).ViewName = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*CreateView).Columns = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteSelectStatement(node, node.Select, func(newNode, parent SQLNode) {
		parent.(*CreateView).Select = newNode.(SelectStatement)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfCurTimeFuncExpr(parent SQLNode, node *CurTimeFuncExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*CurTimeFuncExpr).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Fsp, func(newNode, parent SQLNode) {
		parent.(*CurTimeFuncExpr).Fsp = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDefault(parent SQLNode, node *Default, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDelete(parent SQLNode, node *Delete, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfWith(node, node.With, func(newNode, parent SQLNode) {
		parent.(*Delete).With = newNode.(*With)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Delete).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteTableNames(node, node.Targets, func(newNode, parent SQLNode) {
		parent.(*Delete).Targets = newNode.(TableNames)
	}) {
		return false
	}
	if !a.rewriteTableExprs(node, node.TableExprs, func(newNode, parent SQLNode) {
		parent.(*Delete).TableExprs = newNode.(TableExprs)
	}) {
		return false
	}
	if !a.rewritePartitions(node, node.Partitions, func(newNode, parent SQLNode) {
		parent.(*Delete).Partitions = newNode.(Partitions)
	}) {
		return false
	}
	if !a.rewriteRefOfWhere(node, node.Where, func(newNode, parent SQLNode) {
		parent.(*Delete).Where = newNode.(*Where)
	}) {
		return false
	}
	if !a.rewriteOrderBy(node, node.OrderBy, func(newNode, parent SQLNode) {
		parent.(*Delete).OrderBy = newNode.(OrderBy)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*Delete).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDerivedTable(parent SQLNode, node *DerivedTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSelectStatement(node, node.Select, func(newNode, parent SQLNode) {
		parent.(*DerivedTable).Select = newNode.(SelectStatement)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDropColumn(parent SQLNode, node *DropColumn, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColName(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*DropColumn).Name = newNode.(*ColName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDropDatabase(parent SQLNode, node *DropDatabase, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*DropDatabase).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.DBName, func(newNode, parent SQLNode) {
		parent.(*DropDatabase).DBName = newNode.(TableIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDropKey(parent SQLNode, node *DropKey, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*DropKey).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDropTable(parent SQLNode, node *DropTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableNames(node, node.FromTables, func(newNode, parent SQLNode) {
		parent.(*DropTable).FromTables = newNode.(TableNames)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*DropTable).Comments = newNode.(Comments)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfDropView(parent SQLNode, node *DropView, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableNames(node, node.FromTables, func(newNode, parent SQLNode) {
		parent.(*DropView).FromTables = newNode.(TableNames)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExistsExpr(parent SQLNode, node *ExistsExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfSubquery(node, node.Subquery, func(newNode, parent SQLNode) {
		parent.(*ExistsExpr).Subquery = newNode.(*Subquery)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExplainStmt(parent SQLNode, node *ExplainStmt, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteStatement(node, node.Statement, func(newNode, parent SQLNode) {
		parent.(*ExplainStmt).Statement = newNode.(Statement)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExplainTab(parent SQLNode, node *ExplainTab, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*ExplainTab).Table = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExprOrColumns(parent SQLNode, node *ExprOrColumns, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*ExprOrColumns).Expr = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.ColumnList, func(newNode, parent SQLNode) {
		parent.(*ExprOrColumns).ColumnList = newNode.(Columns)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteExprs(parent SQLNode, node Exprs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(Exprs)
			a.cur.revisit = false
			return a.rewriteExprs(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(Exprs)[idx] = newNode.(Expr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExtractFuncExpr(parent SQLNode, node *ExtractFuncExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*ExtractFuncExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfExtractedSubquery(parent SQLNode, node *ExtractedSubquery, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Original, func(newNode, parent SQLNode) {
		parent.(*ExtractedSubquery).Original = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteRefOfSubquery(node, node.Subquery, func(newNode, parent SQLNode) {
		parent.(*ExtractedSubquery).Subquery = newNode.(*Subquery)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.OtherSide, func(newNode, parent SQLNode) {
		parent.(*ExtractedSubquery).OtherSide = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.alternative, func(newNode, parent SQLNode) {
		parent.(*ExtractedSubquery).alternative = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfFlush(parent SQLNode, node *Flush, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableNames(node, node.TableNames, func(newNode, parent SQLNode) {
		parent.(*Flush).TableNames = newNode.(TableNames)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfForce(parent SQLNode, node *Force, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfForeignKeyDefinition(parent SQLNode, node *ForeignKeyDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColumns(node, node.Source, func(newNode, parent SQLNode) {
		parent.(*ForeignKeyDefinition).Source = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.IndexName, func(newNode, parent SQLNode) {
		parent.(*ForeignKeyDefinition).IndexName = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteRefOfReferenceDefinition(node, node.ReferenceDefinition, func(newNode, parent SQLNode) {
		parent.(*ForeignKeyDefinition).ReferenceDefinition = newNode.(*ReferenceDefinition)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfFuncExpr(parent SQLNode, node *FuncExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.Qualifier, func(newNode, parent SQLNode) {
		parent.(*FuncExpr).Qualifier = newNode.(TableIdent)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*FuncExpr).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteSelectExprs(node, node.Exprs, func(newNode, parent SQLNode) {
		parent.(*FuncExpr).Exprs = newNode.(SelectExprs)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteGroupBy(parent SQLNode, node GroupBy, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(GroupBy)
			a.cur.revisit = false
			return a.rewriteGroupBy(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(GroupBy)[idx] = newNode.(Expr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfGroupConcatExpr(parent SQLNode, node *GroupConcatExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSelectExprs(node, node.Exprs, func(newNode, parent SQLNode) {
		parent.(*GroupConcatExpr).Exprs = newNode.(SelectExprs)
	}) {
		return false
	}
	if !a.rewriteOrderBy(node, node.OrderBy, func(newNode, parent SQLNode) {
		parent.(*GroupConcatExpr).OrderBy = newNode.(OrderBy)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*GroupConcatExpr).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIndexDefinition(parent SQLNode, node *IndexDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfIndexInfo(node, node.Info, func(newNode, parent SQLNode) {
		parent.(*IndexDefinition).Info = newNode.(*IndexInfo)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIndexHints(parent SQLNode, node *IndexHints, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	for x, el := range node.Indexes {
		if !a.rewriteColIdent(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*IndexHints).Indexes[idx] = newNode.(ColIdent)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIndexInfo(parent SQLNode, node *IndexInfo, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*IndexInfo).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.ConstraintName, func(newNode, parent SQLNode) {
		parent.(*IndexInfo).ConstraintName = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfInsert(parent SQLNode, node *Insert, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Insert).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*Insert).Table = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewritePartitions(node, node.Partitions, func(newNode, parent SQLNode) {
		parent.(*Insert).Partitions = newNode.(Partitions)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*Insert).Columns = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteInsertRows(node, node.Rows, func(newNode, parent SQLNode) {
		parent.(*Insert).Rows = newNode.(InsertRows)
	}) {
		return false
	}
	if !a.rewriteOnDup(node, node.OnDup, func(newNode, parent SQLNode) {
		parent.(*Insert).OnDup = newNode.(OnDup)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIntervalExpr(parent SQLNode, node *IntervalExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*IntervalExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIntroducerExpr(parent SQLNode, node *IntroducerExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*IntroducerExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfIsExpr(parent SQLNode, node *IsExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*IsExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfJoinCondition(parent SQLNode, node *JoinCondition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.On, func(newNode, parent SQLNode) {
		parent.(*JoinCondition).On = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.Using, func(newNode, parent SQLNode) {
		parent.(*JoinCondition).Using = newNode.(Columns)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfJoinTableExpr(parent SQLNode, node *JoinTableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableExpr(node, node.LeftExpr, func(newNode, parent SQLNode) {
		parent.(*JoinTableExpr).LeftExpr = newNode.(TableExpr)
	}) {
		return false
	}
	if !a.rewriteTableExpr(node, node.RightExpr, func(newNode, parent SQLNode) {
		parent.(*JoinTableExpr).RightExpr = newNode.(TableExpr)
	}) {
		return false
	}
	if !a.rewriteRefOfJoinCondition(node, node.Condition, func(newNode, parent SQLNode) {
		parent.(*JoinTableExpr).Condition = newNode.(*JoinCondition)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfKeyState(parent SQLNode, node *KeyState, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfLimit(parent SQLNode, node *Limit, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Offset, func(newNode, parent SQLNode) {
		parent.(*Limit).Offset = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Rowcount, func(newNode, parent SQLNode) {
		parent.(*Limit).Rowcount = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfLiteral(parent SQLNode, node *Literal, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfLoad(parent SQLNode, node *Load, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfLockOption(parent SQLNode, node *LockOption, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfLockTables(parent SQLNode, node *LockTables, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfMatchExpr(parent SQLNode, node *MatchExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSelectExprs(node, node.Columns, func(newNode, parent SQLNode) {
		parent.(*MatchExpr).Columns = newNode.(SelectExprs)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*MatchExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfModifyColumn(parent SQLNode, node *ModifyColumn, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColumnDefinition(node, node.NewColDefinition, func(newNode, parent SQLNode) {
		parent.(*ModifyColumn).NewColDefinition = newNode.(*ColumnDefinition)
	}) {
		return false
	}
	if !a.rewriteRefOfColName(node, node.After, func(newNode, parent SQLNode) {
		parent.(*ModifyColumn).After = newNode.(*ColName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfNextval(parent SQLNode, node *Nextval, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*Nextval).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfNotExpr(parent SQLNode, node *NotExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*NotExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfNullVal(parent SQLNode, node *NullVal, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteOnDup(parent SQLNode, node OnDup, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(OnDup)
			a.cur.revisit = false
			return a.rewriteOnDup(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteRefOfUpdateExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(OnDup)[idx] = newNode.(*UpdateExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOptLike(parent SQLNode, node *OptLike, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.LikeTable, func(newNode, parent SQLNode) {
		parent.(*OptLike).LikeTable = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOrExpr(parent SQLNode, node *OrExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*OrExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*OrExpr).Right = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOrder(parent SQLNode, node *Order, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*Order).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteOrderBy(parent SQLNode, node OrderBy, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(OrderBy)
			a.cur.revisit = false
			return a.rewriteOrderBy(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteRefOfOrder(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(OrderBy)[idx] = newNode.(*Order)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOrderByOption(parent SQLNode, node *OrderByOption, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColumns(node, node.Cols, func(newNode, parent SQLNode) {
		parent.(*OrderByOption).Cols = newNode.(Columns)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOtherAdmin(parent SQLNode, node *OtherAdmin, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfOtherRead(parent SQLNode, node *OtherRead, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfParenTableExpr(parent SQLNode, node *ParenTableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableExprs(node, node.Exprs, func(newNode, parent SQLNode) {
		parent.(*ParenTableExpr).Exprs = newNode.(TableExprs)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfPartitionDefinition(parent SQLNode, node *PartitionDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*PartitionDefinition).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*PartitionDefinition).Limit = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfPartitionOption(parent SQLNode, node *PartitionOption, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColumns(node, node.KeyColList, func(newNode, parent SQLNode) {
		parent.(*PartitionOption).KeyColList = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteRefOfExprOrColumns(node, node.ExprOrCol, func(newNode, parent SQLNode) {
		parent.(*PartitionOption).ExprOrCol = newNode.(*ExprOrColumns)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*PartitionOption).Expr = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteRefOfSubPartition(node, node.SubPartition, func(newNode, parent SQLNode) {
		parent.(*PartitionOption).SubPartition = newNode.(*SubPartition)
	}) {
		return false
	}
	for x, el := range node.Definitions {
		if !a.rewriteRefOfPartitionDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*PartitionOption).Definitions[idx] = newNode.(*PartitionDefinition)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfPartitionSpec(parent SQLNode, node *PartitionSpec, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewritePartitions(node, node.Names, func(newNode, parent SQLNode) {
		parent.(*PartitionSpec).Names = newNode.(Partitions)
	}) {
		return false
	}
	if !a.rewriteRefOfLiteral(node, node.Number, func(newNode, parent SQLNode) {
		parent.(*PartitionSpec).Number = newNode.(*Literal)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.TableName, func(newNode, parent SQLNode) {
		parent.(*PartitionSpec).TableName = newNode.(TableName)
	}) {
		return false
	}
	for x, el := range node.Definitions {
		if !a.rewriteRefOfPartitionDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*PartitionSpec).Definitions[idx] = newNode.(*PartitionDefinition)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewritePartitions(parent SQLNode, node Partitions, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(Partitions)
			a.cur.revisit = false
			return a.rewritePartitions(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteColIdent(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(Partitions)[idx] = newNode.(ColIdent)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfReferenceDefinition(parent SQLNode, node *ReferenceDefinition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.ReferencedTable, func(newNode, parent SQLNode) {
		parent.(*ReferenceDefinition).ReferencedTable = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteColumns(node, node.ReferencedColumns, func(newNode, parent SQLNode) {
		parent.(*ReferenceDefinition).ReferencedColumns = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteReferenceAction(node, node.OnDelete, func(newNode, parent SQLNode) {
		parent.(*ReferenceDefinition).OnDelete = newNode.(ReferenceAction)
	}) {
		return false
	}
	if !a.rewriteReferenceAction(node, node.OnUpdate, func(newNode, parent SQLNode) {
		parent.(*ReferenceDefinition).OnUpdate = newNode.(ReferenceAction)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRelease(parent SQLNode, node *Release, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*Release).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRenameIndex(parent SQLNode, node *RenameIndex, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.OldName, func(newNode, parent SQLNode) {
		parent.(*RenameIndex).OldName = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.NewName, func(newNode, parent SQLNode) {
		parent.(*RenameIndex).NewName = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRenameTable(parent SQLNode, node *RenameTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRenameTableName(parent SQLNode, node *RenameTableName, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*RenameTableName).Table = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRevertMigration(parent SQLNode, node *RevertMigration, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*RevertMigration).Comments = newNode.(Comments)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRollback(parent SQLNode, node *Rollback, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRootNode(parent SQLNode, node RootNode, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSQLNode(node, node.SQLNode, func(newNode, parent SQLNode) {
		panic("[BUG] tried to replace 'SQLNode' on 'RootNode'")
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSRollback(parent SQLNode, node *SRollback, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*SRollback).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSavepoint(parent SQLNode, node *Savepoint, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*Savepoint).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSelect(parent SQLNode, node *Select, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	for x, el := range node.From {
		if !a.rewriteTableExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*Select).From[idx] = newNode.(TableExpr)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Select).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteSelectExprs(node, node.SelectExprs, func(newNode, parent SQLNode) {
		parent.(*Select).SelectExprs = newNode.(SelectExprs)
	}) {
		return false
	}
	if !a.rewriteRefOfWhere(node, node.Where, func(newNode, parent SQLNode) {
		parent.(*Select).Where = newNode.(*Where)
	}) {
		return false
	}
	if !a.rewriteRefOfWith(node, node.With, func(newNode, parent SQLNode) {
		parent.(*Select).With = newNode.(*With)
	}) {
		return false
	}
	if !a.rewriteGroupBy(node, node.GroupBy, func(newNode, parent SQLNode) {
		parent.(*Select).GroupBy = newNode.(GroupBy)
	}) {
		return false
	}
	if !a.rewriteRefOfWhere(node, node.Having, func(newNode, parent SQLNode) {
		parent.(*Select).Having = newNode.(*Where)
	}) {
		return false
	}
	if !a.rewriteOrderBy(node, node.OrderBy, func(newNode, parent SQLNode) {
		parent.(*Select).OrderBy = newNode.(OrderBy)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*Select).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if !a.rewriteRefOfSelectInto(node, node.Into, func(newNode, parent SQLNode) {
		parent.(*Select).Into = newNode.(*SelectInto)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteSelectExprs(parent SQLNode, node SelectExprs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(SelectExprs)
			a.cur.revisit = false
			return a.rewriteSelectExprs(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteSelectExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(SelectExprs)[idx] = newNode.(SelectExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSelectInto(parent SQLNode, node *SelectInto, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSet(parent SQLNode, node *Set, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Set).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteSetExprs(node, node.Exprs, func(newNode, parent SQLNode) {
		parent.(*Set).Exprs = newNode.(SetExprs)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSetExpr(parent SQLNode, node *SetExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*SetExpr).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*SetExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteSetExprs(parent SQLNode, node SetExprs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(SetExprs)
			a.cur.revisit = false
			return a.rewriteSetExprs(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteRefOfSetExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(SetExprs)[idx] = newNode.(*SetExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSetTransaction(parent SQLNode, node *SetTransaction, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSQLNode(node, node.SQLNode, func(newNode, parent SQLNode) {
		parent.(*SetTransaction).SQLNode = newNode.(SQLNode)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*SetTransaction).Comments = newNode.(Comments)
	}) {
		return false
	}
	for x, el := range node.Characteristics {
		if !a.rewriteCharacteristic(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*SetTransaction).Characteristics[idx] = newNode.(Characteristic)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShow(parent SQLNode, node *Show, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteShowInternal(node, node.Internal, func(newNode, parent SQLNode) {
		parent.(*Show).Internal = newNode.(ShowInternal)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShowBasic(parent SQLNode, node *ShowBasic, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Tbl, func(newNode, parent SQLNode) {
		parent.(*ShowBasic).Tbl = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.DbName, func(newNode, parent SQLNode) {
		parent.(*ShowBasic).DbName = newNode.(TableIdent)
	}) {
		return false
	}
	if !a.rewriteRefOfShowFilter(node, node.Filter, func(newNode, parent SQLNode) {
		parent.(*ShowBasic).Filter = newNode.(*ShowFilter)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShowCreate(parent SQLNode, node *ShowCreate, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Op, func(newNode, parent SQLNode) {
		parent.(*ShowCreate).Op = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShowFilter(parent SQLNode, node *ShowFilter, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Filter, func(newNode, parent SQLNode) {
		parent.(*ShowFilter).Filter = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShowLegacy(parent SQLNode, node *ShowLegacy, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.OnTable, func(newNode, parent SQLNode) {
		parent.(*ShowLegacy).OnTable = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*ShowLegacy).Table = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.ShowCollationFilterOpt, func(newNode, parent SQLNode) {
		parent.(*ShowLegacy).ShowCollationFilterOpt = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfShowMigrationLogs(parent SQLNode, node *ShowMigrationLogs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*ShowMigrationLogs).Comments = newNode.(Comments)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfStarExpr(parent SQLNode, node *StarExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.TableName, func(newNode, parent SQLNode) {
		parent.(*StarExpr).TableName = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfStream(parent SQLNode, node *Stream, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Stream).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteSelectExpr(node, node.SelectExpr, func(newNode, parent SQLNode) {
		parent.(*Stream).SelectExpr = newNode.(SelectExpr)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*Stream).Table = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSubPartition(parent SQLNode, node *SubPartition, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColumns(node, node.KeyColList, func(newNode, parent SQLNode) {
		parent.(*SubPartition).KeyColList = newNode.(Columns)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*SubPartition).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSubquery(parent SQLNode, node *Subquery, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSelectStatement(node, node.Select, func(newNode, parent SQLNode) {
		parent.(*Subquery).Select = newNode.(SelectStatement)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfSubstrExpr(parent SQLNode, node *SubstrExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*SubstrExpr).Name = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.From, func(newNode, parent SQLNode) {
		parent.(*SubstrExpr).From = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.To, func(newNode, parent SQLNode) {
		parent.(*SubstrExpr).To = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteTableExprs(parent SQLNode, node TableExprs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(TableExprs)
			a.cur.revisit = false
			return a.rewriteTableExprs(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteTableExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(TableExprs)[idx] = newNode.(TableExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteTableIdent(parent SQLNode, node TableIdent, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteTableName(parent SQLNode, node TableName, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.Name, func(newNode, parent SQLNode) {
		panic("[BUG] tried to replace 'Name' on 'TableName'")
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.Qualifier, func(newNode, parent SQLNode) {
		panic("[BUG] tried to replace 'Qualifier' on 'TableName'")
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteTableNames(parent SQLNode, node TableNames, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(TableNames)
			a.cur.revisit = false
			return a.rewriteTableNames(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteTableName(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(TableNames)[idx] = newNode.(TableName)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteTableOptions(parent SQLNode, node TableOptions, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(TableOptions)
			a.cur.revisit = false
			return a.rewriteTableOptions(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTableSpec(parent SQLNode, node *TableSpec, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	for x, el := range node.Columns {
		if !a.rewriteRefOfColumnDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*TableSpec).Columns[idx] = newNode.(*ColumnDefinition)
			}
		}(x)) {
			return false
		}
	}
	for x, el := range node.Indexes {
		if !a.rewriteRefOfIndexDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*TableSpec).Indexes[idx] = newNode.(*IndexDefinition)
			}
		}(x)) {
			return false
		}
	}
	for x, el := range node.Constraints {
		if !a.rewriteRefOfConstraintDefinition(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*TableSpec).Constraints[idx] = newNode.(*ConstraintDefinition)
			}
		}(x)) {
			return false
		}
	}
	if !a.rewriteTableOptions(node, node.Options, func(newNode, parent SQLNode) {
		parent.(*TableSpec).Options = newNode.(TableOptions)
	}) {
		return false
	}
	if !a.rewriteRefOfPartitionOption(node, node.PartitionOption, func(newNode, parent SQLNode) {
		parent.(*TableSpec).PartitionOption = newNode.(*PartitionOption)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTablespaceOperation(parent SQLNode, node *TablespaceOperation, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTimestampFuncExpr(parent SQLNode, node *TimestampFuncExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr1, func(newNode, parent SQLNode) {
		parent.(*TimestampFuncExpr).Expr1 = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr2, func(newNode, parent SQLNode) {
		parent.(*TimestampFuncExpr).Expr2 = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTruncateTable(parent SQLNode, node *TruncateTable, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*TruncateTable).Table = newNode.(TableName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUnaryExpr(parent SQLNode, node *UnaryExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*UnaryExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUnion(parent SQLNode, node *Union, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSelectStatement(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*Union).Left = newNode.(SelectStatement)
	}) {
		return false
	}
	if !a.rewriteSelectStatement(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*Union).Right = newNode.(SelectStatement)
	}) {
		return false
	}
	if !a.rewriteOrderBy(node, node.OrderBy, func(newNode, parent SQLNode) {
		parent.(*Union).OrderBy = newNode.(OrderBy)
	}) {
		return false
	}
	if !a.rewriteRefOfWith(node, node.With, func(newNode, parent SQLNode) {
		parent.(*Union).With = newNode.(*With)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*Union).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if !a.rewriteRefOfSelectInto(node, node.Into, func(newNode, parent SQLNode) {
		parent.(*Union).Into = newNode.(*SelectInto)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUnlockTables(parent SQLNode, node *UnlockTables, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUpdate(parent SQLNode, node *Update, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfWith(node, node.With, func(newNode, parent SQLNode) {
		parent.(*Update).With = newNode.(*With)
	}) {
		return false
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*Update).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteTableExprs(node, node.TableExprs, func(newNode, parent SQLNode) {
		parent.(*Update).TableExprs = newNode.(TableExprs)
	}) {
		return false
	}
	if !a.rewriteUpdateExprs(node, node.Exprs, func(newNode, parent SQLNode) {
		parent.(*Update).Exprs = newNode.(UpdateExprs)
	}) {
		return false
	}
	if !a.rewriteRefOfWhere(node, node.Where, func(newNode, parent SQLNode) {
		parent.(*Update).Where = newNode.(*Where)
	}) {
		return false
	}
	if !a.rewriteOrderBy(node, node.OrderBy, func(newNode, parent SQLNode) {
		parent.(*Update).OrderBy = newNode.(OrderBy)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*Update).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUpdateExpr(parent SQLNode, node *UpdateExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColName(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*UpdateExpr).Name = newNode.(*ColName)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*UpdateExpr).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteUpdateExprs(parent SQLNode, node UpdateExprs, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(UpdateExprs)
			a.cur.revisit = false
			return a.rewriteUpdateExprs(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteRefOfUpdateExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(UpdateExprs)[idx] = newNode.(*UpdateExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfUse(parent SQLNode, node *Use, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.DBName, func(newNode, parent SQLNode) {
		parent.(*Use).DBName = newNode.(TableIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfVStream(parent SQLNode, node *VStream, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteComments(node, node.Comments, func(newNode, parent SQLNode) {
		parent.(*VStream).Comments = newNode.(Comments)
	}) {
		return false
	}
	if !a.rewriteSelectExpr(node, node.SelectExpr, func(newNode, parent SQLNode) {
		parent.(*VStream).SelectExpr = newNode.(SelectExpr)
	}) {
		return false
	}
	if !a.rewriteTableName(node, node.Table, func(newNode, parent SQLNode) {
		parent.(*VStream).Table = newNode.(TableName)
	}) {
		return false
	}
	if !a.rewriteRefOfWhere(node, node.Where, func(newNode, parent SQLNode) {
		parent.(*VStream).Where = newNode.(*Where)
	}) {
		return false
	}
	if !a.rewriteRefOfLimit(node, node.Limit, func(newNode, parent SQLNode) {
		parent.(*VStream).Limit = newNode.(*Limit)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteValTuple(parent SQLNode, node ValTuple, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(ValTuple)
			a.cur.revisit = false
			return a.rewriteValTuple(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(ValTuple)[idx] = newNode.(Expr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfValidation(parent SQLNode, node *Validation, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteValues(parent SQLNode, node Values, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		kontinue := !a.pre(&a.cur)
		if a.cur.revisit {
			node = a.cur.node.(Values)
			a.cur.revisit = false
			return a.rewriteValues(parent, node, replacer)
		}
		if kontinue {
			return true
		}
	}
	for x, el := range node {
		if !a.rewriteValTuple(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(Values)[idx] = newNode.(ValTuple)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfValuesFuncExpr(parent SQLNode, node *ValuesFuncExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteRefOfColName(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*ValuesFuncExpr).Name = newNode.(*ColName)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteVindexParam(parent SQLNode, node VindexParam, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Key, func(newNode, parent SQLNode) {
		panic("[BUG] tried to replace 'Key' on 'VindexParam'")
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfVindexSpec(parent SQLNode, node *VindexSpec, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*VindexSpec).Name = newNode.(ColIdent)
	}) {
		return false
	}
	if !a.rewriteColIdent(node, node.Type, func(newNode, parent SQLNode) {
		parent.(*VindexSpec).Type = newNode.(ColIdent)
	}) {
		return false
	}
	for x, el := range node.Params {
		if !a.rewriteVindexParam(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*VindexSpec).Params[idx] = newNode.(VindexParam)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfWhen(parent SQLNode, node *When, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Cond, func(newNode, parent SQLNode) {
		parent.(*When).Cond = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Val, func(newNode, parent SQLNode) {
		parent.(*When).Val = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfWhere(parent SQLNode, node *Where, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Expr, func(newNode, parent SQLNode) {
		parent.(*Where).Expr = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfWith(parent SQLNode, node *With, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	for x, el := range node.ctes {
		if !a.rewriteRefOfCommonTableExpr(node, el, func(idx int) replacerFunc {
			return func(newNode, parent SQLNode) {
				parent.(*With).ctes[idx] = newNode.(*CommonTableExpr)
			}
		}(x)) {
			return false
		}
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfXorExpr(parent SQLNode, node *XorExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteExpr(node, node.Left, func(newNode, parent SQLNode) {
		parent.(*XorExpr).Left = newNode.(Expr)
	}) {
		return false
	}
	if !a.rewriteExpr(node, node.Right, func(newNode, parent SQLNode) {
		parent.(*XorExpr).Right = newNode.(Expr)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteAlterOption(parent SQLNode, node AlterOption, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AddColumns:
		return a.rewriteRefOfAddColumns(parent, node, replacer)
	case *AddConstraintDefinition:
		return a.rewriteRefOfAddConstraintDefinition(parent, node, replacer)
	case *AddIndexDefinition:
		return a.rewriteRefOfAddIndexDefinition(parent, node, replacer)
	case AlgorithmValue:
		return a.rewriteAlgorithmValue(parent, node, replacer)
	case *AlterCharset:
		return a.rewriteRefOfAlterCharset(parent, node, replacer)
	case *AlterColumn:
		return a.rewriteRefOfAlterColumn(parent, node, replacer)
	case *ChangeColumn:
		return a.rewriteRefOfChangeColumn(parent, node, replacer)
	case *DropColumn:
		return a.rewriteRefOfDropColumn(parent, node, replacer)
	case *DropKey:
		return a.rewriteRefOfDropKey(parent, node, replacer)
	case *Force:
		return a.rewriteRefOfForce(parent, node, replacer)
	case *KeyState:
		return a.rewriteRefOfKeyState(parent, node, replacer)
	case *LockOption:
		return a.rewriteRefOfLockOption(parent, node, replacer)
	case *ModifyColumn:
		return a.rewriteRefOfModifyColumn(parent, node, replacer)
	case *OrderByOption:
		return a.rewriteRefOfOrderByOption(parent, node, replacer)
	case *RenameIndex:
		return a.rewriteRefOfRenameIndex(parent, node, replacer)
	case *RenameTableName:
		return a.rewriteRefOfRenameTableName(parent, node, replacer)
	case TableOptions:
		return a.rewriteTableOptions(parent, node, replacer)
	case *TablespaceOperation:
		return a.rewriteRefOfTablespaceOperation(parent, node, replacer)
	case *Validation:
		return a.rewriteRefOfValidation(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteCharacteristic(parent SQLNode, node Characteristic, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case AccessMode:
		return a.rewriteAccessMode(parent, node, replacer)
	case IsolationLevel:
		return a.rewriteIsolationLevel(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteColTuple(parent SQLNode, node ColTuple, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case ListArg:
		return a.rewriteListArg(parent, node, replacer)
	case *Subquery:
		return a.rewriteRefOfSubquery(parent, node, replacer)
	case ValTuple:
		return a.rewriteValTuple(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteConstraintInfo(parent SQLNode, node ConstraintInfo, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *CheckConstraintDefinition:
		return a.rewriteRefOfCheckConstraintDefinition(parent, node, replacer)
	case *ForeignKeyDefinition:
		return a.rewriteRefOfForeignKeyDefinition(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteDBDDLStatement(parent SQLNode, node DBDDLStatement, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AlterDatabase:
		return a.rewriteRefOfAlterDatabase(parent, node, replacer)
	case *CreateDatabase:
		return a.rewriteRefOfCreateDatabase(parent, node, replacer)
	case *DropDatabase:
		return a.rewriteRefOfDropDatabase(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteDDLStatement(parent SQLNode, node DDLStatement, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AlterTable:
		return a.rewriteRefOfAlterTable(parent, node, replacer)
	case *AlterView:
		return a.rewriteRefOfAlterView(parent, node, replacer)
	case *CreateTable:
		return a.rewriteRefOfCreateTable(parent, node, replacer)
	case *CreateView:
		return a.rewriteRefOfCreateView(parent, node, replacer)
	case *DropTable:
		return a.rewriteRefOfDropTable(parent, node, replacer)
	case *DropView:
		return a.rewriteRefOfDropView(parent, node, replacer)
	case *RenameTable:
		return a.rewriteRefOfRenameTable(parent, node, replacer)
	case *TruncateTable:
		return a.rewriteRefOfTruncateTable(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteExplain(parent SQLNode, node Explain, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *ExplainStmt:
		return a.rewriteRefOfExplainStmt(parent, node, replacer)
	case *ExplainTab:
		return a.rewriteRefOfExplainTab(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteExpr(parent SQLNode, node Expr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AndExpr:
		return a.rewriteRefOfAndExpr(parent, node, replacer)
	case Argument:
		return a.rewriteArgument(parent, node, replacer)
	case *BetweenExpr:
		return a.rewriteRefOfBetweenExpr(parent, node, replacer)
	case *BinaryExpr:
		return a.rewriteRefOfBinaryExpr(parent, node, replacer)
	case BoolVal:
		return a.rewriteBoolVal(parent, node, replacer)
	case *CaseExpr:
		return a.rewriteRefOfCaseExpr(parent, node, replacer)
	case *ColName:
		return a.rewriteRefOfColName(parent, node, replacer)
	case *CollateExpr:
		return a.rewriteRefOfCollateExpr(parent, node, replacer)
	case *ComparisonExpr:
		return a.rewriteRefOfComparisonExpr(parent, node, replacer)
	case *ConvertExpr:
		return a.rewriteRefOfConvertExpr(parent, node, replacer)
	case *ConvertUsingExpr:
		return a.rewriteRefOfConvertUsingExpr(parent, node, replacer)
	case *CurTimeFuncExpr:
		return a.rewriteRefOfCurTimeFuncExpr(parent, node, replacer)
	case *Default:
		return a.rewriteRefOfDefault(parent, node, replacer)
	case *ExistsExpr:
		return a.rewriteRefOfExistsExpr(parent, node, replacer)
	case *ExtractFuncExpr:
		return a.rewriteRefOfExtractFuncExpr(parent, node, replacer)
	case *ExtractedSubquery:
		return a.rewriteRefOfExtractedSubquery(parent, node, replacer)
	case *FuncExpr:
		return a.rewriteRefOfFuncExpr(parent, node, replacer)
	case *GroupConcatExpr:
		return a.rewriteRefOfGroupConcatExpr(parent, node, replacer)
	case *IntervalExpr:
		return a.rewriteRefOfIntervalExpr(parent, node, replacer)
	case *IntroducerExpr:
		return a.rewriteRefOfIntroducerExpr(parent, node, replacer)
	case *IsExpr:
		return a.rewriteRefOfIsExpr(parent, node, replacer)
	case ListArg:
		return a.rewriteListArg(parent, node, replacer)
	case *Literal:
		return a.rewriteRefOfLiteral(parent, node, replacer)
	case *MatchExpr:
		return a.rewriteRefOfMatchExpr(parent, node, replacer)
	case *NotExpr:
		return a.rewriteRefOfNotExpr(parent, node, replacer)
	case *NullVal:
		return a.rewriteRefOfNullVal(parent, node, replacer)
	case *OrExpr:
		return a.rewriteRefOfOrExpr(parent, node, replacer)
	case *Subquery:
		return a.rewriteRefOfSubquery(parent, node, replacer)
	case *SubstrExpr:
		return a.rewriteRefOfSubstrExpr(parent, node, replacer)
	case *TimestampFuncExpr:
		return a.rewriteRefOfTimestampFuncExpr(parent, node, replacer)
	case *UnaryExpr:
		return a.rewriteRefOfUnaryExpr(parent, node, replacer)
	case ValTuple:
		return a.rewriteValTuple(parent, node, replacer)
	case *ValuesFuncExpr:
		return a.rewriteRefOfValuesFuncExpr(parent, node, replacer)
	case *XorExpr:
		return a.rewriteRefOfXorExpr(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteInsertRows(parent SQLNode, node InsertRows, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *Select:
		return a.rewriteRefOfSelect(parent, node, replacer)
	case *Union:
		return a.rewriteRefOfUnion(parent, node, replacer)
	case Values:
		return a.rewriteValues(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteSelectExpr(parent SQLNode, node SelectExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AliasedExpr:
		return a.rewriteRefOfAliasedExpr(parent, node, replacer)
	case *Nextval:
		return a.rewriteRefOfNextval(parent, node, replacer)
	case *StarExpr:
		return a.rewriteRefOfStarExpr(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteSelectStatement(parent SQLNode, node SelectStatement, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *Select:
		return a.rewriteRefOfSelect(parent, node, replacer)
	case *Union:
		return a.rewriteRefOfUnion(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteShowInternal(parent SQLNode, node ShowInternal, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *ShowBasic:
		return a.rewriteRefOfShowBasic(parent, node, replacer)
	case *ShowCreate:
		return a.rewriteRefOfShowCreate(parent, node, replacer)
	case *ShowLegacy:
		return a.rewriteRefOfShowLegacy(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteSimpleTableExpr(parent SQLNode, node SimpleTableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *DerivedTable:
		return a.rewriteRefOfDerivedTable(parent, node, replacer)
	case TableName:
		return a.rewriteTableName(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteStatement(parent SQLNode, node Statement, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AlterDatabase:
		return a.rewriteRefOfAlterDatabase(parent, node, replacer)
	case *AlterMigration:
		return a.rewriteRefOfAlterMigration(parent, node, replacer)
	case *AlterTable:
		return a.rewriteRefOfAlterTable(parent, node, replacer)
	case *AlterView:
		return a.rewriteRefOfAlterView(parent, node, replacer)
	case *AlterVschema:
		return a.rewriteRefOfAlterVschema(parent, node, replacer)
	case *Begin:
		return a.rewriteRefOfBegin(parent, node, replacer)
	case *CallProc:
		return a.rewriteRefOfCallProc(parent, node, replacer)
	case *Commit:
		return a.rewriteRefOfCommit(parent, node, replacer)
	case *CreateDatabase:
		return a.rewriteRefOfCreateDatabase(parent, node, replacer)
	case *CreateTable:
		return a.rewriteRefOfCreateTable(parent, node, replacer)
	case *CreateView:
		return a.rewriteRefOfCreateView(parent, node, replacer)
	case *Delete:
		return a.rewriteRefOfDelete(parent, node, replacer)
	case *DropDatabase:
		return a.rewriteRefOfDropDatabase(parent, node, replacer)
	case *DropTable:
		return a.rewriteRefOfDropTable(parent, node, replacer)
	case *DropView:
		return a.rewriteRefOfDropView(parent, node, replacer)
	case *ExplainStmt:
		return a.rewriteRefOfExplainStmt(parent, node, replacer)
	case *ExplainTab:
		return a.rewriteRefOfExplainTab(parent, node, replacer)
	case *Flush:
		return a.rewriteRefOfFlush(parent, node, replacer)
	case *Insert:
		return a.rewriteRefOfInsert(parent, node, replacer)
	case *Load:
		return a.rewriteRefOfLoad(parent, node, replacer)
	case *LockTables:
		return a.rewriteRefOfLockTables(parent, node, replacer)
	case *OtherAdmin:
		return a.rewriteRefOfOtherAdmin(parent, node, replacer)
	case *OtherRead:
		return a.rewriteRefOfOtherRead(parent, node, replacer)
	case *Release:
		return a.rewriteRefOfRelease(parent, node, replacer)
	case *RenameTable:
		return a.rewriteRefOfRenameTable(parent, node, replacer)
	case *RevertMigration:
		return a.rewriteRefOfRevertMigration(parent, node, replacer)
	case *Rollback:
		return a.rewriteRefOfRollback(parent, node, replacer)
	case *SRollback:
		return a.rewriteRefOfSRollback(parent, node, replacer)
	case *Savepoint:
		return a.rewriteRefOfSavepoint(parent, node, replacer)
	case *Select:
		return a.rewriteRefOfSelect(parent, node, replacer)
	case *Set:
		return a.rewriteRefOfSet(parent, node, replacer)
	case *SetTransaction:
		return a.rewriteRefOfSetTransaction(parent, node, replacer)
	case *Show:
		return a.rewriteRefOfShow(parent, node, replacer)
	case *ShowMigrationLogs:
		return a.rewriteRefOfShowMigrationLogs(parent, node, replacer)
	case *Stream:
		return a.rewriteRefOfStream(parent, node, replacer)
	case *TruncateTable:
		return a.rewriteRefOfTruncateTable(parent, node, replacer)
	case *Union:
		return a.rewriteRefOfUnion(parent, node, replacer)
	case *UnlockTables:
		return a.rewriteRefOfUnlockTables(parent, node, replacer)
	case *Update:
		return a.rewriteRefOfUpdate(parent, node, replacer)
	case *Use:
		return a.rewriteRefOfUse(parent, node, replacer)
	case *VStream:
		return a.rewriteRefOfVStream(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteTableExpr(parent SQLNode, node TableExpr, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	switch node := node.(type) {
	case *AliasedTableExpr:
		return a.rewriteRefOfAliasedTableExpr(parent, node, replacer)
	case *JoinTableExpr:
		return a.rewriteRefOfJoinTableExpr(parent, node, replacer)
	case *ParenTableExpr:
		return a.rewriteRefOfParenTableExpr(parent, node, replacer)
	default:
		// this should never happen
		return true
	}
}
func (a *application) rewriteAccessMode(parent SQLNode, node AccessMode, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteAlgorithmValue(parent SQLNode, node AlgorithmValue, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteArgument(parent SQLNode, node Argument, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteBoolVal(parent SQLNode, node BoolVal, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteIsolationLevel(parent SQLNode, node IsolationLevel, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteListArg(parent SQLNode, node ListArg, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteReferenceAction(parent SQLNode, node ReferenceAction, replacer replacerFunc) bool {
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfColIdent(parent SQLNode, node *ColIdent, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfRootNode(parent SQLNode, node *RootNode, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteSQLNode(node, node.SQLNode, func(newNode, parent SQLNode) {
		parent.(*RootNode).SQLNode = newNode.(SQLNode)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTableIdent(parent SQLNode, node *TableIdent, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if a.post != nil {
		if a.pre == nil {
			a.cur.replacer = replacer
			a.cur.parent = parent
			a.cur.node = node
		}
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfTableName(parent SQLNode, node *TableName, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteTableIdent(node, node.Name, func(newNode, parent SQLNode) {
		parent.(*TableName).Name = newNode.(TableIdent)
	}) {
		return false
	}
	if !a.rewriteTableIdent(node, node.Qualifier, func(newNode, parent SQLNode) {
		parent.(*TableName).Qualifier = newNode.(TableIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}
func (a *application) rewriteRefOfVindexParam(parent SQLNode, node *VindexParam, replacer replacerFunc) bool {
	if node == nil {
		return true
	}
	if a.pre != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.pre(&a.cur) {
			return true
		}
	}
	if !a.rewriteColIdent(node, node.Key, func(newNode, parent SQLNode) {
		parent.(*VindexParam).Key = newNode.(ColIdent)
	}) {
		return false
	}
	if a.post != nil {
		a.cur.replacer = replacer
		a.cur.parent = parent
		a.cur.node = node
		if !a.post(&a.cur) {
			return false
		}
	}
	return true
}