github.com/team-ide/go-dialect@v1.9.20/vitess/sqlparser/ast_equals.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

// EqualsSQLNode does deep equals between the two objects.
func EqualsSQLNode(inA, inB SQLNode) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case AccessMode:
		b, ok := inB.(AccessMode)
		if !ok {
			return false
		}
		return a == b
	case *AddColumns:
		b, ok := inB.(*AddColumns)
		if !ok {
			return false
		}
		return EqualsRefOfAddColumns(a, b)
	case *AddConstraintDefinition:
		b, ok := inB.(*AddConstraintDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfAddConstraintDefinition(a, b)
	case *AddIndexDefinition:
		b, ok := inB.(*AddIndexDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfAddIndexDefinition(a, b)
	case AlgorithmValue:
		b, ok := inB.(AlgorithmValue)
		if !ok {
			return false
		}
		return a == b
	case *AliasedExpr:
		b, ok := inB.(*AliasedExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAliasedExpr(a, b)
	case *AliasedTableExpr:
		b, ok := inB.(*AliasedTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAliasedTableExpr(a, b)
	case *AlterCharset:
		b, ok := inB.(*AlterCharset)
		if !ok {
			return false
		}
		return EqualsRefOfAlterCharset(a, b)
	case *AlterColumn:
		b, ok := inB.(*AlterColumn)
		if !ok {
			return false
		}
		return EqualsRefOfAlterColumn(a, b)
	case *AlterDatabase:
		b, ok := inB.(*AlterDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfAlterDatabase(a, b)
	case *AlterMigration:
		b, ok := inB.(*AlterMigration)
		if !ok {
			return false
		}
		return EqualsRefOfAlterMigration(a, b)
	case *AlterTable:
		b, ok := inB.(*AlterTable)
		if !ok {
			return false
		}
		return EqualsRefOfAlterTable(a, b)
	case *AlterView:
		b, ok := inB.(*AlterView)
		if !ok {
			return false
		}
		return EqualsRefOfAlterView(a, b)
	case *AlterVschema:
		b, ok := inB.(*AlterVschema)
		if !ok {
			return false
		}
		return EqualsRefOfAlterVschema(a, b)
	case *AndExpr:
		b, ok := inB.(*AndExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAndExpr(a, b)
	case Argument:
		b, ok := inB.(Argument)
		if !ok {
			return false
		}
		return a == b
	case *AutoIncSpec:
		b, ok := inB.(*AutoIncSpec)
		if !ok {
			return false
		}
		return EqualsRefOfAutoIncSpec(a, b)
	case *Begin:
		b, ok := inB.(*Begin)
		if !ok {
			return false
		}
		return EqualsRefOfBegin(a, b)
	case *BetweenExpr:
		b, ok := inB.(*BetweenExpr)
		if !ok {
			return false
		}
		return EqualsRefOfBetweenExpr(a, b)
	case *BinaryExpr:
		b, ok := inB.(*BinaryExpr)
		if !ok {
			return false
		}
		return EqualsRefOfBinaryExpr(a, b)
	case BoolVal:
		b, ok := inB.(BoolVal)
		if !ok {
			return false
		}
		return a == b
	case *CallProc:
		b, ok := inB.(*CallProc)
		if !ok {
			return false
		}
		return EqualsRefOfCallProc(a, b)
	case *CaseExpr:
		b, ok := inB.(*CaseExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCaseExpr(a, b)
	case *ChangeColumn:
		b, ok := inB.(*ChangeColumn)
		if !ok {
			return false
		}
		return EqualsRefOfChangeColumn(a, b)
	case *CheckConstraintDefinition:
		b, ok := inB.(*CheckConstraintDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfCheckConstraintDefinition(a, b)
	case ColIdent:
		b, ok := inB.(ColIdent)
		if !ok {
			return false
		}
		return EqualsColIdent(a, b)
	case *ColName:
		b, ok := inB.(*ColName)
		if !ok {
			return false
		}
		return EqualsRefOfColName(a, b)
	case *CollateExpr:
		b, ok := inB.(*CollateExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCollateExpr(a, b)
	case *ColumnDefinition:
		b, ok := inB.(*ColumnDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfColumnDefinition(a, b)
	case *ColumnType:
		b, ok := inB.(*ColumnType)
		if !ok {
			return false
		}
		return EqualsRefOfColumnType(a, b)
	case Columns:
		b, ok := inB.(Columns)
		if !ok {
			return false
		}
		return EqualsColumns(a, b)
	case Comments:
		b, ok := inB.(Comments)
		if !ok {
			return false
		}
		return EqualsComments(a, b)
	case *Commit:
		b, ok := inB.(*Commit)
		if !ok {
			return false
		}
		return EqualsRefOfCommit(a, b)
	case *CommonTableExpr:
		b, ok := inB.(*CommonTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCommonTableExpr(a, b)
	case *ComparisonExpr:
		b, ok := inB.(*ComparisonExpr)
		if !ok {
			return false
		}
		return EqualsRefOfComparisonExpr(a, b)
	case *ConstraintDefinition:
		b, ok := inB.(*ConstraintDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfConstraintDefinition(a, b)
	case *ConvertExpr:
		b, ok := inB.(*ConvertExpr)
		if !ok {
			return false
		}
		return EqualsRefOfConvertExpr(a, b)
	case *ConvertType:
		b, ok := inB.(*ConvertType)
		if !ok {
			return false
		}
		return EqualsRefOfConvertType(a, b)
	case *ConvertUsingExpr:
		b, ok := inB.(*ConvertUsingExpr)
		if !ok {
			return false
		}
		return EqualsRefOfConvertUsingExpr(a, b)
	case *CreateDatabase:
		b, ok := inB.(*CreateDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfCreateDatabase(a, b)
	case *CreateTable:
		b, ok := inB.(*CreateTable)
		if !ok {
			return false
		}
		return EqualsRefOfCreateTable(a, b)
	case *CreateView:
		b, ok := inB.(*CreateView)
		if !ok {
			return false
		}
		return EqualsRefOfCreateView(a, b)
	case *CurTimeFuncExpr:
		b, ok := inB.(*CurTimeFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCurTimeFuncExpr(a, b)
	case *Default:
		b, ok := inB.(*Default)
		if !ok {
			return false
		}
		return EqualsRefOfDefault(a, b)
	case *Delete:
		b, ok := inB.(*Delete)
		if !ok {
			return false
		}
		return EqualsRefOfDelete(a, b)
	case *DerivedTable:
		b, ok := inB.(*DerivedTable)
		if !ok {
			return false
		}
		return EqualsRefOfDerivedTable(a, b)
	case *DropColumn:
		b, ok := inB.(*DropColumn)
		if !ok {
			return false
		}
		return EqualsRefOfDropColumn(a, b)
	case *DropDatabase:
		b, ok := inB.(*DropDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfDropDatabase(a, b)
	case *DropKey:
		b, ok := inB.(*DropKey)
		if !ok {
			return false
		}
		return EqualsRefOfDropKey(a, b)
	case *DropTable:
		b, ok := inB.(*DropTable)
		if !ok {
			return false
		}
		return EqualsRefOfDropTable(a, b)
	case *DropView:
		b, ok := inB.(*DropView)
		if !ok {
			return false
		}
		return EqualsRefOfDropView(a, b)
	case *ExistsExpr:
		b, ok := inB.(*ExistsExpr)
		if !ok {
			return false
		}
		return EqualsRefOfExistsExpr(a, b)
	case *ExplainStmt:
		b, ok := inB.(*ExplainStmt)
		if !ok {
			return false
		}
		return EqualsRefOfExplainStmt(a, b)
	case *ExplainTab:
		b, ok := inB.(*ExplainTab)
		if !ok {
			return false
		}
		return EqualsRefOfExplainTab(a, b)
	case *ExprOrColumns:
		b, ok := inB.(*ExprOrColumns)
		if !ok {
			return false
		}
		return EqualsRefOfExprOrColumns(a, b)
	case Exprs:
		b, ok := inB.(Exprs)
		if !ok {
			return false
		}
		return EqualsExprs(a, b)
	case *ExtractFuncExpr:
		b, ok := inB.(*ExtractFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfExtractFuncExpr(a, b)
	case *ExtractedSubquery:
		b, ok := inB.(*ExtractedSubquery)
		if !ok {
			return false
		}
		return EqualsRefOfExtractedSubquery(a, b)
	case *Flush:
		b, ok := inB.(*Flush)
		if !ok {
			return false
		}
		return EqualsRefOfFlush(a, b)
	case *Force:
		b, ok := inB.(*Force)
		if !ok {
			return false
		}
		return EqualsRefOfForce(a, b)
	case *ForeignKeyDefinition:
		b, ok := inB.(*ForeignKeyDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfForeignKeyDefinition(a, b)
	case *FuncExpr:
		b, ok := inB.(*FuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfFuncExpr(a, b)
	case GroupBy:
		b, ok := inB.(GroupBy)
		if !ok {
			return false
		}
		return EqualsGroupBy(a, b)
	case *GroupConcatExpr:
		b, ok := inB.(*GroupConcatExpr)
		if !ok {
			return false
		}
		return EqualsRefOfGroupConcatExpr(a, b)
	case *IndexDefinition:
		b, ok := inB.(*IndexDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfIndexDefinition(a, b)
	case *IndexHints:
		b, ok := inB.(*IndexHints)
		if !ok {
			return false
		}
		return EqualsRefOfIndexHints(a, b)
	case *IndexInfo:
		b, ok := inB.(*IndexInfo)
		if !ok {
			return false
		}
		return EqualsRefOfIndexInfo(a, b)
	case *Insert:
		b, ok := inB.(*Insert)
		if !ok {
			return false
		}
		return EqualsRefOfInsert(a, b)
	case *IntervalExpr:
		b, ok := inB.(*IntervalExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIntervalExpr(a, b)
	case *IntroducerExpr:
		b, ok := inB.(*IntroducerExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIntroducerExpr(a, b)
	case *IsExpr:
		b, ok := inB.(*IsExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIsExpr(a, b)
	case IsolationLevel:
		b, ok := inB.(IsolationLevel)
		if !ok {
			return false
		}
		return a == b
	case *JoinCondition:
		b, ok := inB.(*JoinCondition)
		if !ok {
			return false
		}
		return EqualsRefOfJoinCondition(a, b)
	case *JoinTableExpr:
		b, ok := inB.(*JoinTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfJoinTableExpr(a, b)
	case *KeyState:
		b, ok := inB.(*KeyState)
		if !ok {
			return false
		}
		return EqualsRefOfKeyState(a, b)
	case *Limit:
		b, ok := inB.(*Limit)
		if !ok {
			return false
		}
		return EqualsRefOfLimit(a, b)
	case ListArg:
		b, ok := inB.(ListArg)
		if !ok {
			return false
		}
		return a == b
	case *Literal:
		b, ok := inB.(*Literal)
		if !ok {
			return false
		}
		return EqualsRefOfLiteral(a, b)
	case *Load:
		b, ok := inB.(*Load)
		if !ok {
			return false
		}
		return EqualsRefOfLoad(a, b)
	case *LockOption:
		b, ok := inB.(*LockOption)
		if !ok {
			return false
		}
		return EqualsRefOfLockOption(a, b)
	case *LockTables:
		b, ok := inB.(*LockTables)
		if !ok {
			return false
		}
		return EqualsRefOfLockTables(a, b)
	case *MatchExpr:
		b, ok := inB.(*MatchExpr)
		if !ok {
			return false
		}
		return EqualsRefOfMatchExpr(a, b)
	case *ModifyColumn:
		b, ok := inB.(*ModifyColumn)
		if !ok {
			return false
		}
		return EqualsRefOfModifyColumn(a, b)
	case *Nextval:
		b, ok := inB.(*Nextval)
		if !ok {
			return false
		}
		return EqualsRefOfNextval(a, b)
	case *NotExpr:
		b, ok := inB.(*NotExpr)
		if !ok {
			return false
		}
		return EqualsRefOfNotExpr(a, b)
	case *NullVal:
		b, ok := inB.(*NullVal)
		if !ok {
			return false
		}
		return EqualsRefOfNullVal(a, b)
	case OnDup:
		b, ok := inB.(OnDup)
		if !ok {
			return false
		}
		return EqualsOnDup(a, b)
	case *OptLike:
		b, ok := inB.(*OptLike)
		if !ok {
			return false
		}
		return EqualsRefOfOptLike(a, b)
	case *OrExpr:
		b, ok := inB.(*OrExpr)
		if !ok {
			return false
		}
		return EqualsRefOfOrExpr(a, b)
	case *Order:
		b, ok := inB.(*Order)
		if !ok {
			return false
		}
		return EqualsRefOfOrder(a, b)
	case OrderBy:
		b, ok := inB.(OrderBy)
		if !ok {
			return false
		}
		return EqualsOrderBy(a, b)
	case *OrderByOption:
		b, ok := inB.(*OrderByOption)
		if !ok {
			return false
		}
		return EqualsRefOfOrderByOption(a, b)
	case *OtherAdmin:
		b, ok := inB.(*OtherAdmin)
		if !ok {
			return false
		}
		return EqualsRefOfOtherAdmin(a, b)
	case *OtherRead:
		b, ok := inB.(*OtherRead)
		if !ok {
			return false
		}
		return EqualsRefOfOtherRead(a, b)
	case *ParenTableExpr:
		b, ok := inB.(*ParenTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfParenTableExpr(a, b)
	case *PartitionDefinition:
		b, ok := inB.(*PartitionDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfPartitionDefinition(a, b)
	case *PartitionOption:
		b, ok := inB.(*PartitionOption)
		if !ok {
			return false
		}
		return EqualsRefOfPartitionOption(a, b)
	case *PartitionSpec:
		b, ok := inB.(*PartitionSpec)
		if !ok {
			return false
		}
		return EqualsRefOfPartitionSpec(a, b)
	case Partitions:
		b, ok := inB.(Partitions)
		if !ok {
			return false
		}
		return EqualsPartitions(a, b)
	case ReferenceAction:
		b, ok := inB.(ReferenceAction)
		if !ok {
			return false
		}
		return a == b
	case *ReferenceDefinition:
		b, ok := inB.(*ReferenceDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfReferenceDefinition(a, b)
	case *Release:
		b, ok := inB.(*Release)
		if !ok {
			return false
		}
		return EqualsRefOfRelease(a, b)
	case *RenameIndex:
		b, ok := inB.(*RenameIndex)
		if !ok {
			return false
		}
		return EqualsRefOfRenameIndex(a, b)
	case *RenameTable:
		b, ok := inB.(*RenameTable)
		if !ok {
			return false
		}
		return EqualsRefOfRenameTable(a, b)
	case *RenameTableName:
		b, ok := inB.(*RenameTableName)
		if !ok {
			return false
		}
		return EqualsRefOfRenameTableName(a, b)
	case *RevertMigration:
		b, ok := inB.(*RevertMigration)
		if !ok {
			return false
		}
		return EqualsRefOfRevertMigration(a, b)
	case *Rollback:
		b, ok := inB.(*Rollback)
		if !ok {
			return false
		}
		return EqualsRefOfRollback(a, b)
	case RootNode:
		b, ok := inB.(RootNode)
		if !ok {
			return false
		}
		return EqualsRootNode(a, b)
	case *SRollback:
		b, ok := inB.(*SRollback)
		if !ok {
			return false
		}
		return EqualsRefOfSRollback(a, b)
	case *Savepoint:
		b, ok := inB.(*Savepoint)
		if !ok {
			return false
		}
		return EqualsRefOfSavepoint(a, b)
	case *Select:
		b, ok := inB.(*Select)
		if !ok {
			return false
		}
		return EqualsRefOfSelect(a, b)
	case SelectExprs:
		b, ok := inB.(SelectExprs)
		if !ok {
			return false
		}
		return EqualsSelectExprs(a, b)
	case *SelectInto:
		b, ok := inB.(*SelectInto)
		if !ok {
			return false
		}
		return EqualsRefOfSelectInto(a, b)
	case *Set:
		b, ok := inB.(*Set)
		if !ok {
			return false
		}
		return EqualsRefOfSet(a, b)
	case *SetExpr:
		b, ok := inB.(*SetExpr)
		if !ok {
			return false
		}
		return EqualsRefOfSetExpr(a, b)
	case SetExprs:
		b, ok := inB.(SetExprs)
		if !ok {
			return false
		}
		return EqualsSetExprs(a, b)
	case *SetTransaction:
		b, ok := inB.(*SetTransaction)
		if !ok {
			return false
		}
		return EqualsRefOfSetTransaction(a, b)
	case *Show:
		b, ok := inB.(*Show)
		if !ok {
			return false
		}
		return EqualsRefOfShow(a, b)
	case *ShowBasic:
		b, ok := inB.(*ShowBasic)
		if !ok {
			return false
		}
		return EqualsRefOfShowBasic(a, b)
	case *ShowCreate:
		b, ok := inB.(*ShowCreate)
		if !ok {
			return false
		}
		return EqualsRefOfShowCreate(a, b)
	case *ShowFilter:
		b, ok := inB.(*ShowFilter)
		if !ok {
			return false
		}
		return EqualsRefOfShowFilter(a, b)
	case *ShowLegacy:
		b, ok := inB.(*ShowLegacy)
		if !ok {
			return false
		}
		return EqualsRefOfShowLegacy(a, b)
	case *ShowMigrationLogs:
		b, ok := inB.(*ShowMigrationLogs)
		if !ok {
			return false
		}
		return EqualsRefOfShowMigrationLogs(a, b)
	case *StarExpr:
		b, ok := inB.(*StarExpr)
		if !ok {
			return false
		}
		return EqualsRefOfStarExpr(a, b)
	case *Stream:
		b, ok := inB.(*Stream)
		if !ok {
			return false
		}
		return EqualsRefOfStream(a, b)
	case *SubPartition:
		b, ok := inB.(*SubPartition)
		if !ok {
			return false
		}
		return EqualsRefOfSubPartition(a, b)
	case *Subquery:
		b, ok := inB.(*Subquery)
		if !ok {
			return false
		}
		return EqualsRefOfSubquery(a, b)
	case *SubstrExpr:
		b, ok := inB.(*SubstrExpr)
		if !ok {
			return false
		}
		return EqualsRefOfSubstrExpr(a, b)
	case TableExprs:
		b, ok := inB.(TableExprs)
		if !ok {
			return false
		}
		return EqualsTableExprs(a, b)
	case TableIdent:
		b, ok := inB.(TableIdent)
		if !ok {
			return false
		}
		return EqualsTableIdent(a, b)
	case TableName:
		b, ok := inB.(TableName)
		if !ok {
			return false
		}
		return EqualsTableName(a, b)
	case TableNames:
		b, ok := inB.(TableNames)
		if !ok {
			return false
		}
		return EqualsTableNames(a, b)
	case TableOptions:
		b, ok := inB.(TableOptions)
		if !ok {
			return false
		}
		return EqualsTableOptions(a, b)
	case *TableSpec:
		b, ok := inB.(*TableSpec)
		if !ok {
			return false
		}
		return EqualsRefOfTableSpec(a, b)
	case *TablespaceOperation:
		b, ok := inB.(*TablespaceOperation)
		if !ok {
			return false
		}
		return EqualsRefOfTablespaceOperation(a, b)
	case *TimestampFuncExpr:
		b, ok := inB.(*TimestampFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfTimestampFuncExpr(a, b)
	case *TruncateTable:
		b, ok := inB.(*TruncateTable)
		if !ok {
			return false
		}
		return EqualsRefOfTruncateTable(a, b)
	case *UnaryExpr:
		b, ok := inB.(*UnaryExpr)
		if !ok {
			return false
		}
		return EqualsRefOfUnaryExpr(a, b)
	case *Union:
		b, ok := inB.(*Union)
		if !ok {
			return false
		}
		return EqualsRefOfUnion(a, b)
	case *UnlockTables:
		b, ok := inB.(*UnlockTables)
		if !ok {
			return false
		}
		return EqualsRefOfUnlockTables(a, b)
	case *Update:
		b, ok := inB.(*Update)
		if !ok {
			return false
		}
		return EqualsRefOfUpdate(a, b)
	case *UpdateExpr:
		b, ok := inB.(*UpdateExpr)
		if !ok {
			return false
		}
		return EqualsRefOfUpdateExpr(a, b)
	case UpdateExprs:
		b, ok := inB.(UpdateExprs)
		if !ok {
			return false
		}
		return EqualsUpdateExprs(a, b)
	case *Use:
		b, ok := inB.(*Use)
		if !ok {
			return false
		}
		return EqualsRefOfUse(a, b)
	case *VStream:
		b, ok := inB.(*VStream)
		if !ok {
			return false
		}
		return EqualsRefOfVStream(a, b)
	case ValTuple:
		b, ok := inB.(ValTuple)
		if !ok {
			return false
		}
		return EqualsValTuple(a, b)
	case *Validation:
		b, ok := inB.(*Validation)
		if !ok {
			return false
		}
		return EqualsRefOfValidation(a, b)
	case Values:
		b, ok := inB.(Values)
		if !ok {
			return false
		}
		return EqualsValues(a, b)
	case *ValuesFuncExpr:
		b, ok := inB.(*ValuesFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfValuesFuncExpr(a, b)
	case VindexParam:
		b, ok := inB.(VindexParam)
		if !ok {
			return false
		}
		return EqualsVindexParam(a, b)
	case *VindexSpec:
		b, ok := inB.(*VindexSpec)
		if !ok {
			return false
		}
		return EqualsRefOfVindexSpec(a, b)
	case *When:
		b, ok := inB.(*When)
		if !ok {
			return false
		}
		return EqualsRefOfWhen(a, b)
	case *Where:
		b, ok := inB.(*Where)
		if !ok {
			return false
		}
		return EqualsRefOfWhere(a, b)
	case *With:
		b, ok := inB.(*With)
		if !ok {
			return false
		}
		return EqualsRefOfWith(a, b)
	case *XorExpr:
		b, ok := inB.(*XorExpr)
		if !ok {
			return false
		}
		return EqualsRefOfXorExpr(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsRefOfAddColumns does deep equals between the two objects.
func EqualsRefOfAddColumns(a, b *AddColumns) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.First == b.First &&
		EqualsSliceOfRefOfColumnDefinition(a.Columns, b.Columns) &&
		EqualsRefOfColName(a.After, b.After)
}

// EqualsRefOfAddConstraintDefinition does deep equals between the two objects.
func EqualsRefOfAddConstraintDefinition(a, b *AddConstraintDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfConstraintDefinition(a.ConstraintDefinition, b.ConstraintDefinition)
}

// EqualsRefOfAddIndexDefinition does deep equals between the two objects.
func EqualsRefOfAddIndexDefinition(a, b *AddIndexDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfIndexDefinition(a.IndexDefinition, b.IndexDefinition)
}

// EqualsRefOfAliasedExpr does deep equals between the two objects.
func EqualsRefOfAliasedExpr(a, b *AliasedExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr) &&
		EqualsColIdent(a.As, b.As)
}

// EqualsRefOfAliasedTableExpr does deep equals between the two objects.
func EqualsRefOfAliasedTableExpr(a, b *AliasedTableExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSimpleTableExpr(a.Expr, b.Expr) &&
		EqualsPartitions(a.Partitions, b.Partitions) &&
		EqualsTableIdent(a.As, b.As) &&
		EqualsRefOfIndexHints(a.Hints, b.Hints) &&
		EqualsColumns(a.Columns, b.Columns)
}

// EqualsRefOfAlterCharset does deep equals between the two objects.
func EqualsRefOfAlterCharset(a, b *AlterCharset) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.CharacterSet == b.CharacterSet &&
		a.Collate == b.Collate
}

// EqualsRefOfAlterColumn does deep equals between the two objects.
func EqualsRefOfAlterColumn(a, b *AlterColumn) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.DropDefault == b.DropDefault &&
		EqualsRefOfColName(a.Column, b.Column) &&
		EqualsExpr(a.DefaultVal, b.DefaultVal)
}

// EqualsRefOfAlterDatabase does deep equals between the two objects.
func EqualsRefOfAlterDatabase(a, b *AlterDatabase) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.UpdateDataDirectory == b.UpdateDataDirectory &&
		a.FullyParsed == b.FullyParsed &&
		EqualsTableIdent(a.DBName, b.DBName) &&
		EqualsSliceOfCollateAndCharset(a.AlterOptions, b.AlterOptions)
}

// EqualsRefOfAlterMigration does deep equals between the two objects.
func EqualsRefOfAlterMigration(a, b *AlterMigration) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.UUID == b.UUID &&
		a.Type == b.Type
}

// EqualsRefOfAlterTable does deep equals between the two objects.
func EqualsRefOfAlterTable(a, b *AlterTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.FullyParsed == b.FullyParsed &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsSliceOfAlterOption(a.AlterOptions, b.AlterOptions) &&
		EqualsRefOfPartitionSpec(a.PartitionSpec, b.PartitionSpec) &&
		EqualsComments(a.Comments, b.Comments)
}

// EqualsRefOfAlterView does deep equals between the two objects.
func EqualsRefOfAlterView(a, b *AlterView) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Algorithm == b.Algorithm &&
		a.Definer == b.Definer &&
		a.Security == b.Security &&
		a.CheckOption == b.CheckOption &&
		EqualsTableName(a.ViewName, b.ViewName) &&
		EqualsColumns(a.Columns, b.Columns) &&
		EqualsSelectStatement(a.Select, b.Select)
}

// EqualsRefOfAlterVschema does deep equals between the two objects.
func EqualsRefOfAlterVschema(a, b *AlterVschema) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Action == b.Action &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsRefOfVindexSpec(a.VindexSpec, b.VindexSpec) &&
		EqualsSliceOfColIdent(a.VindexCols, b.VindexCols) &&
		EqualsRefOfAutoIncSpec(a.AutoIncSpec, b.AutoIncSpec)
}

// EqualsRefOfAndExpr does deep equals between the two objects.
func EqualsRefOfAndExpr(a, b *AndExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.Right, b.Right)
}

// EqualsRefOfAutoIncSpec does deep equals between the two objects.
func EqualsRefOfAutoIncSpec(a, b *AutoIncSpec) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Column, b.Column) &&
		EqualsTableName(a.Sequence, b.Sequence)
}

// EqualsRefOfBegin does deep equals between the two objects.
func EqualsRefOfBegin(a, b *Begin) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfBetweenExpr does deep equals between the two objects.
func EqualsRefOfBetweenExpr(a, b *BetweenExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IsBetween == b.IsBetween &&
		EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.From, b.From) &&
		EqualsExpr(a.To, b.To)
}

// EqualsRefOfBinaryExpr does deep equals between the two objects.
func EqualsRefOfBinaryExpr(a, b *BinaryExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Operator == b.Operator &&
		EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.Right, b.Right)
}

// EqualsRefOfCallProc does deep equals between the two objects.
func EqualsRefOfCallProc(a, b *CallProc) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.Name, b.Name) &&
		EqualsExprs(a.Params, b.Params)
}

// EqualsRefOfCaseExpr does deep equals between the two objects.
func EqualsRefOfCaseExpr(a, b *CaseExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr) &&
		EqualsSliceOfRefOfWhen(a.Whens, b.Whens) &&
		EqualsExpr(a.Else, b.Else)
}

// EqualsRefOfChangeColumn does deep equals between the two objects.
func EqualsRefOfChangeColumn(a, b *ChangeColumn) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.First == b.First &&
		EqualsRefOfColName(a.OldColumn, b.OldColumn) &&
		EqualsRefOfColumnDefinition(a.NewColDefinition, b.NewColDefinition) &&
		EqualsRefOfColName(a.After, b.After)
}

// EqualsRefOfCheckConstraintDefinition does deep equals between the two objects.
func EqualsRefOfCheckConstraintDefinition(a, b *CheckConstraintDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Enforced == b.Enforced &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsColIdent does deep equals between the two objects.
func EqualsColIdent(a, b ColIdent) bool {
	return a.val == b.val &&
		a.lowered == b.lowered &&
		a.at == b.at
}

// EqualsRefOfColName does deep equals between the two objects.
func EqualsRefOfColName(a, b *ColName) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name) &&
		EqualsTableName(a.Qualifier, b.Qualifier)
}

// EqualsRefOfCollateExpr does deep equals between the two objects.
func EqualsRefOfCollateExpr(a, b *CollateExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Collation == b.Collation &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfColumnDefinition does deep equals between the two objects.
func EqualsRefOfColumnDefinition(a, b *ColumnDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name) &&
		EqualsColumnType(a.Type, b.Type)
}

// EqualsRefOfColumnType does deep equals between the two objects.
func EqualsRefOfColumnType(a, b *ColumnType) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		a.Unsigned == b.Unsigned &&
		a.Zerofill == b.Zerofill &&
		a.Charset == b.Charset &&
		EqualsRefOfColumnTypeOptions(a.Options, b.Options) &&
		EqualsRefOfLiteral(a.Length, b.Length) &&
		EqualsRefOfLiteral(a.Scale, b.Scale) &&
		EqualsSliceOfString(a.EnumValues, b.EnumValues)
}

// EqualsColumns does deep equals between the two objects.
func EqualsColumns(a, b Columns) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsColIdent(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsComments does deep equals between the two objects.
func EqualsComments(a, b Comments) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

// EqualsRefOfCommit does deep equals between the two objects.
func EqualsRefOfCommit(a, b *Commit) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfCommonTableExpr does deep equals between the two objects.
func EqualsRefOfCommonTableExpr(a, b *CommonTableExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableIdent(a.TableID, b.TableID) &&
		EqualsColumns(a.Columns, b.Columns) &&
		EqualsRefOfSubquery(a.Subquery, b.Subquery)
}

// EqualsRefOfComparisonExpr does deep equals between the two objects.
func EqualsRefOfComparisonExpr(a, b *ComparisonExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Operator == b.Operator &&
		EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.Right, b.Right) &&
		EqualsExpr(a.Escape, b.Escape)
}

// EqualsRefOfConstraintDefinition does deep equals between the two objects.
func EqualsRefOfConstraintDefinition(a, b *ConstraintDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name) &&
		EqualsConstraintInfo(a.Details, b.Details)
}

// EqualsRefOfConvertExpr does deep equals between the two objects.
func EqualsRefOfConvertExpr(a, b *ConvertExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr) &&
		EqualsRefOfConvertType(a.Type, b.Type)
}

// EqualsRefOfConvertType does deep equals between the two objects.
func EqualsRefOfConvertType(a, b *ConvertType) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		a.Charset == b.Charset &&
		EqualsRefOfLiteral(a.Length, b.Length) &&
		EqualsRefOfLiteral(a.Scale, b.Scale) &&
		a.Operator == b.Operator
}

// EqualsRefOfConvertUsingExpr does deep equals between the two objects.
func EqualsRefOfConvertUsingExpr(a, b *ConvertUsingExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfCreateDatabase does deep equals between the two objects.
func EqualsRefOfCreateDatabase(a, b *CreateDatabase) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IfNotExists == b.IfNotExists &&
		a.FullyParsed == b.FullyParsed &&
		EqualsComments(a.Comments, b.Comments) &&
		EqualsTableIdent(a.DBName, b.DBName) &&
		EqualsSliceOfCollateAndCharset(a.CreateOptions, b.CreateOptions)
}

// EqualsRefOfCreateTable does deep equals between the two objects.
func EqualsRefOfCreateTable(a, b *CreateTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Temp == b.Temp &&
		a.IfNotExists == b.IfNotExists &&
		a.FullyParsed == b.FullyParsed &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsRefOfTableSpec(a.TableSpec, b.TableSpec) &&
		EqualsRefOfOptLike(a.OptLike, b.OptLike) &&
		EqualsComments(a.Comments, b.Comments)
}

// EqualsRefOfCreateView does deep equals between the two objects.
func EqualsRefOfCreateView(a, b *CreateView) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Algorithm == b.Algorithm &&
		a.Definer == b.Definer &&
		a.Security == b.Security &&
		a.CheckOption == b.CheckOption &&
		a.IsReplace == b.IsReplace &&
		EqualsTableName(a.ViewName, b.ViewName) &&
		EqualsColumns(a.Columns, b.Columns) &&
		EqualsSelectStatement(a.Select, b.Select)
}

// EqualsRefOfCurTimeFuncExpr does deep equals between the two objects.
func EqualsRefOfCurTimeFuncExpr(a, b *CurTimeFuncExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name) &&
		EqualsExpr(a.Fsp, b.Fsp)
}

// EqualsRefOfDefault does deep equals between the two objects.
func EqualsRefOfDefault(a, b *Default) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.ColName == b.ColName
}

// EqualsRefOfDelete does deep equals between the two objects.
func EqualsRefOfDelete(a, b *Delete) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfWith(a.With, b.With) &&
		a.Ignore == b.Ignore &&
		EqualsComments(a.Comments, b.Comments) &&
		EqualsTableNames(a.Targets, b.Targets) &&
		EqualsTableExprs(a.TableExprs, b.TableExprs) &&
		EqualsPartitions(a.Partitions, b.Partitions) &&
		EqualsRefOfWhere(a.Where, b.Where) &&
		EqualsOrderBy(a.OrderBy, b.OrderBy) &&
		EqualsRefOfLimit(a.Limit, b.Limit)
}

// EqualsRefOfDerivedTable does deep equals between the two objects.
func EqualsRefOfDerivedTable(a, b *DerivedTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSelectStatement(a.Select, b.Select)
}

// EqualsRefOfDropColumn does deep equals between the two objects.
func EqualsRefOfDropColumn(a, b *DropColumn) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfColName(a.Name, b.Name)
}

// EqualsRefOfDropDatabase does deep equals between the two objects.
func EqualsRefOfDropDatabase(a, b *DropDatabase) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IfExists == b.IfExists &&
		EqualsComments(a.Comments, b.Comments) &&
		EqualsTableIdent(a.DBName, b.DBName)
}

// EqualsRefOfDropKey does deep equals between the two objects.
func EqualsRefOfDropKey(a, b *DropKey) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		EqualsColIdent(a.Name, b.Name)
}

// EqualsRefOfDropTable does deep equals between the two objects.
func EqualsRefOfDropTable(a, b *DropTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Temp == b.Temp &&
		a.IfExists == b.IfExists &&
		EqualsTableNames(a.FromTables, b.FromTables) &&
		EqualsComments(a.Comments, b.Comments)
}

// EqualsRefOfDropView does deep equals between the two objects.
func EqualsRefOfDropView(a, b *DropView) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IfExists == b.IfExists &&
		EqualsTableNames(a.FromTables, b.FromTables)
}

// EqualsRefOfExistsExpr does deep equals between the two objects.
func EqualsRefOfExistsExpr(a, b *ExistsExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfSubquery(a.Subquery, b.Subquery)
}

// EqualsRefOfExplainStmt does deep equals between the two objects.
func EqualsRefOfExplainStmt(a, b *ExplainStmt) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		EqualsStatement(a.Statement, b.Statement)
}

// EqualsRefOfExplainTab does deep equals between the two objects.
func EqualsRefOfExplainTab(a, b *ExplainTab) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Wild == b.Wild &&
		EqualsTableName(a.Table, b.Table)
}

// EqualsRefOfExprOrColumns does deep equals between the two objects.
func EqualsRefOfExprOrColumns(a, b *ExprOrColumns) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr) &&
		EqualsColumns(a.ColumnList, b.ColumnList)
}

// EqualsExprs does deep equals between the two objects.
func EqualsExprs(a, b Exprs) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfExtractFuncExpr does deep equals between the two objects.
func EqualsRefOfExtractFuncExpr(a, b *ExtractFuncExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IntervalTypes == b.IntervalTypes &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfExtractedSubquery does deep equals between the two objects.
func EqualsRefOfExtractedSubquery(a, b *ExtractedSubquery) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.OpCode == b.OpCode &&
		a.NeedsRewrite == b.NeedsRewrite &&
		a.hasValuesArg == b.hasValuesArg &&
		a.argName == b.argName &&
		EqualsExpr(a.Original, b.Original) &&
		EqualsRefOfSubquery(a.Subquery, b.Subquery) &&
		EqualsExpr(a.OtherSide, b.OtherSide) &&
		EqualsExpr(a.alternative, b.alternative)
}

// EqualsRefOfFlush does deep equals between the two objects.
func EqualsRefOfFlush(a, b *Flush) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IsLocal == b.IsLocal &&
		a.WithLock == b.WithLock &&
		a.ForExport == b.ForExport &&
		EqualsSliceOfString(a.FlushOptions, b.FlushOptions) &&
		EqualsTableNames(a.TableNames, b.TableNames)
}

// EqualsRefOfForce does deep equals between the two objects.
func EqualsRefOfForce(a, b *Force) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfForeignKeyDefinition does deep equals between the two objects.
func EqualsRefOfForeignKeyDefinition(a, b *ForeignKeyDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColumns(a.Source, b.Source) &&
		EqualsColIdent(a.IndexName, b.IndexName) &&
		EqualsRefOfReferenceDefinition(a.ReferenceDefinition, b.ReferenceDefinition)
}

// EqualsRefOfFuncExpr does deep equals between the two objects.
func EqualsRefOfFuncExpr(a, b *FuncExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Distinct == b.Distinct &&
		EqualsTableIdent(a.Qualifier, b.Qualifier) &&
		EqualsColIdent(a.Name, b.Name) &&
		EqualsSelectExprs(a.Exprs, b.Exprs)
}

// EqualsGroupBy does deep equals between the two objects.
func EqualsGroupBy(a, b GroupBy) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfGroupConcatExpr does deep equals between the two objects.
func EqualsRefOfGroupConcatExpr(a, b *GroupConcatExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Distinct == b.Distinct &&
		a.Separator == b.Separator &&
		EqualsSelectExprs(a.Exprs, b.Exprs) &&
		EqualsOrderBy(a.OrderBy, b.OrderBy) &&
		EqualsRefOfLimit(a.Limit, b.Limit)
}

// EqualsRefOfIndexDefinition does deep equals between the two objects.
func EqualsRefOfIndexDefinition(a, b *IndexDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfIndexInfo(a.Info, b.Info) &&
		EqualsSliceOfRefOfIndexColumn(a.Columns, b.Columns) &&
		EqualsSliceOfRefOfIndexOption(a.Options, b.Options)
}

// EqualsRefOfIndexHints does deep equals between the two objects.
func EqualsRefOfIndexHints(a, b *IndexHints) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		EqualsSliceOfColIdent(a.Indexes, b.Indexes)
}

// EqualsRefOfIndexInfo does deep equals between the two objects.
func EqualsRefOfIndexInfo(a, b *IndexInfo) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		a.Primary == b.Primary &&
		a.Spatial == b.Spatial &&
		a.Fulltext == b.Fulltext &&
		a.Unique == b.Unique &&
		EqualsColIdent(a.Name, b.Name) &&
		EqualsColIdent(a.ConstraintName, b.ConstraintName)
}

// EqualsRefOfInsert does deep equals between the two objects.
func EqualsRefOfInsert(a, b *Insert) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Action == b.Action &&
		EqualsComments(a.Comments, b.Comments) &&
		a.Ignore == b.Ignore &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsPartitions(a.Partitions, b.Partitions) &&
		EqualsColumns(a.Columns, b.Columns) &&
		EqualsInsertRows(a.Rows, b.Rows) &&
		EqualsOnDup(a.OnDup, b.OnDup)
}

// EqualsRefOfIntervalExpr does deep equals between the two objects.
func EqualsRefOfIntervalExpr(a, b *IntervalExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Unit == b.Unit &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfIntroducerExpr does deep equals between the two objects.
func EqualsRefOfIntroducerExpr(a, b *IntroducerExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.CharacterSet == b.CharacterSet &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfIsExpr does deep equals between the two objects.
func EqualsRefOfIsExpr(a, b *IsExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Left, b.Left) &&
		a.Right == b.Right
}

// EqualsRefOfJoinCondition does deep equals between the two objects.
func EqualsRefOfJoinCondition(a, b *JoinCondition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.On, b.On) &&
		EqualsColumns(a.Using, b.Using)
}

// EqualsRefOfJoinTableExpr does deep equals between the two objects.
func EqualsRefOfJoinTableExpr(a, b *JoinTableExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableExpr(a.LeftExpr, b.LeftExpr) &&
		a.Join == b.Join &&
		EqualsTableExpr(a.RightExpr, b.RightExpr) &&
		EqualsRefOfJoinCondition(a.Condition, b.Condition)
}

// EqualsRefOfKeyState does deep equals between the two objects.
func EqualsRefOfKeyState(a, b *KeyState) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Enable == b.Enable
}

// EqualsRefOfLimit does deep equals between the two objects.
func EqualsRefOfLimit(a, b *Limit) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Offset, b.Offset) &&
		EqualsExpr(a.Rowcount, b.Rowcount)
}

// EqualsRefOfLiteral does deep equals between the two objects.
func EqualsRefOfLiteral(a, b *Literal) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Val == b.Val &&
		a.Type == b.Type
}

// EqualsRefOfLoad does deep equals between the two objects.
func EqualsRefOfLoad(a, b *Load) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfLockOption does deep equals between the two objects.
func EqualsRefOfLockOption(a, b *LockOption) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type
}

// EqualsRefOfLockTables does deep equals between the two objects.
func EqualsRefOfLockTables(a, b *LockTables) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableAndLockTypes(a.Tables, b.Tables)
}

// EqualsRefOfMatchExpr does deep equals between the two objects.
func EqualsRefOfMatchExpr(a, b *MatchExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSelectExprs(a.Columns, b.Columns) &&
		EqualsExpr(a.Expr, b.Expr) &&
		a.Option == b.Option
}

// EqualsRefOfModifyColumn does deep equals between the two objects.
func EqualsRefOfModifyColumn(a, b *ModifyColumn) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.First == b.First &&
		EqualsRefOfColumnDefinition(a.NewColDefinition, b.NewColDefinition) &&
		EqualsRefOfColName(a.After, b.After)
}

// EqualsRefOfNextval does deep equals between the two objects.
func EqualsRefOfNextval(a, b *Nextval) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfNotExpr does deep equals between the two objects.
func EqualsRefOfNotExpr(a, b *NotExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfNullVal does deep equals between the two objects.
func EqualsRefOfNullVal(a, b *NullVal) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsOnDup does deep equals between the two objects.
func EqualsOnDup(a, b OnDup) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfUpdateExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfOptLike does deep equals between the two objects.
func EqualsRefOfOptLike(a, b *OptLike) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.LikeTable, b.LikeTable)
}

// EqualsRefOfOrExpr does deep equals between the two objects.
func EqualsRefOfOrExpr(a, b *OrExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.Right, b.Right)
}

// EqualsRefOfOrder does deep equals between the two objects.
func EqualsRefOfOrder(a, b *Order) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Expr, b.Expr) &&
		a.Direction == b.Direction
}

// EqualsOrderBy does deep equals between the two objects.
func EqualsOrderBy(a, b OrderBy) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfOrder(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfOrderByOption does deep equals between the two objects.
func EqualsRefOfOrderByOption(a, b *OrderByOption) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColumns(a.Cols, b.Cols)
}

// EqualsRefOfOtherAdmin does deep equals between the two objects.
func EqualsRefOfOtherAdmin(a, b *OtherAdmin) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfOtherRead does deep equals between the two objects.
func EqualsRefOfOtherRead(a, b *OtherRead) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfParenTableExpr does deep equals between the two objects.
func EqualsRefOfParenTableExpr(a, b *ParenTableExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableExprs(a.Exprs, b.Exprs)
}

// EqualsRefOfPartitionDefinition does deep equals between the two objects.
func EqualsRefOfPartitionDefinition(a, b *PartitionDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Maxvalue == b.Maxvalue &&
		EqualsColIdent(a.Name, b.Name) &&
		EqualsExpr(a.Limit, b.Limit)
}

// EqualsRefOfPartitionOption does deep equals between the two objects.
func EqualsRefOfPartitionOption(a, b *PartitionOption) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Linear == b.Linear &&
		a.isHASH == b.isHASH &&
		a.isKEY == b.isKEY &&
		a.KeyAlgorithm == b.KeyAlgorithm &&
		a.RangeOrList == b.RangeOrList &&
		a.Partitions == b.Partitions &&
		EqualsColumns(a.KeyColList, b.KeyColList) &&
		EqualsRefOfExprOrColumns(a.ExprOrCol, b.ExprOrCol) &&
		EqualsExpr(a.Expr, b.Expr) &&
		EqualsRefOfSubPartition(a.SubPartition, b.SubPartition) &&
		EqualsSliceOfRefOfPartitionDefinition(a.Definitions, b.Definitions)
}

// EqualsRefOfPartitionSpec does deep equals between the two objects.
func EqualsRefOfPartitionSpec(a, b *PartitionSpec) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IsAll == b.IsAll &&
		a.WithoutValidation == b.WithoutValidation &&
		a.Action == b.Action &&
		EqualsPartitions(a.Names, b.Names) &&
		EqualsRefOfLiteral(a.Number, b.Number) &&
		EqualsTableName(a.TableName, b.TableName) &&
		EqualsSliceOfRefOfPartitionDefinition(a.Definitions, b.Definitions)
}

// EqualsPartitions does deep equals between the two objects.
func EqualsPartitions(a, b Partitions) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsColIdent(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfReferenceDefinition does deep equals between the two objects.
func EqualsRefOfReferenceDefinition(a, b *ReferenceDefinition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.ReferencedTable, b.ReferencedTable) &&
		EqualsColumns(a.ReferencedColumns, b.ReferencedColumns) &&
		a.OnDelete == b.OnDelete &&
		a.OnUpdate == b.OnUpdate
}

// EqualsRefOfRelease does deep equals between the two objects.
func EqualsRefOfRelease(a, b *Release) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name)
}

// EqualsRefOfRenameIndex does deep equals between the two objects.
func EqualsRefOfRenameIndex(a, b *RenameIndex) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.OldName, b.OldName) &&
		EqualsColIdent(a.NewName, b.NewName)
}

// EqualsRefOfRenameTable does deep equals between the two objects.
func EqualsRefOfRenameTable(a, b *RenameTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSliceOfRefOfRenameTablePair(a.TablePairs, b.TablePairs)
}

// EqualsRefOfRenameTableName does deep equals between the two objects.
func EqualsRefOfRenameTableName(a, b *RenameTableName) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.Table, b.Table)
}

// EqualsRefOfRevertMigration does deep equals between the two objects.
func EqualsRefOfRevertMigration(a, b *RevertMigration) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.UUID == b.UUID &&
		EqualsComments(a.Comments, b.Comments)
}

// EqualsRefOfRollback does deep equals between the two objects.
func EqualsRefOfRollback(a, b *Rollback) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRootNode does deep equals between the two objects.
func EqualsRootNode(a, b RootNode) bool {
	return EqualsSQLNode(a.SQLNode, b.SQLNode)
}

// EqualsRefOfSRollback does deep equals between the two objects.
func EqualsRefOfSRollback(a, b *SRollback) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name)
}

// EqualsRefOfSavepoint does deep equals between the two objects.
func EqualsRefOfSavepoint(a, b *Savepoint) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name)
}

// EqualsRefOfSelect does deep equals between the two objects.
func EqualsRefOfSelect(a, b *Select) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Distinct == b.Distinct &&
		a.StraightJoinHint == b.StraightJoinHint &&
		a.SQLCalcFoundRows == b.SQLCalcFoundRows &&
		EqualsRefOfBool(a.Cache, b.Cache) &&
		EqualsSliceOfTableExpr(a.From, b.From) &&
		EqualsComments(a.Comments, b.Comments) &&
		EqualsSelectExprs(a.SelectExprs, b.SelectExprs) &&
		EqualsRefOfWhere(a.Where, b.Where) &&
		EqualsRefOfWith(a.With, b.With) &&
		EqualsGroupBy(a.GroupBy, b.GroupBy) &&
		EqualsRefOfWhere(a.Having, b.Having) &&
		EqualsOrderBy(a.OrderBy, b.OrderBy) &&
		EqualsRefOfLimit(a.Limit, b.Limit) &&
		a.Lock == b.Lock &&
		EqualsRefOfSelectInto(a.Into, b.Into)
}

// EqualsSelectExprs does deep equals between the two objects.
func EqualsSelectExprs(a, b SelectExprs) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsSelectExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfSelectInto does deep equals between the two objects.
func EqualsRefOfSelectInto(a, b *SelectInto) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.FileName == b.FileName &&
		a.Charset == b.Charset &&
		a.FormatOption == b.FormatOption &&
		a.ExportOption == b.ExportOption &&
		a.Manifest == b.Manifest &&
		a.Overwrite == b.Overwrite &&
		a.Type == b.Type
}

// EqualsRefOfSet does deep equals between the two objects.
func EqualsRefOfSet(a, b *Set) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsComments(a.Comments, b.Comments) &&
		EqualsSetExprs(a.Exprs, b.Exprs)
}

// EqualsRefOfSetExpr does deep equals between the two objects.
func EqualsRefOfSetExpr(a, b *SetExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Scope == b.Scope &&
		EqualsColIdent(a.Name, b.Name) &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsSetExprs does deep equals between the two objects.
func EqualsSetExprs(a, b SetExprs) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfSetExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfSetTransaction does deep equals between the two objects.
func EqualsRefOfSetTransaction(a, b *SetTransaction) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSQLNode(a.SQLNode, b.SQLNode) &&
		EqualsComments(a.Comments, b.Comments) &&
		a.Scope == b.Scope &&
		EqualsSliceOfCharacteristic(a.Characteristics, b.Characteristics)
}

// EqualsRefOfShow does deep equals between the two objects.
func EqualsRefOfShow(a, b *Show) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsShowInternal(a.Internal, b.Internal)
}

// EqualsRefOfShowBasic does deep equals between the two objects.
func EqualsRefOfShowBasic(a, b *ShowBasic) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Full == b.Full &&
		a.Command == b.Command &&
		EqualsTableName(a.Tbl, b.Tbl) &&
		EqualsTableIdent(a.DbName, b.DbName) &&
		EqualsRefOfShowFilter(a.Filter, b.Filter)
}

// EqualsRefOfShowCreate does deep equals between the two objects.
func EqualsRefOfShowCreate(a, b *ShowCreate) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Command == b.Command &&
		EqualsTableName(a.Op, b.Op)
}

// EqualsRefOfShowFilter does deep equals between the two objects.
func EqualsRefOfShowFilter(a, b *ShowFilter) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Like == b.Like &&
		EqualsExpr(a.Filter, b.Filter)
}

// EqualsRefOfShowLegacy does deep equals between the two objects.
func EqualsRefOfShowLegacy(a, b *ShowLegacy) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Extended == b.Extended &&
		a.Type == b.Type &&
		EqualsTableName(a.OnTable, b.OnTable) &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsRefOfShowTablesOpt(a.ShowTablesOpt, b.ShowTablesOpt) &&
		a.Scope == b.Scope &&
		EqualsExpr(a.ShowCollationFilterOpt, b.ShowCollationFilterOpt)
}

// EqualsRefOfShowMigrationLogs does deep equals between the two objects.
func EqualsRefOfShowMigrationLogs(a, b *ShowMigrationLogs) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.UUID == b.UUID &&
		EqualsComments(a.Comments, b.Comments)
}

// EqualsRefOfStarExpr does deep equals between the two objects.
func EqualsRefOfStarExpr(a, b *StarExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.TableName, b.TableName)
}

// EqualsRefOfStream does deep equals between the two objects.
func EqualsRefOfStream(a, b *Stream) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsComments(a.Comments, b.Comments) &&
		EqualsSelectExpr(a.SelectExpr, b.SelectExpr) &&
		EqualsTableName(a.Table, b.Table)
}

// EqualsRefOfSubPartition does deep equals between the two objects.
func EqualsRefOfSubPartition(a, b *SubPartition) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Linear == b.Linear &&
		a.isHASH == b.isHASH &&
		a.isKEY == b.isKEY &&
		a.KeyAlgorithm == b.KeyAlgorithm &&
		a.SubPartitions == b.SubPartitions &&
		EqualsColumns(a.KeyColList, b.KeyColList) &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfSubquery does deep equals between the two objects.
func EqualsRefOfSubquery(a, b *Subquery) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSelectStatement(a.Select, b.Select)
}

// EqualsRefOfSubstrExpr does deep equals between the two objects.
func EqualsRefOfSubstrExpr(a, b *SubstrExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Name, b.Name) &&
		EqualsExpr(a.From, b.From) &&
		EqualsExpr(a.To, b.To)
}

// EqualsTableExprs does deep equals between the two objects.
func EqualsTableExprs(a, b TableExprs) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsTableExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsTableIdent does deep equals between the two objects.
func EqualsTableIdent(a, b TableIdent) bool {
	return a.v == b.v
}

// EqualsTableName does deep equals between the two objects.
func EqualsTableName(a, b TableName) bool {
	return EqualsTableIdent(a.Name, b.Name) &&
		EqualsTableIdent(a.Qualifier, b.Qualifier)
}

// EqualsTableNames does deep equals between the two objects.
func EqualsTableNames(a, b TableNames) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsTableName(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsTableOptions does deep equals between the two objects.
func EqualsTableOptions(a, b TableOptions) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfTableOption(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfTableSpec does deep equals between the two objects.
func EqualsRefOfTableSpec(a, b *TableSpec) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSliceOfRefOfColumnDefinition(a.Columns, b.Columns) &&
		EqualsSliceOfRefOfIndexDefinition(a.Indexes, b.Indexes) &&
		EqualsSliceOfRefOfConstraintDefinition(a.Constraints, b.Constraints) &&
		EqualsTableOptions(a.Options, b.Options) &&
		EqualsRefOfPartitionOption(a.PartitionOption, b.PartitionOption)
}

// EqualsRefOfTablespaceOperation does deep equals between the two objects.
func EqualsRefOfTablespaceOperation(a, b *TablespaceOperation) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Import == b.Import
}

// EqualsRefOfTimestampFuncExpr does deep equals between the two objects.
func EqualsRefOfTimestampFuncExpr(a, b *TimestampFuncExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Name == b.Name &&
		a.Unit == b.Unit &&
		EqualsExpr(a.Expr1, b.Expr1) &&
		EqualsExpr(a.Expr2, b.Expr2)
}

// EqualsRefOfTruncateTable does deep equals between the two objects.
func EqualsRefOfTruncateTable(a, b *TruncateTable) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.Table, b.Table)
}

// EqualsRefOfUnaryExpr does deep equals between the two objects.
func EqualsRefOfUnaryExpr(a, b *UnaryExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Operator == b.Operator &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfUnion does deep equals between the two objects.
func EqualsRefOfUnion(a, b *Union) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Distinct == b.Distinct &&
		EqualsSelectStatement(a.Left, b.Left) &&
		EqualsSelectStatement(a.Right, b.Right) &&
		EqualsOrderBy(a.OrderBy, b.OrderBy) &&
		EqualsRefOfWith(a.With, b.With) &&
		EqualsRefOfLimit(a.Limit, b.Limit) &&
		a.Lock == b.Lock &&
		EqualsRefOfSelectInto(a.Into, b.Into)
}

// EqualsRefOfUnlockTables does deep equals between the two objects.
func EqualsRefOfUnlockTables(a, b *UnlockTables) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return true
}

// EqualsRefOfUpdate does deep equals between the two objects.
func EqualsRefOfUpdate(a, b *Update) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfWith(a.With, b.With) &&
		EqualsComments(a.Comments, b.Comments) &&
		a.Ignore == b.Ignore &&
		EqualsTableExprs(a.TableExprs, b.TableExprs) &&
		EqualsUpdateExprs(a.Exprs, b.Exprs) &&
		EqualsRefOfWhere(a.Where, b.Where) &&
		EqualsOrderBy(a.OrderBy, b.OrderBy) &&
		EqualsRefOfLimit(a.Limit, b.Limit)
}

// EqualsRefOfUpdateExpr does deep equals between the two objects.
func EqualsRefOfUpdateExpr(a, b *UpdateExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfColName(a.Name, b.Name) &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsUpdateExprs does deep equals between the two objects.
func EqualsUpdateExprs(a, b UpdateExprs) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfUpdateExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfUse does deep equals between the two objects.
func EqualsRefOfUse(a, b *Use) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableIdent(a.DBName, b.DBName)
}

// EqualsRefOfVStream does deep equals between the two objects.
func EqualsRefOfVStream(a, b *VStream) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsComments(a.Comments, b.Comments) &&
		EqualsSelectExpr(a.SelectExpr, b.SelectExpr) &&
		EqualsTableName(a.Table, b.Table) &&
		EqualsRefOfWhere(a.Where, b.Where) &&
		EqualsRefOfLimit(a.Limit, b.Limit)
}

// EqualsValTuple does deep equals between the two objects.
func EqualsValTuple(a, b ValTuple) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfValidation does deep equals between the two objects.
func EqualsRefOfValidation(a, b *Validation) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.With == b.With
}

// EqualsValues does deep equals between the two objects.
func EqualsValues(a, b Values) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsValTuple(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfValuesFuncExpr does deep equals between the two objects.
func EqualsRefOfValuesFuncExpr(a, b *ValuesFuncExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsRefOfColName(a.Name, b.Name)
}

// EqualsVindexParam does deep equals between the two objects.
func EqualsVindexParam(a, b VindexParam) bool {
	return a.Val == b.Val &&
		EqualsColIdent(a.Key, b.Key)
}

// EqualsRefOfVindexSpec does deep equals between the two objects.
func EqualsRefOfVindexSpec(a, b *VindexSpec) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Name, b.Name) &&
		EqualsColIdent(a.Type, b.Type) &&
		EqualsSliceOfVindexParam(a.Params, b.Params)
}

// EqualsRefOfWhen does deep equals between the two objects.
func EqualsRefOfWhen(a, b *When) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Cond, b.Cond) &&
		EqualsExpr(a.Val, b.Val)
}

// EqualsRefOfWhere does deep equals between the two objects.
func EqualsRefOfWhere(a, b *Where) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Type == b.Type &&
		EqualsExpr(a.Expr, b.Expr)
}

// EqualsRefOfWith does deep equals between the two objects.
func EqualsRefOfWith(a, b *With) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Recursive == b.Recursive &&
		EqualsSliceOfRefOfCommonTableExpr(a.ctes, b.ctes)
}

// EqualsRefOfXorExpr does deep equals between the two objects.
func EqualsRefOfXorExpr(a, b *XorExpr) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsExpr(a.Left, b.Left) &&
		EqualsExpr(a.Right, b.Right)
}

// EqualsAlterOption does deep equals between the two objects.
func EqualsAlterOption(inA, inB AlterOption) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AddColumns:
		b, ok := inB.(*AddColumns)
		if !ok {
			return false
		}
		return EqualsRefOfAddColumns(a, b)
	case *AddConstraintDefinition:
		b, ok := inB.(*AddConstraintDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfAddConstraintDefinition(a, b)
	case *AddIndexDefinition:
		b, ok := inB.(*AddIndexDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfAddIndexDefinition(a, b)
	case AlgorithmValue:
		b, ok := inB.(AlgorithmValue)
		if !ok {
			return false
		}
		return a == b
	case *AlterCharset:
		b, ok := inB.(*AlterCharset)
		if !ok {
			return false
		}
		return EqualsRefOfAlterCharset(a, b)
	case *AlterColumn:
		b, ok := inB.(*AlterColumn)
		if !ok {
			return false
		}
		return EqualsRefOfAlterColumn(a, b)
	case *ChangeColumn:
		b, ok := inB.(*ChangeColumn)
		if !ok {
			return false
		}
		return EqualsRefOfChangeColumn(a, b)
	case *DropColumn:
		b, ok := inB.(*DropColumn)
		if !ok {
			return false
		}
		return EqualsRefOfDropColumn(a, b)
	case *DropKey:
		b, ok := inB.(*DropKey)
		if !ok {
			return false
		}
		return EqualsRefOfDropKey(a, b)
	case *Force:
		b, ok := inB.(*Force)
		if !ok {
			return false
		}
		return EqualsRefOfForce(a, b)
	case *KeyState:
		b, ok := inB.(*KeyState)
		if !ok {
			return false
		}
		return EqualsRefOfKeyState(a, b)
	case *LockOption:
		b, ok := inB.(*LockOption)
		if !ok {
			return false
		}
		return EqualsRefOfLockOption(a, b)
	case *ModifyColumn:
		b, ok := inB.(*ModifyColumn)
		if !ok {
			return false
		}
		return EqualsRefOfModifyColumn(a, b)
	case *OrderByOption:
		b, ok := inB.(*OrderByOption)
		if !ok {
			return false
		}
		return EqualsRefOfOrderByOption(a, b)
	case *RenameIndex:
		b, ok := inB.(*RenameIndex)
		if !ok {
			return false
		}
		return EqualsRefOfRenameIndex(a, b)
	case *RenameTableName:
		b, ok := inB.(*RenameTableName)
		if !ok {
			return false
		}
		return EqualsRefOfRenameTableName(a, b)
	case TableOptions:
		b, ok := inB.(TableOptions)
		if !ok {
			return false
		}
		return EqualsTableOptions(a, b)
	case *TablespaceOperation:
		b, ok := inB.(*TablespaceOperation)
		if !ok {
			return false
		}
		return EqualsRefOfTablespaceOperation(a, b)
	case *Validation:
		b, ok := inB.(*Validation)
		if !ok {
			return false
		}
		return EqualsRefOfValidation(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsCharacteristic does deep equals between the two objects.
func EqualsCharacteristic(inA, inB Characteristic) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case AccessMode:
		b, ok := inB.(AccessMode)
		if !ok {
			return false
		}
		return a == b
	case IsolationLevel:
		b, ok := inB.(IsolationLevel)
		if !ok {
			return false
		}
		return a == b
	default:
		// this should never happen
		return false
	}
}

// EqualsColTuple does deep equals between the two objects.
func EqualsColTuple(inA, inB ColTuple) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case ListArg:
		b, ok := inB.(ListArg)
		if !ok {
			return false
		}
		return a == b
	case *Subquery:
		b, ok := inB.(*Subquery)
		if !ok {
			return false
		}
		return EqualsRefOfSubquery(a, b)
	case ValTuple:
		b, ok := inB.(ValTuple)
		if !ok {
			return false
		}
		return EqualsValTuple(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsConstraintInfo does deep equals between the two objects.
func EqualsConstraintInfo(inA, inB ConstraintInfo) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *CheckConstraintDefinition:
		b, ok := inB.(*CheckConstraintDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfCheckConstraintDefinition(a, b)
	case *ForeignKeyDefinition:
		b, ok := inB.(*ForeignKeyDefinition)
		if !ok {
			return false
		}
		return EqualsRefOfForeignKeyDefinition(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsDBDDLStatement does deep equals between the two objects.
func EqualsDBDDLStatement(inA, inB DBDDLStatement) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AlterDatabase:
		b, ok := inB.(*AlterDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfAlterDatabase(a, b)
	case *CreateDatabase:
		b, ok := inB.(*CreateDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfCreateDatabase(a, b)
	case *DropDatabase:
		b, ok := inB.(*DropDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfDropDatabase(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsDDLStatement does deep equals between the two objects.
func EqualsDDLStatement(inA, inB DDLStatement) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AlterTable:
		b, ok := inB.(*AlterTable)
		if !ok {
			return false
		}
		return EqualsRefOfAlterTable(a, b)
	case *AlterView:
		b, ok := inB.(*AlterView)
		if !ok {
			return false
		}
		return EqualsRefOfAlterView(a, b)
	case *CreateTable:
		b, ok := inB.(*CreateTable)
		if !ok {
			return false
		}
		return EqualsRefOfCreateTable(a, b)
	case *CreateView:
		b, ok := inB.(*CreateView)
		if !ok {
			return false
		}
		return EqualsRefOfCreateView(a, b)
	case *DropTable:
		b, ok := inB.(*DropTable)
		if !ok {
			return false
		}
		return EqualsRefOfDropTable(a, b)
	case *DropView:
		b, ok := inB.(*DropView)
		if !ok {
			return false
		}
		return EqualsRefOfDropView(a, b)
	case *RenameTable:
		b, ok := inB.(*RenameTable)
		if !ok {
			return false
		}
		return EqualsRefOfRenameTable(a, b)
	case *TruncateTable:
		b, ok := inB.(*TruncateTable)
		if !ok {
			return false
		}
		return EqualsRefOfTruncateTable(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsExplain does deep equals between the two objects.
func EqualsExplain(inA, inB Explain) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *ExplainStmt:
		b, ok := inB.(*ExplainStmt)
		if !ok {
			return false
		}
		return EqualsRefOfExplainStmt(a, b)
	case *ExplainTab:
		b, ok := inB.(*ExplainTab)
		if !ok {
			return false
		}
		return EqualsRefOfExplainTab(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsExpr does deep equals between the two objects.
func EqualsExpr(inA, inB Expr) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AndExpr:
		b, ok := inB.(*AndExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAndExpr(a, b)
	case Argument:
		b, ok := inB.(Argument)
		if !ok {
			return false
		}
		return a == b
	case *BetweenExpr:
		b, ok := inB.(*BetweenExpr)
		if !ok {
			return false
		}
		return EqualsRefOfBetweenExpr(a, b)
	case *BinaryExpr:
		b, ok := inB.(*BinaryExpr)
		if !ok {
			return false
		}
		return EqualsRefOfBinaryExpr(a, b)
	case BoolVal:
		b, ok := inB.(BoolVal)
		if !ok {
			return false
		}
		return a == b
	case *CaseExpr:
		b, ok := inB.(*CaseExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCaseExpr(a, b)
	case *ColName:
		b, ok := inB.(*ColName)
		if !ok {
			return false
		}
		return EqualsRefOfColName(a, b)
	case *CollateExpr:
		b, ok := inB.(*CollateExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCollateExpr(a, b)
	case *ComparisonExpr:
		b, ok := inB.(*ComparisonExpr)
		if !ok {
			return false
		}
		return EqualsRefOfComparisonExpr(a, b)
	case *ConvertExpr:
		b, ok := inB.(*ConvertExpr)
		if !ok {
			return false
		}
		return EqualsRefOfConvertExpr(a, b)
	case *ConvertUsingExpr:
		b, ok := inB.(*ConvertUsingExpr)
		if !ok {
			return false
		}
		return EqualsRefOfConvertUsingExpr(a, b)
	case *CurTimeFuncExpr:
		b, ok := inB.(*CurTimeFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfCurTimeFuncExpr(a, b)
	case *Default:
		b, ok := inB.(*Default)
		if !ok {
			return false
		}
		return EqualsRefOfDefault(a, b)
	case *ExistsExpr:
		b, ok := inB.(*ExistsExpr)
		if !ok {
			return false
		}
		return EqualsRefOfExistsExpr(a, b)
	case *ExtractFuncExpr:
		b, ok := inB.(*ExtractFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfExtractFuncExpr(a, b)
	case *ExtractedSubquery:
		b, ok := inB.(*ExtractedSubquery)
		if !ok {
			return false
		}
		return EqualsRefOfExtractedSubquery(a, b)
	case *FuncExpr:
		b, ok := inB.(*FuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfFuncExpr(a, b)
	case *GroupConcatExpr:
		b, ok := inB.(*GroupConcatExpr)
		if !ok {
			return false
		}
		return EqualsRefOfGroupConcatExpr(a, b)
	case *IntervalExpr:
		b, ok := inB.(*IntervalExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIntervalExpr(a, b)
	case *IntroducerExpr:
		b, ok := inB.(*IntroducerExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIntroducerExpr(a, b)
	case *IsExpr:
		b, ok := inB.(*IsExpr)
		if !ok {
			return false
		}
		return EqualsRefOfIsExpr(a, b)
	case ListArg:
		b, ok := inB.(ListArg)
		if !ok {
			return false
		}
		return a == b
	case *Literal:
		b, ok := inB.(*Literal)
		if !ok {
			return false
		}
		return EqualsRefOfLiteral(a, b)
	case *MatchExpr:
		b, ok := inB.(*MatchExpr)
		if !ok {
			return false
		}
		return EqualsRefOfMatchExpr(a, b)
	case *NotExpr:
		b, ok := inB.(*NotExpr)
		if !ok {
			return false
		}
		return EqualsRefOfNotExpr(a, b)
	case *NullVal:
		b, ok := inB.(*NullVal)
		if !ok {
			return false
		}
		return EqualsRefOfNullVal(a, b)
	case *OrExpr:
		b, ok := inB.(*OrExpr)
		if !ok {
			return false
		}
		return EqualsRefOfOrExpr(a, b)
	case *Subquery:
		b, ok := inB.(*Subquery)
		if !ok {
			return false
		}
		return EqualsRefOfSubquery(a, b)
	case *SubstrExpr:
		b, ok := inB.(*SubstrExpr)
		if !ok {
			return false
		}
		return EqualsRefOfSubstrExpr(a, b)
	case *TimestampFuncExpr:
		b, ok := inB.(*TimestampFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfTimestampFuncExpr(a, b)
	case *UnaryExpr:
		b, ok := inB.(*UnaryExpr)
		if !ok {
			return false
		}
		return EqualsRefOfUnaryExpr(a, b)
	case ValTuple:
		b, ok := inB.(ValTuple)
		if !ok {
			return false
		}
		return EqualsValTuple(a, b)
	case *ValuesFuncExpr:
		b, ok := inB.(*ValuesFuncExpr)
		if !ok {
			return false
		}
		return EqualsRefOfValuesFuncExpr(a, b)
	case *XorExpr:
		b, ok := inB.(*XorExpr)
		if !ok {
			return false
		}
		return EqualsRefOfXorExpr(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsInsertRows does deep equals between the two objects.
func EqualsInsertRows(inA, inB InsertRows) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *Select:
		b, ok := inB.(*Select)
		if !ok {
			return false
		}
		return EqualsRefOfSelect(a, b)
	case *Union:
		b, ok := inB.(*Union)
		if !ok {
			return false
		}
		return EqualsRefOfUnion(a, b)
	case Values:
		b, ok := inB.(Values)
		if !ok {
			return false
		}
		return EqualsValues(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsSelectExpr does deep equals between the two objects.
func EqualsSelectExpr(inA, inB SelectExpr) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AliasedExpr:
		b, ok := inB.(*AliasedExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAliasedExpr(a, b)
	case *Nextval:
		b, ok := inB.(*Nextval)
		if !ok {
			return false
		}
		return EqualsRefOfNextval(a, b)
	case *StarExpr:
		b, ok := inB.(*StarExpr)
		if !ok {
			return false
		}
		return EqualsRefOfStarExpr(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsSelectStatement does deep equals between the two objects.
func EqualsSelectStatement(inA, inB SelectStatement) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *Select:
		b, ok := inB.(*Select)
		if !ok {
			return false
		}
		return EqualsRefOfSelect(a, b)
	case *Union:
		b, ok := inB.(*Union)
		if !ok {
			return false
		}
		return EqualsRefOfUnion(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsShowInternal does deep equals between the two objects.
func EqualsShowInternal(inA, inB ShowInternal) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *ShowBasic:
		b, ok := inB.(*ShowBasic)
		if !ok {
			return false
		}
		return EqualsRefOfShowBasic(a, b)
	case *ShowCreate:
		b, ok := inB.(*ShowCreate)
		if !ok {
			return false
		}
		return EqualsRefOfShowCreate(a, b)
	case *ShowLegacy:
		b, ok := inB.(*ShowLegacy)
		if !ok {
			return false
		}
		return EqualsRefOfShowLegacy(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsSimpleTableExpr does deep equals between the two objects.
func EqualsSimpleTableExpr(inA, inB SimpleTableExpr) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *DerivedTable:
		b, ok := inB.(*DerivedTable)
		if !ok {
			return false
		}
		return EqualsRefOfDerivedTable(a, b)
	case TableName:
		b, ok := inB.(TableName)
		if !ok {
			return false
		}
		return EqualsTableName(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsStatement does deep equals between the two objects.
func EqualsStatement(inA, inB Statement) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AlterDatabase:
		b, ok := inB.(*AlterDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfAlterDatabase(a, b)
	case *AlterMigration:
		b, ok := inB.(*AlterMigration)
		if !ok {
			return false
		}
		return EqualsRefOfAlterMigration(a, b)
	case *AlterTable:
		b, ok := inB.(*AlterTable)
		if !ok {
			return false
		}
		return EqualsRefOfAlterTable(a, b)
	case *AlterView:
		b, ok := inB.(*AlterView)
		if !ok {
			return false
		}
		return EqualsRefOfAlterView(a, b)
	case *AlterVschema:
		b, ok := inB.(*AlterVschema)
		if !ok {
			return false
		}
		return EqualsRefOfAlterVschema(a, b)
	case *Begin:
		b, ok := inB.(*Begin)
		if !ok {
			return false
		}
		return EqualsRefOfBegin(a, b)
	case *CallProc:
		b, ok := inB.(*CallProc)
		if !ok {
			return false
		}
		return EqualsRefOfCallProc(a, b)
	case *Commit:
		b, ok := inB.(*Commit)
		if !ok {
			return false
		}
		return EqualsRefOfCommit(a, b)
	case *CreateDatabase:
		b, ok := inB.(*CreateDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfCreateDatabase(a, b)
	case *CreateTable:
		b, ok := inB.(*CreateTable)
		if !ok {
			return false
		}
		return EqualsRefOfCreateTable(a, b)
	case *CreateView:
		b, ok := inB.(*CreateView)
		if !ok {
			return false
		}
		return EqualsRefOfCreateView(a, b)
	case *Delete:
		b, ok := inB.(*Delete)
		if !ok {
			return false
		}
		return EqualsRefOfDelete(a, b)
	case *DropDatabase:
		b, ok := inB.(*DropDatabase)
		if !ok {
			return false
		}
		return EqualsRefOfDropDatabase(a, b)
	case *DropTable:
		b, ok := inB.(*DropTable)
		if !ok {
			return false
		}
		return EqualsRefOfDropTable(a, b)
	case *DropView:
		b, ok := inB.(*DropView)
		if !ok {
			return false
		}
		return EqualsRefOfDropView(a, b)
	case *ExplainStmt:
		b, ok := inB.(*ExplainStmt)
		if !ok {
			return false
		}
		return EqualsRefOfExplainStmt(a, b)
	case *ExplainTab:
		b, ok := inB.(*ExplainTab)
		if !ok {
			return false
		}
		return EqualsRefOfExplainTab(a, b)
	case *Flush:
		b, ok := inB.(*Flush)
		if !ok {
			return false
		}
		return EqualsRefOfFlush(a, b)
	case *Insert:
		b, ok := inB.(*Insert)
		if !ok {
			return false
		}
		return EqualsRefOfInsert(a, b)
	case *Load:
		b, ok := inB.(*Load)
		if !ok {
			return false
		}
		return EqualsRefOfLoad(a, b)
	case *LockTables:
		b, ok := inB.(*LockTables)
		if !ok {
			return false
		}
		return EqualsRefOfLockTables(a, b)
	case *OtherAdmin:
		b, ok := inB.(*OtherAdmin)
		if !ok {
			return false
		}
		return EqualsRefOfOtherAdmin(a, b)
	case *OtherRead:
		b, ok := inB.(*OtherRead)
		if !ok {
			return false
		}
		return EqualsRefOfOtherRead(a, b)
	case *Release:
		b, ok := inB.(*Release)
		if !ok {
			return false
		}
		return EqualsRefOfRelease(a, b)
	case *RenameTable:
		b, ok := inB.(*RenameTable)
		if !ok {
			return false
		}
		return EqualsRefOfRenameTable(a, b)
	case *RevertMigration:
		b, ok := inB.(*RevertMigration)
		if !ok {
			return false
		}
		return EqualsRefOfRevertMigration(a, b)
	case *Rollback:
		b, ok := inB.(*Rollback)
		if !ok {
			return false
		}
		return EqualsRefOfRollback(a, b)
	case *SRollback:
		b, ok := inB.(*SRollback)
		if !ok {
			return false
		}
		return EqualsRefOfSRollback(a, b)
	case *Savepoint:
		b, ok := inB.(*Savepoint)
		if !ok {
			return false
		}
		return EqualsRefOfSavepoint(a, b)
	case *Select:
		b, ok := inB.(*Select)
		if !ok {
			return false
		}
		return EqualsRefOfSelect(a, b)
	case *Set:
		b, ok := inB.(*Set)
		if !ok {
			return false
		}
		return EqualsRefOfSet(a, b)
	case *SetTransaction:
		b, ok := inB.(*SetTransaction)
		if !ok {
			return false
		}
		return EqualsRefOfSetTransaction(a, b)
	case *Show:
		b, ok := inB.(*Show)
		if !ok {
			return false
		}
		return EqualsRefOfShow(a, b)
	case *ShowMigrationLogs:
		b, ok := inB.(*ShowMigrationLogs)
		if !ok {
			return false
		}
		return EqualsRefOfShowMigrationLogs(a, b)
	case *Stream:
		b, ok := inB.(*Stream)
		if !ok {
			return false
		}
		return EqualsRefOfStream(a, b)
	case *TruncateTable:
		b, ok := inB.(*TruncateTable)
		if !ok {
			return false
		}
		return EqualsRefOfTruncateTable(a, b)
	case *Union:
		b, ok := inB.(*Union)
		if !ok {
			return false
		}
		return EqualsRefOfUnion(a, b)
	case *UnlockTables:
		b, ok := inB.(*UnlockTables)
		if !ok {
			return false
		}
		return EqualsRefOfUnlockTables(a, b)
	case *Update:
		b, ok := inB.(*Update)
		if !ok {
			return false
		}
		return EqualsRefOfUpdate(a, b)
	case *Use:
		b, ok := inB.(*Use)
		if !ok {
			return false
		}
		return EqualsRefOfUse(a, b)
	case *VStream:
		b, ok := inB.(*VStream)
		if !ok {
			return false
		}
		return EqualsRefOfVStream(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsTableExpr does deep equals between the two objects.
func EqualsTableExpr(inA, inB TableExpr) bool {
	if inA == nil && inB == nil {
		return true
	}
	if inA == nil || inB == nil {
		return false
	}
	switch a := inA.(type) {
	case *AliasedTableExpr:
		b, ok := inB.(*AliasedTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfAliasedTableExpr(a, b)
	case *JoinTableExpr:
		b, ok := inB.(*JoinTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfJoinTableExpr(a, b)
	case *ParenTableExpr:
		b, ok := inB.(*ParenTableExpr)
		if !ok {
			return false
		}
		return EqualsRefOfParenTableExpr(a, b)
	default:
		// this should never happen
		return false
	}
}

// EqualsSliceOfRefOfColumnDefinition does deep equals between the two objects.
func EqualsSliceOfRefOfColumnDefinition(a, b []*ColumnDefinition) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfColumnDefinition(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfCollateAndCharset does deep equals between the two objects.
func EqualsSliceOfCollateAndCharset(a, b []CollateAndCharset) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsCollateAndCharset(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfAlterOption does deep equals between the two objects.
func EqualsSliceOfAlterOption(a, b []AlterOption) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsAlterOption(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfColIdent does deep equals between the two objects.
func EqualsSliceOfColIdent(a, b []ColIdent) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsColIdent(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfWhen does deep equals between the two objects.
func EqualsSliceOfRefOfWhen(a, b []*When) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfWhen(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfColIdent does deep equals between the two objects.
func EqualsRefOfColIdent(a, b *ColIdent) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.val == b.val &&
		a.lowered == b.lowered &&
		a.at == b.at
}

// EqualsColumnType does deep equals between the two objects.
func EqualsColumnType(a, b ColumnType) bool {
	return a.Type == b.Type &&
		a.Unsigned == b.Unsigned &&
		a.Zerofill == b.Zerofill &&
		a.Charset == b.Charset &&
		EqualsRefOfColumnTypeOptions(a.Options, b.Options) &&
		EqualsRefOfLiteral(a.Length, b.Length) &&
		EqualsRefOfLiteral(a.Scale, b.Scale) &&
		EqualsSliceOfString(a.EnumValues, b.EnumValues)
}

// EqualsRefOfColumnTypeOptions does deep equals between the two objects.
func EqualsRefOfColumnTypeOptions(a, b *ColumnTypeOptions) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Autoincrement == b.Autoincrement &&
		a.Collate == b.Collate &&
		EqualsRefOfBool(a.Null, b.Null) &&
		EqualsExpr(a.Default, b.Default) &&
		EqualsExpr(a.OnUpdate, b.OnUpdate) &&
		EqualsExpr(a.As, b.As) &&
		EqualsRefOfLiteral(a.Comment, b.Comment) &&
		a.Storage == b.Storage &&
		EqualsRefOfReferenceDefinition(a.Reference, b.Reference) &&
		a.KeyOpt == b.KeyOpt
}

// EqualsSliceOfString does deep equals between the two objects.
func EqualsSliceOfString(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfIndexColumn does deep equals between the two objects.
func EqualsSliceOfRefOfIndexColumn(a, b []*IndexColumn) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfIndexColumn(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfIndexOption does deep equals between the two objects.
func EqualsSliceOfRefOfIndexOption(a, b []*IndexOption) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfIndexOption(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsTableAndLockTypes does deep equals between the two objects.
func EqualsTableAndLockTypes(a, b TableAndLockTypes) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfTableAndLockType(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfPartitionDefinition does deep equals between the two objects.
func EqualsSliceOfRefOfPartitionDefinition(a, b []*PartitionDefinition) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfPartitionDefinition(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfRenameTablePair does deep equals between the two objects.
func EqualsSliceOfRefOfRenameTablePair(a, b []*RenameTablePair) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfRenameTablePair(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfRootNode does deep equals between the two objects.
func EqualsRefOfRootNode(a, b *RootNode) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsSQLNode(a.SQLNode, b.SQLNode)
}

// EqualsRefOfBool does deep equals between the two objects.
func EqualsRefOfBool(a, b *bool) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return *a == *b
}

// EqualsSliceOfTableExpr does deep equals between the two objects.
func EqualsSliceOfTableExpr(a, b []TableExpr) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsTableExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfCharacteristic does deep equals between the two objects.
func EqualsSliceOfCharacteristic(a, b []Characteristic) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsCharacteristic(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfShowTablesOpt does deep equals between the two objects.
func EqualsRefOfShowTablesOpt(a, b *ShowTablesOpt) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Full == b.Full &&
		a.DbName == b.DbName &&
		EqualsRefOfShowFilter(a.Filter, b.Filter)
}

// EqualsRefOfTableIdent does deep equals between the two objects.
func EqualsRefOfTableIdent(a, b *TableIdent) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.v == b.v
}

// EqualsRefOfTableName does deep equals between the two objects.
func EqualsRefOfTableName(a, b *TableName) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableIdent(a.Name, b.Name) &&
		EqualsTableIdent(a.Qualifier, b.Qualifier)
}

// EqualsRefOfTableOption does deep equals between the two objects.
func EqualsRefOfTableOption(a, b *TableOption) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Name == b.Name &&
		a.String == b.String &&
		EqualsRefOfLiteral(a.Value, b.Value) &&
		EqualsTableNames(a.Tables, b.Tables)
}

// EqualsSliceOfRefOfIndexDefinition does deep equals between the two objects.
func EqualsSliceOfRefOfIndexDefinition(a, b []*IndexDefinition) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfIndexDefinition(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfConstraintDefinition does deep equals between the two objects.
func EqualsSliceOfRefOfConstraintDefinition(a, b []*ConstraintDefinition) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfConstraintDefinition(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsRefOfVindexParam does deep equals between the two objects.
func EqualsRefOfVindexParam(a, b *VindexParam) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Val == b.Val &&
		EqualsColIdent(a.Key, b.Key)
}

// EqualsSliceOfVindexParam does deep equals between the two objects.
func EqualsSliceOfVindexParam(a, b []VindexParam) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsVindexParam(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsSliceOfRefOfCommonTableExpr does deep equals between the two objects.
func EqualsSliceOfRefOfCommonTableExpr(a, b []*CommonTableExpr) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		if !EqualsRefOfCommonTableExpr(a[i], b[i]) {
			return false
		}
	}
	return true
}

// EqualsCollateAndCharset does deep equals between the two objects.
func EqualsCollateAndCharset(a, b CollateAndCharset) bool {
	return a.IsDefault == b.IsDefault &&
		a.Value == b.Value &&
		a.Type == b.Type
}

// EqualsRefOfIndexColumn does deep equals between the two objects.
func EqualsRefOfIndexColumn(a, b *IndexColumn) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsColIdent(a.Column, b.Column) &&
		EqualsRefOfLiteral(a.Length, b.Length) &&
		a.Direction == b.Direction
}

// EqualsRefOfIndexOption does deep equals between the two objects.
func EqualsRefOfIndexOption(a, b *IndexOption) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.Name == b.Name &&
		a.String == b.String &&
		EqualsRefOfLiteral(a.Value, b.Value)
}

// EqualsRefOfTableAndLockType does deep equals between the two objects.
func EqualsRefOfTableAndLockType(a, b *TableAndLockType) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableExpr(a.Table, b.Table) &&
		a.Lock == b.Lock
}

// EqualsRefOfRenameTablePair does deep equals between the two objects.
func EqualsRefOfRenameTablePair(a, b *RenameTablePair) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return EqualsTableName(a.FromTable, b.FromTable) &&
		EqualsTableName(a.ToTable, b.ToTable)
}

// EqualsRefOfCollateAndCharset does deep equals between the two objects.
func EqualsRefOfCollateAndCharset(a, b *CollateAndCharset) bool {
	if a == b {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return a.IsDefault == b.IsDefault &&
		a.Value == b.Value &&
		a.Type == b.Type
}