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 }