vitess.io/vitess@v0.16.2/go/vt/sqlparser/ast_equals.go (about)

     1  /*
     2  Copyright 2023 The Vitess Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  // Code generated by ASTHelperGen. DO NOT EDIT.
    17  
    18  package sqlparser
    19  
    20  // SQLNode does deep equals between the two objects.
    21  func (cmp *Comparator) SQLNode(inA, inB SQLNode) bool {
    22  	if inA == nil && inB == nil {
    23  		return true
    24  	}
    25  	if inA == nil || inB == nil {
    26  		return false
    27  	}
    28  	switch a := inA.(type) {
    29  	case *AddColumns:
    30  		b, ok := inB.(*AddColumns)
    31  		if !ok {
    32  			return false
    33  		}
    34  		return cmp.RefOfAddColumns(a, b)
    35  	case *AddConstraintDefinition:
    36  		b, ok := inB.(*AddConstraintDefinition)
    37  		if !ok {
    38  			return false
    39  		}
    40  		return cmp.RefOfAddConstraintDefinition(a, b)
    41  	case *AddIndexDefinition:
    42  		b, ok := inB.(*AddIndexDefinition)
    43  		if !ok {
    44  			return false
    45  		}
    46  		return cmp.RefOfAddIndexDefinition(a, b)
    47  	case AlgorithmValue:
    48  		b, ok := inB.(AlgorithmValue)
    49  		if !ok {
    50  			return false
    51  		}
    52  		return a == b
    53  	case *AliasedExpr:
    54  		b, ok := inB.(*AliasedExpr)
    55  		if !ok {
    56  			return false
    57  		}
    58  		return cmp.RefOfAliasedExpr(a, b)
    59  	case *AliasedTableExpr:
    60  		b, ok := inB.(*AliasedTableExpr)
    61  		if !ok {
    62  			return false
    63  		}
    64  		return cmp.RefOfAliasedTableExpr(a, b)
    65  	case *AlterCharset:
    66  		b, ok := inB.(*AlterCharset)
    67  		if !ok {
    68  			return false
    69  		}
    70  		return cmp.RefOfAlterCharset(a, b)
    71  	case *AlterCheck:
    72  		b, ok := inB.(*AlterCheck)
    73  		if !ok {
    74  			return false
    75  		}
    76  		return cmp.RefOfAlterCheck(a, b)
    77  	case *AlterColumn:
    78  		b, ok := inB.(*AlterColumn)
    79  		if !ok {
    80  			return false
    81  		}
    82  		return cmp.RefOfAlterColumn(a, b)
    83  	case *AlterDatabase:
    84  		b, ok := inB.(*AlterDatabase)
    85  		if !ok {
    86  			return false
    87  		}
    88  		return cmp.RefOfAlterDatabase(a, b)
    89  	case *AlterIndex:
    90  		b, ok := inB.(*AlterIndex)
    91  		if !ok {
    92  			return false
    93  		}
    94  		return cmp.RefOfAlterIndex(a, b)
    95  	case *AlterMigration:
    96  		b, ok := inB.(*AlterMigration)
    97  		if !ok {
    98  			return false
    99  		}
   100  		return cmp.RefOfAlterMigration(a, b)
   101  	case *AlterTable:
   102  		b, ok := inB.(*AlterTable)
   103  		if !ok {
   104  			return false
   105  		}
   106  		return cmp.RefOfAlterTable(a, b)
   107  	case *AlterView:
   108  		b, ok := inB.(*AlterView)
   109  		if !ok {
   110  			return false
   111  		}
   112  		return cmp.RefOfAlterView(a, b)
   113  	case *AlterVschema:
   114  		b, ok := inB.(*AlterVschema)
   115  		if !ok {
   116  			return false
   117  		}
   118  		return cmp.RefOfAlterVschema(a, b)
   119  	case *AndExpr:
   120  		b, ok := inB.(*AndExpr)
   121  		if !ok {
   122  			return false
   123  		}
   124  		return cmp.RefOfAndExpr(a, b)
   125  	case Argument:
   126  		b, ok := inB.(Argument)
   127  		if !ok {
   128  			return false
   129  		}
   130  		return a == b
   131  	case *ArgumentLessWindowExpr:
   132  		b, ok := inB.(*ArgumentLessWindowExpr)
   133  		if !ok {
   134  			return false
   135  		}
   136  		return cmp.RefOfArgumentLessWindowExpr(a, b)
   137  	case *AutoIncSpec:
   138  		b, ok := inB.(*AutoIncSpec)
   139  		if !ok {
   140  			return false
   141  		}
   142  		return cmp.RefOfAutoIncSpec(a, b)
   143  	case *Avg:
   144  		b, ok := inB.(*Avg)
   145  		if !ok {
   146  			return false
   147  		}
   148  		return cmp.RefOfAvg(a, b)
   149  	case *Begin:
   150  		b, ok := inB.(*Begin)
   151  		if !ok {
   152  			return false
   153  		}
   154  		return cmp.RefOfBegin(a, b)
   155  	case *BetweenExpr:
   156  		b, ok := inB.(*BetweenExpr)
   157  		if !ok {
   158  			return false
   159  		}
   160  		return cmp.RefOfBetweenExpr(a, b)
   161  	case *BinaryExpr:
   162  		b, ok := inB.(*BinaryExpr)
   163  		if !ok {
   164  			return false
   165  		}
   166  		return cmp.RefOfBinaryExpr(a, b)
   167  	case *BitAnd:
   168  		b, ok := inB.(*BitAnd)
   169  		if !ok {
   170  			return false
   171  		}
   172  		return cmp.RefOfBitAnd(a, b)
   173  	case *BitOr:
   174  		b, ok := inB.(*BitOr)
   175  		if !ok {
   176  			return false
   177  		}
   178  		return cmp.RefOfBitOr(a, b)
   179  	case *BitXor:
   180  		b, ok := inB.(*BitXor)
   181  		if !ok {
   182  			return false
   183  		}
   184  		return cmp.RefOfBitXor(a, b)
   185  	case BoolVal:
   186  		b, ok := inB.(BoolVal)
   187  		if !ok {
   188  			return false
   189  		}
   190  		return a == b
   191  	case *CallProc:
   192  		b, ok := inB.(*CallProc)
   193  		if !ok {
   194  			return false
   195  		}
   196  		return cmp.RefOfCallProc(a, b)
   197  	case *CaseExpr:
   198  		b, ok := inB.(*CaseExpr)
   199  		if !ok {
   200  			return false
   201  		}
   202  		return cmp.RefOfCaseExpr(a, b)
   203  	case *CastExpr:
   204  		b, ok := inB.(*CastExpr)
   205  		if !ok {
   206  			return false
   207  		}
   208  		return cmp.RefOfCastExpr(a, b)
   209  	case *ChangeColumn:
   210  		b, ok := inB.(*ChangeColumn)
   211  		if !ok {
   212  			return false
   213  		}
   214  		return cmp.RefOfChangeColumn(a, b)
   215  	case *CharExpr:
   216  		b, ok := inB.(*CharExpr)
   217  		if !ok {
   218  			return false
   219  		}
   220  		return cmp.RefOfCharExpr(a, b)
   221  	case *CheckConstraintDefinition:
   222  		b, ok := inB.(*CheckConstraintDefinition)
   223  		if !ok {
   224  			return false
   225  		}
   226  		return cmp.RefOfCheckConstraintDefinition(a, b)
   227  	case *ColName:
   228  		b, ok := inB.(*ColName)
   229  		if !ok {
   230  			return false
   231  		}
   232  		return cmp.RefOfColName(a, b)
   233  	case *CollateExpr:
   234  		b, ok := inB.(*CollateExpr)
   235  		if !ok {
   236  			return false
   237  		}
   238  		return cmp.RefOfCollateExpr(a, b)
   239  	case *ColumnDefinition:
   240  		b, ok := inB.(*ColumnDefinition)
   241  		if !ok {
   242  			return false
   243  		}
   244  		return cmp.RefOfColumnDefinition(a, b)
   245  	case *ColumnType:
   246  		b, ok := inB.(*ColumnType)
   247  		if !ok {
   248  			return false
   249  		}
   250  		return cmp.RefOfColumnType(a, b)
   251  	case Columns:
   252  		b, ok := inB.(Columns)
   253  		if !ok {
   254  			return false
   255  		}
   256  		return cmp.Columns(a, b)
   257  	case *CommentOnly:
   258  		b, ok := inB.(*CommentOnly)
   259  		if !ok {
   260  			return false
   261  		}
   262  		return cmp.RefOfCommentOnly(a, b)
   263  	case *Commit:
   264  		b, ok := inB.(*Commit)
   265  		if !ok {
   266  			return false
   267  		}
   268  		return cmp.RefOfCommit(a, b)
   269  	case *CommonTableExpr:
   270  		b, ok := inB.(*CommonTableExpr)
   271  		if !ok {
   272  			return false
   273  		}
   274  		return cmp.RefOfCommonTableExpr(a, b)
   275  	case *ComparisonExpr:
   276  		b, ok := inB.(*ComparisonExpr)
   277  		if !ok {
   278  			return false
   279  		}
   280  		return cmp.RefOfComparisonExpr(a, b)
   281  	case *ConstraintDefinition:
   282  		b, ok := inB.(*ConstraintDefinition)
   283  		if !ok {
   284  			return false
   285  		}
   286  		return cmp.RefOfConstraintDefinition(a, b)
   287  	case *ConvertExpr:
   288  		b, ok := inB.(*ConvertExpr)
   289  		if !ok {
   290  			return false
   291  		}
   292  		return cmp.RefOfConvertExpr(a, b)
   293  	case *ConvertType:
   294  		b, ok := inB.(*ConvertType)
   295  		if !ok {
   296  			return false
   297  		}
   298  		return cmp.RefOfConvertType(a, b)
   299  	case *ConvertUsingExpr:
   300  		b, ok := inB.(*ConvertUsingExpr)
   301  		if !ok {
   302  			return false
   303  		}
   304  		return cmp.RefOfConvertUsingExpr(a, b)
   305  	case *Count:
   306  		b, ok := inB.(*Count)
   307  		if !ok {
   308  			return false
   309  		}
   310  		return cmp.RefOfCount(a, b)
   311  	case *CountStar:
   312  		b, ok := inB.(*CountStar)
   313  		if !ok {
   314  			return false
   315  		}
   316  		return cmp.RefOfCountStar(a, b)
   317  	case *CreateDatabase:
   318  		b, ok := inB.(*CreateDatabase)
   319  		if !ok {
   320  			return false
   321  		}
   322  		return cmp.RefOfCreateDatabase(a, b)
   323  	case *CreateTable:
   324  		b, ok := inB.(*CreateTable)
   325  		if !ok {
   326  			return false
   327  		}
   328  		return cmp.RefOfCreateTable(a, b)
   329  	case *CreateView:
   330  		b, ok := inB.(*CreateView)
   331  		if !ok {
   332  			return false
   333  		}
   334  		return cmp.RefOfCreateView(a, b)
   335  	case *CurTimeFuncExpr:
   336  		b, ok := inB.(*CurTimeFuncExpr)
   337  		if !ok {
   338  			return false
   339  		}
   340  		return cmp.RefOfCurTimeFuncExpr(a, b)
   341  	case *DeallocateStmt:
   342  		b, ok := inB.(*DeallocateStmt)
   343  		if !ok {
   344  			return false
   345  		}
   346  		return cmp.RefOfDeallocateStmt(a, b)
   347  	case *Default:
   348  		b, ok := inB.(*Default)
   349  		if !ok {
   350  			return false
   351  		}
   352  		return cmp.RefOfDefault(a, b)
   353  	case *Definer:
   354  		b, ok := inB.(*Definer)
   355  		if !ok {
   356  			return false
   357  		}
   358  		return cmp.RefOfDefiner(a, b)
   359  	case *Delete:
   360  		b, ok := inB.(*Delete)
   361  		if !ok {
   362  			return false
   363  		}
   364  		return cmp.RefOfDelete(a, b)
   365  	case *DerivedTable:
   366  		b, ok := inB.(*DerivedTable)
   367  		if !ok {
   368  			return false
   369  		}
   370  		return cmp.RefOfDerivedTable(a, b)
   371  	case *DropColumn:
   372  		b, ok := inB.(*DropColumn)
   373  		if !ok {
   374  			return false
   375  		}
   376  		return cmp.RefOfDropColumn(a, b)
   377  	case *DropDatabase:
   378  		b, ok := inB.(*DropDatabase)
   379  		if !ok {
   380  			return false
   381  		}
   382  		return cmp.RefOfDropDatabase(a, b)
   383  	case *DropKey:
   384  		b, ok := inB.(*DropKey)
   385  		if !ok {
   386  			return false
   387  		}
   388  		return cmp.RefOfDropKey(a, b)
   389  	case *DropTable:
   390  		b, ok := inB.(*DropTable)
   391  		if !ok {
   392  			return false
   393  		}
   394  		return cmp.RefOfDropTable(a, b)
   395  	case *DropView:
   396  		b, ok := inB.(*DropView)
   397  		if !ok {
   398  			return false
   399  		}
   400  		return cmp.RefOfDropView(a, b)
   401  	case *ExecuteStmt:
   402  		b, ok := inB.(*ExecuteStmt)
   403  		if !ok {
   404  			return false
   405  		}
   406  		return cmp.RefOfExecuteStmt(a, b)
   407  	case *ExistsExpr:
   408  		b, ok := inB.(*ExistsExpr)
   409  		if !ok {
   410  			return false
   411  		}
   412  		return cmp.RefOfExistsExpr(a, b)
   413  	case *ExplainStmt:
   414  		b, ok := inB.(*ExplainStmt)
   415  		if !ok {
   416  			return false
   417  		}
   418  		return cmp.RefOfExplainStmt(a, b)
   419  	case *ExplainTab:
   420  		b, ok := inB.(*ExplainTab)
   421  		if !ok {
   422  			return false
   423  		}
   424  		return cmp.RefOfExplainTab(a, b)
   425  	case Exprs:
   426  		b, ok := inB.(Exprs)
   427  		if !ok {
   428  			return false
   429  		}
   430  		return cmp.Exprs(a, b)
   431  	case *ExtractFuncExpr:
   432  		b, ok := inB.(*ExtractFuncExpr)
   433  		if !ok {
   434  			return false
   435  		}
   436  		return cmp.RefOfExtractFuncExpr(a, b)
   437  	case *ExtractValueExpr:
   438  		b, ok := inB.(*ExtractValueExpr)
   439  		if !ok {
   440  			return false
   441  		}
   442  		return cmp.RefOfExtractValueExpr(a, b)
   443  	case *ExtractedSubquery:
   444  		b, ok := inB.(*ExtractedSubquery)
   445  		if !ok {
   446  			return false
   447  		}
   448  		return cmp.RefOfExtractedSubquery(a, b)
   449  	case *FirstOrLastValueExpr:
   450  		b, ok := inB.(*FirstOrLastValueExpr)
   451  		if !ok {
   452  			return false
   453  		}
   454  		return cmp.RefOfFirstOrLastValueExpr(a, b)
   455  	case *Flush:
   456  		b, ok := inB.(*Flush)
   457  		if !ok {
   458  			return false
   459  		}
   460  		return cmp.RefOfFlush(a, b)
   461  	case *Force:
   462  		b, ok := inB.(*Force)
   463  		if !ok {
   464  			return false
   465  		}
   466  		return cmp.RefOfForce(a, b)
   467  	case *ForeignKeyDefinition:
   468  		b, ok := inB.(*ForeignKeyDefinition)
   469  		if !ok {
   470  			return false
   471  		}
   472  		return cmp.RefOfForeignKeyDefinition(a, b)
   473  	case *FrameClause:
   474  		b, ok := inB.(*FrameClause)
   475  		if !ok {
   476  			return false
   477  		}
   478  		return cmp.RefOfFrameClause(a, b)
   479  	case *FramePoint:
   480  		b, ok := inB.(*FramePoint)
   481  		if !ok {
   482  			return false
   483  		}
   484  		return cmp.RefOfFramePoint(a, b)
   485  	case *FromFirstLastClause:
   486  		b, ok := inB.(*FromFirstLastClause)
   487  		if !ok {
   488  			return false
   489  		}
   490  		return cmp.RefOfFromFirstLastClause(a, b)
   491  	case *FuncExpr:
   492  		b, ok := inB.(*FuncExpr)
   493  		if !ok {
   494  			return false
   495  		}
   496  		return cmp.RefOfFuncExpr(a, b)
   497  	case *GTIDFuncExpr:
   498  		b, ok := inB.(*GTIDFuncExpr)
   499  		if !ok {
   500  			return false
   501  		}
   502  		return cmp.RefOfGTIDFuncExpr(a, b)
   503  	case GroupBy:
   504  		b, ok := inB.(GroupBy)
   505  		if !ok {
   506  			return false
   507  		}
   508  		return cmp.GroupBy(a, b)
   509  	case *GroupConcatExpr:
   510  		b, ok := inB.(*GroupConcatExpr)
   511  		if !ok {
   512  			return false
   513  		}
   514  		return cmp.RefOfGroupConcatExpr(a, b)
   515  	case IdentifierCI:
   516  		b, ok := inB.(IdentifierCI)
   517  		if !ok {
   518  			return false
   519  		}
   520  		return cmp.IdentifierCI(a, b)
   521  	case IdentifierCS:
   522  		b, ok := inB.(IdentifierCS)
   523  		if !ok {
   524  			return false
   525  		}
   526  		return cmp.IdentifierCS(a, b)
   527  	case *IndexDefinition:
   528  		b, ok := inB.(*IndexDefinition)
   529  		if !ok {
   530  			return false
   531  		}
   532  		return cmp.RefOfIndexDefinition(a, b)
   533  	case *IndexHint:
   534  		b, ok := inB.(*IndexHint)
   535  		if !ok {
   536  			return false
   537  		}
   538  		return cmp.RefOfIndexHint(a, b)
   539  	case IndexHints:
   540  		b, ok := inB.(IndexHints)
   541  		if !ok {
   542  			return false
   543  		}
   544  		return cmp.IndexHints(a, b)
   545  	case *IndexInfo:
   546  		b, ok := inB.(*IndexInfo)
   547  		if !ok {
   548  			return false
   549  		}
   550  		return cmp.RefOfIndexInfo(a, b)
   551  	case *Insert:
   552  		b, ok := inB.(*Insert)
   553  		if !ok {
   554  			return false
   555  		}
   556  		return cmp.RefOfInsert(a, b)
   557  	case *InsertExpr:
   558  		b, ok := inB.(*InsertExpr)
   559  		if !ok {
   560  			return false
   561  		}
   562  		return cmp.RefOfInsertExpr(a, b)
   563  	case *IntervalExpr:
   564  		b, ok := inB.(*IntervalExpr)
   565  		if !ok {
   566  			return false
   567  		}
   568  		return cmp.RefOfIntervalExpr(a, b)
   569  	case *IntervalFuncExpr:
   570  		b, ok := inB.(*IntervalFuncExpr)
   571  		if !ok {
   572  			return false
   573  		}
   574  		return cmp.RefOfIntervalFuncExpr(a, b)
   575  	case *IntroducerExpr:
   576  		b, ok := inB.(*IntroducerExpr)
   577  		if !ok {
   578  			return false
   579  		}
   580  		return cmp.RefOfIntroducerExpr(a, b)
   581  	case *IsExpr:
   582  		b, ok := inB.(*IsExpr)
   583  		if !ok {
   584  			return false
   585  		}
   586  		return cmp.RefOfIsExpr(a, b)
   587  	case *JSONArrayExpr:
   588  		b, ok := inB.(*JSONArrayExpr)
   589  		if !ok {
   590  			return false
   591  		}
   592  		return cmp.RefOfJSONArrayExpr(a, b)
   593  	case *JSONAttributesExpr:
   594  		b, ok := inB.(*JSONAttributesExpr)
   595  		if !ok {
   596  			return false
   597  		}
   598  		return cmp.RefOfJSONAttributesExpr(a, b)
   599  	case *JSONContainsExpr:
   600  		b, ok := inB.(*JSONContainsExpr)
   601  		if !ok {
   602  			return false
   603  		}
   604  		return cmp.RefOfJSONContainsExpr(a, b)
   605  	case *JSONContainsPathExpr:
   606  		b, ok := inB.(*JSONContainsPathExpr)
   607  		if !ok {
   608  			return false
   609  		}
   610  		return cmp.RefOfJSONContainsPathExpr(a, b)
   611  	case *JSONExtractExpr:
   612  		b, ok := inB.(*JSONExtractExpr)
   613  		if !ok {
   614  			return false
   615  		}
   616  		return cmp.RefOfJSONExtractExpr(a, b)
   617  	case *JSONKeysExpr:
   618  		b, ok := inB.(*JSONKeysExpr)
   619  		if !ok {
   620  			return false
   621  		}
   622  		return cmp.RefOfJSONKeysExpr(a, b)
   623  	case *JSONObjectExpr:
   624  		b, ok := inB.(*JSONObjectExpr)
   625  		if !ok {
   626  			return false
   627  		}
   628  		return cmp.RefOfJSONObjectExpr(a, b)
   629  	case *JSONObjectParam:
   630  		b, ok := inB.(*JSONObjectParam)
   631  		if !ok {
   632  			return false
   633  		}
   634  		return cmp.RefOfJSONObjectParam(a, b)
   635  	case *JSONOverlapsExpr:
   636  		b, ok := inB.(*JSONOverlapsExpr)
   637  		if !ok {
   638  			return false
   639  		}
   640  		return cmp.RefOfJSONOverlapsExpr(a, b)
   641  	case *JSONPrettyExpr:
   642  		b, ok := inB.(*JSONPrettyExpr)
   643  		if !ok {
   644  			return false
   645  		}
   646  		return cmp.RefOfJSONPrettyExpr(a, b)
   647  	case *JSONQuoteExpr:
   648  		b, ok := inB.(*JSONQuoteExpr)
   649  		if !ok {
   650  			return false
   651  		}
   652  		return cmp.RefOfJSONQuoteExpr(a, b)
   653  	case *JSONRemoveExpr:
   654  		b, ok := inB.(*JSONRemoveExpr)
   655  		if !ok {
   656  			return false
   657  		}
   658  		return cmp.RefOfJSONRemoveExpr(a, b)
   659  	case *JSONSchemaValidFuncExpr:
   660  		b, ok := inB.(*JSONSchemaValidFuncExpr)
   661  		if !ok {
   662  			return false
   663  		}
   664  		return cmp.RefOfJSONSchemaValidFuncExpr(a, b)
   665  	case *JSONSchemaValidationReportFuncExpr:
   666  		b, ok := inB.(*JSONSchemaValidationReportFuncExpr)
   667  		if !ok {
   668  			return false
   669  		}
   670  		return cmp.RefOfJSONSchemaValidationReportFuncExpr(a, b)
   671  	case *JSONSearchExpr:
   672  		b, ok := inB.(*JSONSearchExpr)
   673  		if !ok {
   674  			return false
   675  		}
   676  		return cmp.RefOfJSONSearchExpr(a, b)
   677  	case *JSONStorageFreeExpr:
   678  		b, ok := inB.(*JSONStorageFreeExpr)
   679  		if !ok {
   680  			return false
   681  		}
   682  		return cmp.RefOfJSONStorageFreeExpr(a, b)
   683  	case *JSONStorageSizeExpr:
   684  		b, ok := inB.(*JSONStorageSizeExpr)
   685  		if !ok {
   686  			return false
   687  		}
   688  		return cmp.RefOfJSONStorageSizeExpr(a, b)
   689  	case *JSONTableExpr:
   690  		b, ok := inB.(*JSONTableExpr)
   691  		if !ok {
   692  			return false
   693  		}
   694  		return cmp.RefOfJSONTableExpr(a, b)
   695  	case *JSONUnquoteExpr:
   696  		b, ok := inB.(*JSONUnquoteExpr)
   697  		if !ok {
   698  			return false
   699  		}
   700  		return cmp.RefOfJSONUnquoteExpr(a, b)
   701  	case *JSONValueExpr:
   702  		b, ok := inB.(*JSONValueExpr)
   703  		if !ok {
   704  			return false
   705  		}
   706  		return cmp.RefOfJSONValueExpr(a, b)
   707  	case *JSONValueMergeExpr:
   708  		b, ok := inB.(*JSONValueMergeExpr)
   709  		if !ok {
   710  			return false
   711  		}
   712  		return cmp.RefOfJSONValueMergeExpr(a, b)
   713  	case *JSONValueModifierExpr:
   714  		b, ok := inB.(*JSONValueModifierExpr)
   715  		if !ok {
   716  			return false
   717  		}
   718  		return cmp.RefOfJSONValueModifierExpr(a, b)
   719  	case *JoinCondition:
   720  		b, ok := inB.(*JoinCondition)
   721  		if !ok {
   722  			return false
   723  		}
   724  		return cmp.RefOfJoinCondition(a, b)
   725  	case *JoinTableExpr:
   726  		b, ok := inB.(*JoinTableExpr)
   727  		if !ok {
   728  			return false
   729  		}
   730  		return cmp.RefOfJoinTableExpr(a, b)
   731  	case *JtColumnDefinition:
   732  		b, ok := inB.(*JtColumnDefinition)
   733  		if !ok {
   734  			return false
   735  		}
   736  		return cmp.RefOfJtColumnDefinition(a, b)
   737  	case *JtOnResponse:
   738  		b, ok := inB.(*JtOnResponse)
   739  		if !ok {
   740  			return false
   741  		}
   742  		return cmp.RefOfJtOnResponse(a, b)
   743  	case *KeyState:
   744  		b, ok := inB.(*KeyState)
   745  		if !ok {
   746  			return false
   747  		}
   748  		return cmp.RefOfKeyState(a, b)
   749  	case *LagLeadExpr:
   750  		b, ok := inB.(*LagLeadExpr)
   751  		if !ok {
   752  			return false
   753  		}
   754  		return cmp.RefOfLagLeadExpr(a, b)
   755  	case *Limit:
   756  		b, ok := inB.(*Limit)
   757  		if !ok {
   758  			return false
   759  		}
   760  		return cmp.RefOfLimit(a, b)
   761  	case ListArg:
   762  		b, ok := inB.(ListArg)
   763  		if !ok {
   764  			return false
   765  		}
   766  		return a == b
   767  	case *Literal:
   768  		b, ok := inB.(*Literal)
   769  		if !ok {
   770  			return false
   771  		}
   772  		return cmp.RefOfLiteral(a, b)
   773  	case *Load:
   774  		b, ok := inB.(*Load)
   775  		if !ok {
   776  			return false
   777  		}
   778  		return cmp.RefOfLoad(a, b)
   779  	case *LocateExpr:
   780  		b, ok := inB.(*LocateExpr)
   781  		if !ok {
   782  			return false
   783  		}
   784  		return cmp.RefOfLocateExpr(a, b)
   785  	case *LockOption:
   786  		b, ok := inB.(*LockOption)
   787  		if !ok {
   788  			return false
   789  		}
   790  		return cmp.RefOfLockOption(a, b)
   791  	case *LockTables:
   792  		b, ok := inB.(*LockTables)
   793  		if !ok {
   794  			return false
   795  		}
   796  		return cmp.RefOfLockTables(a, b)
   797  	case *LockingFunc:
   798  		b, ok := inB.(*LockingFunc)
   799  		if !ok {
   800  			return false
   801  		}
   802  		return cmp.RefOfLockingFunc(a, b)
   803  	case MatchAction:
   804  		b, ok := inB.(MatchAction)
   805  		if !ok {
   806  			return false
   807  		}
   808  		return a == b
   809  	case *MatchExpr:
   810  		b, ok := inB.(*MatchExpr)
   811  		if !ok {
   812  			return false
   813  		}
   814  		return cmp.RefOfMatchExpr(a, b)
   815  	case *Max:
   816  		b, ok := inB.(*Max)
   817  		if !ok {
   818  			return false
   819  		}
   820  		return cmp.RefOfMax(a, b)
   821  	case *MemberOfExpr:
   822  		b, ok := inB.(*MemberOfExpr)
   823  		if !ok {
   824  			return false
   825  		}
   826  		return cmp.RefOfMemberOfExpr(a, b)
   827  	case *Min:
   828  		b, ok := inB.(*Min)
   829  		if !ok {
   830  			return false
   831  		}
   832  		return cmp.RefOfMin(a, b)
   833  	case *ModifyColumn:
   834  		b, ok := inB.(*ModifyColumn)
   835  		if !ok {
   836  			return false
   837  		}
   838  		return cmp.RefOfModifyColumn(a, b)
   839  	case *NTHValueExpr:
   840  		b, ok := inB.(*NTHValueExpr)
   841  		if !ok {
   842  			return false
   843  		}
   844  		return cmp.RefOfNTHValueExpr(a, b)
   845  	case *NamedWindow:
   846  		b, ok := inB.(*NamedWindow)
   847  		if !ok {
   848  			return false
   849  		}
   850  		return cmp.RefOfNamedWindow(a, b)
   851  	case NamedWindows:
   852  		b, ok := inB.(NamedWindows)
   853  		if !ok {
   854  			return false
   855  		}
   856  		return cmp.NamedWindows(a, b)
   857  	case *Nextval:
   858  		b, ok := inB.(*Nextval)
   859  		if !ok {
   860  			return false
   861  		}
   862  		return cmp.RefOfNextval(a, b)
   863  	case *NotExpr:
   864  		b, ok := inB.(*NotExpr)
   865  		if !ok {
   866  			return false
   867  		}
   868  		return cmp.RefOfNotExpr(a, b)
   869  	case *NtileExpr:
   870  		b, ok := inB.(*NtileExpr)
   871  		if !ok {
   872  			return false
   873  		}
   874  		return cmp.RefOfNtileExpr(a, b)
   875  	case *NullTreatmentClause:
   876  		b, ok := inB.(*NullTreatmentClause)
   877  		if !ok {
   878  			return false
   879  		}
   880  		return cmp.RefOfNullTreatmentClause(a, b)
   881  	case *NullVal:
   882  		b, ok := inB.(*NullVal)
   883  		if !ok {
   884  			return false
   885  		}
   886  		return cmp.RefOfNullVal(a, b)
   887  	case *Offset:
   888  		b, ok := inB.(*Offset)
   889  		if !ok {
   890  			return false
   891  		}
   892  		return cmp.RefOfOffset(a, b)
   893  	case OnDup:
   894  		b, ok := inB.(OnDup)
   895  		if !ok {
   896  			return false
   897  		}
   898  		return cmp.OnDup(a, b)
   899  	case *OptLike:
   900  		b, ok := inB.(*OptLike)
   901  		if !ok {
   902  			return false
   903  		}
   904  		return cmp.RefOfOptLike(a, b)
   905  	case *OrExpr:
   906  		b, ok := inB.(*OrExpr)
   907  		if !ok {
   908  			return false
   909  		}
   910  		return cmp.RefOfOrExpr(a, b)
   911  	case *Order:
   912  		b, ok := inB.(*Order)
   913  		if !ok {
   914  			return false
   915  		}
   916  		return cmp.RefOfOrder(a, b)
   917  	case OrderBy:
   918  		b, ok := inB.(OrderBy)
   919  		if !ok {
   920  			return false
   921  		}
   922  		return cmp.OrderBy(a, b)
   923  	case *OrderByOption:
   924  		b, ok := inB.(*OrderByOption)
   925  		if !ok {
   926  			return false
   927  		}
   928  		return cmp.RefOfOrderByOption(a, b)
   929  	case *OtherAdmin:
   930  		b, ok := inB.(*OtherAdmin)
   931  		if !ok {
   932  			return false
   933  		}
   934  		return cmp.RefOfOtherAdmin(a, b)
   935  	case *OtherRead:
   936  		b, ok := inB.(*OtherRead)
   937  		if !ok {
   938  			return false
   939  		}
   940  		return cmp.RefOfOtherRead(a, b)
   941  	case *OverClause:
   942  		b, ok := inB.(*OverClause)
   943  		if !ok {
   944  			return false
   945  		}
   946  		return cmp.RefOfOverClause(a, b)
   947  	case *ParenTableExpr:
   948  		b, ok := inB.(*ParenTableExpr)
   949  		if !ok {
   950  			return false
   951  		}
   952  		return cmp.RefOfParenTableExpr(a, b)
   953  	case *ParsedComments:
   954  		b, ok := inB.(*ParsedComments)
   955  		if !ok {
   956  			return false
   957  		}
   958  		return cmp.RefOfParsedComments(a, b)
   959  	case *PartitionDefinition:
   960  		b, ok := inB.(*PartitionDefinition)
   961  		if !ok {
   962  			return false
   963  		}
   964  		return cmp.RefOfPartitionDefinition(a, b)
   965  	case *PartitionDefinitionOptions:
   966  		b, ok := inB.(*PartitionDefinitionOptions)
   967  		if !ok {
   968  			return false
   969  		}
   970  		return cmp.RefOfPartitionDefinitionOptions(a, b)
   971  	case *PartitionEngine:
   972  		b, ok := inB.(*PartitionEngine)
   973  		if !ok {
   974  			return false
   975  		}
   976  		return cmp.RefOfPartitionEngine(a, b)
   977  	case *PartitionOption:
   978  		b, ok := inB.(*PartitionOption)
   979  		if !ok {
   980  			return false
   981  		}
   982  		return cmp.RefOfPartitionOption(a, b)
   983  	case *PartitionSpec:
   984  		b, ok := inB.(*PartitionSpec)
   985  		if !ok {
   986  			return false
   987  		}
   988  		return cmp.RefOfPartitionSpec(a, b)
   989  	case *PartitionValueRange:
   990  		b, ok := inB.(*PartitionValueRange)
   991  		if !ok {
   992  			return false
   993  		}
   994  		return cmp.RefOfPartitionValueRange(a, b)
   995  	case Partitions:
   996  		b, ok := inB.(Partitions)
   997  		if !ok {
   998  			return false
   999  		}
  1000  		return cmp.Partitions(a, b)
  1001  	case *PerformanceSchemaFuncExpr:
  1002  		b, ok := inB.(*PerformanceSchemaFuncExpr)
  1003  		if !ok {
  1004  			return false
  1005  		}
  1006  		return cmp.RefOfPerformanceSchemaFuncExpr(a, b)
  1007  	case *PrepareStmt:
  1008  		b, ok := inB.(*PrepareStmt)
  1009  		if !ok {
  1010  			return false
  1011  		}
  1012  		return cmp.RefOfPrepareStmt(a, b)
  1013  	case ReferenceAction:
  1014  		b, ok := inB.(ReferenceAction)
  1015  		if !ok {
  1016  			return false
  1017  		}
  1018  		return a == b
  1019  	case *ReferenceDefinition:
  1020  		b, ok := inB.(*ReferenceDefinition)
  1021  		if !ok {
  1022  			return false
  1023  		}
  1024  		return cmp.RefOfReferenceDefinition(a, b)
  1025  	case *RegexpInstrExpr:
  1026  		b, ok := inB.(*RegexpInstrExpr)
  1027  		if !ok {
  1028  			return false
  1029  		}
  1030  		return cmp.RefOfRegexpInstrExpr(a, b)
  1031  	case *RegexpLikeExpr:
  1032  		b, ok := inB.(*RegexpLikeExpr)
  1033  		if !ok {
  1034  			return false
  1035  		}
  1036  		return cmp.RefOfRegexpLikeExpr(a, b)
  1037  	case *RegexpReplaceExpr:
  1038  		b, ok := inB.(*RegexpReplaceExpr)
  1039  		if !ok {
  1040  			return false
  1041  		}
  1042  		return cmp.RefOfRegexpReplaceExpr(a, b)
  1043  	case *RegexpSubstrExpr:
  1044  		b, ok := inB.(*RegexpSubstrExpr)
  1045  		if !ok {
  1046  			return false
  1047  		}
  1048  		return cmp.RefOfRegexpSubstrExpr(a, b)
  1049  	case *Release:
  1050  		b, ok := inB.(*Release)
  1051  		if !ok {
  1052  			return false
  1053  		}
  1054  		return cmp.RefOfRelease(a, b)
  1055  	case *RenameColumn:
  1056  		b, ok := inB.(*RenameColumn)
  1057  		if !ok {
  1058  			return false
  1059  		}
  1060  		return cmp.RefOfRenameColumn(a, b)
  1061  	case *RenameIndex:
  1062  		b, ok := inB.(*RenameIndex)
  1063  		if !ok {
  1064  			return false
  1065  		}
  1066  		return cmp.RefOfRenameIndex(a, b)
  1067  	case *RenameTable:
  1068  		b, ok := inB.(*RenameTable)
  1069  		if !ok {
  1070  			return false
  1071  		}
  1072  		return cmp.RefOfRenameTable(a, b)
  1073  	case *RenameTableName:
  1074  		b, ok := inB.(*RenameTableName)
  1075  		if !ok {
  1076  			return false
  1077  		}
  1078  		return cmp.RefOfRenameTableName(a, b)
  1079  	case *RevertMigration:
  1080  		b, ok := inB.(*RevertMigration)
  1081  		if !ok {
  1082  			return false
  1083  		}
  1084  		return cmp.RefOfRevertMigration(a, b)
  1085  	case *Rollback:
  1086  		b, ok := inB.(*Rollback)
  1087  		if !ok {
  1088  			return false
  1089  		}
  1090  		return cmp.RefOfRollback(a, b)
  1091  	case RootNode:
  1092  		b, ok := inB.(RootNode)
  1093  		if !ok {
  1094  			return false
  1095  		}
  1096  		return cmp.RootNode(a, b)
  1097  	case *SRollback:
  1098  		b, ok := inB.(*SRollback)
  1099  		if !ok {
  1100  			return false
  1101  		}
  1102  		return cmp.RefOfSRollback(a, b)
  1103  	case *Savepoint:
  1104  		b, ok := inB.(*Savepoint)
  1105  		if !ok {
  1106  			return false
  1107  		}
  1108  		return cmp.RefOfSavepoint(a, b)
  1109  	case *Select:
  1110  		b, ok := inB.(*Select)
  1111  		if !ok {
  1112  			return false
  1113  		}
  1114  		return cmp.RefOfSelect(a, b)
  1115  	case SelectExprs:
  1116  		b, ok := inB.(SelectExprs)
  1117  		if !ok {
  1118  			return false
  1119  		}
  1120  		return cmp.SelectExprs(a, b)
  1121  	case *SelectInto:
  1122  		b, ok := inB.(*SelectInto)
  1123  		if !ok {
  1124  			return false
  1125  		}
  1126  		return cmp.RefOfSelectInto(a, b)
  1127  	case *Set:
  1128  		b, ok := inB.(*Set)
  1129  		if !ok {
  1130  			return false
  1131  		}
  1132  		return cmp.RefOfSet(a, b)
  1133  	case *SetExpr:
  1134  		b, ok := inB.(*SetExpr)
  1135  		if !ok {
  1136  			return false
  1137  		}
  1138  		return cmp.RefOfSetExpr(a, b)
  1139  	case SetExprs:
  1140  		b, ok := inB.(SetExprs)
  1141  		if !ok {
  1142  			return false
  1143  		}
  1144  		return cmp.SetExprs(a, b)
  1145  	case *Show:
  1146  		b, ok := inB.(*Show)
  1147  		if !ok {
  1148  			return false
  1149  		}
  1150  		return cmp.RefOfShow(a, b)
  1151  	case *ShowBasic:
  1152  		b, ok := inB.(*ShowBasic)
  1153  		if !ok {
  1154  			return false
  1155  		}
  1156  		return cmp.RefOfShowBasic(a, b)
  1157  	case *ShowCreate:
  1158  		b, ok := inB.(*ShowCreate)
  1159  		if !ok {
  1160  			return false
  1161  		}
  1162  		return cmp.RefOfShowCreate(a, b)
  1163  	case *ShowFilter:
  1164  		b, ok := inB.(*ShowFilter)
  1165  		if !ok {
  1166  			return false
  1167  		}
  1168  		return cmp.RefOfShowFilter(a, b)
  1169  	case *ShowMigrationLogs:
  1170  		b, ok := inB.(*ShowMigrationLogs)
  1171  		if !ok {
  1172  			return false
  1173  		}
  1174  		return cmp.RefOfShowMigrationLogs(a, b)
  1175  	case *ShowOther:
  1176  		b, ok := inB.(*ShowOther)
  1177  		if !ok {
  1178  			return false
  1179  		}
  1180  		return cmp.RefOfShowOther(a, b)
  1181  	case *ShowThrottledApps:
  1182  		b, ok := inB.(*ShowThrottledApps)
  1183  		if !ok {
  1184  			return false
  1185  		}
  1186  		return cmp.RefOfShowThrottledApps(a, b)
  1187  	case *ShowThrottlerStatus:
  1188  		b, ok := inB.(*ShowThrottlerStatus)
  1189  		if !ok {
  1190  			return false
  1191  		}
  1192  		return cmp.RefOfShowThrottlerStatus(a, b)
  1193  	case *StarExpr:
  1194  		b, ok := inB.(*StarExpr)
  1195  		if !ok {
  1196  			return false
  1197  		}
  1198  		return cmp.RefOfStarExpr(a, b)
  1199  	case *Std:
  1200  		b, ok := inB.(*Std)
  1201  		if !ok {
  1202  			return false
  1203  		}
  1204  		return cmp.RefOfStd(a, b)
  1205  	case *StdDev:
  1206  		b, ok := inB.(*StdDev)
  1207  		if !ok {
  1208  			return false
  1209  		}
  1210  		return cmp.RefOfStdDev(a, b)
  1211  	case *StdPop:
  1212  		b, ok := inB.(*StdPop)
  1213  		if !ok {
  1214  			return false
  1215  		}
  1216  		return cmp.RefOfStdPop(a, b)
  1217  	case *StdSamp:
  1218  		b, ok := inB.(*StdSamp)
  1219  		if !ok {
  1220  			return false
  1221  		}
  1222  		return cmp.RefOfStdSamp(a, b)
  1223  	case *Stream:
  1224  		b, ok := inB.(*Stream)
  1225  		if !ok {
  1226  			return false
  1227  		}
  1228  		return cmp.RefOfStream(a, b)
  1229  	case *SubPartition:
  1230  		b, ok := inB.(*SubPartition)
  1231  		if !ok {
  1232  			return false
  1233  		}
  1234  		return cmp.RefOfSubPartition(a, b)
  1235  	case *SubPartitionDefinition:
  1236  		b, ok := inB.(*SubPartitionDefinition)
  1237  		if !ok {
  1238  			return false
  1239  		}
  1240  		return cmp.RefOfSubPartitionDefinition(a, b)
  1241  	case *SubPartitionDefinitionOptions:
  1242  		b, ok := inB.(*SubPartitionDefinitionOptions)
  1243  		if !ok {
  1244  			return false
  1245  		}
  1246  		return cmp.RefOfSubPartitionDefinitionOptions(a, b)
  1247  	case SubPartitionDefinitions:
  1248  		b, ok := inB.(SubPartitionDefinitions)
  1249  		if !ok {
  1250  			return false
  1251  		}
  1252  		return cmp.SubPartitionDefinitions(a, b)
  1253  	case *Subquery:
  1254  		b, ok := inB.(*Subquery)
  1255  		if !ok {
  1256  			return false
  1257  		}
  1258  		return cmp.RefOfSubquery(a, b)
  1259  	case *SubstrExpr:
  1260  		b, ok := inB.(*SubstrExpr)
  1261  		if !ok {
  1262  			return false
  1263  		}
  1264  		return cmp.RefOfSubstrExpr(a, b)
  1265  	case *Sum:
  1266  		b, ok := inB.(*Sum)
  1267  		if !ok {
  1268  			return false
  1269  		}
  1270  		return cmp.RefOfSum(a, b)
  1271  	case TableExprs:
  1272  		b, ok := inB.(TableExprs)
  1273  		if !ok {
  1274  			return false
  1275  		}
  1276  		return cmp.TableExprs(a, b)
  1277  	case TableName:
  1278  		b, ok := inB.(TableName)
  1279  		if !ok {
  1280  			return false
  1281  		}
  1282  		return cmp.TableName(a, b)
  1283  	case TableNames:
  1284  		b, ok := inB.(TableNames)
  1285  		if !ok {
  1286  			return false
  1287  		}
  1288  		return cmp.TableNames(a, b)
  1289  	case TableOptions:
  1290  		b, ok := inB.(TableOptions)
  1291  		if !ok {
  1292  			return false
  1293  		}
  1294  		return cmp.TableOptions(a, b)
  1295  	case *TableSpec:
  1296  		b, ok := inB.(*TableSpec)
  1297  		if !ok {
  1298  			return false
  1299  		}
  1300  		return cmp.RefOfTableSpec(a, b)
  1301  	case *TablespaceOperation:
  1302  		b, ok := inB.(*TablespaceOperation)
  1303  		if !ok {
  1304  			return false
  1305  		}
  1306  		return cmp.RefOfTablespaceOperation(a, b)
  1307  	case *TimestampFuncExpr:
  1308  		b, ok := inB.(*TimestampFuncExpr)
  1309  		if !ok {
  1310  			return false
  1311  		}
  1312  		return cmp.RefOfTimestampFuncExpr(a, b)
  1313  	case *TrimFuncExpr:
  1314  		b, ok := inB.(*TrimFuncExpr)
  1315  		if !ok {
  1316  			return false
  1317  		}
  1318  		return cmp.RefOfTrimFuncExpr(a, b)
  1319  	case *TruncateTable:
  1320  		b, ok := inB.(*TruncateTable)
  1321  		if !ok {
  1322  			return false
  1323  		}
  1324  		return cmp.RefOfTruncateTable(a, b)
  1325  	case *UnaryExpr:
  1326  		b, ok := inB.(*UnaryExpr)
  1327  		if !ok {
  1328  			return false
  1329  		}
  1330  		return cmp.RefOfUnaryExpr(a, b)
  1331  	case *Union:
  1332  		b, ok := inB.(*Union)
  1333  		if !ok {
  1334  			return false
  1335  		}
  1336  		return cmp.RefOfUnion(a, b)
  1337  	case *UnlockTables:
  1338  		b, ok := inB.(*UnlockTables)
  1339  		if !ok {
  1340  			return false
  1341  		}
  1342  		return cmp.RefOfUnlockTables(a, b)
  1343  	case *Update:
  1344  		b, ok := inB.(*Update)
  1345  		if !ok {
  1346  			return false
  1347  		}
  1348  		return cmp.RefOfUpdate(a, b)
  1349  	case *UpdateExpr:
  1350  		b, ok := inB.(*UpdateExpr)
  1351  		if !ok {
  1352  			return false
  1353  		}
  1354  		return cmp.RefOfUpdateExpr(a, b)
  1355  	case UpdateExprs:
  1356  		b, ok := inB.(UpdateExprs)
  1357  		if !ok {
  1358  			return false
  1359  		}
  1360  		return cmp.UpdateExprs(a, b)
  1361  	case *UpdateXMLExpr:
  1362  		b, ok := inB.(*UpdateXMLExpr)
  1363  		if !ok {
  1364  			return false
  1365  		}
  1366  		return cmp.RefOfUpdateXMLExpr(a, b)
  1367  	case *Use:
  1368  		b, ok := inB.(*Use)
  1369  		if !ok {
  1370  			return false
  1371  		}
  1372  		return cmp.RefOfUse(a, b)
  1373  	case *VExplainStmt:
  1374  		b, ok := inB.(*VExplainStmt)
  1375  		if !ok {
  1376  			return false
  1377  		}
  1378  		return cmp.RefOfVExplainStmt(a, b)
  1379  	case *VStream:
  1380  		b, ok := inB.(*VStream)
  1381  		if !ok {
  1382  			return false
  1383  		}
  1384  		return cmp.RefOfVStream(a, b)
  1385  	case ValTuple:
  1386  		b, ok := inB.(ValTuple)
  1387  		if !ok {
  1388  			return false
  1389  		}
  1390  		return cmp.ValTuple(a, b)
  1391  	case *Validation:
  1392  		b, ok := inB.(*Validation)
  1393  		if !ok {
  1394  			return false
  1395  		}
  1396  		return cmp.RefOfValidation(a, b)
  1397  	case Values:
  1398  		b, ok := inB.(Values)
  1399  		if !ok {
  1400  			return false
  1401  		}
  1402  		return cmp.Values(a, b)
  1403  	case *ValuesFuncExpr:
  1404  		b, ok := inB.(*ValuesFuncExpr)
  1405  		if !ok {
  1406  			return false
  1407  		}
  1408  		return cmp.RefOfValuesFuncExpr(a, b)
  1409  	case *VarPop:
  1410  		b, ok := inB.(*VarPop)
  1411  		if !ok {
  1412  			return false
  1413  		}
  1414  		return cmp.RefOfVarPop(a, b)
  1415  	case *VarSamp:
  1416  		b, ok := inB.(*VarSamp)
  1417  		if !ok {
  1418  			return false
  1419  		}
  1420  		return cmp.RefOfVarSamp(a, b)
  1421  	case *Variable:
  1422  		b, ok := inB.(*Variable)
  1423  		if !ok {
  1424  			return false
  1425  		}
  1426  		return cmp.RefOfVariable(a, b)
  1427  	case *Variance:
  1428  		b, ok := inB.(*Variance)
  1429  		if !ok {
  1430  			return false
  1431  		}
  1432  		return cmp.RefOfVariance(a, b)
  1433  	case VindexParam:
  1434  		b, ok := inB.(VindexParam)
  1435  		if !ok {
  1436  			return false
  1437  		}
  1438  		return cmp.VindexParam(a, b)
  1439  	case *VindexSpec:
  1440  		b, ok := inB.(*VindexSpec)
  1441  		if !ok {
  1442  			return false
  1443  		}
  1444  		return cmp.RefOfVindexSpec(a, b)
  1445  	case *WeightStringFuncExpr:
  1446  		b, ok := inB.(*WeightStringFuncExpr)
  1447  		if !ok {
  1448  			return false
  1449  		}
  1450  		return cmp.RefOfWeightStringFuncExpr(a, b)
  1451  	case *When:
  1452  		b, ok := inB.(*When)
  1453  		if !ok {
  1454  			return false
  1455  		}
  1456  		return cmp.RefOfWhen(a, b)
  1457  	case *Where:
  1458  		b, ok := inB.(*Where)
  1459  		if !ok {
  1460  			return false
  1461  		}
  1462  		return cmp.RefOfWhere(a, b)
  1463  	case *WindowDefinition:
  1464  		b, ok := inB.(*WindowDefinition)
  1465  		if !ok {
  1466  			return false
  1467  		}
  1468  		return cmp.RefOfWindowDefinition(a, b)
  1469  	case WindowDefinitions:
  1470  		b, ok := inB.(WindowDefinitions)
  1471  		if !ok {
  1472  			return false
  1473  		}
  1474  		return cmp.WindowDefinitions(a, b)
  1475  	case *WindowSpecification:
  1476  		b, ok := inB.(*WindowSpecification)
  1477  		if !ok {
  1478  			return false
  1479  		}
  1480  		return cmp.RefOfWindowSpecification(a, b)
  1481  	case *With:
  1482  		b, ok := inB.(*With)
  1483  		if !ok {
  1484  			return false
  1485  		}
  1486  		return cmp.RefOfWith(a, b)
  1487  	case *XorExpr:
  1488  		b, ok := inB.(*XorExpr)
  1489  		if !ok {
  1490  			return false
  1491  		}
  1492  		return cmp.RefOfXorExpr(a, b)
  1493  	default:
  1494  		// this should never happen
  1495  		return false
  1496  	}
  1497  }
  1498  
  1499  // RefOfAddColumns does deep equals between the two objects.
  1500  func (cmp *Comparator) RefOfAddColumns(a, b *AddColumns) bool {
  1501  	if a == b {
  1502  		return true
  1503  	}
  1504  	if a == nil || b == nil {
  1505  		return false
  1506  	}
  1507  	return a.First == b.First &&
  1508  		cmp.SliceOfRefOfColumnDefinition(a.Columns, b.Columns) &&
  1509  		cmp.RefOfColName(a.After, b.After)
  1510  }
  1511  
  1512  // RefOfAddConstraintDefinition does deep equals between the two objects.
  1513  func (cmp *Comparator) RefOfAddConstraintDefinition(a, b *AddConstraintDefinition) bool {
  1514  	if a == b {
  1515  		return true
  1516  	}
  1517  	if a == nil || b == nil {
  1518  		return false
  1519  	}
  1520  	return cmp.RefOfConstraintDefinition(a.ConstraintDefinition, b.ConstraintDefinition)
  1521  }
  1522  
  1523  // RefOfAddIndexDefinition does deep equals between the two objects.
  1524  func (cmp *Comparator) RefOfAddIndexDefinition(a, b *AddIndexDefinition) bool {
  1525  	if a == b {
  1526  		return true
  1527  	}
  1528  	if a == nil || b == nil {
  1529  		return false
  1530  	}
  1531  	return cmp.RefOfIndexDefinition(a.IndexDefinition, b.IndexDefinition)
  1532  }
  1533  
  1534  // RefOfAliasedExpr does deep equals between the two objects.
  1535  func (cmp *Comparator) RefOfAliasedExpr(a, b *AliasedExpr) bool {
  1536  	if a == b {
  1537  		return true
  1538  	}
  1539  	if a == nil || b == nil {
  1540  		return false
  1541  	}
  1542  	return cmp.Expr(a.Expr, b.Expr) &&
  1543  		cmp.IdentifierCI(a.As, b.As)
  1544  }
  1545  
  1546  // RefOfAliasedTableExpr does deep equals between the two objects.
  1547  func (cmp *Comparator) RefOfAliasedTableExpr(a, b *AliasedTableExpr) bool {
  1548  	if a == b {
  1549  		return true
  1550  	}
  1551  	if a == nil || b == nil {
  1552  		return false
  1553  	}
  1554  	return cmp.SimpleTableExpr(a.Expr, b.Expr) &&
  1555  		cmp.Partitions(a.Partitions, b.Partitions) &&
  1556  		cmp.IdentifierCS(a.As, b.As) &&
  1557  		cmp.IndexHints(a.Hints, b.Hints) &&
  1558  		cmp.Columns(a.Columns, b.Columns)
  1559  }
  1560  
  1561  // RefOfAlterCharset does deep equals between the two objects.
  1562  func (cmp *Comparator) RefOfAlterCharset(a, b *AlterCharset) bool {
  1563  	if a == b {
  1564  		return true
  1565  	}
  1566  	if a == nil || b == nil {
  1567  		return false
  1568  	}
  1569  	return a.CharacterSet == b.CharacterSet &&
  1570  		a.Collate == b.Collate
  1571  }
  1572  
  1573  // RefOfAlterCheck does deep equals between the two objects.
  1574  func (cmp *Comparator) RefOfAlterCheck(a, b *AlterCheck) bool {
  1575  	if a == b {
  1576  		return true
  1577  	}
  1578  	if a == nil || b == nil {
  1579  		return false
  1580  	}
  1581  	return a.Enforced == b.Enforced &&
  1582  		cmp.IdentifierCI(a.Name, b.Name)
  1583  }
  1584  
  1585  // RefOfAlterColumn does deep equals between the two objects.
  1586  func (cmp *Comparator) RefOfAlterColumn(a, b *AlterColumn) bool {
  1587  	if a == b {
  1588  		return true
  1589  	}
  1590  	if a == nil || b == nil {
  1591  		return false
  1592  	}
  1593  	return a.DropDefault == b.DropDefault &&
  1594  		cmp.RefOfColName(a.Column, b.Column) &&
  1595  		cmp.Expr(a.DefaultVal, b.DefaultVal) &&
  1596  		cmp.RefOfBool(a.Invisible, b.Invisible)
  1597  }
  1598  
  1599  // RefOfAlterDatabase does deep equals between the two objects.
  1600  func (cmp *Comparator) RefOfAlterDatabase(a, b *AlterDatabase) bool {
  1601  	if a == b {
  1602  		return true
  1603  	}
  1604  	if a == nil || b == nil {
  1605  		return false
  1606  	}
  1607  	return a.UpdateDataDirectory == b.UpdateDataDirectory &&
  1608  		a.FullyParsed == b.FullyParsed &&
  1609  		cmp.IdentifierCS(a.DBName, b.DBName) &&
  1610  		cmp.SliceOfDatabaseOption(a.AlterOptions, b.AlterOptions)
  1611  }
  1612  
  1613  // RefOfAlterIndex does deep equals between the two objects.
  1614  func (cmp *Comparator) RefOfAlterIndex(a, b *AlterIndex) bool {
  1615  	if a == b {
  1616  		return true
  1617  	}
  1618  	if a == nil || b == nil {
  1619  		return false
  1620  	}
  1621  	return a.Invisible == b.Invisible &&
  1622  		cmp.IdentifierCI(a.Name, b.Name)
  1623  }
  1624  
  1625  // RefOfAlterMigration does deep equals between the two objects.
  1626  func (cmp *Comparator) RefOfAlterMigration(a, b *AlterMigration) bool {
  1627  	if a == b {
  1628  		return true
  1629  	}
  1630  	if a == nil || b == nil {
  1631  		return false
  1632  	}
  1633  	return a.UUID == b.UUID &&
  1634  		a.Expire == b.Expire &&
  1635  		a.Shards == b.Shards &&
  1636  		a.Type == b.Type &&
  1637  		cmp.RefOfLiteral(a.Ratio, b.Ratio)
  1638  }
  1639  
  1640  // RefOfAlterTable does deep equals between the two objects.
  1641  func (cmp *Comparator) RefOfAlterTable(a, b *AlterTable) bool {
  1642  	if a == b {
  1643  		return true
  1644  	}
  1645  	if a == nil || b == nil {
  1646  		return false
  1647  	}
  1648  	return a.FullyParsed == b.FullyParsed &&
  1649  		cmp.TableName(a.Table, b.Table) &&
  1650  		cmp.SliceOfAlterOption(a.AlterOptions, b.AlterOptions) &&
  1651  		cmp.RefOfPartitionSpec(a.PartitionSpec, b.PartitionSpec) &&
  1652  		cmp.RefOfPartitionOption(a.PartitionOption, b.PartitionOption) &&
  1653  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  1654  }
  1655  
  1656  // RefOfAlterView does deep equals between the two objects.
  1657  func (cmp *Comparator) RefOfAlterView(a, b *AlterView) bool {
  1658  	if a == b {
  1659  		return true
  1660  	}
  1661  	if a == nil || b == nil {
  1662  		return false
  1663  	}
  1664  	return a.Algorithm == b.Algorithm &&
  1665  		a.Security == b.Security &&
  1666  		a.CheckOption == b.CheckOption &&
  1667  		cmp.TableName(a.ViewName, b.ViewName) &&
  1668  		cmp.RefOfDefiner(a.Definer, b.Definer) &&
  1669  		cmp.Columns(a.Columns, b.Columns) &&
  1670  		cmp.SelectStatement(a.Select, b.Select) &&
  1671  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  1672  }
  1673  
  1674  // RefOfAlterVschema does deep equals between the two objects.
  1675  func (cmp *Comparator) RefOfAlterVschema(a, b *AlterVschema) bool {
  1676  	if a == b {
  1677  		return true
  1678  	}
  1679  	if a == nil || b == nil {
  1680  		return false
  1681  	}
  1682  	return a.Action == b.Action &&
  1683  		cmp.TableName(a.Table, b.Table) &&
  1684  		cmp.RefOfVindexSpec(a.VindexSpec, b.VindexSpec) &&
  1685  		cmp.SliceOfIdentifierCI(a.VindexCols, b.VindexCols) &&
  1686  		cmp.RefOfAutoIncSpec(a.AutoIncSpec, b.AutoIncSpec)
  1687  }
  1688  
  1689  // RefOfAndExpr does deep equals between the two objects.
  1690  func (cmp *Comparator) RefOfAndExpr(a, b *AndExpr) bool {
  1691  	if a == b {
  1692  		return true
  1693  	}
  1694  	if a == nil || b == nil {
  1695  		return false
  1696  	}
  1697  	return cmp.Expr(a.Left, b.Left) &&
  1698  		cmp.Expr(a.Right, b.Right)
  1699  }
  1700  
  1701  // RefOfArgumentLessWindowExpr does deep equals between the two objects.
  1702  func (cmp *Comparator) RefOfArgumentLessWindowExpr(a, b *ArgumentLessWindowExpr) bool {
  1703  	if a == b {
  1704  		return true
  1705  	}
  1706  	if a == nil || b == nil {
  1707  		return false
  1708  	}
  1709  	return a.Type == b.Type &&
  1710  		cmp.RefOfOverClause(a.OverClause, b.OverClause)
  1711  }
  1712  
  1713  // RefOfAutoIncSpec does deep equals between the two objects.
  1714  func (cmp *Comparator) RefOfAutoIncSpec(a, b *AutoIncSpec) bool {
  1715  	if a == b {
  1716  		return true
  1717  	}
  1718  	if a == nil || b == nil {
  1719  		return false
  1720  	}
  1721  	return cmp.IdentifierCI(a.Column, b.Column) &&
  1722  		cmp.TableName(a.Sequence, b.Sequence)
  1723  }
  1724  
  1725  // RefOfAvg does deep equals between the two objects.
  1726  func (cmp *Comparator) RefOfAvg(a, b *Avg) bool {
  1727  	if a == b {
  1728  		return true
  1729  	}
  1730  	if a == nil || b == nil {
  1731  		return false
  1732  	}
  1733  	return a.Distinct == b.Distinct &&
  1734  		cmp.Expr(a.Arg, b.Arg)
  1735  }
  1736  
  1737  // RefOfBegin does deep equals between the two objects.
  1738  func (cmp *Comparator) RefOfBegin(a, b *Begin) bool {
  1739  	if a == b {
  1740  		return true
  1741  	}
  1742  	if a == nil || b == nil {
  1743  		return false
  1744  	}
  1745  	return cmp.SliceOfTxAccessMode(a.TxAccessModes, b.TxAccessModes)
  1746  }
  1747  
  1748  // RefOfBetweenExpr does deep equals between the two objects.
  1749  func (cmp *Comparator) RefOfBetweenExpr(a, b *BetweenExpr) bool {
  1750  	if a == b {
  1751  		return true
  1752  	}
  1753  	if a == nil || b == nil {
  1754  		return false
  1755  	}
  1756  	return a.IsBetween == b.IsBetween &&
  1757  		cmp.Expr(a.Left, b.Left) &&
  1758  		cmp.Expr(a.From, b.From) &&
  1759  		cmp.Expr(a.To, b.To)
  1760  }
  1761  
  1762  // RefOfBinaryExpr does deep equals between the two objects.
  1763  func (cmp *Comparator) RefOfBinaryExpr(a, b *BinaryExpr) bool {
  1764  	if a == b {
  1765  		return true
  1766  	}
  1767  	if a == nil || b == nil {
  1768  		return false
  1769  	}
  1770  	return a.Operator == b.Operator &&
  1771  		cmp.Expr(a.Left, b.Left) &&
  1772  		cmp.Expr(a.Right, b.Right)
  1773  }
  1774  
  1775  // RefOfBitAnd does deep equals between the two objects.
  1776  func (cmp *Comparator) RefOfBitAnd(a, b *BitAnd) bool {
  1777  	if a == b {
  1778  		return true
  1779  	}
  1780  	if a == nil || b == nil {
  1781  		return false
  1782  	}
  1783  	return cmp.Expr(a.Arg, b.Arg)
  1784  }
  1785  
  1786  // RefOfBitOr does deep equals between the two objects.
  1787  func (cmp *Comparator) RefOfBitOr(a, b *BitOr) bool {
  1788  	if a == b {
  1789  		return true
  1790  	}
  1791  	if a == nil || b == nil {
  1792  		return false
  1793  	}
  1794  	return cmp.Expr(a.Arg, b.Arg)
  1795  }
  1796  
  1797  // RefOfBitXor does deep equals between the two objects.
  1798  func (cmp *Comparator) RefOfBitXor(a, b *BitXor) bool {
  1799  	if a == b {
  1800  		return true
  1801  	}
  1802  	if a == nil || b == nil {
  1803  		return false
  1804  	}
  1805  	return cmp.Expr(a.Arg, b.Arg)
  1806  }
  1807  
  1808  // RefOfCallProc does deep equals between the two objects.
  1809  func (cmp *Comparator) RefOfCallProc(a, b *CallProc) bool {
  1810  	if a == b {
  1811  		return true
  1812  	}
  1813  	if a == nil || b == nil {
  1814  		return false
  1815  	}
  1816  	return cmp.TableName(a.Name, b.Name) &&
  1817  		cmp.Exprs(a.Params, b.Params)
  1818  }
  1819  
  1820  // RefOfCaseExpr does deep equals between the two objects.
  1821  func (cmp *Comparator) RefOfCaseExpr(a, b *CaseExpr) bool {
  1822  	if a == b {
  1823  		return true
  1824  	}
  1825  	if a == nil || b == nil {
  1826  		return false
  1827  	}
  1828  	return cmp.Expr(a.Expr, b.Expr) &&
  1829  		cmp.SliceOfRefOfWhen(a.Whens, b.Whens) &&
  1830  		cmp.Expr(a.Else, b.Else)
  1831  }
  1832  
  1833  // RefOfCastExpr does deep equals between the two objects.
  1834  func (cmp *Comparator) RefOfCastExpr(a, b *CastExpr) bool {
  1835  	if a == b {
  1836  		return true
  1837  	}
  1838  	if a == nil || b == nil {
  1839  		return false
  1840  	}
  1841  	return a.Array == b.Array &&
  1842  		cmp.Expr(a.Expr, b.Expr) &&
  1843  		cmp.RefOfConvertType(a.Type, b.Type)
  1844  }
  1845  
  1846  // RefOfChangeColumn does deep equals between the two objects.
  1847  func (cmp *Comparator) RefOfChangeColumn(a, b *ChangeColumn) bool {
  1848  	if a == b {
  1849  		return true
  1850  	}
  1851  	if a == nil || b == nil {
  1852  		return false
  1853  	}
  1854  	return a.First == b.First &&
  1855  		cmp.RefOfColName(a.OldColumn, b.OldColumn) &&
  1856  		cmp.RefOfColumnDefinition(a.NewColDefinition, b.NewColDefinition) &&
  1857  		cmp.RefOfColName(a.After, b.After)
  1858  }
  1859  
  1860  // RefOfCharExpr does deep equals between the two objects.
  1861  func (cmp *Comparator) RefOfCharExpr(a, b *CharExpr) bool {
  1862  	if a == b {
  1863  		return true
  1864  	}
  1865  	if a == nil || b == nil {
  1866  		return false
  1867  	}
  1868  	return a.Charset == b.Charset &&
  1869  		cmp.Exprs(a.Exprs, b.Exprs)
  1870  }
  1871  
  1872  // RefOfCheckConstraintDefinition does deep equals between the two objects.
  1873  func (cmp *Comparator) RefOfCheckConstraintDefinition(a, b *CheckConstraintDefinition) bool {
  1874  	if a == b {
  1875  		return true
  1876  	}
  1877  	if a == nil || b == nil {
  1878  		return false
  1879  	}
  1880  	return a.Enforced == b.Enforced &&
  1881  		cmp.Expr(a.Expr, b.Expr)
  1882  }
  1883  
  1884  // RefOfColName does deep equals between the two objects.
  1885  func (cmp *Comparator) RefOfColName(a, b *ColName) bool {
  1886  	if a == b {
  1887  		return true
  1888  	}
  1889  	if a == nil || b == nil {
  1890  		return false
  1891  	}
  1892  	if cmp.RefOfColName_ != nil {
  1893  		return cmp.RefOfColName_(a, b)
  1894  	}
  1895  	return cmp.IdentifierCI(a.Name, b.Name) &&
  1896  		cmp.TableName(a.Qualifier, b.Qualifier)
  1897  }
  1898  
  1899  // RefOfCollateExpr does deep equals between the two objects.
  1900  func (cmp *Comparator) RefOfCollateExpr(a, b *CollateExpr) bool {
  1901  	if a == b {
  1902  		return true
  1903  	}
  1904  	if a == nil || b == nil {
  1905  		return false
  1906  	}
  1907  	return a.Collation == b.Collation &&
  1908  		cmp.Expr(a.Expr, b.Expr)
  1909  }
  1910  
  1911  // RefOfColumnDefinition does deep equals between the two objects.
  1912  func (cmp *Comparator) RefOfColumnDefinition(a, b *ColumnDefinition) bool {
  1913  	if a == b {
  1914  		return true
  1915  	}
  1916  	if a == nil || b == nil {
  1917  		return false
  1918  	}
  1919  	return cmp.IdentifierCI(a.Name, b.Name) &&
  1920  		cmp.RefOfColumnType(a.Type, b.Type)
  1921  }
  1922  
  1923  // RefOfColumnType does deep equals between the two objects.
  1924  func (cmp *Comparator) RefOfColumnType(a, b *ColumnType) bool {
  1925  	if a == b {
  1926  		return true
  1927  	}
  1928  	if a == nil || b == nil {
  1929  		return false
  1930  	}
  1931  	return a.Type == b.Type &&
  1932  		a.Unsigned == b.Unsigned &&
  1933  		a.Zerofill == b.Zerofill &&
  1934  		cmp.RefOfColumnTypeOptions(a.Options, b.Options) &&
  1935  		cmp.RefOfLiteral(a.Length, b.Length) &&
  1936  		cmp.RefOfLiteral(a.Scale, b.Scale) &&
  1937  		cmp.ColumnCharset(a.Charset, b.Charset) &&
  1938  		cmp.SliceOfString(a.EnumValues, b.EnumValues)
  1939  }
  1940  
  1941  // Columns does deep equals between the two objects.
  1942  func (cmp *Comparator) Columns(a, b Columns) bool {
  1943  	if len(a) != len(b) {
  1944  		return false
  1945  	}
  1946  	for i := 0; i < len(a); i++ {
  1947  		if !cmp.IdentifierCI(a[i], b[i]) {
  1948  			return false
  1949  		}
  1950  	}
  1951  	return true
  1952  }
  1953  
  1954  // RefOfCommentOnly does deep equals between the two objects.
  1955  func (cmp *Comparator) RefOfCommentOnly(a, b *CommentOnly) bool {
  1956  	if a == b {
  1957  		return true
  1958  	}
  1959  	if a == nil || b == nil {
  1960  		return false
  1961  	}
  1962  	return cmp.SliceOfString(a.Comments, b.Comments)
  1963  }
  1964  
  1965  // RefOfCommit does deep equals between the two objects.
  1966  func (cmp *Comparator) RefOfCommit(a, b *Commit) bool {
  1967  	if a == b {
  1968  		return true
  1969  	}
  1970  	if a == nil || b == nil {
  1971  		return false
  1972  	}
  1973  	return true
  1974  }
  1975  
  1976  // RefOfCommonTableExpr does deep equals between the two objects.
  1977  func (cmp *Comparator) RefOfCommonTableExpr(a, b *CommonTableExpr) bool {
  1978  	if a == b {
  1979  		return true
  1980  	}
  1981  	if a == nil || b == nil {
  1982  		return false
  1983  	}
  1984  	return cmp.IdentifierCS(a.ID, b.ID) &&
  1985  		cmp.Columns(a.Columns, b.Columns) &&
  1986  		cmp.RefOfSubquery(a.Subquery, b.Subquery)
  1987  }
  1988  
  1989  // RefOfComparisonExpr does deep equals between the two objects.
  1990  func (cmp *Comparator) RefOfComparisonExpr(a, b *ComparisonExpr) bool {
  1991  	if a == b {
  1992  		return true
  1993  	}
  1994  	if a == nil || b == nil {
  1995  		return false
  1996  	}
  1997  	return a.Operator == b.Operator &&
  1998  		cmp.Expr(a.Left, b.Left) &&
  1999  		cmp.Expr(a.Right, b.Right) &&
  2000  		cmp.Expr(a.Escape, b.Escape)
  2001  }
  2002  
  2003  // RefOfConstraintDefinition does deep equals between the two objects.
  2004  func (cmp *Comparator) RefOfConstraintDefinition(a, b *ConstraintDefinition) bool {
  2005  	if a == b {
  2006  		return true
  2007  	}
  2008  	if a == nil || b == nil {
  2009  		return false
  2010  	}
  2011  	return cmp.IdentifierCI(a.Name, b.Name) &&
  2012  		cmp.ConstraintInfo(a.Details, b.Details)
  2013  }
  2014  
  2015  // RefOfConvertExpr does deep equals between the two objects.
  2016  func (cmp *Comparator) RefOfConvertExpr(a, b *ConvertExpr) bool {
  2017  	if a == b {
  2018  		return true
  2019  	}
  2020  	if a == nil || b == nil {
  2021  		return false
  2022  	}
  2023  	return cmp.Expr(a.Expr, b.Expr) &&
  2024  		cmp.RefOfConvertType(a.Type, b.Type)
  2025  }
  2026  
  2027  // RefOfConvertType does deep equals between the two objects.
  2028  func (cmp *Comparator) RefOfConvertType(a, b *ConvertType) bool {
  2029  	if a == b {
  2030  		return true
  2031  	}
  2032  	if a == nil || b == nil {
  2033  		return false
  2034  	}
  2035  	return a.Type == b.Type &&
  2036  		cmp.RefOfLiteral(a.Length, b.Length) &&
  2037  		cmp.RefOfLiteral(a.Scale, b.Scale) &&
  2038  		cmp.ColumnCharset(a.Charset, b.Charset)
  2039  }
  2040  
  2041  // RefOfConvertUsingExpr does deep equals between the two objects.
  2042  func (cmp *Comparator) RefOfConvertUsingExpr(a, b *ConvertUsingExpr) bool {
  2043  	if a == b {
  2044  		return true
  2045  	}
  2046  	if a == nil || b == nil {
  2047  		return false
  2048  	}
  2049  	return a.Type == b.Type &&
  2050  		cmp.Expr(a.Expr, b.Expr)
  2051  }
  2052  
  2053  // RefOfCount does deep equals between the two objects.
  2054  func (cmp *Comparator) RefOfCount(a, b *Count) bool {
  2055  	if a == b {
  2056  		return true
  2057  	}
  2058  	if a == nil || b == nil {
  2059  		return false
  2060  	}
  2061  	return a.Distinct == b.Distinct &&
  2062  		cmp.Exprs(a.Args, b.Args)
  2063  }
  2064  
  2065  // RefOfCountStar does deep equals between the two objects.
  2066  func (cmp *Comparator) RefOfCountStar(a, b *CountStar) bool {
  2067  	if a == b {
  2068  		return true
  2069  	}
  2070  	if a == nil || b == nil {
  2071  		return false
  2072  	}
  2073  	return true
  2074  }
  2075  
  2076  // RefOfCreateDatabase does deep equals between the two objects.
  2077  func (cmp *Comparator) RefOfCreateDatabase(a, b *CreateDatabase) bool {
  2078  	if a == b {
  2079  		return true
  2080  	}
  2081  	if a == nil || b == nil {
  2082  		return false
  2083  	}
  2084  	return a.IfNotExists == b.IfNotExists &&
  2085  		a.FullyParsed == b.FullyParsed &&
  2086  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2087  		cmp.IdentifierCS(a.DBName, b.DBName) &&
  2088  		cmp.SliceOfDatabaseOption(a.CreateOptions, b.CreateOptions)
  2089  }
  2090  
  2091  // RefOfCreateTable does deep equals between the two objects.
  2092  func (cmp *Comparator) RefOfCreateTable(a, b *CreateTable) bool {
  2093  	if a == b {
  2094  		return true
  2095  	}
  2096  	if a == nil || b == nil {
  2097  		return false
  2098  	}
  2099  	return a.Temp == b.Temp &&
  2100  		a.IfNotExists == b.IfNotExists &&
  2101  		a.FullyParsed == b.FullyParsed &&
  2102  		cmp.TableName(a.Table, b.Table) &&
  2103  		cmp.RefOfTableSpec(a.TableSpec, b.TableSpec) &&
  2104  		cmp.RefOfOptLike(a.OptLike, b.OptLike) &&
  2105  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  2106  }
  2107  
  2108  // RefOfCreateView does deep equals between the two objects.
  2109  func (cmp *Comparator) RefOfCreateView(a, b *CreateView) bool {
  2110  	if a == b {
  2111  		return true
  2112  	}
  2113  	if a == nil || b == nil {
  2114  		return false
  2115  	}
  2116  	return a.Algorithm == b.Algorithm &&
  2117  		a.Security == b.Security &&
  2118  		a.CheckOption == b.CheckOption &&
  2119  		a.IsReplace == b.IsReplace &&
  2120  		cmp.TableName(a.ViewName, b.ViewName) &&
  2121  		cmp.RefOfDefiner(a.Definer, b.Definer) &&
  2122  		cmp.Columns(a.Columns, b.Columns) &&
  2123  		cmp.SelectStatement(a.Select, b.Select) &&
  2124  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  2125  }
  2126  
  2127  // RefOfCurTimeFuncExpr does deep equals between the two objects.
  2128  func (cmp *Comparator) RefOfCurTimeFuncExpr(a, b *CurTimeFuncExpr) bool {
  2129  	if a == b {
  2130  		return true
  2131  	}
  2132  	if a == nil || b == nil {
  2133  		return false
  2134  	}
  2135  	return cmp.IdentifierCI(a.Name, b.Name) &&
  2136  		cmp.Expr(a.Fsp, b.Fsp)
  2137  }
  2138  
  2139  // RefOfDeallocateStmt does deep equals between the two objects.
  2140  func (cmp *Comparator) RefOfDeallocateStmt(a, b *DeallocateStmt) bool {
  2141  	if a == b {
  2142  		return true
  2143  	}
  2144  	if a == nil || b == nil {
  2145  		return false
  2146  	}
  2147  	return a.Type == b.Type &&
  2148  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2149  		cmp.IdentifierCI(a.Name, b.Name)
  2150  }
  2151  
  2152  // RefOfDefault does deep equals between the two objects.
  2153  func (cmp *Comparator) RefOfDefault(a, b *Default) bool {
  2154  	if a == b {
  2155  		return true
  2156  	}
  2157  	if a == nil || b == nil {
  2158  		return false
  2159  	}
  2160  	return a.ColName == b.ColName
  2161  }
  2162  
  2163  // RefOfDefiner does deep equals between the two objects.
  2164  func (cmp *Comparator) RefOfDefiner(a, b *Definer) bool {
  2165  	if a == b {
  2166  		return true
  2167  	}
  2168  	if a == nil || b == nil {
  2169  		return false
  2170  	}
  2171  	return a.Name == b.Name &&
  2172  		a.Address == b.Address
  2173  }
  2174  
  2175  // RefOfDelete does deep equals between the two objects.
  2176  func (cmp *Comparator) RefOfDelete(a, b *Delete) bool {
  2177  	if a == b {
  2178  		return true
  2179  	}
  2180  	if a == nil || b == nil {
  2181  		return false
  2182  	}
  2183  	return cmp.RefOfWith(a.With, b.With) &&
  2184  		a.Ignore == b.Ignore &&
  2185  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2186  		cmp.TableNames(a.Targets, b.Targets) &&
  2187  		cmp.TableExprs(a.TableExprs, b.TableExprs) &&
  2188  		cmp.Partitions(a.Partitions, b.Partitions) &&
  2189  		cmp.RefOfWhere(a.Where, b.Where) &&
  2190  		cmp.OrderBy(a.OrderBy, b.OrderBy) &&
  2191  		cmp.RefOfLimit(a.Limit, b.Limit)
  2192  }
  2193  
  2194  // RefOfDerivedTable does deep equals between the two objects.
  2195  func (cmp *Comparator) RefOfDerivedTable(a, b *DerivedTable) bool {
  2196  	if a == b {
  2197  		return true
  2198  	}
  2199  	if a == nil || b == nil {
  2200  		return false
  2201  	}
  2202  	return a.Lateral == b.Lateral &&
  2203  		cmp.SelectStatement(a.Select, b.Select)
  2204  }
  2205  
  2206  // RefOfDropColumn does deep equals between the two objects.
  2207  func (cmp *Comparator) RefOfDropColumn(a, b *DropColumn) bool {
  2208  	if a == b {
  2209  		return true
  2210  	}
  2211  	if a == nil || b == nil {
  2212  		return false
  2213  	}
  2214  	return cmp.RefOfColName(a.Name, b.Name)
  2215  }
  2216  
  2217  // RefOfDropDatabase does deep equals between the two objects.
  2218  func (cmp *Comparator) RefOfDropDatabase(a, b *DropDatabase) bool {
  2219  	if a == b {
  2220  		return true
  2221  	}
  2222  	if a == nil || b == nil {
  2223  		return false
  2224  	}
  2225  	return a.IfExists == b.IfExists &&
  2226  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2227  		cmp.IdentifierCS(a.DBName, b.DBName)
  2228  }
  2229  
  2230  // RefOfDropKey does deep equals between the two objects.
  2231  func (cmp *Comparator) RefOfDropKey(a, b *DropKey) bool {
  2232  	if a == b {
  2233  		return true
  2234  	}
  2235  	if a == nil || b == nil {
  2236  		return false
  2237  	}
  2238  	return a.Type == b.Type &&
  2239  		cmp.IdentifierCI(a.Name, b.Name)
  2240  }
  2241  
  2242  // RefOfDropTable does deep equals between the two objects.
  2243  func (cmp *Comparator) RefOfDropTable(a, b *DropTable) bool {
  2244  	if a == b {
  2245  		return true
  2246  	}
  2247  	if a == nil || b == nil {
  2248  		return false
  2249  	}
  2250  	return a.Temp == b.Temp &&
  2251  		a.IfExists == b.IfExists &&
  2252  		cmp.TableNames(a.FromTables, b.FromTables) &&
  2253  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  2254  }
  2255  
  2256  // RefOfDropView does deep equals between the two objects.
  2257  func (cmp *Comparator) RefOfDropView(a, b *DropView) bool {
  2258  	if a == b {
  2259  		return true
  2260  	}
  2261  	if a == nil || b == nil {
  2262  		return false
  2263  	}
  2264  	return a.IfExists == b.IfExists &&
  2265  		cmp.TableNames(a.FromTables, b.FromTables) &&
  2266  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  2267  }
  2268  
  2269  // RefOfExecuteStmt does deep equals between the two objects.
  2270  func (cmp *Comparator) RefOfExecuteStmt(a, b *ExecuteStmt) bool {
  2271  	if a == b {
  2272  		return true
  2273  	}
  2274  	if a == nil || b == nil {
  2275  		return false
  2276  	}
  2277  	return cmp.IdentifierCI(a.Name, b.Name) &&
  2278  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2279  		cmp.SliceOfRefOfVariable(a.Arguments, b.Arguments)
  2280  }
  2281  
  2282  // RefOfExistsExpr does deep equals between the two objects.
  2283  func (cmp *Comparator) RefOfExistsExpr(a, b *ExistsExpr) bool {
  2284  	if a == b {
  2285  		return true
  2286  	}
  2287  	if a == nil || b == nil {
  2288  		return false
  2289  	}
  2290  	return cmp.RefOfSubquery(a.Subquery, b.Subquery)
  2291  }
  2292  
  2293  // RefOfExplainStmt does deep equals between the two objects.
  2294  func (cmp *Comparator) RefOfExplainStmt(a, b *ExplainStmt) bool {
  2295  	if a == b {
  2296  		return true
  2297  	}
  2298  	if a == nil || b == nil {
  2299  		return false
  2300  	}
  2301  	return a.Type == b.Type &&
  2302  		cmp.Statement(a.Statement, b.Statement) &&
  2303  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  2304  }
  2305  
  2306  // RefOfExplainTab does deep equals between the two objects.
  2307  func (cmp *Comparator) RefOfExplainTab(a, b *ExplainTab) bool {
  2308  	if a == b {
  2309  		return true
  2310  	}
  2311  	if a == nil || b == nil {
  2312  		return false
  2313  	}
  2314  	return a.Wild == b.Wild &&
  2315  		cmp.TableName(a.Table, b.Table)
  2316  }
  2317  
  2318  // Exprs does deep equals between the two objects.
  2319  func (cmp *Comparator) Exprs(a, b Exprs) bool {
  2320  	if len(a) != len(b) {
  2321  		return false
  2322  	}
  2323  	for i := 0; i < len(a); i++ {
  2324  		if !cmp.Expr(a[i], b[i]) {
  2325  			return false
  2326  		}
  2327  	}
  2328  	return true
  2329  }
  2330  
  2331  // RefOfExtractFuncExpr does deep equals between the two objects.
  2332  func (cmp *Comparator) RefOfExtractFuncExpr(a, b *ExtractFuncExpr) bool {
  2333  	if a == b {
  2334  		return true
  2335  	}
  2336  	if a == nil || b == nil {
  2337  		return false
  2338  	}
  2339  	return a.IntervalTypes == b.IntervalTypes &&
  2340  		cmp.Expr(a.Expr, b.Expr)
  2341  }
  2342  
  2343  // RefOfExtractValueExpr does deep equals between the two objects.
  2344  func (cmp *Comparator) RefOfExtractValueExpr(a, b *ExtractValueExpr) bool {
  2345  	if a == b {
  2346  		return true
  2347  	}
  2348  	if a == nil || b == nil {
  2349  		return false
  2350  	}
  2351  	return cmp.Expr(a.Fragment, b.Fragment) &&
  2352  		cmp.Expr(a.XPathExpr, b.XPathExpr)
  2353  }
  2354  
  2355  // RefOfExtractedSubquery does deep equals between the two objects.
  2356  func (cmp *Comparator) RefOfExtractedSubquery(a, b *ExtractedSubquery) bool {
  2357  	if a == b {
  2358  		return true
  2359  	}
  2360  	if a == nil || b == nil {
  2361  		return false
  2362  	}
  2363  	return a.OpCode == b.OpCode &&
  2364  		a.NeedsRewrite == b.NeedsRewrite &&
  2365  		a.hasValuesArg == b.hasValuesArg &&
  2366  		a.argName == b.argName &&
  2367  		cmp.Expr(a.Original, b.Original) &&
  2368  		cmp.RefOfSubquery(a.Subquery, b.Subquery) &&
  2369  		cmp.Expr(a.OtherSide, b.OtherSide) &&
  2370  		cmp.Expr(a.alternative, b.alternative)
  2371  }
  2372  
  2373  // RefOfFirstOrLastValueExpr does deep equals between the two objects.
  2374  func (cmp *Comparator) RefOfFirstOrLastValueExpr(a, b *FirstOrLastValueExpr) bool {
  2375  	if a == b {
  2376  		return true
  2377  	}
  2378  	if a == nil || b == nil {
  2379  		return false
  2380  	}
  2381  	return a.Type == b.Type &&
  2382  		cmp.Expr(a.Expr, b.Expr) &&
  2383  		cmp.RefOfNullTreatmentClause(a.NullTreatmentClause, b.NullTreatmentClause) &&
  2384  		cmp.RefOfOverClause(a.OverClause, b.OverClause)
  2385  }
  2386  
  2387  // RefOfFlush does deep equals between the two objects.
  2388  func (cmp *Comparator) RefOfFlush(a, b *Flush) bool {
  2389  	if a == b {
  2390  		return true
  2391  	}
  2392  	if a == nil || b == nil {
  2393  		return false
  2394  	}
  2395  	return a.IsLocal == b.IsLocal &&
  2396  		a.WithLock == b.WithLock &&
  2397  		a.ForExport == b.ForExport &&
  2398  		cmp.SliceOfString(a.FlushOptions, b.FlushOptions) &&
  2399  		cmp.TableNames(a.TableNames, b.TableNames)
  2400  }
  2401  
  2402  // RefOfForce does deep equals between the two objects.
  2403  func (cmp *Comparator) RefOfForce(a, b *Force) bool {
  2404  	if a == b {
  2405  		return true
  2406  	}
  2407  	if a == nil || b == nil {
  2408  		return false
  2409  	}
  2410  	return true
  2411  }
  2412  
  2413  // RefOfForeignKeyDefinition does deep equals between the two objects.
  2414  func (cmp *Comparator) RefOfForeignKeyDefinition(a, b *ForeignKeyDefinition) bool {
  2415  	if a == b {
  2416  		return true
  2417  	}
  2418  	if a == nil || b == nil {
  2419  		return false
  2420  	}
  2421  	return cmp.Columns(a.Source, b.Source) &&
  2422  		cmp.IdentifierCI(a.IndexName, b.IndexName) &&
  2423  		cmp.RefOfReferenceDefinition(a.ReferenceDefinition, b.ReferenceDefinition)
  2424  }
  2425  
  2426  // RefOfFrameClause does deep equals between the two objects.
  2427  func (cmp *Comparator) RefOfFrameClause(a, b *FrameClause) bool {
  2428  	if a == b {
  2429  		return true
  2430  	}
  2431  	if a == nil || b == nil {
  2432  		return false
  2433  	}
  2434  	return a.Unit == b.Unit &&
  2435  		cmp.RefOfFramePoint(a.Start, b.Start) &&
  2436  		cmp.RefOfFramePoint(a.End, b.End)
  2437  }
  2438  
  2439  // RefOfFramePoint does deep equals between the two objects.
  2440  func (cmp *Comparator) RefOfFramePoint(a, b *FramePoint) bool {
  2441  	if a == b {
  2442  		return true
  2443  	}
  2444  	if a == nil || b == nil {
  2445  		return false
  2446  	}
  2447  	return a.Type == b.Type &&
  2448  		cmp.Expr(a.Expr, b.Expr)
  2449  }
  2450  
  2451  // RefOfFromFirstLastClause does deep equals between the two objects.
  2452  func (cmp *Comparator) RefOfFromFirstLastClause(a, b *FromFirstLastClause) bool {
  2453  	if a == b {
  2454  		return true
  2455  	}
  2456  	if a == nil || b == nil {
  2457  		return false
  2458  	}
  2459  	return a.Type == b.Type
  2460  }
  2461  
  2462  // RefOfFuncExpr does deep equals between the two objects.
  2463  func (cmp *Comparator) RefOfFuncExpr(a, b *FuncExpr) bool {
  2464  	if a == b {
  2465  		return true
  2466  	}
  2467  	if a == nil || b == nil {
  2468  		return false
  2469  	}
  2470  	return cmp.IdentifierCS(a.Qualifier, b.Qualifier) &&
  2471  		cmp.IdentifierCI(a.Name, b.Name) &&
  2472  		cmp.SelectExprs(a.Exprs, b.Exprs)
  2473  }
  2474  
  2475  // RefOfGTIDFuncExpr does deep equals between the two objects.
  2476  func (cmp *Comparator) RefOfGTIDFuncExpr(a, b *GTIDFuncExpr) bool {
  2477  	if a == b {
  2478  		return true
  2479  	}
  2480  	if a == nil || b == nil {
  2481  		return false
  2482  	}
  2483  	return a.Type == b.Type &&
  2484  		cmp.Expr(a.Set1, b.Set1) &&
  2485  		cmp.Expr(a.Set2, b.Set2) &&
  2486  		cmp.Expr(a.Timeout, b.Timeout) &&
  2487  		cmp.Expr(a.Channel, b.Channel)
  2488  }
  2489  
  2490  // GroupBy does deep equals between the two objects.
  2491  func (cmp *Comparator) GroupBy(a, b GroupBy) bool {
  2492  	if len(a) != len(b) {
  2493  		return false
  2494  	}
  2495  	for i := 0; i < len(a); i++ {
  2496  		if !cmp.Expr(a[i], b[i]) {
  2497  			return false
  2498  		}
  2499  	}
  2500  	return true
  2501  }
  2502  
  2503  // RefOfGroupConcatExpr does deep equals between the two objects.
  2504  func (cmp *Comparator) RefOfGroupConcatExpr(a, b *GroupConcatExpr) bool {
  2505  	if a == b {
  2506  		return true
  2507  	}
  2508  	if a == nil || b == nil {
  2509  		return false
  2510  	}
  2511  	return a.Distinct == b.Distinct &&
  2512  		a.Separator == b.Separator &&
  2513  		cmp.Exprs(a.Exprs, b.Exprs) &&
  2514  		cmp.OrderBy(a.OrderBy, b.OrderBy) &&
  2515  		cmp.RefOfLimit(a.Limit, b.Limit)
  2516  }
  2517  
  2518  // IdentifierCI does deep equals between the two objects.
  2519  func (cmp *Comparator) IdentifierCI(a, b IdentifierCI) bool {
  2520  	return a.val == b.val &&
  2521  		a.lowered == b.lowered
  2522  }
  2523  
  2524  // IdentifierCS does deep equals between the two objects.
  2525  func (cmp *Comparator) IdentifierCS(a, b IdentifierCS) bool {
  2526  	return a.v == b.v
  2527  }
  2528  
  2529  // RefOfIndexDefinition does deep equals between the two objects.
  2530  func (cmp *Comparator) RefOfIndexDefinition(a, b *IndexDefinition) bool {
  2531  	if a == b {
  2532  		return true
  2533  	}
  2534  	if a == nil || b == nil {
  2535  		return false
  2536  	}
  2537  	return cmp.RefOfIndexInfo(a.Info, b.Info) &&
  2538  		cmp.SliceOfRefOfIndexColumn(a.Columns, b.Columns) &&
  2539  		cmp.SliceOfRefOfIndexOption(a.Options, b.Options)
  2540  }
  2541  
  2542  // RefOfIndexHint does deep equals between the two objects.
  2543  func (cmp *Comparator) RefOfIndexHint(a, b *IndexHint) bool {
  2544  	if a == b {
  2545  		return true
  2546  	}
  2547  	if a == nil || b == nil {
  2548  		return false
  2549  	}
  2550  	return a.Type == b.Type &&
  2551  		a.ForType == b.ForType &&
  2552  		cmp.SliceOfIdentifierCI(a.Indexes, b.Indexes)
  2553  }
  2554  
  2555  // IndexHints does deep equals between the two objects.
  2556  func (cmp *Comparator) IndexHints(a, b IndexHints) bool {
  2557  	if len(a) != len(b) {
  2558  		return false
  2559  	}
  2560  	for i := 0; i < len(a); i++ {
  2561  		if !cmp.RefOfIndexHint(a[i], b[i]) {
  2562  			return false
  2563  		}
  2564  	}
  2565  	return true
  2566  }
  2567  
  2568  // RefOfIndexInfo does deep equals between the two objects.
  2569  func (cmp *Comparator) RefOfIndexInfo(a, b *IndexInfo) bool {
  2570  	if a == b {
  2571  		return true
  2572  	}
  2573  	if a == nil || b == nil {
  2574  		return false
  2575  	}
  2576  	return a.Type == b.Type &&
  2577  		a.Primary == b.Primary &&
  2578  		a.Spatial == b.Spatial &&
  2579  		a.Fulltext == b.Fulltext &&
  2580  		a.Unique == b.Unique &&
  2581  		cmp.IdentifierCI(a.Name, b.Name) &&
  2582  		cmp.IdentifierCI(a.ConstraintName, b.ConstraintName)
  2583  }
  2584  
  2585  // RefOfInsert does deep equals between the two objects.
  2586  func (cmp *Comparator) RefOfInsert(a, b *Insert) bool {
  2587  	if a == b {
  2588  		return true
  2589  	}
  2590  	if a == nil || b == nil {
  2591  		return false
  2592  	}
  2593  	return a.Action == b.Action &&
  2594  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  2595  		a.Ignore == b.Ignore &&
  2596  		cmp.TableName(a.Table, b.Table) &&
  2597  		cmp.Partitions(a.Partitions, b.Partitions) &&
  2598  		cmp.Columns(a.Columns, b.Columns) &&
  2599  		cmp.InsertRows(a.Rows, b.Rows) &&
  2600  		cmp.OnDup(a.OnDup, b.OnDup)
  2601  }
  2602  
  2603  // RefOfInsertExpr does deep equals between the two objects.
  2604  func (cmp *Comparator) RefOfInsertExpr(a, b *InsertExpr) bool {
  2605  	if a == b {
  2606  		return true
  2607  	}
  2608  	if a == nil || b == nil {
  2609  		return false
  2610  	}
  2611  	return cmp.Expr(a.Str, b.Str) &&
  2612  		cmp.Expr(a.Pos, b.Pos) &&
  2613  		cmp.Expr(a.Len, b.Len) &&
  2614  		cmp.Expr(a.NewStr, b.NewStr)
  2615  }
  2616  
  2617  // RefOfIntervalExpr does deep equals between the two objects.
  2618  func (cmp *Comparator) RefOfIntervalExpr(a, b *IntervalExpr) bool {
  2619  	if a == b {
  2620  		return true
  2621  	}
  2622  	if a == nil || b == nil {
  2623  		return false
  2624  	}
  2625  	return a.Unit == b.Unit &&
  2626  		cmp.Expr(a.Expr, b.Expr)
  2627  }
  2628  
  2629  // RefOfIntervalFuncExpr does deep equals between the two objects.
  2630  func (cmp *Comparator) RefOfIntervalFuncExpr(a, b *IntervalFuncExpr) bool {
  2631  	if a == b {
  2632  		return true
  2633  	}
  2634  	if a == nil || b == nil {
  2635  		return false
  2636  	}
  2637  	return cmp.Expr(a.Expr, b.Expr) &&
  2638  		cmp.Exprs(a.Exprs, b.Exprs)
  2639  }
  2640  
  2641  // RefOfIntroducerExpr does deep equals between the two objects.
  2642  func (cmp *Comparator) RefOfIntroducerExpr(a, b *IntroducerExpr) bool {
  2643  	if a == b {
  2644  		return true
  2645  	}
  2646  	if a == nil || b == nil {
  2647  		return false
  2648  	}
  2649  	return a.CharacterSet == b.CharacterSet &&
  2650  		cmp.Expr(a.Expr, b.Expr)
  2651  }
  2652  
  2653  // RefOfIsExpr does deep equals between the two objects.
  2654  func (cmp *Comparator) RefOfIsExpr(a, b *IsExpr) bool {
  2655  	if a == b {
  2656  		return true
  2657  	}
  2658  	if a == nil || b == nil {
  2659  		return false
  2660  	}
  2661  	return cmp.Expr(a.Left, b.Left) &&
  2662  		a.Right == b.Right
  2663  }
  2664  
  2665  // RefOfJSONArrayExpr does deep equals between the two objects.
  2666  func (cmp *Comparator) RefOfJSONArrayExpr(a, b *JSONArrayExpr) bool {
  2667  	if a == b {
  2668  		return true
  2669  	}
  2670  	if a == nil || b == nil {
  2671  		return false
  2672  	}
  2673  	return cmp.Exprs(a.Params, b.Params)
  2674  }
  2675  
  2676  // RefOfJSONAttributesExpr does deep equals between the two objects.
  2677  func (cmp *Comparator) RefOfJSONAttributesExpr(a, b *JSONAttributesExpr) bool {
  2678  	if a == b {
  2679  		return true
  2680  	}
  2681  	if a == nil || b == nil {
  2682  		return false
  2683  	}
  2684  	return a.Type == b.Type &&
  2685  		cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2686  		cmp.Expr(a.Path, b.Path)
  2687  }
  2688  
  2689  // RefOfJSONContainsExpr does deep equals between the two objects.
  2690  func (cmp *Comparator) RefOfJSONContainsExpr(a, b *JSONContainsExpr) bool {
  2691  	if a == b {
  2692  		return true
  2693  	}
  2694  	if a == nil || b == nil {
  2695  		return false
  2696  	}
  2697  	return cmp.Expr(a.Target, b.Target) &&
  2698  		cmp.Expr(a.Candidate, b.Candidate) &&
  2699  		cmp.SliceOfExpr(a.PathList, b.PathList)
  2700  }
  2701  
  2702  // RefOfJSONContainsPathExpr does deep equals between the two objects.
  2703  func (cmp *Comparator) RefOfJSONContainsPathExpr(a, b *JSONContainsPathExpr) bool {
  2704  	if a == b {
  2705  		return true
  2706  	}
  2707  	if a == nil || b == nil {
  2708  		return false
  2709  	}
  2710  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2711  		cmp.Expr(a.OneOrAll, b.OneOrAll) &&
  2712  		cmp.SliceOfExpr(a.PathList, b.PathList)
  2713  }
  2714  
  2715  // RefOfJSONExtractExpr does deep equals between the two objects.
  2716  func (cmp *Comparator) RefOfJSONExtractExpr(a, b *JSONExtractExpr) bool {
  2717  	if a == b {
  2718  		return true
  2719  	}
  2720  	if a == nil || b == nil {
  2721  		return false
  2722  	}
  2723  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2724  		cmp.SliceOfExpr(a.PathList, b.PathList)
  2725  }
  2726  
  2727  // RefOfJSONKeysExpr does deep equals between the two objects.
  2728  func (cmp *Comparator) RefOfJSONKeysExpr(a, b *JSONKeysExpr) bool {
  2729  	if a == b {
  2730  		return true
  2731  	}
  2732  	if a == nil || b == nil {
  2733  		return false
  2734  	}
  2735  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2736  		cmp.Expr(a.Path, b.Path)
  2737  }
  2738  
  2739  // RefOfJSONObjectExpr does deep equals between the two objects.
  2740  func (cmp *Comparator) RefOfJSONObjectExpr(a, b *JSONObjectExpr) bool {
  2741  	if a == b {
  2742  		return true
  2743  	}
  2744  	if a == nil || b == nil {
  2745  		return false
  2746  	}
  2747  	return cmp.SliceOfRefOfJSONObjectParam(a.Params, b.Params)
  2748  }
  2749  
  2750  // RefOfJSONObjectParam does deep equals between the two objects.
  2751  func (cmp *Comparator) RefOfJSONObjectParam(a, b *JSONObjectParam) bool {
  2752  	if a == b {
  2753  		return true
  2754  	}
  2755  	if a == nil || b == nil {
  2756  		return false
  2757  	}
  2758  	return cmp.Expr(a.Key, b.Key) &&
  2759  		cmp.Expr(a.Value, b.Value)
  2760  }
  2761  
  2762  // RefOfJSONOverlapsExpr does deep equals between the two objects.
  2763  func (cmp *Comparator) RefOfJSONOverlapsExpr(a, b *JSONOverlapsExpr) bool {
  2764  	if a == b {
  2765  		return true
  2766  	}
  2767  	if a == nil || b == nil {
  2768  		return false
  2769  	}
  2770  	return cmp.Expr(a.JSONDoc1, b.JSONDoc1) &&
  2771  		cmp.Expr(a.JSONDoc2, b.JSONDoc2)
  2772  }
  2773  
  2774  // RefOfJSONPrettyExpr does deep equals between the two objects.
  2775  func (cmp *Comparator) RefOfJSONPrettyExpr(a, b *JSONPrettyExpr) bool {
  2776  	if a == b {
  2777  		return true
  2778  	}
  2779  	if a == nil || b == nil {
  2780  		return false
  2781  	}
  2782  	return cmp.Expr(a.JSONVal, b.JSONVal)
  2783  }
  2784  
  2785  // RefOfJSONQuoteExpr does deep equals between the two objects.
  2786  func (cmp *Comparator) RefOfJSONQuoteExpr(a, b *JSONQuoteExpr) bool {
  2787  	if a == b {
  2788  		return true
  2789  	}
  2790  	if a == nil || b == nil {
  2791  		return false
  2792  	}
  2793  	return cmp.Expr(a.StringArg, b.StringArg)
  2794  }
  2795  
  2796  // RefOfJSONRemoveExpr does deep equals between the two objects.
  2797  func (cmp *Comparator) RefOfJSONRemoveExpr(a, b *JSONRemoveExpr) bool {
  2798  	if a == b {
  2799  		return true
  2800  	}
  2801  	if a == nil || b == nil {
  2802  		return false
  2803  	}
  2804  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2805  		cmp.Exprs(a.PathList, b.PathList)
  2806  }
  2807  
  2808  // RefOfJSONSchemaValidFuncExpr does deep equals between the two objects.
  2809  func (cmp *Comparator) RefOfJSONSchemaValidFuncExpr(a, b *JSONSchemaValidFuncExpr) bool {
  2810  	if a == b {
  2811  		return true
  2812  	}
  2813  	if a == nil || b == nil {
  2814  		return false
  2815  	}
  2816  	return cmp.Expr(a.Schema, b.Schema) &&
  2817  		cmp.Expr(a.Document, b.Document)
  2818  }
  2819  
  2820  // RefOfJSONSchemaValidationReportFuncExpr does deep equals between the two objects.
  2821  func (cmp *Comparator) RefOfJSONSchemaValidationReportFuncExpr(a, b *JSONSchemaValidationReportFuncExpr) bool {
  2822  	if a == b {
  2823  		return true
  2824  	}
  2825  	if a == nil || b == nil {
  2826  		return false
  2827  	}
  2828  	return cmp.Expr(a.Schema, b.Schema) &&
  2829  		cmp.Expr(a.Document, b.Document)
  2830  }
  2831  
  2832  // RefOfJSONSearchExpr does deep equals between the two objects.
  2833  func (cmp *Comparator) RefOfJSONSearchExpr(a, b *JSONSearchExpr) bool {
  2834  	if a == b {
  2835  		return true
  2836  	}
  2837  	if a == nil || b == nil {
  2838  		return false
  2839  	}
  2840  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2841  		cmp.Expr(a.OneOrAll, b.OneOrAll) &&
  2842  		cmp.Expr(a.SearchStr, b.SearchStr) &&
  2843  		cmp.Expr(a.EscapeChar, b.EscapeChar) &&
  2844  		cmp.SliceOfExpr(a.PathList, b.PathList)
  2845  }
  2846  
  2847  // RefOfJSONStorageFreeExpr does deep equals between the two objects.
  2848  func (cmp *Comparator) RefOfJSONStorageFreeExpr(a, b *JSONStorageFreeExpr) bool {
  2849  	if a == b {
  2850  		return true
  2851  	}
  2852  	if a == nil || b == nil {
  2853  		return false
  2854  	}
  2855  	return cmp.Expr(a.JSONVal, b.JSONVal)
  2856  }
  2857  
  2858  // RefOfJSONStorageSizeExpr does deep equals between the two objects.
  2859  func (cmp *Comparator) RefOfJSONStorageSizeExpr(a, b *JSONStorageSizeExpr) bool {
  2860  	if a == b {
  2861  		return true
  2862  	}
  2863  	if a == nil || b == nil {
  2864  		return false
  2865  	}
  2866  	return cmp.Expr(a.JSONVal, b.JSONVal)
  2867  }
  2868  
  2869  // RefOfJSONTableExpr does deep equals between the two objects.
  2870  func (cmp *Comparator) RefOfJSONTableExpr(a, b *JSONTableExpr) bool {
  2871  	if a == b {
  2872  		return true
  2873  	}
  2874  	if a == nil || b == nil {
  2875  		return false
  2876  	}
  2877  	return cmp.Expr(a.Expr, b.Expr) &&
  2878  		cmp.IdentifierCS(a.Alias, b.Alias) &&
  2879  		cmp.Expr(a.Filter, b.Filter) &&
  2880  		cmp.SliceOfRefOfJtColumnDefinition(a.Columns, b.Columns)
  2881  }
  2882  
  2883  // RefOfJSONUnquoteExpr does deep equals between the two objects.
  2884  func (cmp *Comparator) RefOfJSONUnquoteExpr(a, b *JSONUnquoteExpr) bool {
  2885  	if a == b {
  2886  		return true
  2887  	}
  2888  	if a == nil || b == nil {
  2889  		return false
  2890  	}
  2891  	return cmp.Expr(a.JSONValue, b.JSONValue)
  2892  }
  2893  
  2894  // RefOfJSONValueExpr does deep equals between the two objects.
  2895  func (cmp *Comparator) RefOfJSONValueExpr(a, b *JSONValueExpr) bool {
  2896  	if a == b {
  2897  		return true
  2898  	}
  2899  	if a == nil || b == nil {
  2900  		return false
  2901  	}
  2902  	return cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2903  		cmp.Expr(a.Path, b.Path) &&
  2904  		cmp.RefOfConvertType(a.ReturningType, b.ReturningType) &&
  2905  		cmp.RefOfJtOnResponse(a.EmptyOnResponse, b.EmptyOnResponse) &&
  2906  		cmp.RefOfJtOnResponse(a.ErrorOnResponse, b.ErrorOnResponse)
  2907  }
  2908  
  2909  // RefOfJSONValueMergeExpr does deep equals between the two objects.
  2910  func (cmp *Comparator) RefOfJSONValueMergeExpr(a, b *JSONValueMergeExpr) bool {
  2911  	if a == b {
  2912  		return true
  2913  	}
  2914  	if a == nil || b == nil {
  2915  		return false
  2916  	}
  2917  	return a.Type == b.Type &&
  2918  		cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2919  		cmp.Exprs(a.JSONDocList, b.JSONDocList)
  2920  }
  2921  
  2922  // RefOfJSONValueModifierExpr does deep equals between the two objects.
  2923  func (cmp *Comparator) RefOfJSONValueModifierExpr(a, b *JSONValueModifierExpr) bool {
  2924  	if a == b {
  2925  		return true
  2926  	}
  2927  	if a == nil || b == nil {
  2928  		return false
  2929  	}
  2930  	return a.Type == b.Type &&
  2931  		cmp.Expr(a.JSONDoc, b.JSONDoc) &&
  2932  		cmp.SliceOfRefOfJSONObjectParam(a.Params, b.Params)
  2933  }
  2934  
  2935  // RefOfJoinCondition does deep equals between the two objects.
  2936  func (cmp *Comparator) RefOfJoinCondition(a, b *JoinCondition) bool {
  2937  	if a == b {
  2938  		return true
  2939  	}
  2940  	if a == nil || b == nil {
  2941  		return false
  2942  	}
  2943  	return cmp.Expr(a.On, b.On) &&
  2944  		cmp.Columns(a.Using, b.Using)
  2945  }
  2946  
  2947  // RefOfJoinTableExpr does deep equals between the two objects.
  2948  func (cmp *Comparator) RefOfJoinTableExpr(a, b *JoinTableExpr) bool {
  2949  	if a == b {
  2950  		return true
  2951  	}
  2952  	if a == nil || b == nil {
  2953  		return false
  2954  	}
  2955  	return cmp.TableExpr(a.LeftExpr, b.LeftExpr) &&
  2956  		a.Join == b.Join &&
  2957  		cmp.TableExpr(a.RightExpr, b.RightExpr) &&
  2958  		cmp.RefOfJoinCondition(a.Condition, b.Condition)
  2959  }
  2960  
  2961  // RefOfJtColumnDefinition does deep equals between the two objects.
  2962  func (cmp *Comparator) RefOfJtColumnDefinition(a, b *JtColumnDefinition) bool {
  2963  	if a == b {
  2964  		return true
  2965  	}
  2966  	if a == nil || b == nil {
  2967  		return false
  2968  	}
  2969  	return cmp.RefOfJtOrdinalColDef(a.JtOrdinal, b.JtOrdinal) &&
  2970  		cmp.RefOfJtPathColDef(a.JtPath, b.JtPath) &&
  2971  		cmp.RefOfJtNestedPathColDef(a.JtNestedPath, b.JtNestedPath)
  2972  }
  2973  
  2974  // RefOfJtOnResponse does deep equals between the two objects.
  2975  func (cmp *Comparator) RefOfJtOnResponse(a, b *JtOnResponse) bool {
  2976  	if a == b {
  2977  		return true
  2978  	}
  2979  	if a == nil || b == nil {
  2980  		return false
  2981  	}
  2982  	return a.ResponseType == b.ResponseType &&
  2983  		cmp.Expr(a.Expr, b.Expr)
  2984  }
  2985  
  2986  // RefOfKeyState does deep equals between the two objects.
  2987  func (cmp *Comparator) RefOfKeyState(a, b *KeyState) bool {
  2988  	if a == b {
  2989  		return true
  2990  	}
  2991  	if a == nil || b == nil {
  2992  		return false
  2993  	}
  2994  	return a.Enable == b.Enable
  2995  }
  2996  
  2997  // RefOfLagLeadExpr does deep equals between the two objects.
  2998  func (cmp *Comparator) RefOfLagLeadExpr(a, b *LagLeadExpr) bool {
  2999  	if a == b {
  3000  		return true
  3001  	}
  3002  	if a == nil || b == nil {
  3003  		return false
  3004  	}
  3005  	return a.Type == b.Type &&
  3006  		cmp.Expr(a.Expr, b.Expr) &&
  3007  		cmp.Expr(a.N, b.N) &&
  3008  		cmp.Expr(a.Default, b.Default) &&
  3009  		cmp.RefOfOverClause(a.OverClause, b.OverClause) &&
  3010  		cmp.RefOfNullTreatmentClause(a.NullTreatmentClause, b.NullTreatmentClause)
  3011  }
  3012  
  3013  // RefOfLimit does deep equals between the two objects.
  3014  func (cmp *Comparator) RefOfLimit(a, b *Limit) bool {
  3015  	if a == b {
  3016  		return true
  3017  	}
  3018  	if a == nil || b == nil {
  3019  		return false
  3020  	}
  3021  	return cmp.Expr(a.Offset, b.Offset) &&
  3022  		cmp.Expr(a.Rowcount, b.Rowcount)
  3023  }
  3024  
  3025  // RefOfLiteral does deep equals between the two objects.
  3026  func (cmp *Comparator) RefOfLiteral(a, b *Literal) bool {
  3027  	if a == b {
  3028  		return true
  3029  	}
  3030  	if a == nil || b == nil {
  3031  		return false
  3032  	}
  3033  	return a.Val == b.Val &&
  3034  		a.Type == b.Type
  3035  }
  3036  
  3037  // RefOfLoad does deep equals between the two objects.
  3038  func (cmp *Comparator) RefOfLoad(a, b *Load) bool {
  3039  	if a == b {
  3040  		return true
  3041  	}
  3042  	if a == nil || b == nil {
  3043  		return false
  3044  	}
  3045  	return true
  3046  }
  3047  
  3048  // RefOfLocateExpr does deep equals between the two objects.
  3049  func (cmp *Comparator) RefOfLocateExpr(a, b *LocateExpr) bool {
  3050  	if a == b {
  3051  		return true
  3052  	}
  3053  	if a == nil || b == nil {
  3054  		return false
  3055  	}
  3056  	return cmp.Expr(a.SubStr, b.SubStr) &&
  3057  		cmp.Expr(a.Str, b.Str) &&
  3058  		cmp.Expr(a.Pos, b.Pos)
  3059  }
  3060  
  3061  // RefOfLockOption does deep equals between the two objects.
  3062  func (cmp *Comparator) RefOfLockOption(a, b *LockOption) bool {
  3063  	if a == b {
  3064  		return true
  3065  	}
  3066  	if a == nil || b == nil {
  3067  		return false
  3068  	}
  3069  	return a.Type == b.Type
  3070  }
  3071  
  3072  // RefOfLockTables does deep equals between the two objects.
  3073  func (cmp *Comparator) RefOfLockTables(a, b *LockTables) bool {
  3074  	if a == b {
  3075  		return true
  3076  	}
  3077  	if a == nil || b == nil {
  3078  		return false
  3079  	}
  3080  	return cmp.TableAndLockTypes(a.Tables, b.Tables)
  3081  }
  3082  
  3083  // RefOfLockingFunc does deep equals between the two objects.
  3084  func (cmp *Comparator) RefOfLockingFunc(a, b *LockingFunc) bool {
  3085  	if a == b {
  3086  		return true
  3087  	}
  3088  	if a == nil || b == nil {
  3089  		return false
  3090  	}
  3091  	return a.Type == b.Type &&
  3092  		cmp.Expr(a.Name, b.Name) &&
  3093  		cmp.Expr(a.Timeout, b.Timeout)
  3094  }
  3095  
  3096  // RefOfMatchExpr does deep equals between the two objects.
  3097  func (cmp *Comparator) RefOfMatchExpr(a, b *MatchExpr) bool {
  3098  	if a == b {
  3099  		return true
  3100  	}
  3101  	if a == nil || b == nil {
  3102  		return false
  3103  	}
  3104  	return cmp.SliceOfRefOfColName(a.Columns, b.Columns) &&
  3105  		cmp.Expr(a.Expr, b.Expr) &&
  3106  		a.Option == b.Option
  3107  }
  3108  
  3109  // RefOfMax does deep equals between the two objects.
  3110  func (cmp *Comparator) RefOfMax(a, b *Max) bool {
  3111  	if a == b {
  3112  		return true
  3113  	}
  3114  	if a == nil || b == nil {
  3115  		return false
  3116  	}
  3117  	return a.Distinct == b.Distinct &&
  3118  		cmp.Expr(a.Arg, b.Arg)
  3119  }
  3120  
  3121  // RefOfMemberOfExpr does deep equals between the two objects.
  3122  func (cmp *Comparator) RefOfMemberOfExpr(a, b *MemberOfExpr) bool {
  3123  	if a == b {
  3124  		return true
  3125  	}
  3126  	if a == nil || b == nil {
  3127  		return false
  3128  	}
  3129  	return cmp.Expr(a.Value, b.Value) &&
  3130  		cmp.Expr(a.JSONArr, b.JSONArr)
  3131  }
  3132  
  3133  // RefOfMin does deep equals between the two objects.
  3134  func (cmp *Comparator) RefOfMin(a, b *Min) bool {
  3135  	if a == b {
  3136  		return true
  3137  	}
  3138  	if a == nil || b == nil {
  3139  		return false
  3140  	}
  3141  	return a.Distinct == b.Distinct &&
  3142  		cmp.Expr(a.Arg, b.Arg)
  3143  }
  3144  
  3145  // RefOfModifyColumn does deep equals between the two objects.
  3146  func (cmp *Comparator) RefOfModifyColumn(a, b *ModifyColumn) bool {
  3147  	if a == b {
  3148  		return true
  3149  	}
  3150  	if a == nil || b == nil {
  3151  		return false
  3152  	}
  3153  	return a.First == b.First &&
  3154  		cmp.RefOfColumnDefinition(a.NewColDefinition, b.NewColDefinition) &&
  3155  		cmp.RefOfColName(a.After, b.After)
  3156  }
  3157  
  3158  // RefOfNTHValueExpr does deep equals between the two objects.
  3159  func (cmp *Comparator) RefOfNTHValueExpr(a, b *NTHValueExpr) bool {
  3160  	if a == b {
  3161  		return true
  3162  	}
  3163  	if a == nil || b == nil {
  3164  		return false
  3165  	}
  3166  	return cmp.Expr(a.Expr, b.Expr) &&
  3167  		cmp.Expr(a.N, b.N) &&
  3168  		cmp.RefOfOverClause(a.OverClause, b.OverClause) &&
  3169  		cmp.RefOfFromFirstLastClause(a.FromFirstLastClause, b.FromFirstLastClause) &&
  3170  		cmp.RefOfNullTreatmentClause(a.NullTreatmentClause, b.NullTreatmentClause)
  3171  }
  3172  
  3173  // RefOfNamedWindow does deep equals between the two objects.
  3174  func (cmp *Comparator) RefOfNamedWindow(a, b *NamedWindow) bool {
  3175  	if a == b {
  3176  		return true
  3177  	}
  3178  	if a == nil || b == nil {
  3179  		return false
  3180  	}
  3181  	return cmp.WindowDefinitions(a.Windows, b.Windows)
  3182  }
  3183  
  3184  // NamedWindows does deep equals between the two objects.
  3185  func (cmp *Comparator) NamedWindows(a, b NamedWindows) bool {
  3186  	if len(a) != len(b) {
  3187  		return false
  3188  	}
  3189  	for i := 0; i < len(a); i++ {
  3190  		if !cmp.RefOfNamedWindow(a[i], b[i]) {
  3191  			return false
  3192  		}
  3193  	}
  3194  	return true
  3195  }
  3196  
  3197  // RefOfNextval does deep equals between the two objects.
  3198  func (cmp *Comparator) RefOfNextval(a, b *Nextval) bool {
  3199  	if a == b {
  3200  		return true
  3201  	}
  3202  	if a == nil || b == nil {
  3203  		return false
  3204  	}
  3205  	return cmp.Expr(a.Expr, b.Expr)
  3206  }
  3207  
  3208  // RefOfNotExpr does deep equals between the two objects.
  3209  func (cmp *Comparator) RefOfNotExpr(a, b *NotExpr) bool {
  3210  	if a == b {
  3211  		return true
  3212  	}
  3213  	if a == nil || b == nil {
  3214  		return false
  3215  	}
  3216  	return cmp.Expr(a.Expr, b.Expr)
  3217  }
  3218  
  3219  // RefOfNtileExpr does deep equals between the two objects.
  3220  func (cmp *Comparator) RefOfNtileExpr(a, b *NtileExpr) bool {
  3221  	if a == b {
  3222  		return true
  3223  	}
  3224  	if a == nil || b == nil {
  3225  		return false
  3226  	}
  3227  	return cmp.Expr(a.N, b.N) &&
  3228  		cmp.RefOfOverClause(a.OverClause, b.OverClause)
  3229  }
  3230  
  3231  // RefOfNullTreatmentClause does deep equals between the two objects.
  3232  func (cmp *Comparator) RefOfNullTreatmentClause(a, b *NullTreatmentClause) bool {
  3233  	if a == b {
  3234  		return true
  3235  	}
  3236  	if a == nil || b == nil {
  3237  		return false
  3238  	}
  3239  	return a.Type == b.Type
  3240  }
  3241  
  3242  // RefOfNullVal does deep equals between the two objects.
  3243  func (cmp *Comparator) RefOfNullVal(a, b *NullVal) bool {
  3244  	if a == b {
  3245  		return true
  3246  	}
  3247  	if a == nil || b == nil {
  3248  		return false
  3249  	}
  3250  	return true
  3251  }
  3252  
  3253  // RefOfOffset does deep equals between the two objects.
  3254  func (cmp *Comparator) RefOfOffset(a, b *Offset) bool {
  3255  	if a == b {
  3256  		return true
  3257  	}
  3258  	if a == nil || b == nil {
  3259  		return false
  3260  	}
  3261  	return a.V == b.V &&
  3262  		a.Original == b.Original
  3263  }
  3264  
  3265  // OnDup does deep equals between the two objects.
  3266  func (cmp *Comparator) OnDup(a, b OnDup) bool {
  3267  	if len(a) != len(b) {
  3268  		return false
  3269  	}
  3270  	for i := 0; i < len(a); i++ {
  3271  		if !cmp.RefOfUpdateExpr(a[i], b[i]) {
  3272  			return false
  3273  		}
  3274  	}
  3275  	return true
  3276  }
  3277  
  3278  // RefOfOptLike does deep equals between the two objects.
  3279  func (cmp *Comparator) RefOfOptLike(a, b *OptLike) bool {
  3280  	if a == b {
  3281  		return true
  3282  	}
  3283  	if a == nil || b == nil {
  3284  		return false
  3285  	}
  3286  	return cmp.TableName(a.LikeTable, b.LikeTable)
  3287  }
  3288  
  3289  // RefOfOrExpr does deep equals between the two objects.
  3290  func (cmp *Comparator) RefOfOrExpr(a, b *OrExpr) bool {
  3291  	if a == b {
  3292  		return true
  3293  	}
  3294  	if a == nil || b == nil {
  3295  		return false
  3296  	}
  3297  	return cmp.Expr(a.Left, b.Left) &&
  3298  		cmp.Expr(a.Right, b.Right)
  3299  }
  3300  
  3301  // RefOfOrder does deep equals between the two objects.
  3302  func (cmp *Comparator) RefOfOrder(a, b *Order) bool {
  3303  	if a == b {
  3304  		return true
  3305  	}
  3306  	if a == nil || b == nil {
  3307  		return false
  3308  	}
  3309  	return cmp.Expr(a.Expr, b.Expr) &&
  3310  		a.Direction == b.Direction
  3311  }
  3312  
  3313  // OrderBy does deep equals between the two objects.
  3314  func (cmp *Comparator) OrderBy(a, b OrderBy) bool {
  3315  	if len(a) != len(b) {
  3316  		return false
  3317  	}
  3318  	for i := 0; i < len(a); i++ {
  3319  		if !cmp.RefOfOrder(a[i], b[i]) {
  3320  			return false
  3321  		}
  3322  	}
  3323  	return true
  3324  }
  3325  
  3326  // RefOfOrderByOption does deep equals between the two objects.
  3327  func (cmp *Comparator) RefOfOrderByOption(a, b *OrderByOption) bool {
  3328  	if a == b {
  3329  		return true
  3330  	}
  3331  	if a == nil || b == nil {
  3332  		return false
  3333  	}
  3334  	return cmp.Columns(a.Cols, b.Cols)
  3335  }
  3336  
  3337  // RefOfOtherAdmin does deep equals between the two objects.
  3338  func (cmp *Comparator) RefOfOtherAdmin(a, b *OtherAdmin) bool {
  3339  	if a == b {
  3340  		return true
  3341  	}
  3342  	if a == nil || b == nil {
  3343  		return false
  3344  	}
  3345  	return true
  3346  }
  3347  
  3348  // RefOfOtherRead does deep equals between the two objects.
  3349  func (cmp *Comparator) RefOfOtherRead(a, b *OtherRead) bool {
  3350  	if a == b {
  3351  		return true
  3352  	}
  3353  	if a == nil || b == nil {
  3354  		return false
  3355  	}
  3356  	return true
  3357  }
  3358  
  3359  // RefOfOverClause does deep equals between the two objects.
  3360  func (cmp *Comparator) RefOfOverClause(a, b *OverClause) bool {
  3361  	if a == b {
  3362  		return true
  3363  	}
  3364  	if a == nil || b == nil {
  3365  		return false
  3366  	}
  3367  	return cmp.IdentifierCI(a.WindowName, b.WindowName) &&
  3368  		cmp.RefOfWindowSpecification(a.WindowSpec, b.WindowSpec)
  3369  }
  3370  
  3371  // RefOfParenTableExpr does deep equals between the two objects.
  3372  func (cmp *Comparator) RefOfParenTableExpr(a, b *ParenTableExpr) bool {
  3373  	if a == b {
  3374  		return true
  3375  	}
  3376  	if a == nil || b == nil {
  3377  		return false
  3378  	}
  3379  	return cmp.TableExprs(a.Exprs, b.Exprs)
  3380  }
  3381  
  3382  // RefOfParsedComments does deep equals between the two objects.
  3383  func (cmp *Comparator) RefOfParsedComments(a, b *ParsedComments) bool {
  3384  	if a == b {
  3385  		return true
  3386  	}
  3387  	if a == nil || b == nil {
  3388  		return false
  3389  	}
  3390  	return cmp.Comments(a.comments, b.comments)
  3391  }
  3392  
  3393  // RefOfPartitionDefinition does deep equals between the two objects.
  3394  func (cmp *Comparator) RefOfPartitionDefinition(a, b *PartitionDefinition) bool {
  3395  	if a == b {
  3396  		return true
  3397  	}
  3398  	if a == nil || b == nil {
  3399  		return false
  3400  	}
  3401  	return cmp.IdentifierCI(a.Name, b.Name) &&
  3402  		cmp.RefOfPartitionDefinitionOptions(a.Options, b.Options)
  3403  }
  3404  
  3405  // RefOfPartitionDefinitionOptions does deep equals between the two objects.
  3406  func (cmp *Comparator) RefOfPartitionDefinitionOptions(a, b *PartitionDefinitionOptions) bool {
  3407  	if a == b {
  3408  		return true
  3409  	}
  3410  	if a == nil || b == nil {
  3411  		return false
  3412  	}
  3413  	return a.TableSpace == b.TableSpace &&
  3414  		cmp.RefOfPartitionValueRange(a.ValueRange, b.ValueRange) &&
  3415  		cmp.RefOfLiteral(a.Comment, b.Comment) &&
  3416  		cmp.RefOfPartitionEngine(a.Engine, b.Engine) &&
  3417  		cmp.RefOfLiteral(a.DataDirectory, b.DataDirectory) &&
  3418  		cmp.RefOfLiteral(a.IndexDirectory, b.IndexDirectory) &&
  3419  		cmp.RefOfInt(a.MaxRows, b.MaxRows) &&
  3420  		cmp.RefOfInt(a.MinRows, b.MinRows) &&
  3421  		cmp.SubPartitionDefinitions(a.SubPartitionDefinitions, b.SubPartitionDefinitions)
  3422  }
  3423  
  3424  // RefOfPartitionEngine does deep equals between the two objects.
  3425  func (cmp *Comparator) RefOfPartitionEngine(a, b *PartitionEngine) bool {
  3426  	if a == b {
  3427  		return true
  3428  	}
  3429  	if a == nil || b == nil {
  3430  		return false
  3431  	}
  3432  	return a.Storage == b.Storage &&
  3433  		a.Name == b.Name
  3434  }
  3435  
  3436  // RefOfPartitionOption does deep equals between the two objects.
  3437  func (cmp *Comparator) RefOfPartitionOption(a, b *PartitionOption) bool {
  3438  	if a == b {
  3439  		return true
  3440  	}
  3441  	if a == nil || b == nil {
  3442  		return false
  3443  	}
  3444  	return a.IsLinear == b.IsLinear &&
  3445  		a.KeyAlgorithm == b.KeyAlgorithm &&
  3446  		a.Partitions == b.Partitions &&
  3447  		a.Type == b.Type &&
  3448  		cmp.Columns(a.ColList, b.ColList) &&
  3449  		cmp.Expr(a.Expr, b.Expr) &&
  3450  		cmp.RefOfSubPartition(a.SubPartition, b.SubPartition) &&
  3451  		cmp.SliceOfRefOfPartitionDefinition(a.Definitions, b.Definitions)
  3452  }
  3453  
  3454  // RefOfPartitionSpec does deep equals between the two objects.
  3455  func (cmp *Comparator) RefOfPartitionSpec(a, b *PartitionSpec) bool {
  3456  	if a == b {
  3457  		return true
  3458  	}
  3459  	if a == nil || b == nil {
  3460  		return false
  3461  	}
  3462  	return a.IsAll == b.IsAll &&
  3463  		a.WithoutValidation == b.WithoutValidation &&
  3464  		a.Action == b.Action &&
  3465  		cmp.Partitions(a.Names, b.Names) &&
  3466  		cmp.RefOfLiteral(a.Number, b.Number) &&
  3467  		cmp.TableName(a.TableName, b.TableName) &&
  3468  		cmp.SliceOfRefOfPartitionDefinition(a.Definitions, b.Definitions)
  3469  }
  3470  
  3471  // RefOfPartitionValueRange does deep equals between the two objects.
  3472  func (cmp *Comparator) RefOfPartitionValueRange(a, b *PartitionValueRange) bool {
  3473  	if a == b {
  3474  		return true
  3475  	}
  3476  	if a == nil || b == nil {
  3477  		return false
  3478  	}
  3479  	return a.Maxvalue == b.Maxvalue &&
  3480  		a.Type == b.Type &&
  3481  		cmp.ValTuple(a.Range, b.Range)
  3482  }
  3483  
  3484  // Partitions does deep equals between the two objects.
  3485  func (cmp *Comparator) Partitions(a, b Partitions) bool {
  3486  	if len(a) != len(b) {
  3487  		return false
  3488  	}
  3489  	for i := 0; i < len(a); i++ {
  3490  		if !cmp.IdentifierCI(a[i], b[i]) {
  3491  			return false
  3492  		}
  3493  	}
  3494  	return true
  3495  }
  3496  
  3497  // RefOfPerformanceSchemaFuncExpr does deep equals between the two objects.
  3498  func (cmp *Comparator) RefOfPerformanceSchemaFuncExpr(a, b *PerformanceSchemaFuncExpr) bool {
  3499  	if a == b {
  3500  		return true
  3501  	}
  3502  	if a == nil || b == nil {
  3503  		return false
  3504  	}
  3505  	return a.Type == b.Type &&
  3506  		cmp.Expr(a.Argument, b.Argument)
  3507  }
  3508  
  3509  // RefOfPrepareStmt does deep equals between the two objects.
  3510  func (cmp *Comparator) RefOfPrepareStmt(a, b *PrepareStmt) bool {
  3511  	if a == b {
  3512  		return true
  3513  	}
  3514  	if a == nil || b == nil {
  3515  		return false
  3516  	}
  3517  	return cmp.IdentifierCI(a.Name, b.Name) &&
  3518  		cmp.Expr(a.Statement, b.Statement) &&
  3519  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  3520  }
  3521  
  3522  // RefOfReferenceDefinition does deep equals between the two objects.
  3523  func (cmp *Comparator) RefOfReferenceDefinition(a, b *ReferenceDefinition) bool {
  3524  	if a == b {
  3525  		return true
  3526  	}
  3527  	if a == nil || b == nil {
  3528  		return false
  3529  	}
  3530  	return cmp.TableName(a.ReferencedTable, b.ReferencedTable) &&
  3531  		cmp.Columns(a.ReferencedColumns, b.ReferencedColumns) &&
  3532  		a.Match == b.Match &&
  3533  		a.OnDelete == b.OnDelete &&
  3534  		a.OnUpdate == b.OnUpdate
  3535  }
  3536  
  3537  // RefOfRegexpInstrExpr does deep equals between the two objects.
  3538  func (cmp *Comparator) RefOfRegexpInstrExpr(a, b *RegexpInstrExpr) bool {
  3539  	if a == b {
  3540  		return true
  3541  	}
  3542  	if a == nil || b == nil {
  3543  		return false
  3544  	}
  3545  	return cmp.Expr(a.Expr, b.Expr) &&
  3546  		cmp.Expr(a.Pattern, b.Pattern) &&
  3547  		cmp.Expr(a.Position, b.Position) &&
  3548  		cmp.Expr(a.Occurrence, b.Occurrence) &&
  3549  		cmp.Expr(a.ReturnOption, b.ReturnOption) &&
  3550  		cmp.Expr(a.MatchType, b.MatchType)
  3551  }
  3552  
  3553  // RefOfRegexpLikeExpr does deep equals between the two objects.
  3554  func (cmp *Comparator) RefOfRegexpLikeExpr(a, b *RegexpLikeExpr) bool {
  3555  	if a == b {
  3556  		return true
  3557  	}
  3558  	if a == nil || b == nil {
  3559  		return false
  3560  	}
  3561  	return cmp.Expr(a.Expr, b.Expr) &&
  3562  		cmp.Expr(a.Pattern, b.Pattern) &&
  3563  		cmp.Expr(a.MatchType, b.MatchType)
  3564  }
  3565  
  3566  // RefOfRegexpReplaceExpr does deep equals between the two objects.
  3567  func (cmp *Comparator) RefOfRegexpReplaceExpr(a, b *RegexpReplaceExpr) bool {
  3568  	if a == b {
  3569  		return true
  3570  	}
  3571  	if a == nil || b == nil {
  3572  		return false
  3573  	}
  3574  	return cmp.Expr(a.Expr, b.Expr) &&
  3575  		cmp.Expr(a.Pattern, b.Pattern) &&
  3576  		cmp.Expr(a.Repl, b.Repl) &&
  3577  		cmp.Expr(a.Occurrence, b.Occurrence) &&
  3578  		cmp.Expr(a.Position, b.Position) &&
  3579  		cmp.Expr(a.MatchType, b.MatchType)
  3580  }
  3581  
  3582  // RefOfRegexpSubstrExpr does deep equals between the two objects.
  3583  func (cmp *Comparator) RefOfRegexpSubstrExpr(a, b *RegexpSubstrExpr) bool {
  3584  	if a == b {
  3585  		return true
  3586  	}
  3587  	if a == nil || b == nil {
  3588  		return false
  3589  	}
  3590  	return cmp.Expr(a.Expr, b.Expr) &&
  3591  		cmp.Expr(a.Pattern, b.Pattern) &&
  3592  		cmp.Expr(a.Occurrence, b.Occurrence) &&
  3593  		cmp.Expr(a.Position, b.Position) &&
  3594  		cmp.Expr(a.MatchType, b.MatchType)
  3595  }
  3596  
  3597  // RefOfRelease does deep equals between the two objects.
  3598  func (cmp *Comparator) RefOfRelease(a, b *Release) bool {
  3599  	if a == b {
  3600  		return true
  3601  	}
  3602  	if a == nil || b == nil {
  3603  		return false
  3604  	}
  3605  	return cmp.IdentifierCI(a.Name, b.Name)
  3606  }
  3607  
  3608  // RefOfRenameColumn does deep equals between the two objects.
  3609  func (cmp *Comparator) RefOfRenameColumn(a, b *RenameColumn) bool {
  3610  	if a == b {
  3611  		return true
  3612  	}
  3613  	if a == nil || b == nil {
  3614  		return false
  3615  	}
  3616  	return cmp.RefOfColName(a.OldName, b.OldName) &&
  3617  		cmp.RefOfColName(a.NewName, b.NewName)
  3618  }
  3619  
  3620  // RefOfRenameIndex does deep equals between the two objects.
  3621  func (cmp *Comparator) RefOfRenameIndex(a, b *RenameIndex) bool {
  3622  	if a == b {
  3623  		return true
  3624  	}
  3625  	if a == nil || b == nil {
  3626  		return false
  3627  	}
  3628  	return cmp.IdentifierCI(a.OldName, b.OldName) &&
  3629  		cmp.IdentifierCI(a.NewName, b.NewName)
  3630  }
  3631  
  3632  // RefOfRenameTable does deep equals between the two objects.
  3633  func (cmp *Comparator) RefOfRenameTable(a, b *RenameTable) bool {
  3634  	if a == b {
  3635  		return true
  3636  	}
  3637  	if a == nil || b == nil {
  3638  		return false
  3639  	}
  3640  	return cmp.SliceOfRefOfRenameTablePair(a.TablePairs, b.TablePairs)
  3641  }
  3642  
  3643  // RefOfRenameTableName does deep equals between the two objects.
  3644  func (cmp *Comparator) RefOfRenameTableName(a, b *RenameTableName) bool {
  3645  	if a == b {
  3646  		return true
  3647  	}
  3648  	if a == nil || b == nil {
  3649  		return false
  3650  	}
  3651  	return cmp.TableName(a.Table, b.Table)
  3652  }
  3653  
  3654  // RefOfRevertMigration does deep equals between the two objects.
  3655  func (cmp *Comparator) RefOfRevertMigration(a, b *RevertMigration) bool {
  3656  	if a == b {
  3657  		return true
  3658  	}
  3659  	if a == nil || b == nil {
  3660  		return false
  3661  	}
  3662  	return a.UUID == b.UUID &&
  3663  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  3664  }
  3665  
  3666  // RefOfRollback does deep equals between the two objects.
  3667  func (cmp *Comparator) RefOfRollback(a, b *Rollback) bool {
  3668  	if a == b {
  3669  		return true
  3670  	}
  3671  	if a == nil || b == nil {
  3672  		return false
  3673  	}
  3674  	return true
  3675  }
  3676  
  3677  // RootNode does deep equals between the two objects.
  3678  func (cmp *Comparator) RootNode(a, b RootNode) bool {
  3679  	return cmp.SQLNode(a.SQLNode, b.SQLNode)
  3680  }
  3681  
  3682  // RefOfSRollback does deep equals between the two objects.
  3683  func (cmp *Comparator) RefOfSRollback(a, b *SRollback) bool {
  3684  	if a == b {
  3685  		return true
  3686  	}
  3687  	if a == nil || b == nil {
  3688  		return false
  3689  	}
  3690  	return cmp.IdentifierCI(a.Name, b.Name)
  3691  }
  3692  
  3693  // RefOfSavepoint does deep equals between the two objects.
  3694  func (cmp *Comparator) RefOfSavepoint(a, b *Savepoint) bool {
  3695  	if a == b {
  3696  		return true
  3697  	}
  3698  	if a == nil || b == nil {
  3699  		return false
  3700  	}
  3701  	return cmp.IdentifierCI(a.Name, b.Name)
  3702  }
  3703  
  3704  // RefOfSelect does deep equals between the two objects.
  3705  func (cmp *Comparator) RefOfSelect(a, b *Select) bool {
  3706  	if a == b {
  3707  		return true
  3708  	}
  3709  	if a == nil || b == nil {
  3710  		return false
  3711  	}
  3712  	return a.Distinct == b.Distinct &&
  3713  		a.StraightJoinHint == b.StraightJoinHint &&
  3714  		a.SQLCalcFoundRows == b.SQLCalcFoundRows &&
  3715  		cmp.RefOfBool(a.Cache, b.Cache) &&
  3716  		cmp.SliceOfTableExpr(a.From, b.From) &&
  3717  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  3718  		cmp.SelectExprs(a.SelectExprs, b.SelectExprs) &&
  3719  		cmp.RefOfWhere(a.Where, b.Where) &&
  3720  		cmp.RefOfWith(a.With, b.With) &&
  3721  		cmp.GroupBy(a.GroupBy, b.GroupBy) &&
  3722  		cmp.RefOfWhere(a.Having, b.Having) &&
  3723  		cmp.NamedWindows(a.Windows, b.Windows) &&
  3724  		cmp.OrderBy(a.OrderBy, b.OrderBy) &&
  3725  		cmp.RefOfLimit(a.Limit, b.Limit) &&
  3726  		a.Lock == b.Lock &&
  3727  		cmp.RefOfSelectInto(a.Into, b.Into)
  3728  }
  3729  
  3730  // SelectExprs does deep equals between the two objects.
  3731  func (cmp *Comparator) SelectExprs(a, b SelectExprs) bool {
  3732  	if len(a) != len(b) {
  3733  		return false
  3734  	}
  3735  	for i := 0; i < len(a); i++ {
  3736  		if !cmp.SelectExpr(a[i], b[i]) {
  3737  			return false
  3738  		}
  3739  	}
  3740  	return true
  3741  }
  3742  
  3743  // RefOfSelectInto does deep equals between the two objects.
  3744  func (cmp *Comparator) RefOfSelectInto(a, b *SelectInto) bool {
  3745  	if a == b {
  3746  		return true
  3747  	}
  3748  	if a == nil || b == nil {
  3749  		return false
  3750  	}
  3751  	return a.FileName == b.FileName &&
  3752  		a.FormatOption == b.FormatOption &&
  3753  		a.ExportOption == b.ExportOption &&
  3754  		a.Manifest == b.Manifest &&
  3755  		a.Overwrite == b.Overwrite &&
  3756  		a.Type == b.Type &&
  3757  		cmp.ColumnCharset(a.Charset, b.Charset)
  3758  }
  3759  
  3760  // RefOfSet does deep equals between the two objects.
  3761  func (cmp *Comparator) RefOfSet(a, b *Set) bool {
  3762  	if a == b {
  3763  		return true
  3764  	}
  3765  	if a == nil || b == nil {
  3766  		return false
  3767  	}
  3768  	return cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  3769  		cmp.SetExprs(a.Exprs, b.Exprs)
  3770  }
  3771  
  3772  // RefOfSetExpr does deep equals between the two objects.
  3773  func (cmp *Comparator) RefOfSetExpr(a, b *SetExpr) bool {
  3774  	if a == b {
  3775  		return true
  3776  	}
  3777  	if a == nil || b == nil {
  3778  		return false
  3779  	}
  3780  	return cmp.RefOfVariable(a.Var, b.Var) &&
  3781  		cmp.Expr(a.Expr, b.Expr)
  3782  }
  3783  
  3784  // SetExprs does deep equals between the two objects.
  3785  func (cmp *Comparator) SetExprs(a, b SetExprs) bool {
  3786  	if len(a) != len(b) {
  3787  		return false
  3788  	}
  3789  	for i := 0; i < len(a); i++ {
  3790  		if !cmp.RefOfSetExpr(a[i], b[i]) {
  3791  			return false
  3792  		}
  3793  	}
  3794  	return true
  3795  }
  3796  
  3797  // RefOfShow does deep equals between the two objects.
  3798  func (cmp *Comparator) RefOfShow(a, b *Show) bool {
  3799  	if a == b {
  3800  		return true
  3801  	}
  3802  	if a == nil || b == nil {
  3803  		return false
  3804  	}
  3805  	return cmp.ShowInternal(a.Internal, b.Internal)
  3806  }
  3807  
  3808  // RefOfShowBasic does deep equals between the two objects.
  3809  func (cmp *Comparator) RefOfShowBasic(a, b *ShowBasic) bool {
  3810  	if a == b {
  3811  		return true
  3812  	}
  3813  	if a == nil || b == nil {
  3814  		return false
  3815  	}
  3816  	return a.Full == b.Full &&
  3817  		a.Command == b.Command &&
  3818  		cmp.TableName(a.Tbl, b.Tbl) &&
  3819  		cmp.IdentifierCS(a.DbName, b.DbName) &&
  3820  		cmp.RefOfShowFilter(a.Filter, b.Filter)
  3821  }
  3822  
  3823  // RefOfShowCreate does deep equals between the two objects.
  3824  func (cmp *Comparator) RefOfShowCreate(a, b *ShowCreate) bool {
  3825  	if a == b {
  3826  		return true
  3827  	}
  3828  	if a == nil || b == nil {
  3829  		return false
  3830  	}
  3831  	return a.Command == b.Command &&
  3832  		cmp.TableName(a.Op, b.Op)
  3833  }
  3834  
  3835  // RefOfShowFilter does deep equals between the two objects.
  3836  func (cmp *Comparator) RefOfShowFilter(a, b *ShowFilter) bool {
  3837  	if a == b {
  3838  		return true
  3839  	}
  3840  	if a == nil || b == nil {
  3841  		return false
  3842  	}
  3843  	return a.Like == b.Like &&
  3844  		cmp.Expr(a.Filter, b.Filter)
  3845  }
  3846  
  3847  // RefOfShowMigrationLogs does deep equals between the two objects.
  3848  func (cmp *Comparator) RefOfShowMigrationLogs(a, b *ShowMigrationLogs) bool {
  3849  	if a == b {
  3850  		return true
  3851  	}
  3852  	if a == nil || b == nil {
  3853  		return false
  3854  	}
  3855  	return a.UUID == b.UUID &&
  3856  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  3857  }
  3858  
  3859  // RefOfShowOther does deep equals between the two objects.
  3860  func (cmp *Comparator) RefOfShowOther(a, b *ShowOther) bool {
  3861  	if a == b {
  3862  		return true
  3863  	}
  3864  	if a == nil || b == nil {
  3865  		return false
  3866  	}
  3867  	return a.Command == b.Command
  3868  }
  3869  
  3870  // RefOfShowThrottledApps does deep equals between the two objects.
  3871  func (cmp *Comparator) RefOfShowThrottledApps(a, b *ShowThrottledApps) bool {
  3872  	if a == b {
  3873  		return true
  3874  	}
  3875  	if a == nil || b == nil {
  3876  		return false
  3877  	}
  3878  	return cmp.Comments(a.Comments, b.Comments)
  3879  }
  3880  
  3881  // RefOfShowThrottlerStatus does deep equals between the two objects.
  3882  func (cmp *Comparator) RefOfShowThrottlerStatus(a, b *ShowThrottlerStatus) bool {
  3883  	if a == b {
  3884  		return true
  3885  	}
  3886  	if a == nil || b == nil {
  3887  		return false
  3888  	}
  3889  	return cmp.Comments(a.Comments, b.Comments)
  3890  }
  3891  
  3892  // RefOfStarExpr does deep equals between the two objects.
  3893  func (cmp *Comparator) RefOfStarExpr(a, b *StarExpr) bool {
  3894  	if a == b {
  3895  		return true
  3896  	}
  3897  	if a == nil || b == nil {
  3898  		return false
  3899  	}
  3900  	return cmp.TableName(a.TableName, b.TableName)
  3901  }
  3902  
  3903  // RefOfStd does deep equals between the two objects.
  3904  func (cmp *Comparator) RefOfStd(a, b *Std) bool {
  3905  	if a == b {
  3906  		return true
  3907  	}
  3908  	if a == nil || b == nil {
  3909  		return false
  3910  	}
  3911  	return cmp.Expr(a.Arg, b.Arg)
  3912  }
  3913  
  3914  // RefOfStdDev does deep equals between the two objects.
  3915  func (cmp *Comparator) RefOfStdDev(a, b *StdDev) bool {
  3916  	if a == b {
  3917  		return true
  3918  	}
  3919  	if a == nil || b == nil {
  3920  		return false
  3921  	}
  3922  	return cmp.Expr(a.Arg, b.Arg)
  3923  }
  3924  
  3925  // RefOfStdPop does deep equals between the two objects.
  3926  func (cmp *Comparator) RefOfStdPop(a, b *StdPop) bool {
  3927  	if a == b {
  3928  		return true
  3929  	}
  3930  	if a == nil || b == nil {
  3931  		return false
  3932  	}
  3933  	return cmp.Expr(a.Arg, b.Arg)
  3934  }
  3935  
  3936  // RefOfStdSamp does deep equals between the two objects.
  3937  func (cmp *Comparator) RefOfStdSamp(a, b *StdSamp) bool {
  3938  	if a == b {
  3939  		return true
  3940  	}
  3941  	if a == nil || b == nil {
  3942  		return false
  3943  	}
  3944  	return cmp.Expr(a.Arg, b.Arg)
  3945  }
  3946  
  3947  // RefOfStream does deep equals between the two objects.
  3948  func (cmp *Comparator) RefOfStream(a, b *Stream) bool {
  3949  	if a == b {
  3950  		return true
  3951  	}
  3952  	if a == nil || b == nil {
  3953  		return false
  3954  	}
  3955  	return cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  3956  		cmp.SelectExpr(a.SelectExpr, b.SelectExpr) &&
  3957  		cmp.TableName(a.Table, b.Table)
  3958  }
  3959  
  3960  // RefOfSubPartition does deep equals between the two objects.
  3961  func (cmp *Comparator) RefOfSubPartition(a, b *SubPartition) bool {
  3962  	if a == b {
  3963  		return true
  3964  	}
  3965  	if a == nil || b == nil {
  3966  		return false
  3967  	}
  3968  	return a.IsLinear == b.IsLinear &&
  3969  		a.KeyAlgorithm == b.KeyAlgorithm &&
  3970  		a.SubPartitions == b.SubPartitions &&
  3971  		a.Type == b.Type &&
  3972  		cmp.Columns(a.ColList, b.ColList) &&
  3973  		cmp.Expr(a.Expr, b.Expr)
  3974  }
  3975  
  3976  // RefOfSubPartitionDefinition does deep equals between the two objects.
  3977  func (cmp *Comparator) RefOfSubPartitionDefinition(a, b *SubPartitionDefinition) bool {
  3978  	if a == b {
  3979  		return true
  3980  	}
  3981  	if a == nil || b == nil {
  3982  		return false
  3983  	}
  3984  	return cmp.IdentifierCI(a.Name, b.Name) &&
  3985  		cmp.RefOfSubPartitionDefinitionOptions(a.Options, b.Options)
  3986  }
  3987  
  3988  // RefOfSubPartitionDefinitionOptions does deep equals between the two objects.
  3989  func (cmp *Comparator) RefOfSubPartitionDefinitionOptions(a, b *SubPartitionDefinitionOptions) bool {
  3990  	if a == b {
  3991  		return true
  3992  	}
  3993  	if a == nil || b == nil {
  3994  		return false
  3995  	}
  3996  	return a.TableSpace == b.TableSpace &&
  3997  		cmp.RefOfLiteral(a.Comment, b.Comment) &&
  3998  		cmp.RefOfPartitionEngine(a.Engine, b.Engine) &&
  3999  		cmp.RefOfLiteral(a.DataDirectory, b.DataDirectory) &&
  4000  		cmp.RefOfLiteral(a.IndexDirectory, b.IndexDirectory) &&
  4001  		cmp.RefOfInt(a.MaxRows, b.MaxRows) &&
  4002  		cmp.RefOfInt(a.MinRows, b.MinRows)
  4003  }
  4004  
  4005  // SubPartitionDefinitions does deep equals between the two objects.
  4006  func (cmp *Comparator) SubPartitionDefinitions(a, b SubPartitionDefinitions) bool {
  4007  	if len(a) != len(b) {
  4008  		return false
  4009  	}
  4010  	for i := 0; i < len(a); i++ {
  4011  		if !cmp.RefOfSubPartitionDefinition(a[i], b[i]) {
  4012  			return false
  4013  		}
  4014  	}
  4015  	return true
  4016  }
  4017  
  4018  // RefOfSubquery does deep equals between the two objects.
  4019  func (cmp *Comparator) RefOfSubquery(a, b *Subquery) bool {
  4020  	if a == b {
  4021  		return true
  4022  	}
  4023  	if a == nil || b == nil {
  4024  		return false
  4025  	}
  4026  	return cmp.SelectStatement(a.Select, b.Select)
  4027  }
  4028  
  4029  // RefOfSubstrExpr does deep equals between the two objects.
  4030  func (cmp *Comparator) RefOfSubstrExpr(a, b *SubstrExpr) bool {
  4031  	if a == b {
  4032  		return true
  4033  	}
  4034  	if a == nil || b == nil {
  4035  		return false
  4036  	}
  4037  	return cmp.Expr(a.Name, b.Name) &&
  4038  		cmp.Expr(a.From, b.From) &&
  4039  		cmp.Expr(a.To, b.To)
  4040  }
  4041  
  4042  // RefOfSum does deep equals between the two objects.
  4043  func (cmp *Comparator) RefOfSum(a, b *Sum) bool {
  4044  	if a == b {
  4045  		return true
  4046  	}
  4047  	if a == nil || b == nil {
  4048  		return false
  4049  	}
  4050  	return a.Distinct == b.Distinct &&
  4051  		cmp.Expr(a.Arg, b.Arg)
  4052  }
  4053  
  4054  // TableExprs does deep equals between the two objects.
  4055  func (cmp *Comparator) TableExprs(a, b TableExprs) bool {
  4056  	if len(a) != len(b) {
  4057  		return false
  4058  	}
  4059  	for i := 0; i < len(a); i++ {
  4060  		if !cmp.TableExpr(a[i], b[i]) {
  4061  			return false
  4062  		}
  4063  	}
  4064  	return true
  4065  }
  4066  
  4067  // TableName does deep equals between the two objects.
  4068  func (cmp *Comparator) TableName(a, b TableName) bool {
  4069  	return cmp.IdentifierCS(a.Name, b.Name) &&
  4070  		cmp.IdentifierCS(a.Qualifier, b.Qualifier)
  4071  }
  4072  
  4073  // TableNames does deep equals between the two objects.
  4074  func (cmp *Comparator) TableNames(a, b TableNames) bool {
  4075  	if len(a) != len(b) {
  4076  		return false
  4077  	}
  4078  	for i := 0; i < len(a); i++ {
  4079  		if !cmp.TableName(a[i], b[i]) {
  4080  			return false
  4081  		}
  4082  	}
  4083  	return true
  4084  }
  4085  
  4086  // TableOptions does deep equals between the two objects.
  4087  func (cmp *Comparator) TableOptions(a, b TableOptions) bool {
  4088  	if len(a) != len(b) {
  4089  		return false
  4090  	}
  4091  	for i := 0; i < len(a); i++ {
  4092  		if !cmp.RefOfTableOption(a[i], b[i]) {
  4093  			return false
  4094  		}
  4095  	}
  4096  	return true
  4097  }
  4098  
  4099  // RefOfTableSpec does deep equals between the two objects.
  4100  func (cmp *Comparator) RefOfTableSpec(a, b *TableSpec) bool {
  4101  	if a == b {
  4102  		return true
  4103  	}
  4104  	if a == nil || b == nil {
  4105  		return false
  4106  	}
  4107  	return cmp.SliceOfRefOfColumnDefinition(a.Columns, b.Columns) &&
  4108  		cmp.SliceOfRefOfIndexDefinition(a.Indexes, b.Indexes) &&
  4109  		cmp.SliceOfRefOfConstraintDefinition(a.Constraints, b.Constraints) &&
  4110  		cmp.TableOptions(a.Options, b.Options) &&
  4111  		cmp.RefOfPartitionOption(a.PartitionOption, b.PartitionOption)
  4112  }
  4113  
  4114  // RefOfTablespaceOperation does deep equals between the two objects.
  4115  func (cmp *Comparator) RefOfTablespaceOperation(a, b *TablespaceOperation) bool {
  4116  	if a == b {
  4117  		return true
  4118  	}
  4119  	if a == nil || b == nil {
  4120  		return false
  4121  	}
  4122  	return a.Import == b.Import
  4123  }
  4124  
  4125  // RefOfTimestampFuncExpr does deep equals between the two objects.
  4126  func (cmp *Comparator) RefOfTimestampFuncExpr(a, b *TimestampFuncExpr) bool {
  4127  	if a == b {
  4128  		return true
  4129  	}
  4130  	if a == nil || b == nil {
  4131  		return false
  4132  	}
  4133  	return a.Name == b.Name &&
  4134  		a.Unit == b.Unit &&
  4135  		cmp.Expr(a.Expr1, b.Expr1) &&
  4136  		cmp.Expr(a.Expr2, b.Expr2)
  4137  }
  4138  
  4139  // RefOfTrimFuncExpr does deep equals between the two objects.
  4140  func (cmp *Comparator) RefOfTrimFuncExpr(a, b *TrimFuncExpr) bool {
  4141  	if a == b {
  4142  		return true
  4143  	}
  4144  	if a == nil || b == nil {
  4145  		return false
  4146  	}
  4147  	return a.TrimFuncType == b.TrimFuncType &&
  4148  		a.Type == b.Type &&
  4149  		cmp.Expr(a.TrimArg, b.TrimArg) &&
  4150  		cmp.Expr(a.StringArg, b.StringArg)
  4151  }
  4152  
  4153  // RefOfTruncateTable does deep equals between the two objects.
  4154  func (cmp *Comparator) RefOfTruncateTable(a, b *TruncateTable) bool {
  4155  	if a == b {
  4156  		return true
  4157  	}
  4158  	if a == nil || b == nil {
  4159  		return false
  4160  	}
  4161  	return cmp.TableName(a.Table, b.Table)
  4162  }
  4163  
  4164  // RefOfUnaryExpr does deep equals between the two objects.
  4165  func (cmp *Comparator) RefOfUnaryExpr(a, b *UnaryExpr) bool {
  4166  	if a == b {
  4167  		return true
  4168  	}
  4169  	if a == nil || b == nil {
  4170  		return false
  4171  	}
  4172  	return a.Operator == b.Operator &&
  4173  		cmp.Expr(a.Expr, b.Expr)
  4174  }
  4175  
  4176  // RefOfUnion does deep equals between the two objects.
  4177  func (cmp *Comparator) RefOfUnion(a, b *Union) bool {
  4178  	if a == b {
  4179  		return true
  4180  	}
  4181  	if a == nil || b == nil {
  4182  		return false
  4183  	}
  4184  	return a.Distinct == b.Distinct &&
  4185  		cmp.SelectStatement(a.Left, b.Left) &&
  4186  		cmp.SelectStatement(a.Right, b.Right) &&
  4187  		cmp.OrderBy(a.OrderBy, b.OrderBy) &&
  4188  		cmp.RefOfWith(a.With, b.With) &&
  4189  		cmp.RefOfLimit(a.Limit, b.Limit) &&
  4190  		a.Lock == b.Lock &&
  4191  		cmp.RefOfSelectInto(a.Into, b.Into)
  4192  }
  4193  
  4194  // RefOfUnlockTables does deep equals between the two objects.
  4195  func (cmp *Comparator) RefOfUnlockTables(a, b *UnlockTables) bool {
  4196  	if a == b {
  4197  		return true
  4198  	}
  4199  	if a == nil || b == nil {
  4200  		return false
  4201  	}
  4202  	return true
  4203  }
  4204  
  4205  // RefOfUpdate does deep equals between the two objects.
  4206  func (cmp *Comparator) RefOfUpdate(a, b *Update) bool {
  4207  	if a == b {
  4208  		return true
  4209  	}
  4210  	if a == nil || b == nil {
  4211  		return false
  4212  	}
  4213  	return cmp.RefOfWith(a.With, b.With) &&
  4214  		cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  4215  		a.Ignore == b.Ignore &&
  4216  		cmp.TableExprs(a.TableExprs, b.TableExprs) &&
  4217  		cmp.UpdateExprs(a.Exprs, b.Exprs) &&
  4218  		cmp.RefOfWhere(a.Where, b.Where) &&
  4219  		cmp.OrderBy(a.OrderBy, b.OrderBy) &&
  4220  		cmp.RefOfLimit(a.Limit, b.Limit)
  4221  }
  4222  
  4223  // RefOfUpdateExpr does deep equals between the two objects.
  4224  func (cmp *Comparator) RefOfUpdateExpr(a, b *UpdateExpr) bool {
  4225  	if a == b {
  4226  		return true
  4227  	}
  4228  	if a == nil || b == nil {
  4229  		return false
  4230  	}
  4231  	return cmp.RefOfColName(a.Name, b.Name) &&
  4232  		cmp.Expr(a.Expr, b.Expr)
  4233  }
  4234  
  4235  // UpdateExprs does deep equals between the two objects.
  4236  func (cmp *Comparator) UpdateExprs(a, b UpdateExprs) bool {
  4237  	if len(a) != len(b) {
  4238  		return false
  4239  	}
  4240  	for i := 0; i < len(a); i++ {
  4241  		if !cmp.RefOfUpdateExpr(a[i], b[i]) {
  4242  			return false
  4243  		}
  4244  	}
  4245  	return true
  4246  }
  4247  
  4248  // RefOfUpdateXMLExpr does deep equals between the two objects.
  4249  func (cmp *Comparator) RefOfUpdateXMLExpr(a, b *UpdateXMLExpr) bool {
  4250  	if a == b {
  4251  		return true
  4252  	}
  4253  	if a == nil || b == nil {
  4254  		return false
  4255  	}
  4256  	return cmp.Expr(a.Target, b.Target) &&
  4257  		cmp.Expr(a.XPathExpr, b.XPathExpr) &&
  4258  		cmp.Expr(a.NewXML, b.NewXML)
  4259  }
  4260  
  4261  // RefOfUse does deep equals between the two objects.
  4262  func (cmp *Comparator) RefOfUse(a, b *Use) bool {
  4263  	if a == b {
  4264  		return true
  4265  	}
  4266  	if a == nil || b == nil {
  4267  		return false
  4268  	}
  4269  	return cmp.IdentifierCS(a.DBName, b.DBName)
  4270  }
  4271  
  4272  // RefOfVExplainStmt does deep equals between the two objects.
  4273  func (cmp *Comparator) RefOfVExplainStmt(a, b *VExplainStmt) bool {
  4274  	if a == b {
  4275  		return true
  4276  	}
  4277  	if a == nil || b == nil {
  4278  		return false
  4279  	}
  4280  	return a.Type == b.Type &&
  4281  		cmp.Statement(a.Statement, b.Statement) &&
  4282  		cmp.RefOfParsedComments(a.Comments, b.Comments)
  4283  }
  4284  
  4285  // RefOfVStream does deep equals between the two objects.
  4286  func (cmp *Comparator) RefOfVStream(a, b *VStream) bool {
  4287  	if a == b {
  4288  		return true
  4289  	}
  4290  	if a == nil || b == nil {
  4291  		return false
  4292  	}
  4293  	return cmp.RefOfParsedComments(a.Comments, b.Comments) &&
  4294  		cmp.SelectExpr(a.SelectExpr, b.SelectExpr) &&
  4295  		cmp.TableName(a.Table, b.Table) &&
  4296  		cmp.RefOfWhere(a.Where, b.Where) &&
  4297  		cmp.RefOfLimit(a.Limit, b.Limit)
  4298  }
  4299  
  4300  // ValTuple does deep equals between the two objects.
  4301  func (cmp *Comparator) ValTuple(a, b ValTuple) bool {
  4302  	if len(a) != len(b) {
  4303  		return false
  4304  	}
  4305  	for i := 0; i < len(a); i++ {
  4306  		if !cmp.Expr(a[i], b[i]) {
  4307  			return false
  4308  		}
  4309  	}
  4310  	return true
  4311  }
  4312  
  4313  // RefOfValidation does deep equals between the two objects.
  4314  func (cmp *Comparator) RefOfValidation(a, b *Validation) bool {
  4315  	if a == b {
  4316  		return true
  4317  	}
  4318  	if a == nil || b == nil {
  4319  		return false
  4320  	}
  4321  	return a.With == b.With
  4322  }
  4323  
  4324  // Values does deep equals between the two objects.
  4325  func (cmp *Comparator) Values(a, b Values) bool {
  4326  	if len(a) != len(b) {
  4327  		return false
  4328  	}
  4329  	for i := 0; i < len(a); i++ {
  4330  		if !cmp.ValTuple(a[i], b[i]) {
  4331  			return false
  4332  		}
  4333  	}
  4334  	return true
  4335  }
  4336  
  4337  // RefOfValuesFuncExpr does deep equals between the two objects.
  4338  func (cmp *Comparator) RefOfValuesFuncExpr(a, b *ValuesFuncExpr) bool {
  4339  	if a == b {
  4340  		return true
  4341  	}
  4342  	if a == nil || b == nil {
  4343  		return false
  4344  	}
  4345  	return cmp.RefOfColName(a.Name, b.Name)
  4346  }
  4347  
  4348  // RefOfVarPop does deep equals between the two objects.
  4349  func (cmp *Comparator) RefOfVarPop(a, b *VarPop) bool {
  4350  	if a == b {
  4351  		return true
  4352  	}
  4353  	if a == nil || b == nil {
  4354  		return false
  4355  	}
  4356  	return cmp.Expr(a.Arg, b.Arg)
  4357  }
  4358  
  4359  // RefOfVarSamp does deep equals between the two objects.
  4360  func (cmp *Comparator) RefOfVarSamp(a, b *VarSamp) bool {
  4361  	if a == b {
  4362  		return true
  4363  	}
  4364  	if a == nil || b == nil {
  4365  		return false
  4366  	}
  4367  	return cmp.Expr(a.Arg, b.Arg)
  4368  }
  4369  
  4370  // RefOfVariable does deep equals between the two objects.
  4371  func (cmp *Comparator) RefOfVariable(a, b *Variable) bool {
  4372  	if a == b {
  4373  		return true
  4374  	}
  4375  	if a == nil || b == nil {
  4376  		return false
  4377  	}
  4378  	return a.Scope == b.Scope &&
  4379  		cmp.IdentifierCI(a.Name, b.Name)
  4380  }
  4381  
  4382  // RefOfVariance does deep equals between the two objects.
  4383  func (cmp *Comparator) RefOfVariance(a, b *Variance) bool {
  4384  	if a == b {
  4385  		return true
  4386  	}
  4387  	if a == nil || b == nil {
  4388  		return false
  4389  	}
  4390  	return cmp.Expr(a.Arg, b.Arg)
  4391  }
  4392  
  4393  // VindexParam does deep equals between the two objects.
  4394  func (cmp *Comparator) VindexParam(a, b VindexParam) bool {
  4395  	return a.Val == b.Val &&
  4396  		cmp.IdentifierCI(a.Key, b.Key)
  4397  }
  4398  
  4399  // RefOfVindexSpec does deep equals between the two objects.
  4400  func (cmp *Comparator) RefOfVindexSpec(a, b *VindexSpec) bool {
  4401  	if a == b {
  4402  		return true
  4403  	}
  4404  	if a == nil || b == nil {
  4405  		return false
  4406  	}
  4407  	return cmp.IdentifierCI(a.Name, b.Name) &&
  4408  		cmp.IdentifierCI(a.Type, b.Type) &&
  4409  		cmp.SliceOfVindexParam(a.Params, b.Params)
  4410  }
  4411  
  4412  // RefOfWeightStringFuncExpr does deep equals between the two objects.
  4413  func (cmp *Comparator) RefOfWeightStringFuncExpr(a, b *WeightStringFuncExpr) bool {
  4414  	if a == b {
  4415  		return true
  4416  	}
  4417  	if a == nil || b == nil {
  4418  		return false
  4419  	}
  4420  	return cmp.Expr(a.Expr, b.Expr) &&
  4421  		cmp.RefOfConvertType(a.As, b.As)
  4422  }
  4423  
  4424  // RefOfWhen does deep equals between the two objects.
  4425  func (cmp *Comparator) RefOfWhen(a, b *When) bool {
  4426  	if a == b {
  4427  		return true
  4428  	}
  4429  	if a == nil || b == nil {
  4430  		return false
  4431  	}
  4432  	return cmp.Expr(a.Cond, b.Cond) &&
  4433  		cmp.Expr(a.Val, b.Val)
  4434  }
  4435  
  4436  // RefOfWhere does deep equals between the two objects.
  4437  func (cmp *Comparator) RefOfWhere(a, b *Where) bool {
  4438  	if a == b {
  4439  		return true
  4440  	}
  4441  	if a == nil || b == nil {
  4442  		return false
  4443  	}
  4444  	return a.Type == b.Type &&
  4445  		cmp.Expr(a.Expr, b.Expr)
  4446  }
  4447  
  4448  // RefOfWindowDefinition does deep equals between the two objects.
  4449  func (cmp *Comparator) RefOfWindowDefinition(a, b *WindowDefinition) bool {
  4450  	if a == b {
  4451  		return true
  4452  	}
  4453  	if a == nil || b == nil {
  4454  		return false
  4455  	}
  4456  	return cmp.IdentifierCI(a.Name, b.Name) &&
  4457  		cmp.RefOfWindowSpecification(a.WindowSpec, b.WindowSpec)
  4458  }
  4459  
  4460  // WindowDefinitions does deep equals between the two objects.
  4461  func (cmp *Comparator) WindowDefinitions(a, b WindowDefinitions) bool {
  4462  	if len(a) != len(b) {
  4463  		return false
  4464  	}
  4465  	for i := 0; i < len(a); i++ {
  4466  		if !cmp.RefOfWindowDefinition(a[i], b[i]) {
  4467  			return false
  4468  		}
  4469  	}
  4470  	return true
  4471  }
  4472  
  4473  // RefOfWindowSpecification does deep equals between the two objects.
  4474  func (cmp *Comparator) RefOfWindowSpecification(a, b *WindowSpecification) bool {
  4475  	if a == b {
  4476  		return true
  4477  	}
  4478  	if a == nil || b == nil {
  4479  		return false
  4480  	}
  4481  	return cmp.IdentifierCI(a.Name, b.Name) &&
  4482  		cmp.Exprs(a.PartitionClause, b.PartitionClause) &&
  4483  		cmp.OrderBy(a.OrderClause, b.OrderClause) &&
  4484  		cmp.RefOfFrameClause(a.FrameClause, b.FrameClause)
  4485  }
  4486  
  4487  // RefOfWith does deep equals between the two objects.
  4488  func (cmp *Comparator) RefOfWith(a, b *With) bool {
  4489  	if a == b {
  4490  		return true
  4491  	}
  4492  	if a == nil || b == nil {
  4493  		return false
  4494  	}
  4495  	return a.Recursive == b.Recursive &&
  4496  		cmp.SliceOfRefOfCommonTableExpr(a.ctes, b.ctes)
  4497  }
  4498  
  4499  // RefOfXorExpr does deep equals between the two objects.
  4500  func (cmp *Comparator) RefOfXorExpr(a, b *XorExpr) bool {
  4501  	if a == b {
  4502  		return true
  4503  	}
  4504  	if a == nil || b == nil {
  4505  		return false
  4506  	}
  4507  	return cmp.Expr(a.Left, b.Left) &&
  4508  		cmp.Expr(a.Right, b.Right)
  4509  }
  4510  
  4511  // AggrFunc does deep equals between the two objects.
  4512  func (cmp *Comparator) AggrFunc(inA, inB AggrFunc) bool {
  4513  	if inA == nil && inB == nil {
  4514  		return true
  4515  	}
  4516  	if inA == nil || inB == nil {
  4517  		return false
  4518  	}
  4519  	switch a := inA.(type) {
  4520  	case *Avg:
  4521  		b, ok := inB.(*Avg)
  4522  		if !ok {
  4523  			return false
  4524  		}
  4525  		return cmp.RefOfAvg(a, b)
  4526  	case *BitAnd:
  4527  		b, ok := inB.(*BitAnd)
  4528  		if !ok {
  4529  			return false
  4530  		}
  4531  		return cmp.RefOfBitAnd(a, b)
  4532  	case *BitOr:
  4533  		b, ok := inB.(*BitOr)
  4534  		if !ok {
  4535  			return false
  4536  		}
  4537  		return cmp.RefOfBitOr(a, b)
  4538  	case *BitXor:
  4539  		b, ok := inB.(*BitXor)
  4540  		if !ok {
  4541  			return false
  4542  		}
  4543  		return cmp.RefOfBitXor(a, b)
  4544  	case *Count:
  4545  		b, ok := inB.(*Count)
  4546  		if !ok {
  4547  			return false
  4548  		}
  4549  		return cmp.RefOfCount(a, b)
  4550  	case *CountStar:
  4551  		b, ok := inB.(*CountStar)
  4552  		if !ok {
  4553  			return false
  4554  		}
  4555  		return cmp.RefOfCountStar(a, b)
  4556  	case *GroupConcatExpr:
  4557  		b, ok := inB.(*GroupConcatExpr)
  4558  		if !ok {
  4559  			return false
  4560  		}
  4561  		return cmp.RefOfGroupConcatExpr(a, b)
  4562  	case *Max:
  4563  		b, ok := inB.(*Max)
  4564  		if !ok {
  4565  			return false
  4566  		}
  4567  		return cmp.RefOfMax(a, b)
  4568  	case *Min:
  4569  		b, ok := inB.(*Min)
  4570  		if !ok {
  4571  			return false
  4572  		}
  4573  		return cmp.RefOfMin(a, b)
  4574  	case *Std:
  4575  		b, ok := inB.(*Std)
  4576  		if !ok {
  4577  			return false
  4578  		}
  4579  		return cmp.RefOfStd(a, b)
  4580  	case *StdDev:
  4581  		b, ok := inB.(*StdDev)
  4582  		if !ok {
  4583  			return false
  4584  		}
  4585  		return cmp.RefOfStdDev(a, b)
  4586  	case *StdPop:
  4587  		b, ok := inB.(*StdPop)
  4588  		if !ok {
  4589  			return false
  4590  		}
  4591  		return cmp.RefOfStdPop(a, b)
  4592  	case *StdSamp:
  4593  		b, ok := inB.(*StdSamp)
  4594  		if !ok {
  4595  			return false
  4596  		}
  4597  		return cmp.RefOfStdSamp(a, b)
  4598  	case *Sum:
  4599  		b, ok := inB.(*Sum)
  4600  		if !ok {
  4601  			return false
  4602  		}
  4603  		return cmp.RefOfSum(a, b)
  4604  	case *VarPop:
  4605  		b, ok := inB.(*VarPop)
  4606  		if !ok {
  4607  			return false
  4608  		}
  4609  		return cmp.RefOfVarPop(a, b)
  4610  	case *VarSamp:
  4611  		b, ok := inB.(*VarSamp)
  4612  		if !ok {
  4613  			return false
  4614  		}
  4615  		return cmp.RefOfVarSamp(a, b)
  4616  	case *Variance:
  4617  		b, ok := inB.(*Variance)
  4618  		if !ok {
  4619  			return false
  4620  		}
  4621  		return cmp.RefOfVariance(a, b)
  4622  	default:
  4623  		// this should never happen
  4624  		return false
  4625  	}
  4626  }
  4627  
  4628  // AlterOption does deep equals between the two objects.
  4629  func (cmp *Comparator) AlterOption(inA, inB AlterOption) bool {
  4630  	if inA == nil && inB == nil {
  4631  		return true
  4632  	}
  4633  	if inA == nil || inB == nil {
  4634  		return false
  4635  	}
  4636  	switch a := inA.(type) {
  4637  	case *AddColumns:
  4638  		b, ok := inB.(*AddColumns)
  4639  		if !ok {
  4640  			return false
  4641  		}
  4642  		return cmp.RefOfAddColumns(a, b)
  4643  	case *AddConstraintDefinition:
  4644  		b, ok := inB.(*AddConstraintDefinition)
  4645  		if !ok {
  4646  			return false
  4647  		}
  4648  		return cmp.RefOfAddConstraintDefinition(a, b)
  4649  	case *AddIndexDefinition:
  4650  		b, ok := inB.(*AddIndexDefinition)
  4651  		if !ok {
  4652  			return false
  4653  		}
  4654  		return cmp.RefOfAddIndexDefinition(a, b)
  4655  	case AlgorithmValue:
  4656  		b, ok := inB.(AlgorithmValue)
  4657  		if !ok {
  4658  			return false
  4659  		}
  4660  		return a == b
  4661  	case *AlterCharset:
  4662  		b, ok := inB.(*AlterCharset)
  4663  		if !ok {
  4664  			return false
  4665  		}
  4666  		return cmp.RefOfAlterCharset(a, b)
  4667  	case *AlterCheck:
  4668  		b, ok := inB.(*AlterCheck)
  4669  		if !ok {
  4670  			return false
  4671  		}
  4672  		return cmp.RefOfAlterCheck(a, b)
  4673  	case *AlterColumn:
  4674  		b, ok := inB.(*AlterColumn)
  4675  		if !ok {
  4676  			return false
  4677  		}
  4678  		return cmp.RefOfAlterColumn(a, b)
  4679  	case *AlterIndex:
  4680  		b, ok := inB.(*AlterIndex)
  4681  		if !ok {
  4682  			return false
  4683  		}
  4684  		return cmp.RefOfAlterIndex(a, b)
  4685  	case *ChangeColumn:
  4686  		b, ok := inB.(*ChangeColumn)
  4687  		if !ok {
  4688  			return false
  4689  		}
  4690  		return cmp.RefOfChangeColumn(a, b)
  4691  	case *DropColumn:
  4692  		b, ok := inB.(*DropColumn)
  4693  		if !ok {
  4694  			return false
  4695  		}
  4696  		return cmp.RefOfDropColumn(a, b)
  4697  	case *DropKey:
  4698  		b, ok := inB.(*DropKey)
  4699  		if !ok {
  4700  			return false
  4701  		}
  4702  		return cmp.RefOfDropKey(a, b)
  4703  	case *Force:
  4704  		b, ok := inB.(*Force)
  4705  		if !ok {
  4706  			return false
  4707  		}
  4708  		return cmp.RefOfForce(a, b)
  4709  	case *KeyState:
  4710  		b, ok := inB.(*KeyState)
  4711  		if !ok {
  4712  			return false
  4713  		}
  4714  		return cmp.RefOfKeyState(a, b)
  4715  	case *LockOption:
  4716  		b, ok := inB.(*LockOption)
  4717  		if !ok {
  4718  			return false
  4719  		}
  4720  		return cmp.RefOfLockOption(a, b)
  4721  	case *ModifyColumn:
  4722  		b, ok := inB.(*ModifyColumn)
  4723  		if !ok {
  4724  			return false
  4725  		}
  4726  		return cmp.RefOfModifyColumn(a, b)
  4727  	case *OrderByOption:
  4728  		b, ok := inB.(*OrderByOption)
  4729  		if !ok {
  4730  			return false
  4731  		}
  4732  		return cmp.RefOfOrderByOption(a, b)
  4733  	case *RenameColumn:
  4734  		b, ok := inB.(*RenameColumn)
  4735  		if !ok {
  4736  			return false
  4737  		}
  4738  		return cmp.RefOfRenameColumn(a, b)
  4739  	case *RenameIndex:
  4740  		b, ok := inB.(*RenameIndex)
  4741  		if !ok {
  4742  			return false
  4743  		}
  4744  		return cmp.RefOfRenameIndex(a, b)
  4745  	case *RenameTableName:
  4746  		b, ok := inB.(*RenameTableName)
  4747  		if !ok {
  4748  			return false
  4749  		}
  4750  		return cmp.RefOfRenameTableName(a, b)
  4751  	case TableOptions:
  4752  		b, ok := inB.(TableOptions)
  4753  		if !ok {
  4754  			return false
  4755  		}
  4756  		return cmp.TableOptions(a, b)
  4757  	case *TablespaceOperation:
  4758  		b, ok := inB.(*TablespaceOperation)
  4759  		if !ok {
  4760  			return false
  4761  		}
  4762  		return cmp.RefOfTablespaceOperation(a, b)
  4763  	case *Validation:
  4764  		b, ok := inB.(*Validation)
  4765  		if !ok {
  4766  			return false
  4767  		}
  4768  		return cmp.RefOfValidation(a, b)
  4769  	default:
  4770  		// this should never happen
  4771  		return false
  4772  	}
  4773  }
  4774  
  4775  // Callable does deep equals between the two objects.
  4776  func (cmp *Comparator) Callable(inA, inB Callable) bool {
  4777  	if inA == nil && inB == nil {
  4778  		return true
  4779  	}
  4780  	if inA == nil || inB == nil {
  4781  		return false
  4782  	}
  4783  	switch a := inA.(type) {
  4784  	case *ArgumentLessWindowExpr:
  4785  		b, ok := inB.(*ArgumentLessWindowExpr)
  4786  		if !ok {
  4787  			return false
  4788  		}
  4789  		return cmp.RefOfArgumentLessWindowExpr(a, b)
  4790  	case *Avg:
  4791  		b, ok := inB.(*Avg)
  4792  		if !ok {
  4793  			return false
  4794  		}
  4795  		return cmp.RefOfAvg(a, b)
  4796  	case *CharExpr:
  4797  		b, ok := inB.(*CharExpr)
  4798  		if !ok {
  4799  			return false
  4800  		}
  4801  		return cmp.RefOfCharExpr(a, b)
  4802  	case *ConvertExpr:
  4803  		b, ok := inB.(*ConvertExpr)
  4804  		if !ok {
  4805  			return false
  4806  		}
  4807  		return cmp.RefOfConvertExpr(a, b)
  4808  	case *ConvertUsingExpr:
  4809  		b, ok := inB.(*ConvertUsingExpr)
  4810  		if !ok {
  4811  			return false
  4812  		}
  4813  		return cmp.RefOfConvertUsingExpr(a, b)
  4814  	case *Count:
  4815  		b, ok := inB.(*Count)
  4816  		if !ok {
  4817  			return false
  4818  		}
  4819  		return cmp.RefOfCount(a, b)
  4820  	case *CountStar:
  4821  		b, ok := inB.(*CountStar)
  4822  		if !ok {
  4823  			return false
  4824  		}
  4825  		return cmp.RefOfCountStar(a, b)
  4826  	case *CurTimeFuncExpr:
  4827  		b, ok := inB.(*CurTimeFuncExpr)
  4828  		if !ok {
  4829  			return false
  4830  		}
  4831  		return cmp.RefOfCurTimeFuncExpr(a, b)
  4832  	case *ExtractFuncExpr:
  4833  		b, ok := inB.(*ExtractFuncExpr)
  4834  		if !ok {
  4835  			return false
  4836  		}
  4837  		return cmp.RefOfExtractFuncExpr(a, b)
  4838  	case *ExtractValueExpr:
  4839  		b, ok := inB.(*ExtractValueExpr)
  4840  		if !ok {
  4841  			return false
  4842  		}
  4843  		return cmp.RefOfExtractValueExpr(a, b)
  4844  	case *FirstOrLastValueExpr:
  4845  		b, ok := inB.(*FirstOrLastValueExpr)
  4846  		if !ok {
  4847  			return false
  4848  		}
  4849  		return cmp.RefOfFirstOrLastValueExpr(a, b)
  4850  	case *FuncExpr:
  4851  		b, ok := inB.(*FuncExpr)
  4852  		if !ok {
  4853  			return false
  4854  		}
  4855  		return cmp.RefOfFuncExpr(a, b)
  4856  	case *GTIDFuncExpr:
  4857  		b, ok := inB.(*GTIDFuncExpr)
  4858  		if !ok {
  4859  			return false
  4860  		}
  4861  		return cmp.RefOfGTIDFuncExpr(a, b)
  4862  	case *GroupConcatExpr:
  4863  		b, ok := inB.(*GroupConcatExpr)
  4864  		if !ok {
  4865  			return false
  4866  		}
  4867  		return cmp.RefOfGroupConcatExpr(a, b)
  4868  	case *InsertExpr:
  4869  		b, ok := inB.(*InsertExpr)
  4870  		if !ok {
  4871  			return false
  4872  		}
  4873  		return cmp.RefOfInsertExpr(a, b)
  4874  	case *IntervalFuncExpr:
  4875  		b, ok := inB.(*IntervalFuncExpr)
  4876  		if !ok {
  4877  			return false
  4878  		}
  4879  		return cmp.RefOfIntervalFuncExpr(a, b)
  4880  	case *JSONArrayExpr:
  4881  		b, ok := inB.(*JSONArrayExpr)
  4882  		if !ok {
  4883  			return false
  4884  		}
  4885  		return cmp.RefOfJSONArrayExpr(a, b)
  4886  	case *JSONAttributesExpr:
  4887  		b, ok := inB.(*JSONAttributesExpr)
  4888  		if !ok {
  4889  			return false
  4890  		}
  4891  		return cmp.RefOfJSONAttributesExpr(a, b)
  4892  	case *JSONContainsExpr:
  4893  		b, ok := inB.(*JSONContainsExpr)
  4894  		if !ok {
  4895  			return false
  4896  		}
  4897  		return cmp.RefOfJSONContainsExpr(a, b)
  4898  	case *JSONContainsPathExpr:
  4899  		b, ok := inB.(*JSONContainsPathExpr)
  4900  		if !ok {
  4901  			return false
  4902  		}
  4903  		return cmp.RefOfJSONContainsPathExpr(a, b)
  4904  	case *JSONExtractExpr:
  4905  		b, ok := inB.(*JSONExtractExpr)
  4906  		if !ok {
  4907  			return false
  4908  		}
  4909  		return cmp.RefOfJSONExtractExpr(a, b)
  4910  	case *JSONKeysExpr:
  4911  		b, ok := inB.(*JSONKeysExpr)
  4912  		if !ok {
  4913  			return false
  4914  		}
  4915  		return cmp.RefOfJSONKeysExpr(a, b)
  4916  	case *JSONObjectExpr:
  4917  		b, ok := inB.(*JSONObjectExpr)
  4918  		if !ok {
  4919  			return false
  4920  		}
  4921  		return cmp.RefOfJSONObjectExpr(a, b)
  4922  	case *JSONOverlapsExpr:
  4923  		b, ok := inB.(*JSONOverlapsExpr)
  4924  		if !ok {
  4925  			return false
  4926  		}
  4927  		return cmp.RefOfJSONOverlapsExpr(a, b)
  4928  	case *JSONPrettyExpr:
  4929  		b, ok := inB.(*JSONPrettyExpr)
  4930  		if !ok {
  4931  			return false
  4932  		}
  4933  		return cmp.RefOfJSONPrettyExpr(a, b)
  4934  	case *JSONQuoteExpr:
  4935  		b, ok := inB.(*JSONQuoteExpr)
  4936  		if !ok {
  4937  			return false
  4938  		}
  4939  		return cmp.RefOfJSONQuoteExpr(a, b)
  4940  	case *JSONRemoveExpr:
  4941  		b, ok := inB.(*JSONRemoveExpr)
  4942  		if !ok {
  4943  			return false
  4944  		}
  4945  		return cmp.RefOfJSONRemoveExpr(a, b)
  4946  	case *JSONSchemaValidFuncExpr:
  4947  		b, ok := inB.(*JSONSchemaValidFuncExpr)
  4948  		if !ok {
  4949  			return false
  4950  		}
  4951  		return cmp.RefOfJSONSchemaValidFuncExpr(a, b)
  4952  	case *JSONSchemaValidationReportFuncExpr:
  4953  		b, ok := inB.(*JSONSchemaValidationReportFuncExpr)
  4954  		if !ok {
  4955  			return false
  4956  		}
  4957  		return cmp.RefOfJSONSchemaValidationReportFuncExpr(a, b)
  4958  	case *JSONSearchExpr:
  4959  		b, ok := inB.(*JSONSearchExpr)
  4960  		if !ok {
  4961  			return false
  4962  		}
  4963  		return cmp.RefOfJSONSearchExpr(a, b)
  4964  	case *JSONStorageFreeExpr:
  4965  		b, ok := inB.(*JSONStorageFreeExpr)
  4966  		if !ok {
  4967  			return false
  4968  		}
  4969  		return cmp.RefOfJSONStorageFreeExpr(a, b)
  4970  	case *JSONStorageSizeExpr:
  4971  		b, ok := inB.(*JSONStorageSizeExpr)
  4972  		if !ok {
  4973  			return false
  4974  		}
  4975  		return cmp.RefOfJSONStorageSizeExpr(a, b)
  4976  	case *JSONUnquoteExpr:
  4977  		b, ok := inB.(*JSONUnquoteExpr)
  4978  		if !ok {
  4979  			return false
  4980  		}
  4981  		return cmp.RefOfJSONUnquoteExpr(a, b)
  4982  	case *JSONValueExpr:
  4983  		b, ok := inB.(*JSONValueExpr)
  4984  		if !ok {
  4985  			return false
  4986  		}
  4987  		return cmp.RefOfJSONValueExpr(a, b)
  4988  	case *JSONValueMergeExpr:
  4989  		b, ok := inB.(*JSONValueMergeExpr)
  4990  		if !ok {
  4991  			return false
  4992  		}
  4993  		return cmp.RefOfJSONValueMergeExpr(a, b)
  4994  	case *JSONValueModifierExpr:
  4995  		b, ok := inB.(*JSONValueModifierExpr)
  4996  		if !ok {
  4997  			return false
  4998  		}
  4999  		return cmp.RefOfJSONValueModifierExpr(a, b)
  5000  	case *LagLeadExpr:
  5001  		b, ok := inB.(*LagLeadExpr)
  5002  		if !ok {
  5003  			return false
  5004  		}
  5005  		return cmp.RefOfLagLeadExpr(a, b)
  5006  	case *LocateExpr:
  5007  		b, ok := inB.(*LocateExpr)
  5008  		if !ok {
  5009  			return false
  5010  		}
  5011  		return cmp.RefOfLocateExpr(a, b)
  5012  	case *MatchExpr:
  5013  		b, ok := inB.(*MatchExpr)
  5014  		if !ok {
  5015  			return false
  5016  		}
  5017  		return cmp.RefOfMatchExpr(a, b)
  5018  	case *Max:
  5019  		b, ok := inB.(*Max)
  5020  		if !ok {
  5021  			return false
  5022  		}
  5023  		return cmp.RefOfMax(a, b)
  5024  	case *MemberOfExpr:
  5025  		b, ok := inB.(*MemberOfExpr)
  5026  		if !ok {
  5027  			return false
  5028  		}
  5029  		return cmp.RefOfMemberOfExpr(a, b)
  5030  	case *Min:
  5031  		b, ok := inB.(*Min)
  5032  		if !ok {
  5033  			return false
  5034  		}
  5035  		return cmp.RefOfMin(a, b)
  5036  	case *NTHValueExpr:
  5037  		b, ok := inB.(*NTHValueExpr)
  5038  		if !ok {
  5039  			return false
  5040  		}
  5041  		return cmp.RefOfNTHValueExpr(a, b)
  5042  	case *NamedWindow:
  5043  		b, ok := inB.(*NamedWindow)
  5044  		if !ok {
  5045  			return false
  5046  		}
  5047  		return cmp.RefOfNamedWindow(a, b)
  5048  	case *NtileExpr:
  5049  		b, ok := inB.(*NtileExpr)
  5050  		if !ok {
  5051  			return false
  5052  		}
  5053  		return cmp.RefOfNtileExpr(a, b)
  5054  	case *PerformanceSchemaFuncExpr:
  5055  		b, ok := inB.(*PerformanceSchemaFuncExpr)
  5056  		if !ok {
  5057  			return false
  5058  		}
  5059  		return cmp.RefOfPerformanceSchemaFuncExpr(a, b)
  5060  	case *RegexpInstrExpr:
  5061  		b, ok := inB.(*RegexpInstrExpr)
  5062  		if !ok {
  5063  			return false
  5064  		}
  5065  		return cmp.RefOfRegexpInstrExpr(a, b)
  5066  	case *RegexpLikeExpr:
  5067  		b, ok := inB.(*RegexpLikeExpr)
  5068  		if !ok {
  5069  			return false
  5070  		}
  5071  		return cmp.RefOfRegexpLikeExpr(a, b)
  5072  	case *RegexpReplaceExpr:
  5073  		b, ok := inB.(*RegexpReplaceExpr)
  5074  		if !ok {
  5075  			return false
  5076  		}
  5077  		return cmp.RefOfRegexpReplaceExpr(a, b)
  5078  	case *RegexpSubstrExpr:
  5079  		b, ok := inB.(*RegexpSubstrExpr)
  5080  		if !ok {
  5081  			return false
  5082  		}
  5083  		return cmp.RefOfRegexpSubstrExpr(a, b)
  5084  	case *SubstrExpr:
  5085  		b, ok := inB.(*SubstrExpr)
  5086  		if !ok {
  5087  			return false
  5088  		}
  5089  		return cmp.RefOfSubstrExpr(a, b)
  5090  	case *Sum:
  5091  		b, ok := inB.(*Sum)
  5092  		if !ok {
  5093  			return false
  5094  		}
  5095  		return cmp.RefOfSum(a, b)
  5096  	case *TimestampFuncExpr:
  5097  		b, ok := inB.(*TimestampFuncExpr)
  5098  		if !ok {
  5099  			return false
  5100  		}
  5101  		return cmp.RefOfTimestampFuncExpr(a, b)
  5102  	case *TrimFuncExpr:
  5103  		b, ok := inB.(*TrimFuncExpr)
  5104  		if !ok {
  5105  			return false
  5106  		}
  5107  		return cmp.RefOfTrimFuncExpr(a, b)
  5108  	case *UpdateXMLExpr:
  5109  		b, ok := inB.(*UpdateXMLExpr)
  5110  		if !ok {
  5111  			return false
  5112  		}
  5113  		return cmp.RefOfUpdateXMLExpr(a, b)
  5114  	case *ValuesFuncExpr:
  5115  		b, ok := inB.(*ValuesFuncExpr)
  5116  		if !ok {
  5117  			return false
  5118  		}
  5119  		return cmp.RefOfValuesFuncExpr(a, b)
  5120  	case *WeightStringFuncExpr:
  5121  		b, ok := inB.(*WeightStringFuncExpr)
  5122  		if !ok {
  5123  			return false
  5124  		}
  5125  		return cmp.RefOfWeightStringFuncExpr(a, b)
  5126  	default:
  5127  		// this should never happen
  5128  		return false
  5129  	}
  5130  }
  5131  
  5132  // ColTuple does deep equals between the two objects.
  5133  func (cmp *Comparator) ColTuple(inA, inB ColTuple) bool {
  5134  	if inA == nil && inB == nil {
  5135  		return true
  5136  	}
  5137  	if inA == nil || inB == nil {
  5138  		return false
  5139  	}
  5140  	switch a := inA.(type) {
  5141  	case ListArg:
  5142  		b, ok := inB.(ListArg)
  5143  		if !ok {
  5144  			return false
  5145  		}
  5146  		return a == b
  5147  	case *Subquery:
  5148  		b, ok := inB.(*Subquery)
  5149  		if !ok {
  5150  			return false
  5151  		}
  5152  		return cmp.RefOfSubquery(a, b)
  5153  	case ValTuple:
  5154  		b, ok := inB.(ValTuple)
  5155  		if !ok {
  5156  			return false
  5157  		}
  5158  		return cmp.ValTuple(a, b)
  5159  	default:
  5160  		// this should never happen
  5161  		return false
  5162  	}
  5163  }
  5164  
  5165  // ConstraintInfo does deep equals between the two objects.
  5166  func (cmp *Comparator) ConstraintInfo(inA, inB ConstraintInfo) bool {
  5167  	if inA == nil && inB == nil {
  5168  		return true
  5169  	}
  5170  	if inA == nil || inB == nil {
  5171  		return false
  5172  	}
  5173  	switch a := inA.(type) {
  5174  	case *CheckConstraintDefinition:
  5175  		b, ok := inB.(*CheckConstraintDefinition)
  5176  		if !ok {
  5177  			return false
  5178  		}
  5179  		return cmp.RefOfCheckConstraintDefinition(a, b)
  5180  	case *ForeignKeyDefinition:
  5181  		b, ok := inB.(*ForeignKeyDefinition)
  5182  		if !ok {
  5183  			return false
  5184  		}
  5185  		return cmp.RefOfForeignKeyDefinition(a, b)
  5186  	default:
  5187  		// this should never happen
  5188  		return false
  5189  	}
  5190  }
  5191  
  5192  // DBDDLStatement does deep equals between the two objects.
  5193  func (cmp *Comparator) DBDDLStatement(inA, inB DBDDLStatement) bool {
  5194  	if inA == nil && inB == nil {
  5195  		return true
  5196  	}
  5197  	if inA == nil || inB == nil {
  5198  		return false
  5199  	}
  5200  	switch a := inA.(type) {
  5201  	case *AlterDatabase:
  5202  		b, ok := inB.(*AlterDatabase)
  5203  		if !ok {
  5204  			return false
  5205  		}
  5206  		return cmp.RefOfAlterDatabase(a, b)
  5207  	case *CreateDatabase:
  5208  		b, ok := inB.(*CreateDatabase)
  5209  		if !ok {
  5210  			return false
  5211  		}
  5212  		return cmp.RefOfCreateDatabase(a, b)
  5213  	case *DropDatabase:
  5214  		b, ok := inB.(*DropDatabase)
  5215  		if !ok {
  5216  			return false
  5217  		}
  5218  		return cmp.RefOfDropDatabase(a, b)
  5219  	default:
  5220  		// this should never happen
  5221  		return false
  5222  	}
  5223  }
  5224  
  5225  // DDLStatement does deep equals between the two objects.
  5226  func (cmp *Comparator) DDLStatement(inA, inB DDLStatement) bool {
  5227  	if inA == nil && inB == nil {
  5228  		return true
  5229  	}
  5230  	if inA == nil || inB == nil {
  5231  		return false
  5232  	}
  5233  	switch a := inA.(type) {
  5234  	case *AlterTable:
  5235  		b, ok := inB.(*AlterTable)
  5236  		if !ok {
  5237  			return false
  5238  		}
  5239  		return cmp.RefOfAlterTable(a, b)
  5240  	case *AlterView:
  5241  		b, ok := inB.(*AlterView)
  5242  		if !ok {
  5243  			return false
  5244  		}
  5245  		return cmp.RefOfAlterView(a, b)
  5246  	case *CreateTable:
  5247  		b, ok := inB.(*CreateTable)
  5248  		if !ok {
  5249  			return false
  5250  		}
  5251  		return cmp.RefOfCreateTable(a, b)
  5252  	case *CreateView:
  5253  		b, ok := inB.(*CreateView)
  5254  		if !ok {
  5255  			return false
  5256  		}
  5257  		return cmp.RefOfCreateView(a, b)
  5258  	case *DropTable:
  5259  		b, ok := inB.(*DropTable)
  5260  		if !ok {
  5261  			return false
  5262  		}
  5263  		return cmp.RefOfDropTable(a, b)
  5264  	case *DropView:
  5265  		b, ok := inB.(*DropView)
  5266  		if !ok {
  5267  			return false
  5268  		}
  5269  		return cmp.RefOfDropView(a, b)
  5270  	case *RenameTable:
  5271  		b, ok := inB.(*RenameTable)
  5272  		if !ok {
  5273  			return false
  5274  		}
  5275  		return cmp.RefOfRenameTable(a, b)
  5276  	case *TruncateTable:
  5277  		b, ok := inB.(*TruncateTable)
  5278  		if !ok {
  5279  			return false
  5280  		}
  5281  		return cmp.RefOfTruncateTable(a, b)
  5282  	default:
  5283  		// this should never happen
  5284  		return false
  5285  	}
  5286  }
  5287  
  5288  // Explain does deep equals between the two objects.
  5289  func (cmp *Comparator) Explain(inA, inB Explain) bool {
  5290  	if inA == nil && inB == nil {
  5291  		return true
  5292  	}
  5293  	if inA == nil || inB == nil {
  5294  		return false
  5295  	}
  5296  	switch a := inA.(type) {
  5297  	case *ExplainStmt:
  5298  		b, ok := inB.(*ExplainStmt)
  5299  		if !ok {
  5300  			return false
  5301  		}
  5302  		return cmp.RefOfExplainStmt(a, b)
  5303  	case *ExplainTab:
  5304  		b, ok := inB.(*ExplainTab)
  5305  		if !ok {
  5306  			return false
  5307  		}
  5308  		return cmp.RefOfExplainTab(a, b)
  5309  	default:
  5310  		// this should never happen
  5311  		return false
  5312  	}
  5313  }
  5314  
  5315  // Expr does deep equals between the two objects.
  5316  func (cmp *Comparator) Expr(inA, inB Expr) bool {
  5317  	if inA == nil && inB == nil {
  5318  		return true
  5319  	}
  5320  	if inA == nil || inB == nil {
  5321  		return false
  5322  	}
  5323  	switch a := inA.(type) {
  5324  	case *AndExpr:
  5325  		b, ok := inB.(*AndExpr)
  5326  		if !ok {
  5327  			return false
  5328  		}
  5329  		return cmp.RefOfAndExpr(a, b)
  5330  	case Argument:
  5331  		b, ok := inB.(Argument)
  5332  		if !ok {
  5333  			return false
  5334  		}
  5335  		return a == b
  5336  	case *ArgumentLessWindowExpr:
  5337  		b, ok := inB.(*ArgumentLessWindowExpr)
  5338  		if !ok {
  5339  			return false
  5340  		}
  5341  		return cmp.RefOfArgumentLessWindowExpr(a, b)
  5342  	case *Avg:
  5343  		b, ok := inB.(*Avg)
  5344  		if !ok {
  5345  			return false
  5346  		}
  5347  		return cmp.RefOfAvg(a, b)
  5348  	case *BetweenExpr:
  5349  		b, ok := inB.(*BetweenExpr)
  5350  		if !ok {
  5351  			return false
  5352  		}
  5353  		return cmp.RefOfBetweenExpr(a, b)
  5354  	case *BinaryExpr:
  5355  		b, ok := inB.(*BinaryExpr)
  5356  		if !ok {
  5357  			return false
  5358  		}
  5359  		return cmp.RefOfBinaryExpr(a, b)
  5360  	case *BitAnd:
  5361  		b, ok := inB.(*BitAnd)
  5362  		if !ok {
  5363  			return false
  5364  		}
  5365  		return cmp.RefOfBitAnd(a, b)
  5366  	case *BitOr:
  5367  		b, ok := inB.(*BitOr)
  5368  		if !ok {
  5369  			return false
  5370  		}
  5371  		return cmp.RefOfBitOr(a, b)
  5372  	case *BitXor:
  5373  		b, ok := inB.(*BitXor)
  5374  		if !ok {
  5375  			return false
  5376  		}
  5377  		return cmp.RefOfBitXor(a, b)
  5378  	case BoolVal:
  5379  		b, ok := inB.(BoolVal)
  5380  		if !ok {
  5381  			return false
  5382  		}
  5383  		return a == b
  5384  	case *CaseExpr:
  5385  		b, ok := inB.(*CaseExpr)
  5386  		if !ok {
  5387  			return false
  5388  		}
  5389  		return cmp.RefOfCaseExpr(a, b)
  5390  	case *CastExpr:
  5391  		b, ok := inB.(*CastExpr)
  5392  		if !ok {
  5393  			return false
  5394  		}
  5395  		return cmp.RefOfCastExpr(a, b)
  5396  	case *CharExpr:
  5397  		b, ok := inB.(*CharExpr)
  5398  		if !ok {
  5399  			return false
  5400  		}
  5401  		return cmp.RefOfCharExpr(a, b)
  5402  	case *ColName:
  5403  		b, ok := inB.(*ColName)
  5404  		if !ok {
  5405  			return false
  5406  		}
  5407  		return cmp.RefOfColName(a, b)
  5408  	case *CollateExpr:
  5409  		b, ok := inB.(*CollateExpr)
  5410  		if !ok {
  5411  			return false
  5412  		}
  5413  		return cmp.RefOfCollateExpr(a, b)
  5414  	case *ComparisonExpr:
  5415  		b, ok := inB.(*ComparisonExpr)
  5416  		if !ok {
  5417  			return false
  5418  		}
  5419  		return cmp.RefOfComparisonExpr(a, b)
  5420  	case *ConvertExpr:
  5421  		b, ok := inB.(*ConvertExpr)
  5422  		if !ok {
  5423  			return false
  5424  		}
  5425  		return cmp.RefOfConvertExpr(a, b)
  5426  	case *ConvertUsingExpr:
  5427  		b, ok := inB.(*ConvertUsingExpr)
  5428  		if !ok {
  5429  			return false
  5430  		}
  5431  		return cmp.RefOfConvertUsingExpr(a, b)
  5432  	case *Count:
  5433  		b, ok := inB.(*Count)
  5434  		if !ok {
  5435  			return false
  5436  		}
  5437  		return cmp.RefOfCount(a, b)
  5438  	case *CountStar:
  5439  		b, ok := inB.(*CountStar)
  5440  		if !ok {
  5441  			return false
  5442  		}
  5443  		return cmp.RefOfCountStar(a, b)
  5444  	case *CurTimeFuncExpr:
  5445  		b, ok := inB.(*CurTimeFuncExpr)
  5446  		if !ok {
  5447  			return false
  5448  		}
  5449  		return cmp.RefOfCurTimeFuncExpr(a, b)
  5450  	case *Default:
  5451  		b, ok := inB.(*Default)
  5452  		if !ok {
  5453  			return false
  5454  		}
  5455  		return cmp.RefOfDefault(a, b)
  5456  	case *ExistsExpr:
  5457  		b, ok := inB.(*ExistsExpr)
  5458  		if !ok {
  5459  			return false
  5460  		}
  5461  		return cmp.RefOfExistsExpr(a, b)
  5462  	case *ExtractFuncExpr:
  5463  		b, ok := inB.(*ExtractFuncExpr)
  5464  		if !ok {
  5465  			return false
  5466  		}
  5467  		return cmp.RefOfExtractFuncExpr(a, b)
  5468  	case *ExtractValueExpr:
  5469  		b, ok := inB.(*ExtractValueExpr)
  5470  		if !ok {
  5471  			return false
  5472  		}
  5473  		return cmp.RefOfExtractValueExpr(a, b)
  5474  	case *ExtractedSubquery:
  5475  		b, ok := inB.(*ExtractedSubquery)
  5476  		if !ok {
  5477  			return false
  5478  		}
  5479  		return cmp.RefOfExtractedSubquery(a, b)
  5480  	case *FirstOrLastValueExpr:
  5481  		b, ok := inB.(*FirstOrLastValueExpr)
  5482  		if !ok {
  5483  			return false
  5484  		}
  5485  		return cmp.RefOfFirstOrLastValueExpr(a, b)
  5486  	case *FuncExpr:
  5487  		b, ok := inB.(*FuncExpr)
  5488  		if !ok {
  5489  			return false
  5490  		}
  5491  		return cmp.RefOfFuncExpr(a, b)
  5492  	case *GTIDFuncExpr:
  5493  		b, ok := inB.(*GTIDFuncExpr)
  5494  		if !ok {
  5495  			return false
  5496  		}
  5497  		return cmp.RefOfGTIDFuncExpr(a, b)
  5498  	case *GroupConcatExpr:
  5499  		b, ok := inB.(*GroupConcatExpr)
  5500  		if !ok {
  5501  			return false
  5502  		}
  5503  		return cmp.RefOfGroupConcatExpr(a, b)
  5504  	case *InsertExpr:
  5505  		b, ok := inB.(*InsertExpr)
  5506  		if !ok {
  5507  			return false
  5508  		}
  5509  		return cmp.RefOfInsertExpr(a, b)
  5510  	case *IntervalExpr:
  5511  		b, ok := inB.(*IntervalExpr)
  5512  		if !ok {
  5513  			return false
  5514  		}
  5515  		return cmp.RefOfIntervalExpr(a, b)
  5516  	case *IntervalFuncExpr:
  5517  		b, ok := inB.(*IntervalFuncExpr)
  5518  		if !ok {
  5519  			return false
  5520  		}
  5521  		return cmp.RefOfIntervalFuncExpr(a, b)
  5522  	case *IntroducerExpr:
  5523  		b, ok := inB.(*IntroducerExpr)
  5524  		if !ok {
  5525  			return false
  5526  		}
  5527  		return cmp.RefOfIntroducerExpr(a, b)
  5528  	case *IsExpr:
  5529  		b, ok := inB.(*IsExpr)
  5530  		if !ok {
  5531  			return false
  5532  		}
  5533  		return cmp.RefOfIsExpr(a, b)
  5534  	case *JSONArrayExpr:
  5535  		b, ok := inB.(*JSONArrayExpr)
  5536  		if !ok {
  5537  			return false
  5538  		}
  5539  		return cmp.RefOfJSONArrayExpr(a, b)
  5540  	case *JSONAttributesExpr:
  5541  		b, ok := inB.(*JSONAttributesExpr)
  5542  		if !ok {
  5543  			return false
  5544  		}
  5545  		return cmp.RefOfJSONAttributesExpr(a, b)
  5546  	case *JSONContainsExpr:
  5547  		b, ok := inB.(*JSONContainsExpr)
  5548  		if !ok {
  5549  			return false
  5550  		}
  5551  		return cmp.RefOfJSONContainsExpr(a, b)
  5552  	case *JSONContainsPathExpr:
  5553  		b, ok := inB.(*JSONContainsPathExpr)
  5554  		if !ok {
  5555  			return false
  5556  		}
  5557  		return cmp.RefOfJSONContainsPathExpr(a, b)
  5558  	case *JSONExtractExpr:
  5559  		b, ok := inB.(*JSONExtractExpr)
  5560  		if !ok {
  5561  			return false
  5562  		}
  5563  		return cmp.RefOfJSONExtractExpr(a, b)
  5564  	case *JSONKeysExpr:
  5565  		b, ok := inB.(*JSONKeysExpr)
  5566  		if !ok {
  5567  			return false
  5568  		}
  5569  		return cmp.RefOfJSONKeysExpr(a, b)
  5570  	case *JSONObjectExpr:
  5571  		b, ok := inB.(*JSONObjectExpr)
  5572  		if !ok {
  5573  			return false
  5574  		}
  5575  		return cmp.RefOfJSONObjectExpr(a, b)
  5576  	case *JSONOverlapsExpr:
  5577  		b, ok := inB.(*JSONOverlapsExpr)
  5578  		if !ok {
  5579  			return false
  5580  		}
  5581  		return cmp.RefOfJSONOverlapsExpr(a, b)
  5582  	case *JSONPrettyExpr:
  5583  		b, ok := inB.(*JSONPrettyExpr)
  5584  		if !ok {
  5585  			return false
  5586  		}
  5587  		return cmp.RefOfJSONPrettyExpr(a, b)
  5588  	case *JSONQuoteExpr:
  5589  		b, ok := inB.(*JSONQuoteExpr)
  5590  		if !ok {
  5591  			return false
  5592  		}
  5593  		return cmp.RefOfJSONQuoteExpr(a, b)
  5594  	case *JSONRemoveExpr:
  5595  		b, ok := inB.(*JSONRemoveExpr)
  5596  		if !ok {
  5597  			return false
  5598  		}
  5599  		return cmp.RefOfJSONRemoveExpr(a, b)
  5600  	case *JSONSchemaValidFuncExpr:
  5601  		b, ok := inB.(*JSONSchemaValidFuncExpr)
  5602  		if !ok {
  5603  			return false
  5604  		}
  5605  		return cmp.RefOfJSONSchemaValidFuncExpr(a, b)
  5606  	case *JSONSchemaValidationReportFuncExpr:
  5607  		b, ok := inB.(*JSONSchemaValidationReportFuncExpr)
  5608  		if !ok {
  5609  			return false
  5610  		}
  5611  		return cmp.RefOfJSONSchemaValidationReportFuncExpr(a, b)
  5612  	case *JSONSearchExpr:
  5613  		b, ok := inB.(*JSONSearchExpr)
  5614  		if !ok {
  5615  			return false
  5616  		}
  5617  		return cmp.RefOfJSONSearchExpr(a, b)
  5618  	case *JSONStorageFreeExpr:
  5619  		b, ok := inB.(*JSONStorageFreeExpr)
  5620  		if !ok {
  5621  			return false
  5622  		}
  5623  		return cmp.RefOfJSONStorageFreeExpr(a, b)
  5624  	case *JSONStorageSizeExpr:
  5625  		b, ok := inB.(*JSONStorageSizeExpr)
  5626  		if !ok {
  5627  			return false
  5628  		}
  5629  		return cmp.RefOfJSONStorageSizeExpr(a, b)
  5630  	case *JSONUnquoteExpr:
  5631  		b, ok := inB.(*JSONUnquoteExpr)
  5632  		if !ok {
  5633  			return false
  5634  		}
  5635  		return cmp.RefOfJSONUnquoteExpr(a, b)
  5636  	case *JSONValueExpr:
  5637  		b, ok := inB.(*JSONValueExpr)
  5638  		if !ok {
  5639  			return false
  5640  		}
  5641  		return cmp.RefOfJSONValueExpr(a, b)
  5642  	case *JSONValueMergeExpr:
  5643  		b, ok := inB.(*JSONValueMergeExpr)
  5644  		if !ok {
  5645  			return false
  5646  		}
  5647  		return cmp.RefOfJSONValueMergeExpr(a, b)
  5648  	case *JSONValueModifierExpr:
  5649  		b, ok := inB.(*JSONValueModifierExpr)
  5650  		if !ok {
  5651  			return false
  5652  		}
  5653  		return cmp.RefOfJSONValueModifierExpr(a, b)
  5654  	case *LagLeadExpr:
  5655  		b, ok := inB.(*LagLeadExpr)
  5656  		if !ok {
  5657  			return false
  5658  		}
  5659  		return cmp.RefOfLagLeadExpr(a, b)
  5660  	case ListArg:
  5661  		b, ok := inB.(ListArg)
  5662  		if !ok {
  5663  			return false
  5664  		}
  5665  		return a == b
  5666  	case *Literal:
  5667  		b, ok := inB.(*Literal)
  5668  		if !ok {
  5669  			return false
  5670  		}
  5671  		return cmp.RefOfLiteral(a, b)
  5672  	case *LocateExpr:
  5673  		b, ok := inB.(*LocateExpr)
  5674  		if !ok {
  5675  			return false
  5676  		}
  5677  		return cmp.RefOfLocateExpr(a, b)
  5678  	case *LockingFunc:
  5679  		b, ok := inB.(*LockingFunc)
  5680  		if !ok {
  5681  			return false
  5682  		}
  5683  		return cmp.RefOfLockingFunc(a, b)
  5684  	case *MatchExpr:
  5685  		b, ok := inB.(*MatchExpr)
  5686  		if !ok {
  5687  			return false
  5688  		}
  5689  		return cmp.RefOfMatchExpr(a, b)
  5690  	case *Max:
  5691  		b, ok := inB.(*Max)
  5692  		if !ok {
  5693  			return false
  5694  		}
  5695  		return cmp.RefOfMax(a, b)
  5696  	case *MemberOfExpr:
  5697  		b, ok := inB.(*MemberOfExpr)
  5698  		if !ok {
  5699  			return false
  5700  		}
  5701  		return cmp.RefOfMemberOfExpr(a, b)
  5702  	case *Min:
  5703  		b, ok := inB.(*Min)
  5704  		if !ok {
  5705  			return false
  5706  		}
  5707  		return cmp.RefOfMin(a, b)
  5708  	case *NTHValueExpr:
  5709  		b, ok := inB.(*NTHValueExpr)
  5710  		if !ok {
  5711  			return false
  5712  		}
  5713  		return cmp.RefOfNTHValueExpr(a, b)
  5714  	case *NamedWindow:
  5715  		b, ok := inB.(*NamedWindow)
  5716  		if !ok {
  5717  			return false
  5718  		}
  5719  		return cmp.RefOfNamedWindow(a, b)
  5720  	case *NotExpr:
  5721  		b, ok := inB.(*NotExpr)
  5722  		if !ok {
  5723  			return false
  5724  		}
  5725  		return cmp.RefOfNotExpr(a, b)
  5726  	case *NtileExpr:
  5727  		b, ok := inB.(*NtileExpr)
  5728  		if !ok {
  5729  			return false
  5730  		}
  5731  		return cmp.RefOfNtileExpr(a, b)
  5732  	case *NullVal:
  5733  		b, ok := inB.(*NullVal)
  5734  		if !ok {
  5735  			return false
  5736  		}
  5737  		return cmp.RefOfNullVal(a, b)
  5738  	case *Offset:
  5739  		b, ok := inB.(*Offset)
  5740  		if !ok {
  5741  			return false
  5742  		}
  5743  		return cmp.RefOfOffset(a, b)
  5744  	case *OrExpr:
  5745  		b, ok := inB.(*OrExpr)
  5746  		if !ok {
  5747  			return false
  5748  		}
  5749  		return cmp.RefOfOrExpr(a, b)
  5750  	case *PerformanceSchemaFuncExpr:
  5751  		b, ok := inB.(*PerformanceSchemaFuncExpr)
  5752  		if !ok {
  5753  			return false
  5754  		}
  5755  		return cmp.RefOfPerformanceSchemaFuncExpr(a, b)
  5756  	case *RegexpInstrExpr:
  5757  		b, ok := inB.(*RegexpInstrExpr)
  5758  		if !ok {
  5759  			return false
  5760  		}
  5761  		return cmp.RefOfRegexpInstrExpr(a, b)
  5762  	case *RegexpLikeExpr:
  5763  		b, ok := inB.(*RegexpLikeExpr)
  5764  		if !ok {
  5765  			return false
  5766  		}
  5767  		return cmp.RefOfRegexpLikeExpr(a, b)
  5768  	case *RegexpReplaceExpr:
  5769  		b, ok := inB.(*RegexpReplaceExpr)
  5770  		if !ok {
  5771  			return false
  5772  		}
  5773  		return cmp.RefOfRegexpReplaceExpr(a, b)
  5774  	case *RegexpSubstrExpr:
  5775  		b, ok := inB.(*RegexpSubstrExpr)
  5776  		if !ok {
  5777  			return false
  5778  		}
  5779  		return cmp.RefOfRegexpSubstrExpr(a, b)
  5780  	case *Std:
  5781  		b, ok := inB.(*Std)
  5782  		if !ok {
  5783  			return false
  5784  		}
  5785  		return cmp.RefOfStd(a, b)
  5786  	case *StdDev:
  5787  		b, ok := inB.(*StdDev)
  5788  		if !ok {
  5789  			return false
  5790  		}
  5791  		return cmp.RefOfStdDev(a, b)
  5792  	case *StdPop:
  5793  		b, ok := inB.(*StdPop)
  5794  		if !ok {
  5795  			return false
  5796  		}
  5797  		return cmp.RefOfStdPop(a, b)
  5798  	case *StdSamp:
  5799  		b, ok := inB.(*StdSamp)
  5800  		if !ok {
  5801  			return false
  5802  		}
  5803  		return cmp.RefOfStdSamp(a, b)
  5804  	case *Subquery:
  5805  		b, ok := inB.(*Subquery)
  5806  		if !ok {
  5807  			return false
  5808  		}
  5809  		return cmp.RefOfSubquery(a, b)
  5810  	case *SubstrExpr:
  5811  		b, ok := inB.(*SubstrExpr)
  5812  		if !ok {
  5813  			return false
  5814  		}
  5815  		return cmp.RefOfSubstrExpr(a, b)
  5816  	case *Sum:
  5817  		b, ok := inB.(*Sum)
  5818  		if !ok {
  5819  			return false
  5820  		}
  5821  		return cmp.RefOfSum(a, b)
  5822  	case *TimestampFuncExpr:
  5823  		b, ok := inB.(*TimestampFuncExpr)
  5824  		if !ok {
  5825  			return false
  5826  		}
  5827  		return cmp.RefOfTimestampFuncExpr(a, b)
  5828  	case *TrimFuncExpr:
  5829  		b, ok := inB.(*TrimFuncExpr)
  5830  		if !ok {
  5831  			return false
  5832  		}
  5833  		return cmp.RefOfTrimFuncExpr(a, b)
  5834  	case *UnaryExpr:
  5835  		b, ok := inB.(*UnaryExpr)
  5836  		if !ok {
  5837  			return false
  5838  		}
  5839  		return cmp.RefOfUnaryExpr(a, b)
  5840  	case *UpdateXMLExpr:
  5841  		b, ok := inB.(*UpdateXMLExpr)
  5842  		if !ok {
  5843  			return false
  5844  		}
  5845  		return cmp.RefOfUpdateXMLExpr(a, b)
  5846  	case ValTuple:
  5847  		b, ok := inB.(ValTuple)
  5848  		if !ok {
  5849  			return false
  5850  		}
  5851  		return cmp.ValTuple(a, b)
  5852  	case *ValuesFuncExpr:
  5853  		b, ok := inB.(*ValuesFuncExpr)
  5854  		if !ok {
  5855  			return false
  5856  		}
  5857  		return cmp.RefOfValuesFuncExpr(a, b)
  5858  	case *VarPop:
  5859  		b, ok := inB.(*VarPop)
  5860  		if !ok {
  5861  			return false
  5862  		}
  5863  		return cmp.RefOfVarPop(a, b)
  5864  	case *VarSamp:
  5865  		b, ok := inB.(*VarSamp)
  5866  		if !ok {
  5867  			return false
  5868  		}
  5869  		return cmp.RefOfVarSamp(a, b)
  5870  	case *Variable:
  5871  		b, ok := inB.(*Variable)
  5872  		if !ok {
  5873  			return false
  5874  		}
  5875  		return cmp.RefOfVariable(a, b)
  5876  	case *Variance:
  5877  		b, ok := inB.(*Variance)
  5878  		if !ok {
  5879  			return false
  5880  		}
  5881  		return cmp.RefOfVariance(a, b)
  5882  	case *WeightStringFuncExpr:
  5883  		b, ok := inB.(*WeightStringFuncExpr)
  5884  		if !ok {
  5885  			return false
  5886  		}
  5887  		return cmp.RefOfWeightStringFuncExpr(a, b)
  5888  	case *XorExpr:
  5889  		b, ok := inB.(*XorExpr)
  5890  		if !ok {
  5891  			return false
  5892  		}
  5893  		return cmp.RefOfXorExpr(a, b)
  5894  	default:
  5895  		// this should never happen
  5896  		return false
  5897  	}
  5898  }
  5899  
  5900  // InsertRows does deep equals between the two objects.
  5901  func (cmp *Comparator) InsertRows(inA, inB InsertRows) bool {
  5902  	if inA == nil && inB == nil {
  5903  		return true
  5904  	}
  5905  	if inA == nil || inB == nil {
  5906  		return false
  5907  	}
  5908  	switch a := inA.(type) {
  5909  	case *Select:
  5910  		b, ok := inB.(*Select)
  5911  		if !ok {
  5912  			return false
  5913  		}
  5914  		return cmp.RefOfSelect(a, b)
  5915  	case *Union:
  5916  		b, ok := inB.(*Union)
  5917  		if !ok {
  5918  			return false
  5919  		}
  5920  		return cmp.RefOfUnion(a, b)
  5921  	case Values:
  5922  		b, ok := inB.(Values)
  5923  		if !ok {
  5924  			return false
  5925  		}
  5926  		return cmp.Values(a, b)
  5927  	default:
  5928  		// this should never happen
  5929  		return false
  5930  	}
  5931  }
  5932  
  5933  // SelectExpr does deep equals between the two objects.
  5934  func (cmp *Comparator) SelectExpr(inA, inB SelectExpr) bool {
  5935  	if inA == nil && inB == nil {
  5936  		return true
  5937  	}
  5938  	if inA == nil || inB == nil {
  5939  		return false
  5940  	}
  5941  	switch a := inA.(type) {
  5942  	case *AliasedExpr:
  5943  		b, ok := inB.(*AliasedExpr)
  5944  		if !ok {
  5945  			return false
  5946  		}
  5947  		return cmp.RefOfAliasedExpr(a, b)
  5948  	case *Nextval:
  5949  		b, ok := inB.(*Nextval)
  5950  		if !ok {
  5951  			return false
  5952  		}
  5953  		return cmp.RefOfNextval(a, b)
  5954  	case *StarExpr:
  5955  		b, ok := inB.(*StarExpr)
  5956  		if !ok {
  5957  			return false
  5958  		}
  5959  		return cmp.RefOfStarExpr(a, b)
  5960  	default:
  5961  		// this should never happen
  5962  		return false
  5963  	}
  5964  }
  5965  
  5966  // SelectStatement does deep equals between the two objects.
  5967  func (cmp *Comparator) SelectStatement(inA, inB SelectStatement) bool {
  5968  	if inA == nil && inB == nil {
  5969  		return true
  5970  	}
  5971  	if inA == nil || inB == nil {
  5972  		return false
  5973  	}
  5974  	switch a := inA.(type) {
  5975  	case *Select:
  5976  		b, ok := inB.(*Select)
  5977  		if !ok {
  5978  			return false
  5979  		}
  5980  		return cmp.RefOfSelect(a, b)
  5981  	case *Union:
  5982  		b, ok := inB.(*Union)
  5983  		if !ok {
  5984  			return false
  5985  		}
  5986  		return cmp.RefOfUnion(a, b)
  5987  	default:
  5988  		// this should never happen
  5989  		return false
  5990  	}
  5991  }
  5992  
  5993  // ShowInternal does deep equals between the two objects.
  5994  func (cmp *Comparator) ShowInternal(inA, inB ShowInternal) bool {
  5995  	if inA == nil && inB == nil {
  5996  		return true
  5997  	}
  5998  	if inA == nil || inB == nil {
  5999  		return false
  6000  	}
  6001  	switch a := inA.(type) {
  6002  	case *ShowBasic:
  6003  		b, ok := inB.(*ShowBasic)
  6004  		if !ok {
  6005  			return false
  6006  		}
  6007  		return cmp.RefOfShowBasic(a, b)
  6008  	case *ShowCreate:
  6009  		b, ok := inB.(*ShowCreate)
  6010  		if !ok {
  6011  			return false
  6012  		}
  6013  		return cmp.RefOfShowCreate(a, b)
  6014  	case *ShowOther:
  6015  		b, ok := inB.(*ShowOther)
  6016  		if !ok {
  6017  			return false
  6018  		}
  6019  		return cmp.RefOfShowOther(a, b)
  6020  	default:
  6021  		// this should never happen
  6022  		return false
  6023  	}
  6024  }
  6025  
  6026  // SimpleTableExpr does deep equals between the two objects.
  6027  func (cmp *Comparator) SimpleTableExpr(inA, inB SimpleTableExpr) bool {
  6028  	if inA == nil && inB == nil {
  6029  		return true
  6030  	}
  6031  	if inA == nil || inB == nil {
  6032  		return false
  6033  	}
  6034  	switch a := inA.(type) {
  6035  	case *DerivedTable:
  6036  		b, ok := inB.(*DerivedTable)
  6037  		if !ok {
  6038  			return false
  6039  		}
  6040  		return cmp.RefOfDerivedTable(a, b)
  6041  	case TableName:
  6042  		b, ok := inB.(TableName)
  6043  		if !ok {
  6044  			return false
  6045  		}
  6046  		return cmp.TableName(a, b)
  6047  	default:
  6048  		// this should never happen
  6049  		return false
  6050  	}
  6051  }
  6052  
  6053  // Statement does deep equals between the two objects.
  6054  func (cmp *Comparator) Statement(inA, inB Statement) bool {
  6055  	if inA == nil && inB == nil {
  6056  		return true
  6057  	}
  6058  	if inA == nil || inB == nil {
  6059  		return false
  6060  	}
  6061  	switch a := inA.(type) {
  6062  	case *AlterDatabase:
  6063  		b, ok := inB.(*AlterDatabase)
  6064  		if !ok {
  6065  			return false
  6066  		}
  6067  		return cmp.RefOfAlterDatabase(a, b)
  6068  	case *AlterMigration:
  6069  		b, ok := inB.(*AlterMigration)
  6070  		if !ok {
  6071  			return false
  6072  		}
  6073  		return cmp.RefOfAlterMigration(a, b)
  6074  	case *AlterTable:
  6075  		b, ok := inB.(*AlterTable)
  6076  		if !ok {
  6077  			return false
  6078  		}
  6079  		return cmp.RefOfAlterTable(a, b)
  6080  	case *AlterView:
  6081  		b, ok := inB.(*AlterView)
  6082  		if !ok {
  6083  			return false
  6084  		}
  6085  		return cmp.RefOfAlterView(a, b)
  6086  	case *AlterVschema:
  6087  		b, ok := inB.(*AlterVschema)
  6088  		if !ok {
  6089  			return false
  6090  		}
  6091  		return cmp.RefOfAlterVschema(a, b)
  6092  	case *Begin:
  6093  		b, ok := inB.(*Begin)
  6094  		if !ok {
  6095  			return false
  6096  		}
  6097  		return cmp.RefOfBegin(a, b)
  6098  	case *CallProc:
  6099  		b, ok := inB.(*CallProc)
  6100  		if !ok {
  6101  			return false
  6102  		}
  6103  		return cmp.RefOfCallProc(a, b)
  6104  	case *CommentOnly:
  6105  		b, ok := inB.(*CommentOnly)
  6106  		if !ok {
  6107  			return false
  6108  		}
  6109  		return cmp.RefOfCommentOnly(a, b)
  6110  	case *Commit:
  6111  		b, ok := inB.(*Commit)
  6112  		if !ok {
  6113  			return false
  6114  		}
  6115  		return cmp.RefOfCommit(a, b)
  6116  	case *CreateDatabase:
  6117  		b, ok := inB.(*CreateDatabase)
  6118  		if !ok {
  6119  			return false
  6120  		}
  6121  		return cmp.RefOfCreateDatabase(a, b)
  6122  	case *CreateTable:
  6123  		b, ok := inB.(*CreateTable)
  6124  		if !ok {
  6125  			return false
  6126  		}
  6127  		return cmp.RefOfCreateTable(a, b)
  6128  	case *CreateView:
  6129  		b, ok := inB.(*CreateView)
  6130  		if !ok {
  6131  			return false
  6132  		}
  6133  		return cmp.RefOfCreateView(a, b)
  6134  	case *DeallocateStmt:
  6135  		b, ok := inB.(*DeallocateStmt)
  6136  		if !ok {
  6137  			return false
  6138  		}
  6139  		return cmp.RefOfDeallocateStmt(a, b)
  6140  	case *Delete:
  6141  		b, ok := inB.(*Delete)
  6142  		if !ok {
  6143  			return false
  6144  		}
  6145  		return cmp.RefOfDelete(a, b)
  6146  	case *DropDatabase:
  6147  		b, ok := inB.(*DropDatabase)
  6148  		if !ok {
  6149  			return false
  6150  		}
  6151  		return cmp.RefOfDropDatabase(a, b)
  6152  	case *DropTable:
  6153  		b, ok := inB.(*DropTable)
  6154  		if !ok {
  6155  			return false
  6156  		}
  6157  		return cmp.RefOfDropTable(a, b)
  6158  	case *DropView:
  6159  		b, ok := inB.(*DropView)
  6160  		if !ok {
  6161  			return false
  6162  		}
  6163  		return cmp.RefOfDropView(a, b)
  6164  	case *ExecuteStmt:
  6165  		b, ok := inB.(*ExecuteStmt)
  6166  		if !ok {
  6167  			return false
  6168  		}
  6169  		return cmp.RefOfExecuteStmt(a, b)
  6170  	case *ExplainStmt:
  6171  		b, ok := inB.(*ExplainStmt)
  6172  		if !ok {
  6173  			return false
  6174  		}
  6175  		return cmp.RefOfExplainStmt(a, b)
  6176  	case *ExplainTab:
  6177  		b, ok := inB.(*ExplainTab)
  6178  		if !ok {
  6179  			return false
  6180  		}
  6181  		return cmp.RefOfExplainTab(a, b)
  6182  	case *Flush:
  6183  		b, ok := inB.(*Flush)
  6184  		if !ok {
  6185  			return false
  6186  		}
  6187  		return cmp.RefOfFlush(a, b)
  6188  	case *Insert:
  6189  		b, ok := inB.(*Insert)
  6190  		if !ok {
  6191  			return false
  6192  		}
  6193  		return cmp.RefOfInsert(a, b)
  6194  	case *Load:
  6195  		b, ok := inB.(*Load)
  6196  		if !ok {
  6197  			return false
  6198  		}
  6199  		return cmp.RefOfLoad(a, b)
  6200  	case *LockTables:
  6201  		b, ok := inB.(*LockTables)
  6202  		if !ok {
  6203  			return false
  6204  		}
  6205  		return cmp.RefOfLockTables(a, b)
  6206  	case *OtherAdmin:
  6207  		b, ok := inB.(*OtherAdmin)
  6208  		if !ok {
  6209  			return false
  6210  		}
  6211  		return cmp.RefOfOtherAdmin(a, b)
  6212  	case *OtherRead:
  6213  		b, ok := inB.(*OtherRead)
  6214  		if !ok {
  6215  			return false
  6216  		}
  6217  		return cmp.RefOfOtherRead(a, b)
  6218  	case *PrepareStmt:
  6219  		b, ok := inB.(*PrepareStmt)
  6220  		if !ok {
  6221  			return false
  6222  		}
  6223  		return cmp.RefOfPrepareStmt(a, b)
  6224  	case *Release:
  6225  		b, ok := inB.(*Release)
  6226  		if !ok {
  6227  			return false
  6228  		}
  6229  		return cmp.RefOfRelease(a, b)
  6230  	case *RenameTable:
  6231  		b, ok := inB.(*RenameTable)
  6232  		if !ok {
  6233  			return false
  6234  		}
  6235  		return cmp.RefOfRenameTable(a, b)
  6236  	case *RevertMigration:
  6237  		b, ok := inB.(*RevertMigration)
  6238  		if !ok {
  6239  			return false
  6240  		}
  6241  		return cmp.RefOfRevertMigration(a, b)
  6242  	case *Rollback:
  6243  		b, ok := inB.(*Rollback)
  6244  		if !ok {
  6245  			return false
  6246  		}
  6247  		return cmp.RefOfRollback(a, b)
  6248  	case *SRollback:
  6249  		b, ok := inB.(*SRollback)
  6250  		if !ok {
  6251  			return false
  6252  		}
  6253  		return cmp.RefOfSRollback(a, b)
  6254  	case *Savepoint:
  6255  		b, ok := inB.(*Savepoint)
  6256  		if !ok {
  6257  			return false
  6258  		}
  6259  		return cmp.RefOfSavepoint(a, b)
  6260  	case *Select:
  6261  		b, ok := inB.(*Select)
  6262  		if !ok {
  6263  			return false
  6264  		}
  6265  		return cmp.RefOfSelect(a, b)
  6266  	case *Set:
  6267  		b, ok := inB.(*Set)
  6268  		if !ok {
  6269  			return false
  6270  		}
  6271  		return cmp.RefOfSet(a, b)
  6272  	case *Show:
  6273  		b, ok := inB.(*Show)
  6274  		if !ok {
  6275  			return false
  6276  		}
  6277  		return cmp.RefOfShow(a, b)
  6278  	case *ShowMigrationLogs:
  6279  		b, ok := inB.(*ShowMigrationLogs)
  6280  		if !ok {
  6281  			return false
  6282  		}
  6283  		return cmp.RefOfShowMigrationLogs(a, b)
  6284  	case *ShowThrottledApps:
  6285  		b, ok := inB.(*ShowThrottledApps)
  6286  		if !ok {
  6287  			return false
  6288  		}
  6289  		return cmp.RefOfShowThrottledApps(a, b)
  6290  	case *ShowThrottlerStatus:
  6291  		b, ok := inB.(*ShowThrottlerStatus)
  6292  		if !ok {
  6293  			return false
  6294  		}
  6295  		return cmp.RefOfShowThrottlerStatus(a, b)
  6296  	case *Stream:
  6297  		b, ok := inB.(*Stream)
  6298  		if !ok {
  6299  			return false
  6300  		}
  6301  		return cmp.RefOfStream(a, b)
  6302  	case *TruncateTable:
  6303  		b, ok := inB.(*TruncateTable)
  6304  		if !ok {
  6305  			return false
  6306  		}
  6307  		return cmp.RefOfTruncateTable(a, b)
  6308  	case *Union:
  6309  		b, ok := inB.(*Union)
  6310  		if !ok {
  6311  			return false
  6312  		}
  6313  		return cmp.RefOfUnion(a, b)
  6314  	case *UnlockTables:
  6315  		b, ok := inB.(*UnlockTables)
  6316  		if !ok {
  6317  			return false
  6318  		}
  6319  		return cmp.RefOfUnlockTables(a, b)
  6320  	case *Update:
  6321  		b, ok := inB.(*Update)
  6322  		if !ok {
  6323  			return false
  6324  		}
  6325  		return cmp.RefOfUpdate(a, b)
  6326  	case *Use:
  6327  		b, ok := inB.(*Use)
  6328  		if !ok {
  6329  			return false
  6330  		}
  6331  		return cmp.RefOfUse(a, b)
  6332  	case *VExplainStmt:
  6333  		b, ok := inB.(*VExplainStmt)
  6334  		if !ok {
  6335  			return false
  6336  		}
  6337  		return cmp.RefOfVExplainStmt(a, b)
  6338  	case *VStream:
  6339  		b, ok := inB.(*VStream)
  6340  		if !ok {
  6341  			return false
  6342  		}
  6343  		return cmp.RefOfVStream(a, b)
  6344  	default:
  6345  		// this should never happen
  6346  		return false
  6347  	}
  6348  }
  6349  
  6350  // TableExpr does deep equals between the two objects.
  6351  func (cmp *Comparator) TableExpr(inA, inB TableExpr) bool {
  6352  	if inA == nil && inB == nil {
  6353  		return true
  6354  	}
  6355  	if inA == nil || inB == nil {
  6356  		return false
  6357  	}
  6358  	switch a := inA.(type) {
  6359  	case *AliasedTableExpr:
  6360  		b, ok := inB.(*AliasedTableExpr)
  6361  		if !ok {
  6362  			return false
  6363  		}
  6364  		return cmp.RefOfAliasedTableExpr(a, b)
  6365  	case *JSONTableExpr:
  6366  		b, ok := inB.(*JSONTableExpr)
  6367  		if !ok {
  6368  			return false
  6369  		}
  6370  		return cmp.RefOfJSONTableExpr(a, b)
  6371  	case *JoinTableExpr:
  6372  		b, ok := inB.(*JoinTableExpr)
  6373  		if !ok {
  6374  			return false
  6375  		}
  6376  		return cmp.RefOfJoinTableExpr(a, b)
  6377  	case *ParenTableExpr:
  6378  		b, ok := inB.(*ParenTableExpr)
  6379  		if !ok {
  6380  			return false
  6381  		}
  6382  		return cmp.RefOfParenTableExpr(a, b)
  6383  	default:
  6384  		// this should never happen
  6385  		return false
  6386  	}
  6387  }
  6388  
  6389  // SliceOfRefOfColumnDefinition does deep equals between the two objects.
  6390  func (cmp *Comparator) SliceOfRefOfColumnDefinition(a, b []*ColumnDefinition) bool {
  6391  	if len(a) != len(b) {
  6392  		return false
  6393  	}
  6394  	for i := 0; i < len(a); i++ {
  6395  		if !cmp.RefOfColumnDefinition(a[i], b[i]) {
  6396  			return false
  6397  		}
  6398  	}
  6399  	return true
  6400  }
  6401  
  6402  // RefOfBool does deep equals between the two objects.
  6403  func (cmp *Comparator) RefOfBool(a, b *bool) bool {
  6404  	if a == b {
  6405  		return true
  6406  	}
  6407  	if a == nil || b == nil {
  6408  		return false
  6409  	}
  6410  	return *a == *b
  6411  }
  6412  
  6413  // SliceOfDatabaseOption does deep equals between the two objects.
  6414  func (cmp *Comparator) SliceOfDatabaseOption(a, b []DatabaseOption) bool {
  6415  	if len(a) != len(b) {
  6416  		return false
  6417  	}
  6418  	for i := 0; i < len(a); i++ {
  6419  		if !cmp.DatabaseOption(a[i], b[i]) {
  6420  			return false
  6421  		}
  6422  	}
  6423  	return true
  6424  }
  6425  
  6426  // SliceOfAlterOption does deep equals between the two objects.
  6427  func (cmp *Comparator) SliceOfAlterOption(a, b []AlterOption) bool {
  6428  	if len(a) != len(b) {
  6429  		return false
  6430  	}
  6431  	for i := 0; i < len(a); i++ {
  6432  		if !cmp.AlterOption(a[i], b[i]) {
  6433  			return false
  6434  		}
  6435  	}
  6436  	return true
  6437  }
  6438  
  6439  // SliceOfIdentifierCI does deep equals between the two objects.
  6440  func (cmp *Comparator) SliceOfIdentifierCI(a, b []IdentifierCI) bool {
  6441  	if len(a) != len(b) {
  6442  		return false
  6443  	}
  6444  	for i := 0; i < len(a); i++ {
  6445  		if !cmp.IdentifierCI(a[i], b[i]) {
  6446  			return false
  6447  		}
  6448  	}
  6449  	return true
  6450  }
  6451  
  6452  // SliceOfTxAccessMode does deep equals between the two objects.
  6453  func (cmp *Comparator) SliceOfTxAccessMode(a, b []TxAccessMode) bool {
  6454  	if len(a) != len(b) {
  6455  		return false
  6456  	}
  6457  	for i := 0; i < len(a); i++ {
  6458  		if a[i] != b[i] {
  6459  			return false
  6460  		}
  6461  	}
  6462  	return true
  6463  }
  6464  
  6465  // SliceOfRefOfWhen does deep equals between the two objects.
  6466  func (cmp *Comparator) SliceOfRefOfWhen(a, b []*When) bool {
  6467  	if len(a) != len(b) {
  6468  		return false
  6469  	}
  6470  	for i := 0; i < len(a); i++ {
  6471  		if !cmp.RefOfWhen(a[i], b[i]) {
  6472  			return false
  6473  		}
  6474  	}
  6475  	return true
  6476  }
  6477  
  6478  // RefOfColumnTypeOptions does deep equals between the two objects.
  6479  func (cmp *Comparator) RefOfColumnTypeOptions(a, b *ColumnTypeOptions) bool {
  6480  	if a == b {
  6481  		return true
  6482  	}
  6483  	if a == nil || b == nil {
  6484  		return false
  6485  	}
  6486  	return a.Autoincrement == b.Autoincrement &&
  6487  		a.Collate == b.Collate &&
  6488  		cmp.RefOfBool(a.Null, b.Null) &&
  6489  		cmp.Expr(a.Default, b.Default) &&
  6490  		cmp.Expr(a.OnUpdate, b.OnUpdate) &&
  6491  		cmp.Expr(a.As, b.As) &&
  6492  		cmp.RefOfLiteral(a.Comment, b.Comment) &&
  6493  		a.Storage == b.Storage &&
  6494  		cmp.RefOfReferenceDefinition(a.Reference, b.Reference) &&
  6495  		a.KeyOpt == b.KeyOpt &&
  6496  		cmp.RefOfBool(a.Invisible, b.Invisible) &&
  6497  		a.Format == b.Format &&
  6498  		cmp.RefOfLiteral(a.EngineAttribute, b.EngineAttribute) &&
  6499  		cmp.RefOfLiteral(a.SecondaryEngineAttribute, b.SecondaryEngineAttribute) &&
  6500  		cmp.RefOfLiteral(a.SRID, b.SRID)
  6501  }
  6502  
  6503  // ColumnCharset does deep equals between the two objects.
  6504  func (cmp *Comparator) ColumnCharset(a, b ColumnCharset) bool {
  6505  	return a.Name == b.Name &&
  6506  		a.Binary == b.Binary
  6507  }
  6508  
  6509  // SliceOfString does deep equals between the two objects.
  6510  func (cmp *Comparator) SliceOfString(a, b []string) bool {
  6511  	if len(a) != len(b) {
  6512  		return false
  6513  	}
  6514  	for i := 0; i < len(a); i++ {
  6515  		if a[i] != b[i] {
  6516  			return false
  6517  		}
  6518  	}
  6519  	return true
  6520  }
  6521  
  6522  // SliceOfRefOfVariable does deep equals between the two objects.
  6523  func (cmp *Comparator) SliceOfRefOfVariable(a, b []*Variable) bool {
  6524  	if len(a) != len(b) {
  6525  		return false
  6526  	}
  6527  	for i := 0; i < len(a); i++ {
  6528  		if !cmp.RefOfVariable(a[i], b[i]) {
  6529  			return false
  6530  		}
  6531  	}
  6532  	return true
  6533  }
  6534  
  6535  // RefOfIdentifierCI does deep equals between the two objects.
  6536  func (cmp *Comparator) RefOfIdentifierCI(a, b *IdentifierCI) bool {
  6537  	if a == b {
  6538  		return true
  6539  	}
  6540  	if a == nil || b == nil {
  6541  		return false
  6542  	}
  6543  	return a.val == b.val &&
  6544  		a.lowered == b.lowered
  6545  }
  6546  
  6547  // RefOfIdentifierCS does deep equals between the two objects.
  6548  func (cmp *Comparator) RefOfIdentifierCS(a, b *IdentifierCS) bool {
  6549  	if a == b {
  6550  		return true
  6551  	}
  6552  	if a == nil || b == nil {
  6553  		return false
  6554  	}
  6555  	return a.v == b.v
  6556  }
  6557  
  6558  // SliceOfRefOfIndexColumn does deep equals between the two objects.
  6559  func (cmp *Comparator) SliceOfRefOfIndexColumn(a, b []*IndexColumn) bool {
  6560  	if len(a) != len(b) {
  6561  		return false
  6562  	}
  6563  	for i := 0; i < len(a); i++ {
  6564  		if !cmp.RefOfIndexColumn(a[i], b[i]) {
  6565  			return false
  6566  		}
  6567  	}
  6568  	return true
  6569  }
  6570  
  6571  // SliceOfRefOfIndexOption does deep equals between the two objects.
  6572  func (cmp *Comparator) SliceOfRefOfIndexOption(a, b []*IndexOption) bool {
  6573  	if len(a) != len(b) {
  6574  		return false
  6575  	}
  6576  	for i := 0; i < len(a); i++ {
  6577  		if !cmp.RefOfIndexOption(a[i], b[i]) {
  6578  			return false
  6579  		}
  6580  	}
  6581  	return true
  6582  }
  6583  
  6584  // SliceOfExpr does deep equals between the two objects.
  6585  func (cmp *Comparator) SliceOfExpr(a, b []Expr) bool {
  6586  	if len(a) != len(b) {
  6587  		return false
  6588  	}
  6589  	for i := 0; i < len(a); i++ {
  6590  		if !cmp.Expr(a[i], b[i]) {
  6591  			return false
  6592  		}
  6593  	}
  6594  	return true
  6595  }
  6596  
  6597  // SliceOfRefOfJSONObjectParam does deep equals between the two objects.
  6598  func (cmp *Comparator) SliceOfRefOfJSONObjectParam(a, b []*JSONObjectParam) bool {
  6599  	if len(a) != len(b) {
  6600  		return false
  6601  	}
  6602  	for i := 0; i < len(a); i++ {
  6603  		if !cmp.RefOfJSONObjectParam(a[i], b[i]) {
  6604  			return false
  6605  		}
  6606  	}
  6607  	return true
  6608  }
  6609  
  6610  // SliceOfRefOfJtColumnDefinition does deep equals between the two objects.
  6611  func (cmp *Comparator) SliceOfRefOfJtColumnDefinition(a, b []*JtColumnDefinition) bool {
  6612  	if len(a) != len(b) {
  6613  		return false
  6614  	}
  6615  	for i := 0; i < len(a); i++ {
  6616  		if !cmp.RefOfJtColumnDefinition(a[i], b[i]) {
  6617  			return false
  6618  		}
  6619  	}
  6620  	return true
  6621  }
  6622  
  6623  // RefOfJtOrdinalColDef does deep equals between the two objects.
  6624  func (cmp *Comparator) RefOfJtOrdinalColDef(a, b *JtOrdinalColDef) bool {
  6625  	if a == b {
  6626  		return true
  6627  	}
  6628  	if a == nil || b == nil {
  6629  		return false
  6630  	}
  6631  	return cmp.IdentifierCI(a.Name, b.Name)
  6632  }
  6633  
  6634  // RefOfJtPathColDef does deep equals between the two objects.
  6635  func (cmp *Comparator) RefOfJtPathColDef(a, b *JtPathColDef) bool {
  6636  	if a == b {
  6637  		return true
  6638  	}
  6639  	if a == nil || b == nil {
  6640  		return false
  6641  	}
  6642  	return a.JtColExists == b.JtColExists &&
  6643  		cmp.IdentifierCI(a.Name, b.Name) &&
  6644  		cmp.RefOfColumnType(a.Type, b.Type) &&
  6645  		cmp.Expr(a.Path, b.Path) &&
  6646  		cmp.RefOfJtOnResponse(a.EmptyOnResponse, b.EmptyOnResponse) &&
  6647  		cmp.RefOfJtOnResponse(a.ErrorOnResponse, b.ErrorOnResponse)
  6648  }
  6649  
  6650  // RefOfJtNestedPathColDef does deep equals between the two objects.
  6651  func (cmp *Comparator) RefOfJtNestedPathColDef(a, b *JtNestedPathColDef) bool {
  6652  	if a == b {
  6653  		return true
  6654  	}
  6655  	if a == nil || b == nil {
  6656  		return false
  6657  	}
  6658  	return cmp.Expr(a.Path, b.Path) &&
  6659  		cmp.SliceOfRefOfJtColumnDefinition(a.Columns, b.Columns)
  6660  }
  6661  
  6662  // TableAndLockTypes does deep equals between the two objects.
  6663  func (cmp *Comparator) TableAndLockTypes(a, b TableAndLockTypes) bool {
  6664  	if len(a) != len(b) {
  6665  		return false
  6666  	}
  6667  	for i := 0; i < len(a); i++ {
  6668  		if !cmp.RefOfTableAndLockType(a[i], b[i]) {
  6669  			return false
  6670  		}
  6671  	}
  6672  	return true
  6673  }
  6674  
  6675  // SliceOfRefOfColName does deep equals between the two objects.
  6676  func (cmp *Comparator) SliceOfRefOfColName(a, b []*ColName) bool {
  6677  	if len(a) != len(b) {
  6678  		return false
  6679  	}
  6680  	for i := 0; i < len(a); i++ {
  6681  		if !cmp.RefOfColName(a[i], b[i]) {
  6682  			return false
  6683  		}
  6684  	}
  6685  	return true
  6686  }
  6687  
  6688  // Comments does deep equals between the two objects.
  6689  func (cmp *Comparator) Comments(a, b Comments) bool {
  6690  	if len(a) != len(b) {
  6691  		return false
  6692  	}
  6693  	for i := 0; i < len(a); i++ {
  6694  		if a[i] != b[i] {
  6695  			return false
  6696  		}
  6697  	}
  6698  	return true
  6699  }
  6700  
  6701  // RefOfInt does deep equals between the two objects.
  6702  func (cmp *Comparator) RefOfInt(a, b *int) bool {
  6703  	if a == b {
  6704  		return true
  6705  	}
  6706  	if a == nil || b == nil {
  6707  		return false
  6708  	}
  6709  	return *a == *b
  6710  }
  6711  
  6712  // SliceOfRefOfPartitionDefinition does deep equals between the two objects.
  6713  func (cmp *Comparator) SliceOfRefOfPartitionDefinition(a, b []*PartitionDefinition) bool {
  6714  	if len(a) != len(b) {
  6715  		return false
  6716  	}
  6717  	for i := 0; i < len(a); i++ {
  6718  		if !cmp.RefOfPartitionDefinition(a[i], b[i]) {
  6719  			return false
  6720  		}
  6721  	}
  6722  	return true
  6723  }
  6724  
  6725  // SliceOfRefOfRenameTablePair does deep equals between the two objects.
  6726  func (cmp *Comparator) SliceOfRefOfRenameTablePair(a, b []*RenameTablePair) bool {
  6727  	if len(a) != len(b) {
  6728  		return false
  6729  	}
  6730  	for i := 0; i < len(a); i++ {
  6731  		if !cmp.RefOfRenameTablePair(a[i], b[i]) {
  6732  			return false
  6733  		}
  6734  	}
  6735  	return true
  6736  }
  6737  
  6738  // RefOfRootNode does deep equals between the two objects.
  6739  func (cmp *Comparator) RefOfRootNode(a, b *RootNode) bool {
  6740  	if a == b {
  6741  		return true
  6742  	}
  6743  	if a == nil || b == nil {
  6744  		return false
  6745  	}
  6746  	return cmp.SQLNode(a.SQLNode, b.SQLNode)
  6747  }
  6748  
  6749  // SliceOfTableExpr does deep equals between the two objects.
  6750  func (cmp *Comparator) SliceOfTableExpr(a, b []TableExpr) bool {
  6751  	if len(a) != len(b) {
  6752  		return false
  6753  	}
  6754  	for i := 0; i < len(a); i++ {
  6755  		if !cmp.TableExpr(a[i], b[i]) {
  6756  			return false
  6757  		}
  6758  	}
  6759  	return true
  6760  }
  6761  
  6762  // RefOfTableName does deep equals between the two objects.
  6763  func (cmp *Comparator) RefOfTableName(a, b *TableName) bool {
  6764  	if a == b {
  6765  		return true
  6766  	}
  6767  	if a == nil || b == nil {
  6768  		return false
  6769  	}
  6770  	return cmp.IdentifierCS(a.Name, b.Name) &&
  6771  		cmp.IdentifierCS(a.Qualifier, b.Qualifier)
  6772  }
  6773  
  6774  // RefOfTableOption does deep equals between the two objects.
  6775  func (cmp *Comparator) RefOfTableOption(a, b *TableOption) bool {
  6776  	if a == b {
  6777  		return true
  6778  	}
  6779  	if a == nil || b == nil {
  6780  		return false
  6781  	}
  6782  	return a.Name == b.Name &&
  6783  		a.String == b.String &&
  6784  		a.CaseSensitive == b.CaseSensitive &&
  6785  		cmp.RefOfLiteral(a.Value, b.Value) &&
  6786  		cmp.TableNames(a.Tables, b.Tables)
  6787  }
  6788  
  6789  // SliceOfRefOfIndexDefinition does deep equals between the two objects.
  6790  func (cmp *Comparator) SliceOfRefOfIndexDefinition(a, b []*IndexDefinition) bool {
  6791  	if len(a) != len(b) {
  6792  		return false
  6793  	}
  6794  	for i := 0; i < len(a); i++ {
  6795  		if !cmp.RefOfIndexDefinition(a[i], b[i]) {
  6796  			return false
  6797  		}
  6798  	}
  6799  	return true
  6800  }
  6801  
  6802  // SliceOfRefOfConstraintDefinition does deep equals between the two objects.
  6803  func (cmp *Comparator) SliceOfRefOfConstraintDefinition(a, b []*ConstraintDefinition) bool {
  6804  	if len(a) != len(b) {
  6805  		return false
  6806  	}
  6807  	for i := 0; i < len(a); i++ {
  6808  		if !cmp.RefOfConstraintDefinition(a[i], b[i]) {
  6809  			return false
  6810  		}
  6811  	}
  6812  	return true
  6813  }
  6814  
  6815  // RefOfVindexParam does deep equals between the two objects.
  6816  func (cmp *Comparator) RefOfVindexParam(a, b *VindexParam) bool {
  6817  	if a == b {
  6818  		return true
  6819  	}
  6820  	if a == nil || b == nil {
  6821  		return false
  6822  	}
  6823  	return a.Val == b.Val &&
  6824  		cmp.IdentifierCI(a.Key, b.Key)
  6825  }
  6826  
  6827  // SliceOfVindexParam does deep equals between the two objects.
  6828  func (cmp *Comparator) SliceOfVindexParam(a, b []VindexParam) bool {
  6829  	if len(a) != len(b) {
  6830  		return false
  6831  	}
  6832  	for i := 0; i < len(a); i++ {
  6833  		if !cmp.VindexParam(a[i], b[i]) {
  6834  			return false
  6835  		}
  6836  	}
  6837  	return true
  6838  }
  6839  
  6840  // SliceOfRefOfCommonTableExpr does deep equals between the two objects.
  6841  func (cmp *Comparator) SliceOfRefOfCommonTableExpr(a, b []*CommonTableExpr) bool {
  6842  	if len(a) != len(b) {
  6843  		return false
  6844  	}
  6845  	for i := 0; i < len(a); i++ {
  6846  		if !cmp.RefOfCommonTableExpr(a[i], b[i]) {
  6847  			return false
  6848  		}
  6849  	}
  6850  	return true
  6851  }
  6852  
  6853  // DatabaseOption does deep equals between the two objects.
  6854  func (cmp *Comparator) DatabaseOption(a, b DatabaseOption) bool {
  6855  	return a.IsDefault == b.IsDefault &&
  6856  		a.Value == b.Value &&
  6857  		a.Type == b.Type
  6858  }
  6859  
  6860  // RefOfColumnCharset does deep equals between the two objects.
  6861  func (cmp *Comparator) RefOfColumnCharset(a, b *ColumnCharset) bool {
  6862  	if a == b {
  6863  		return true
  6864  	}
  6865  	if a == nil || b == nil {
  6866  		return false
  6867  	}
  6868  	return a.Name == b.Name &&
  6869  		a.Binary == b.Binary
  6870  }
  6871  
  6872  // RefOfIndexColumn does deep equals between the two objects.
  6873  func (cmp *Comparator) RefOfIndexColumn(a, b *IndexColumn) bool {
  6874  	if a == b {
  6875  		return true
  6876  	}
  6877  	if a == nil || b == nil {
  6878  		return false
  6879  	}
  6880  	return cmp.IdentifierCI(a.Column, b.Column) &&
  6881  		cmp.RefOfLiteral(a.Length, b.Length) &&
  6882  		cmp.Expr(a.Expression, b.Expression) &&
  6883  		a.Direction == b.Direction
  6884  }
  6885  
  6886  // RefOfIndexOption does deep equals between the two objects.
  6887  func (cmp *Comparator) RefOfIndexOption(a, b *IndexOption) bool {
  6888  	if a == b {
  6889  		return true
  6890  	}
  6891  	if a == nil || b == nil {
  6892  		return false
  6893  	}
  6894  	return a.Name == b.Name &&
  6895  		a.String == b.String &&
  6896  		cmp.RefOfLiteral(a.Value, b.Value)
  6897  }
  6898  
  6899  // RefOfTableAndLockType does deep equals between the two objects.
  6900  func (cmp *Comparator) RefOfTableAndLockType(a, b *TableAndLockType) bool {
  6901  	if a == b {
  6902  		return true
  6903  	}
  6904  	if a == nil || b == nil {
  6905  		return false
  6906  	}
  6907  	return cmp.TableExpr(a.Table, b.Table) &&
  6908  		a.Lock == b.Lock
  6909  }
  6910  
  6911  // RefOfRenameTablePair does deep equals between the two objects.
  6912  func (cmp *Comparator) RefOfRenameTablePair(a, b *RenameTablePair) bool {
  6913  	if a == b {
  6914  		return true
  6915  	}
  6916  	if a == nil || b == nil {
  6917  		return false
  6918  	}
  6919  	return cmp.TableName(a.FromTable, b.FromTable) &&
  6920  		cmp.TableName(a.ToTable, b.ToTable)
  6921  }
  6922  
  6923  // RefOfDatabaseOption does deep equals between the two objects.
  6924  func (cmp *Comparator) RefOfDatabaseOption(a, b *DatabaseOption) bool {
  6925  	if a == b {
  6926  		return true
  6927  	}
  6928  	if a == nil || b == nil {
  6929  		return false
  6930  	}
  6931  	return a.IsDefault == b.IsDefault &&
  6932  		a.Value == b.Value &&
  6933  		a.Type == b.Type
  6934  }
  6935  
  6936  type Comparator struct {
  6937  	RefOfColName_ func(a, b *ColName) bool
  6938  }