granicus.if.org Git - postgresql/blob - src/backend/nodes/equalfuncs.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * equalfuncs.c
   4  *        Equality functions to compare node trees.
   5  *
   6  * NOTE: a general convention when copying or comparing plan nodes is
   7  * that we ignore the executor state subnode.  We do not need to look
   8  * at it because no current uses of copyObject() or equal() need to
   9  * deal with already-executing plan trees.      By leaving the state subnodes
  10  * out, we avoid needing to write copy/compare routines for all the
  11  * different executor state node types.
  12  *
  13  * Currently, in fact, equal() doesn't know how to compare Plan nodes
  14  * at all, let alone their executor-state subnodes.  This will probably
  15  * need to be fixed someday, but presently there is no need to compare
  16  * plan trees.
  17  *
  18  *
  19  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  20  * Portions Copyright (c) 1994, Regents of the University of California
  21  *
  22  * IDENTIFICATION
  23  *        $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.147 2002/08/04 19:48:09 momjian Exp $
  24  *
  25  *-------------------------------------------------------------------------
  26  */
  27
  28 #include "postgres.h"
  29
  30 #include "nodes/plannodes.h"
  31 #include "nodes/relation.h"
  32 #include "utils/datum.h"
  33
  34
  35 /* Macro for comparing string fields that might be NULL */
  36 #define equalstr(a, b)  \
  37         (((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
  38
  39
  40 /*
  41  *      Stuff from primnodes.h
  42  */
  43
  44 static bool
  45 _equalResdom(Resdom *a, Resdom *b)
  46 {
  47         if (a->resno != b->resno)
  48                 return false;
  49         if (a->restype != b->restype)
  50                 return false;
  51         if (a->restypmod != b->restypmod)
  52                 return false;
  53         if (!equalstr(a->resname, b->resname))
  54                 return false;
  55         if (a->ressortgroupref != b->ressortgroupref)
  56                 return false;
  57         if (a->reskey != b->reskey)
  58                 return false;
  59         if (a->reskeyop != b->reskeyop)
  60                 return false;
  61         /* we ignore resjunk flag ... is this correct? */
  62
  63         return true;
  64 }
  65
  66 static bool
  67 _equalFjoin(Fjoin *a, Fjoin *b)
  68 {
  69         int                     nNodes;
  70
  71         if (a->fj_initialized != b->fj_initialized)
  72                 return false;
  73         if (a->fj_nNodes != b->fj_nNodes)
  74                 return false;
  75         if (!equal(a->fj_innerNode, b->fj_innerNode))
  76                 return false;
  77
  78         nNodes = a->fj_nNodes;
  79         if (memcmp(a->fj_results, b->fj_results, nNodes * sizeof(Datum)) != 0)
  80                 return false;
  81         if (memcmp(a->fj_alwaysDone, b->fj_alwaysDone, nNodes * sizeof(bool)) != 0)
  82                 return false;
  83
  84         return true;
  85 }
  86
  87 static bool
  88 _equalExpr(Expr *a, Expr *b)
  89 {
  90         /*
  91          * We do not examine typeOid, since the optimizer often doesn't bother
  92          * to set it in created nodes, and it is logically a derivative of the
  93          * oper field anyway.
  94          */
  95         if (a->opType != b->opType)
  96                 return false;
  97         if (!equal(a->oper, b->oper))
  98                 return false;
  99         if (!equal(a->args, b->args))
 100                 return false;
 101
 102         return true;
 103 }
 104
 105 static bool
 106 _equalVar(Var *a, Var *b)
 107 {
 108         if (a->varno != b->varno)
 109                 return false;
 110         if (a->varattno != b->varattno)
 111                 return false;
 112         if (a->vartype != b->vartype)
 113                 return false;
 114         if (a->vartypmod != b->vartypmod)
 115                 return false;
 116         if (a->varlevelsup != b->varlevelsup)
 117                 return false;
 118         if (a->varnoold != b->varnoold)
 119                 return false;
 120         if (a->varoattno != b->varoattno)
 121                 return false;
 122
 123         return true;
 124 }
 125
 126 static bool
 127 _equalOper(Oper *a, Oper *b)
 128 {
 129         if (a->opno != b->opno)
 130                 return false;
 131         if (a->opresulttype != b->opresulttype)
 132                 return false;
 133         if (a->opretset != b->opretset)
 134                 return false;
 135
 136         /*
 137          * We do not examine opid or op_fcache, since these are logically
 138          * derived from opno, and they may not be set yet depending on how far
 139          * along the node is in the parse/plan pipeline.
 140          *
 141          * (Besides, op_fcache is executor state, which we don't check --- see
 142          * notes at head of file.)
 143          *
 144          * It's probably not really necessary to check opresulttype or opretset,
 145          * either...
 146          */
 147
 148         return true;
 149 }
 150
 151 static bool
 152 _equalConst(Const *a, Const *b)
 153 {
 154         if (a->consttype != b->consttype)
 155                 return false;
 156         if (a->constlen != b->constlen)
 157                 return false;
 158         if (a->constisnull != b->constisnull)
 159                 return false;
 160         if (a->constbyval != b->constbyval)
 161                 return false;
 162         /* XXX What about constisset and constiscast? */
 163
 164         /*
 165          * We treat all NULL constants of the same type as equal. Someday this
 166          * might need to change?  But datumIsEqual doesn't work on nulls,
 167          * so...
 168          */
 169         if (a->constisnull)
 170                 return true;
 171         return datumIsEqual(a->constvalue, b->constvalue,
 172                                                 a->constbyval, a->constlen);
 173 }
 174
 175 static bool
 176 _equalParam(Param *a, Param *b)
 177 {
 178         if (a->paramkind != b->paramkind)
 179                 return false;
 180         if (a->paramtype != b->paramtype)
 181                 return false;
 182
 183         switch (a->paramkind)
 184         {
 185                 case PARAM_NAMED:
 186                 case PARAM_NEW:
 187                 case PARAM_OLD:
 188                         if (strcmp(a->paramname, b->paramname) != 0)
 189                                 return false;
 190                         break;
 191                 case PARAM_NUM:
 192                 case PARAM_EXEC:
 193                         if (a->paramid != b->paramid)
 194                                 return false;
 195                         break;
 196                 case PARAM_INVALID:
 197
 198                         /*
 199                          * XXX: Hmmm... What are we supposed to return in this case ??
 200                          */
 201                         return true;
 202                         break;
 203                 default:
 204                         elog(ERROR, "_equalParam: Invalid paramkind value: %d",
 205                                  a->paramkind);
 206         }
 207
 208         return true;
 209 }
 210
 211 static bool
 212 _equalFunc(Func *a, Func *b)
 213 {
 214         if (a->funcid != b->funcid)
 215                 return false;
 216         if (a->funcresulttype != b->funcresulttype)
 217                 return false;
 218         if (a->funcretset != b->funcretset)
 219                 return false;
 220         /* Note we do not look at func_fcache; see notes for _equalOper */
 221
 222         return true;
 223 }
 224
 225 static bool
 226 _equalAggref(Aggref *a, Aggref *b)
 227 {
 228         if (a->aggfnoid != b->aggfnoid)
 229                 return false;
 230         if (a->aggtype != b->aggtype)
 231                 return false;
 232         if (!equal(a->target, b->target))
 233                 return false;
 234         if (a->aggstar != b->aggstar)
 235                 return false;
 236         if (a->aggdistinct != b->aggdistinct)
 237                 return false;
 238         /* ignore aggno, which is only a private field for the executor */
 239         return true;
 240 }
 241
 242 static bool
 243 _equalSubLink(SubLink *a, SubLink *b)
 244 {
 245         if (a->subLinkType != b->subLinkType)
 246                 return false;
 247         if (a->useor != b->useor)
 248                 return false;
 249         if (!equal(a->lefthand, b->lefthand))
 250                 return false;
 251         if (!equal(a->oper, b->oper))
 252                 return false;
 253         if (!equal(a->subselect, b->subselect))
 254                 return false;
 255         return true;
 256 }
 257
 258 static bool
 259 _equalArrayRef(ArrayRef *a, ArrayRef *b)
 260 {
 261         if (a->refelemtype != b->refelemtype)
 262                 return false;
 263         if (a->refattrlength != b->refattrlength)
 264                 return false;
 265         if (a->refelemlength != b->refelemlength)
 266                 return false;
 267         if (a->refelembyval != b->refelembyval)
 268                 return false;
 269         if (!equal(a->refupperindexpr, b->refupperindexpr))
 270                 return false;
 271         if (!equal(a->reflowerindexpr, b->reflowerindexpr))
 272                 return false;
 273         if (!equal(a->refexpr, b->refexpr))
 274                 return false;
 275         return equal(a->refassgnexpr, b->refassgnexpr);
 276 }
 277
 278 static bool
 279 _equalFieldSelect(FieldSelect *a, FieldSelect *b)
 280 {
 281         if (!equal(a->arg, b->arg))
 282                 return false;
 283         if (a->fieldnum != b->fieldnum)
 284                 return false;
 285         if (a->resulttype != b->resulttype)
 286                 return false;
 287         if (a->resulttypmod != b->resulttypmod)
 288                 return false;
 289         return true;
 290 }
 291
 292 static bool
 293 _equalRelabelType(RelabelType *a, RelabelType *b)
 294 {
 295         if (!equal(a->arg, b->arg))
 296                 return false;
 297         if (a->resulttype != b->resulttype)
 298                 return false;
 299         if (a->resulttypmod != b->resulttypmod)
 300                 return false;
 301         return true;
 302 }
 303
 304 static bool
 305 _equalRangeTblRef(RangeTblRef *a, RangeTblRef *b)
 306 {
 307         if (a->rtindex != b->rtindex)
 308                 return false;
 309
 310         return true;
 311 }
 312
 313 static bool
 314 _equalFromExpr(FromExpr *a, FromExpr *b)
 315 {
 316         if (!equal(a->fromlist, b->fromlist))
 317                 return false;
 318         if (!equal(a->quals, b->quals))
 319                 return false;
 320
 321         return true;
 322 }
 323
 324 static bool
 325 _equalJoinExpr(JoinExpr *a, JoinExpr *b)
 326 {
 327         if (a->jointype != b->jointype)
 328                 return false;
 329         if (a->isNatural != b->isNatural)
 330                 return false;
 331         if (!equal(a->larg, b->larg))
 332                 return false;
 333         if (!equal(a->rarg, b->rarg))
 334                 return false;
 335         if (!equal(a->using, b->using))
 336                 return false;
 337         if (!equal(a->quals, b->quals))
 338                 return false;
 339         if (!equal(a->alias, b->alias))
 340                 return false;
 341         if (a->rtindex != b->rtindex)
 342                 return false;
 343
 344         return true;
 345 }
 346
 347 /*
 348  * Stuff from relation.h
 349  */
 350
 351 static bool
 352 _equalRelOptInfo(RelOptInfo *a, RelOptInfo *b)
 353 {
 354         /*
 355          * We treat RelOptInfos as equal if they refer to the same base rels
 356          * joined in the same order.  Is this appropriate/sufficient?
 357          */
 358         return equali(a->relids, b->relids);
 359 }
 360
 361 static bool
 362 _equalIndexOptInfo(IndexOptInfo *a, IndexOptInfo *b)
 363 {
 364         /*
 365          * We treat IndexOptInfos as equal if they refer to the same index. Is
 366          * this sufficient?
 367          */
 368         if (a->indexoid != b->indexoid)
 369                 return false;
 370         return true;
 371 }
 372
 373 static bool
 374 _equalPathKeyItem(PathKeyItem *a, PathKeyItem *b)
 375 {
 376         if (a->sortop != b->sortop)
 377                 return false;
 378         if (!equal(a->key, b->key))
 379                 return false;
 380         return true;
 381 }
 382
 383 static bool
 384 _equalPath(Path *a, Path *b)
 385 {
 386         if (a->pathtype != b->pathtype)
 387                 return false;
 388         if (!equal(a->parent, b->parent))
 389                 return false;
 390
 391         /*
 392          * do not check path costs, since they may not be set yet, and being
 393          * float values there are roundoff error issues anyway...
 394          */
 395         if (!equal(a->pathkeys, b->pathkeys))
 396                 return false;
 397         return true;
 398 }
 399
 400 static bool
 401 _equalIndexPath(IndexPath *a, IndexPath *b)
 402 {
 403         if (!_equalPath((Path *) a, (Path *) b))
 404                 return false;
 405         if (!equal(a->indexinfo, b->indexinfo))
 406                 return false;
 407         if (!equal(a->indexqual, b->indexqual))
 408                 return false;
 409         if (a->indexscandir != b->indexscandir)
 410                 return false;
 411         if (!equali(a->joinrelids, b->joinrelids))
 412                 return false;
 413         if (a->alljoinquals != b->alljoinquals)
 414                 return false;
 415
 416         /*
 417          * Skip 'rows' because of possibility of floating-point roundoff
 418          * error. It should be derivable from the other fields anyway.
 419          */
 420         return true;
 421 }
 422
 423 static bool
 424 _equalTidPath(TidPath *a, TidPath *b)
 425 {
 426         if (!_equalPath((Path *) a, (Path *) b))
 427                 return false;
 428         if (!equal(a->tideval, b->tideval))
 429                 return false;
 430         if (!equali(a->unjoined_relids, b->unjoined_relids))
 431                 return false;
 432         return true;
 433 }
 434
 435 static bool
 436 _equalAppendPath(AppendPath *a, AppendPath *b)
 437 {
 438         if (!_equalPath((Path *) a, (Path *) b))
 439                 return false;
 440         if (!equal(a->subpaths, b->subpaths))
 441                 return false;
 442         return true;
 443 }
 444
 445 static bool
 446 _equalJoinPath(JoinPath *a, JoinPath *b)
 447 {
 448         if (!_equalPath((Path *) a, (Path *) b))
 449                 return false;
 450         if (a->jointype != b->jointype)
 451                 return false;
 452         if (!equal(a->outerjoinpath, b->outerjoinpath))
 453                 return false;
 454         if (!equal(a->innerjoinpath, b->innerjoinpath))
 455                 return false;
 456         if (!equal(a->joinrestrictinfo, b->joinrestrictinfo))
 457                 return false;
 458         return true;
 459 }
 460
 461 static bool
 462 _equalNestPath(NestPath *a, NestPath *b)
 463 {
 464         if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b))
 465                 return false;
 466         return true;
 467 }
 468
 469 static bool
 470 _equalMergePath(MergePath *a, MergePath *b)
 471 {
 472         if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b))
 473                 return false;
 474         if (!equal(a->path_mergeclauses, b->path_mergeclauses))
 475                 return false;
 476         if (!equal(a->outersortkeys, b->outersortkeys))
 477                 return false;
 478         if (!equal(a->innersortkeys, b->innersortkeys))
 479                 return false;
 480         return true;
 481 }
 482
 483 static bool
 484 _equalHashPath(HashPath *a, HashPath *b)
 485 {
 486         if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b))
 487                 return false;
 488         if (!equal(a->path_hashclauses, b->path_hashclauses))
 489                 return false;
 490         return true;
 491 }
 492
 493 static bool
 494 _equalSubPlan(SubPlan *a, SubPlan *b)
 495 {
 496         /* should compare plans, but have to settle for comparing plan IDs */
 497         if (a->plan_id != b->plan_id)
 498                 return false;
 499
 500         if (!equal(a->rtable, b->rtable))
 501                 return false;
 502
 503         if (!equal(a->sublink, b->sublink))
 504                 return false;
 505
 506         return true;
 507 }
 508
 509 static bool
 510 _equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
 511 {
 512         if (!equal(a->clause, b->clause))
 513                 return false;
 514         if (a->ispusheddown != b->ispusheddown)
 515                 return false;
 516
 517         /*
 518          * We ignore eval_cost, this_selec, left/right_pathkey, and
 519          * left/right_bucketsize, since they may not be set yet, and should be
 520          * derivable from the clause anyway.  Probably it's not really
 521          * necessary to compare any of these remaining fields ...
 522          */
 523         if (!equal(a->subclauseindices, b->subclauseindices))
 524                 return false;
 525         if (a->mergejoinoperator != b->mergejoinoperator)
 526                 return false;
 527         if (a->left_sortop != b->left_sortop)
 528                 return false;
 529         if (a->right_sortop != b->right_sortop)
 530                 return false;
 531         if (a->hashjoinoperator != b->hashjoinoperator)
 532                 return false;
 533         return true;
 534 }
 535
 536 static bool
 537 _equalJoinInfo(JoinInfo *a, JoinInfo *b)
 538 {
 539         if (!equali(a->unjoined_relids, b->unjoined_relids))
 540                 return false;
 541         if (!equal(a->jinfo_restrictinfo, b->jinfo_restrictinfo))
 542                 return false;
 543         return true;
 544 }
 545
 546 static bool
 547 _equalStream(Stream *a, Stream *b)
 548 {
 549         if (a->clausetype != b->clausetype)
 550                 return false;
 551         if (a->groupup != b->groupup)
 552                 return false;
 553         if (a->groupcost != b->groupcost)
 554                 return false;
 555         if (a->groupsel != b->groupsel)
 556                 return false;
 557         if (!equal(a->pathptr, b->pathptr))
 558                 return false;
 559         if (!equal(a->cinfo, b->cinfo))
 560                 return false;
 561         if (!equal(a->upstream, b->upstream))
 562                 return false;
 563         return equal(a->downstream, b->downstream);
 564 }
 565
 566 /*
 567  * Stuff from parsenodes.h
 568  */
 569
 570 static bool
 571 _equalQuery(Query *a, Query *b)
 572 {
 573         if (a->commandType != b->commandType)
 574                 return false;
 575         if (!equal(a->utilityStmt, b->utilityStmt))
 576                 return false;
 577         if (a->resultRelation != b->resultRelation)
 578                 return false;
 579         if (!equal(a->into, b->into))
 580                 return false;
 581         if (a->isPortal != b->isPortal)
 582                 return false;
 583         if (a->isBinary != b->isBinary)
 584                 return false;
 585         if (a->hasAggs != b->hasAggs)
 586                 return false;
 587         if (a->hasSubLinks != b->hasSubLinks)
 588                 return false;
 589         /* we deliberately ignore originalQuery */
 590         if (!equal(a->rtable, b->rtable))
 591                 return false;
 592         if (!equal(a->jointree, b->jointree))
 593                 return false;
 594         if (!equali(a->rowMarks, b->rowMarks))
 595                 return false;
 596         if (!equal(a->targetList, b->targetList))
 597                 return false;
 598         if (!equal(a->groupClause, b->groupClause))
 599                 return false;
 600         if (!equal(a->havingQual, b->havingQual))
 601                 return false;
 602         if (!equal(a->distinctClause, b->distinctClause))
 603                 return false;
 604         if (!equal(a->sortClause, b->sortClause))
 605                 return false;
 606         if (!equal(a->limitOffset, b->limitOffset))
 607                 return false;
 608         if (!equal(a->limitCount, b->limitCount))
 609                 return false;
 610         if (!equal(a->setOperations, b->setOperations))
 611                 return false;
 612         if (!equali(a->resultRelations, b->resultRelations))
 613                 return false;
 614
 615         /*
 616          * We do not check the internal-to-the-planner fields: base_rel_list,
 617          * other_rel_list, join_rel_list, equi_key_list, query_pathkeys. They
 618          * might not be set yet, and in any case they should be derivable from
 619          * the other fields.
 620          */
 621         return true;
 622 }
 623
 624 static bool
 625 _equalInsertStmt(InsertStmt *a, InsertStmt *b)
 626 {
 627         if (!equal(a->relation, b->relation))
 628                 return false;
 629         if (!equal(a->cols, b->cols))
 630                 return false;
 631         if (!equal(a->targetList, b->targetList))
 632                 return false;
 633         if (!equal(a->selectStmt, b->selectStmt))
 634                 return false;
 635
 636         return true;
 637 }
 638
 639 static bool
 640 _equalDeleteStmt(DeleteStmt *a, DeleteStmt *b)
 641 {
 642         if (!equal(a->relation, b->relation))
 643                 return false;
 644         if (!equal(a->whereClause, b->whereClause))
 645                 return false;
 646
 647         return true;
 648 }
 649
 650 static bool
 651 _equalUpdateStmt(UpdateStmt *a, UpdateStmt *b)
 652 {
 653         if (!equal(a->relation, b->relation))
 654                 return false;
 655         if (!equal(a->targetList, b->targetList))
 656                 return false;
 657         if (!equal(a->whereClause, b->whereClause))
 658                 return false;
 659         if (!equal(a->fromClause, b->fromClause))
 660                 return false;
 661
 662         return true;
 663 }
 664
 665 static bool
 666 _equalSelectStmt(SelectStmt *a, SelectStmt *b)
 667 {
 668         if (!equal(a->distinctClause, b->distinctClause))
 669                 return false;
 670         if (!equal(a->into, b->into))
 671                 return false;
 672         if (!equal(a->intoColNames, b->intoColNames))
 673                 return false;
 674         if (!equal(a->targetList, b->targetList))
 675                 return false;
 676         if (!equal(a->fromClause, b->fromClause))
 677                 return false;
 678         if (!equal(a->whereClause, b->whereClause))
 679                 return false;
 680         if (!equal(a->groupClause, b->groupClause))
 681                 return false;
 682         if (!equal(a->havingClause, b->havingClause))
 683                 return false;
 684         if (!equal(a->sortClause, b->sortClause))
 685                 return false;
 686         if (!equalstr(a->portalname, b->portalname))
 687                 return false;
 688         if (a->binary != b->binary)
 689                 return false;
 690         if (!equal(a->limitOffset, b->limitOffset))
 691                 return false;
 692         if (!equal(a->limitCount, b->limitCount))
 693                 return false;
 694         if (!equal(a->forUpdate, b->forUpdate))
 695                 return false;
 696         if (a->op != b->op)
 697                 return false;
 698         if (a->all != b->all)
 699                 return false;
 700         if (!equal(a->larg, b->larg))
 701                 return false;
 702         if (!equal(a->rarg, b->rarg))
 703                 return false;
 704
 705         return true;
 706 }
 707
 708 static bool
 709 _equalSetOperationStmt(SetOperationStmt *a, SetOperationStmt *b)
 710 {
 711         if (a->op != b->op)
 712                 return false;
 713         if (a->all != b->all)
 714                 return false;
 715         if (!equal(a->larg, b->larg))
 716                 return false;
 717         if (!equal(a->rarg, b->rarg))
 718                 return false;
 719         if (!equali(a->colTypes, b->colTypes))
 720                 return false;
 721
 722         return true;
 723 }
 724
 725 static bool
 726 _equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
 727 {
 728         if (a->subtype != b->subtype)
 729                 return false;
 730         if (!equal(a->relation, b->relation))
 731                 return false;
 732         if (!equalstr(a->name, b->name))
 733                 return false;
 734         if (!equal(a->def, b->def))
 735                 return false;
 736         if (a->behavior != b->behavior)
 737                 return false;
 738
 739         return true;
 740 }
 741
 742 static bool
 743 _equalGrantStmt(GrantStmt *a, GrantStmt *b)
 744 {
 745         if (a->is_grant != b->is_grant)
 746                 return false;
 747         if (a->objtype != b->objtype)
 748                 return false;
 749         if (!equal(a->objects, b->objects))
 750                 return false;
 751         if (!equali(a->privileges, b->privileges))
 752                 return false;
 753         if (!equal(a->grantees, b->grantees))
 754                 return false;
 755
 756         return true;
 757 }
 758
 759 static bool
 760 _equalPrivGrantee(PrivGrantee *a, PrivGrantee *b)
 761 {
 762         return equalstr(a->username, b->username)
 763                 && equalstr(a->groupname, b->groupname);
 764 }
 765
 766 static bool
 767 _equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
 768 {
 769         return equal(a->funcname, b->funcname)
 770                 && equal(a->funcargs, b->funcargs);
 771 }
 772
 773 static bool
 774 _equalInsertDefault(InsertDefault *a, InsertDefault *b)
 775 {
 776         return true;
 777 }
 778
 779 static bool
 780 _equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b)
 781 {
 782         if (!equalstr(a->portalname, b->portalname))
 783                 return false;
 784
 785         return true;
 786 }
 787
 788 static bool
 789 _equalClusterStmt(ClusterStmt *a, ClusterStmt *b)
 790 {
 791         if (!equal(a->relation, b->relation))
 792                 return false;
 793         if (!equalstr(a->indexname, b->indexname))
 794                 return false;
 795
 796         return true;
 797 }
 798
 799 static bool
 800 _equalCopyStmt(CopyStmt *a, CopyStmt *b)
 801 {
 802         if (!equal(a->relation, b->relation))
 803                 return false;
 804         if (a->is_from != b->is_from)
 805                 return false;
 806         if (!equalstr(a->filename, b->filename))
 807                 return false;
 808         if (!equal(a->options, b->options))
 809                 return false;
 810
 811         return true;
 812 }
 813
 814 static bool
 815 _equalCreateStmt(CreateStmt *a, CreateStmt *b)
 816 {
 817         if (!equal(a->relation, b->relation))
 818                 return false;
 819         if (!equal(a->tableElts, b->tableElts))
 820                 return false;
 821         if (!equal(a->inhRelations, b->inhRelations))
 822                 return false;
 823         if (!equal(a->constraints, b->constraints))
 824                 return false;
 825         if (a->hasoids != b->hasoids)
 826                 return false;
 827
 828         return true;
 829 }
 830
 831 static bool
 832 _equalDefineStmt(DefineStmt *a, DefineStmt *b)
 833 {
 834         if (a->defType != b->defType)
 835                 return false;
 836         if (!equal(a->defnames, b->defnames))
 837                 return false;
 838         if (!equal(a->definition, b->definition))
 839                 return false;
 840
 841         return true;
 842 }
 843
 844 static bool
 845 _equalDropStmt(DropStmt *a, DropStmt *b)
 846 {
 847         if (!equal(a->objects, b->objects))
 848                 return false;
 849         if (a->removeType != b->removeType)
 850                 return false;
 851         if (a->behavior != b->behavior)
 852                 return false;
 853
 854         return true;
 855 }
 856
 857 static bool
 858 _equalTruncateStmt(TruncateStmt *a, TruncateStmt *b)
 859 {
 860         if (!equal(a->relation, b->relation))
 861                 return false;
 862
 863         return true;
 864 }
 865
 866 static bool
 867 _equalCommentStmt(CommentStmt *a, CommentStmt *b)
 868 {
 869         if (a->objtype != b->objtype)
 870                 return false;
 871         if (!equal(a->objname, b->objname))
 872                 return false;
 873         if (!equal(a->objargs, b->objargs))
 874                 return false;
 875         if (!equalstr(a->comment, b->comment))
 876                 return false;
 877
 878         return true;
 879 }
 880
 881 static bool
 882 _equalFetchStmt(FetchStmt *a, FetchStmt *b)
 883 {
 884         if (a->direction != b->direction)
 885                 return false;
 886         if (a->howMany != b->howMany)
 887                 return false;
 888         if (!equalstr(a->portalname, b->portalname))
 889                 return false;
 890         if (a->ismove != b->ismove)
 891                 return false;
 892
 893         return true;
 894 }
 895
 896 static bool
 897 _equalIndexStmt(IndexStmt *a, IndexStmt *b)
 898 {
 899         if (!equalstr(a->idxname, b->idxname))
 900                 return false;
 901         if (!equal(a->relation, b->relation))
 902                 return false;
 903         if (!equalstr(a->accessMethod, b->accessMethod))
 904                 return false;
 905         if (!equal(a->indexParams, b->indexParams))
 906                 return false;
 907         if (!equal(a->whereClause, b->whereClause))
 908                 return false;
 909         if (!equal(a->rangetable, b->rangetable))
 910                 return false;
 911         if (a->unique != b->unique)
 912                 return false;
 913         if (a->primary != b->primary)
 914                 return false;
 915         if (a->isconstraint != b->isconstraint)
 916                 return false;
 917
 918         return true;
 919 }
 920
 921 static bool
 922 _equalCreateFunctionStmt(CreateFunctionStmt *a, CreateFunctionStmt *b)
 923 {
 924         if (a->replace != b->replace)
 925                 return false;
 926         if (!equal(a->funcname, b->funcname))
 927                 return false;
 928         if (!equal(a->argTypes, b->argTypes))
 929                 return false;
 930         if (!equal(a->returnType, b->returnType))
 931                 return false;
 932         if (!equal(a->options, b->options))
 933                 return false;
 934         if (!equal(a->withClause, b->withClause))
 935                 return false;
 936
 937         return true;
 938 }
 939
 940 static bool
 941 _equalRemoveAggrStmt(RemoveAggrStmt *a, RemoveAggrStmt *b)
 942 {
 943         if (!equal(a->aggname, b->aggname))
 944                 return false;
 945         if (!equal(a->aggtype, b->aggtype))
 946                 return false;
 947         if (a->behavior != b->behavior)
 948                 return false;
 949
 950         return true;
 951 }
 952
 953 static bool
 954 _equalRemoveFuncStmt(RemoveFuncStmt *a, RemoveFuncStmt *b)
 955 {
 956         if (!equal(a->funcname, b->funcname))
 957                 return false;
 958         if (!equal(a->args, b->args))
 959                 return false;
 960         if (a->behavior != b->behavior)
 961                 return false;
 962
 963         return true;
 964 }
 965
 966 static bool
 967 _equalRemoveOperStmt(RemoveOperStmt *a, RemoveOperStmt *b)
 968 {
 969         if (!equal(a->opname, b->opname))
 970                 return false;
 971         if (!equal(a->args, b->args))
 972                 return false;
 973         if (a->behavior != b->behavior)
 974                 return false;
 975
 976         return true;
 977 }
 978
 979 static bool
 980 _equalRemoveOpClassStmt(RemoveOpClassStmt *a, RemoveOpClassStmt *b)
 981 {
 982         if (!equal(a->opclassname, b->opclassname))
 983                 return false;
 984         if (!equalstr(a->amname, b->amname))
 985                 return false;
 986         if (a->behavior != b->behavior)
 987                 return false;
 988
 989         return true;
 990 }
 991
 992 static bool
 993 _equalRenameStmt(RenameStmt *a, RenameStmt *b)
 994 {
 995         if (!equal(a->relation, b->relation))
 996                 return false;
 997         if (!equalstr(a->oldname, b->oldname))
 998                 return false;
 999         if (!equalstr(a->newname, b->newname))
1000                 return false;
1001         if (a->renameType != b->renameType)
1002                 return false;
1003
1004         return true;
1005 }
1006
1007 static bool
1008 _equalRuleStmt(RuleStmt *a, RuleStmt *b)
1009 {
1010         if (!equal(a->relation, b->relation))
1011                 return false;
1012         if (!equalstr(a->rulename, b->rulename))
1013                 return false;
1014         if (!equal(a->whereClause, b->whereClause))
1015                 return false;
1016         if (a->event != b->event)
1017                 return false;
1018         if (a->instead != b->instead)
1019                 return false;
1020         if (!equal(a->actions, b->actions))
1021                 return false;
1022
1023         return true;
1024 }
1025
1026 static bool
1027 _equalNotifyStmt(NotifyStmt *a, NotifyStmt *b)
1028 {
1029         if (!equal(a->relation, b->relation))
1030                 return false;
1031
1032         return true;
1033 }
1034
1035 static bool
1036 _equalListenStmt(ListenStmt *a, ListenStmt *b)
1037 {
1038         if (!equal(a->relation, b->relation))
1039                 return false;
1040
1041         return true;
1042 }
1043
1044 static bool
1045 _equalUnlistenStmt(UnlistenStmt *a, UnlistenStmt *b)
1046 {
1047         if (!equal(a->relation, b->relation))
1048                 return false;
1049
1050         return true;
1051 }
1052
1053 static bool
1054 _equalTransactionStmt(TransactionStmt *a, TransactionStmt *b)
1055 {
1056         if (a->command != b->command)
1057                 return false;
1058         if (!equal(a->options, b->options))
1059                 return false;
1060
1061         return true;
1062 }
1063
1064 static bool
1065 _equalViewStmt(ViewStmt *a, ViewStmt *b)
1066 {
1067         if (!equal(a->view, b->view))
1068                 return false;
1069         if (!equal(a->aliases, b->aliases))
1070                 return false;
1071         if (!equal(a->query, b->query))
1072                 return false;
1073
1074         return true;
1075 }
1076
1077 static bool
1078 _equalLoadStmt(LoadStmt *a, LoadStmt *b)
1079 {
1080         if (!equalstr(a->filename, b->filename))
1081                 return false;
1082
1083         return true;
1084 }
1085
1086 static bool
1087 _equalCreateDomainStmt(CreateDomainStmt *a, CreateDomainStmt *b)
1088 {
1089         if (!equal(a->domainname, b->domainname))
1090                 return false;
1091         if (!equal(a->typename, b->typename))
1092                 return false;
1093         if (!equal(a->constraints, b->constraints))
1094                 return false;
1095
1096         return true;
1097 }
1098
1099 static bool
1100 _equalCreateOpClassStmt(CreateOpClassStmt *a, CreateOpClassStmt *b)
1101 {
1102         if (!equal(a->opclassname, b->opclassname))
1103                 return false;
1104         if (!equalstr(a->amname, b->amname))
1105                 return false;
1106         if (!equal(a->datatype, b->datatype))
1107                 return false;
1108         if (!equal(a->items, b->items))
1109                 return false;
1110         if (a->isDefault != b->isDefault)
1111                 return false;
1112
1113         return true;
1114 }
1115
1116 static bool
1117 _equalCreateOpClassItem(CreateOpClassItem *a, CreateOpClassItem *b)
1118 {
1119         if (a->itemtype != b->itemtype)
1120                 return false;
1121         if (!equal(a->name, b->name))
1122                 return false;
1123         if (!equal(a->args, b->args))
1124                 return false;
1125         if (a->number != b->number)
1126                 return false;
1127         if (a->recheck != b->recheck)
1128                 return false;
1129         if (!equal(a->storedtype, b->storedtype))
1130                 return false;
1131
1132         return true;
1133 }
1134
1135 static bool
1136 _equalCreatedbStmt(CreatedbStmt *a, CreatedbStmt *b)
1137 {
1138         if (!equalstr(a->dbname, b->dbname))
1139                 return false;
1140         if (!equal(a->options, b->options))
1141                 return false;
1142
1143         return true;
1144 }
1145
1146 static bool
1147 _equalAlterDatabaseSetStmt(AlterDatabaseSetStmt *a, AlterDatabaseSetStmt *b)
1148 {
1149         if (!equalstr(a->dbname, b->dbname))
1150                 return false;
1151         if (!equalstr(a->variable, b->variable))
1152                 return false;
1153         if (!equal(a->value, b->value))
1154                 return false;
1155
1156         return true;
1157 }
1158
1159 static bool
1160 _equalDropdbStmt(DropdbStmt *a, DropdbStmt *b)
1161 {
1162         if (!equalstr(a->dbname, b->dbname))
1163                 return false;
1164
1165         return true;
1166 }
1167
1168 static bool
1169 _equalVacuumStmt(VacuumStmt *a, VacuumStmt *b)
1170 {
1171         if (a->vacuum != b->vacuum)
1172                 return false;
1173         if (a->full != b->full)
1174                 return false;
1175         if (a->analyze != b->analyze)
1176                 return false;
1177         if (a->freeze != b->freeze)
1178                 return false;
1179         if (a->verbose != b->verbose)
1180                 return false;
1181         if (!equal(a->relation, b->relation))
1182                 return false;
1183         if (!equal(a->va_cols, b->va_cols))
1184                 return false;
1185
1186         return true;
1187 }
1188
1189 static bool
1190 _equalExplainStmt(ExplainStmt *a, ExplainStmt *b)
1191 {
1192         if (!equal(a->query, b->query))
1193                 return false;
1194         if (a->verbose != b->verbose)
1195                 return false;
1196         if (a->analyze != b->analyze)
1197                 return false;
1198
1199         return true;
1200 }
1201
1202 static bool
1203 _equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
1204 {
1205         if (!equal(a->sequence, b->sequence))
1206                 return false;
1207         if (!equal(a->options, b->options))
1208                 return false;
1209
1210         return true;
1211 }
1212
1213 static bool
1214 _equalVariableSetStmt(VariableSetStmt *a, VariableSetStmt *b)
1215 {
1216         if (!equalstr(a->name, b->name))
1217                 return false;
1218         if (!equal(a->args, b->args))
1219                 return false;
1220         if (a->is_local != b->is_local)
1221                 return false;
1222
1223         return true;
1224 }
1225
1226 static bool
1227 _equalVariableShowStmt(VariableShowStmt *a, VariableShowStmt *b)
1228 {
1229         if (!equalstr(a->name, b->name))
1230                 return false;
1231
1232         return true;
1233 }
1234
1235 static bool
1236 _equalVariableResetStmt(VariableResetStmt *a, VariableResetStmt *b)
1237 {
1238         if (!equalstr(a->name, b->name))
1239                 return false;
1240
1241         return true;
1242 }
1243
1244 static bool
1245 _equalCreateTrigStmt(CreateTrigStmt *a, CreateTrigStmt *b)
1246 {
1247         if (!equalstr(a->trigname, b->trigname))
1248                 return false;
1249         if (!equal(a->relation, b->relation))
1250                 return false;
1251         if (!equal(a->funcname, b->funcname))
1252                 return false;
1253         if (!equal(a->args, b->args))
1254                 return false;
1255         if (a->before != b->before)
1256                 return false;
1257         if (a->row != b->row)
1258                 return false;
1259         if (strcmp(a->actions, b->actions) != 0)
1260                 return false;
1261         if (!equalstr(a->lang, b->lang))
1262                 return false;
1263         if (!equalstr(a->text, b->text))
1264                 return false;
1265         if (!equal(a->attr, b->attr))
1266                 return false;
1267         if (!equalstr(a->when, b->when))
1268                 return false;
1269         if (a->isconstraint != b->isconstraint)
1270                 return false;
1271         if (a->deferrable != b->deferrable)
1272                 return false;
1273         if (a->initdeferred != b->initdeferred)
1274                 return false;
1275         if (!equal(a->constrrel, b->constrrel))
1276                 return false;
1277
1278         return true;
1279 }
1280
1281 static bool
1282 _equalDropPropertyStmt(DropPropertyStmt *a, DropPropertyStmt *b)
1283 {
1284         if (!equal(a->relation, b->relation))
1285                 return false;
1286         if (!equalstr(a->property, b->property))
1287                 return false;
1288         if (a->removeType != b->removeType)
1289                 return false;
1290         if (a->behavior != b->behavior)
1291                 return false;
1292
1293         return true;
1294 }
1295
1296 static bool
1297 _equalCreatePLangStmt(CreatePLangStmt *a, CreatePLangStmt *b)
1298 {
1299         if (!equalstr(a->plname, b->plname))
1300                 return false;
1301         if (!equal(a->plhandler, b->plhandler))
1302                 return false;
1303         if (!equal(a->plvalidator, b->plvalidator))
1304                 return false;
1305         if (a->pltrusted != b->pltrusted)
1306                 return false;
1307
1308         return true;
1309 }
1310
1311 static bool
1312 _equalDropPLangStmt(DropPLangStmt *a, DropPLangStmt *b)
1313 {
1314         if (!equalstr(a->plname, b->plname))
1315                 return false;
1316         if (a->behavior != b->behavior)
1317                 return false;
1318
1319         return true;
1320 }
1321
1322 static bool
1323 _equalCreateUserStmt(CreateUserStmt *a, CreateUserStmt *b)
1324 {
1325         if (!equalstr(a->user, b->user))
1326                 return false;
1327         if (!equal(a->options, b->options))
1328                 return false;
1329
1330         return true;
1331 }
1332
1333 static bool
1334 _equalAlterUserStmt(AlterUserStmt *a, AlterUserStmt *b)
1335 {
1336         if (!equalstr(a->user, b->user))
1337                 return false;
1338         if (!equal(a->options, b->options))
1339                 return false;
1340
1341         return true;
1342 }
1343
1344 static bool
1345 _equalAlterUserSetStmt(AlterUserSetStmt *a, AlterUserSetStmt *b)
1346 {
1347         if (!equalstr(a->user, b->user))
1348                 return false;
1349         if (!equalstr(a->variable, b->variable))
1350                 return false;
1351         if (!equal(a->value, b->value))
1352                 return false;
1353
1354         return true;
1355 }
1356
1357 static bool
1358 _equalDropUserStmt(DropUserStmt *a, DropUserStmt *b)
1359 {
1360         if (!equal(a->users, b->users))
1361                 return false;
1362
1363         return true;
1364 }
1365
1366 static bool
1367 _equalLockStmt(LockStmt *a, LockStmt *b)
1368 {
1369         if (!equal(a->relations, b->relations))
1370                 return false;
1371         if (a->mode != b->mode)
1372                 return false;
1373
1374         return true;
1375 }
1376
1377 static bool
1378 _equalConstraintsSetStmt(ConstraintsSetStmt *a, ConstraintsSetStmt *b)
1379 {
1380         if (!equal(a->constraints, b->constraints))
1381                 return false;
1382         if (a->deferred != b->deferred)
1383                 return false;
1384
1385         return true;
1386 }
1387
1388 static bool
1389 _equalCreateGroupStmt(CreateGroupStmt *a, CreateGroupStmt *b)
1390 {
1391         if (!equalstr(a->name, b->name))
1392                 return false;
1393         if (!equal(a->options, b->options))
1394                 return false;
1395
1396         return true;
1397 }
1398
1399 static bool
1400 _equalAlterGroupStmt(AlterGroupStmt *a, AlterGroupStmt *b)
1401 {
1402         if (!equalstr(a->name, b->name))
1403                 return false;
1404         if (a->action != b->action)
1405                 return false;
1406         if (!equal(a->listUsers, b->listUsers))
1407                 return false;
1408
1409         return true;
1410 }
1411
1412 static bool
1413 _equalDropGroupStmt(DropGroupStmt *a, DropGroupStmt *b)
1414 {
1415         if (!equalstr(a->name, b->name))
1416                 return false;
1417
1418         return true;
1419 }
1420
1421 static bool
1422 _equalReindexStmt(ReindexStmt *a, ReindexStmt *b)
1423 {
1424         if (a->reindexType != b->reindexType)
1425                 return false;
1426         if (!equal(a->relation, b->relation))
1427                 return false;
1428         if (!equalstr(a->name, b->name))
1429                 return false;
1430         if (a->force != b->force)
1431                 return false;
1432         if (a->all != b->all)
1433                 return false;
1434
1435         return true;
1436 }
1437
1438 static bool
1439 _equalCreateSchemaStmt(CreateSchemaStmt *a, CreateSchemaStmt *b)
1440 {
1441         if (!equalstr(a->schemaname, b->schemaname))
1442                 return false;
1443         if (!equalstr(a->authid, b->authid))
1444                 return false;
1445         if (!equal(a->schemaElts, b->schemaElts))
1446                 return false;
1447
1448         return true;
1449 }
1450
1451 static bool
1452 _equalAExpr(A_Expr *a, A_Expr *b)
1453 {
1454         if (a->oper != b->oper)
1455                 return false;
1456         if (!equal(a->name, b->name))
1457                 return false;
1458         if (!equal(a->lexpr, b->lexpr))
1459                 return false;
1460         if (!equal(a->rexpr, b->rexpr))
1461                 return false;
1462
1463         return true;
1464 }
1465
1466 static bool
1467 _equalColumnRef(ColumnRef *a, ColumnRef *b)
1468 {
1469         if (!equal(a->fields, b->fields))
1470                 return false;
1471         if (!equal(a->indirection, b->indirection))
1472                 return false;
1473
1474         return true;
1475 }
1476
1477 static bool
1478 _equalParamRef(ParamRef *a, ParamRef *b)
1479 {
1480         if (a->number != b->number)
1481                 return false;
1482         if (!equal(a->fields, b->fields))
1483                 return false;
1484         if (!equal(a->indirection, b->indirection))
1485                 return false;
1486
1487         return true;
1488 }
1489
1490 static bool
1491 _equalAConst(A_Const *a, A_Const *b)
1492 {
1493         if (!equal(&a->val, &b->val))
1494                 return false;
1495         if (!equal(a->typename, b->typename))
1496                 return false;
1497
1498         return true;
1499 }
1500
1501 static bool
1502 _equalIdent(Ident *a, Ident *b)
1503 {
1504         if (!equalstr(a->name, b->name))
1505                 return false;
1506
1507         return true;
1508 }
1509
1510 static bool
1511 _equalFuncCall(FuncCall *a, FuncCall *b)
1512 {
1513         if (!equal(a->funcname, b->funcname))
1514                 return false;
1515         if (!equal(a->args, b->args))
1516                 return false;
1517         if (a->agg_star != b->agg_star)
1518                 return false;
1519         if (a->agg_distinct != b->agg_distinct)
1520                 return false;
1521
1522         return true;
1523 }
1524
1525 static bool
1526 _equalAIndices(A_Indices *a, A_Indices *b)
1527 {
1528         if (!equal(a->lidx, b->lidx))
1529                 return false;
1530         if (!equal(a->uidx, b->uidx))
1531                 return false;
1532
1533         return true;
1534 }
1535
1536 static bool
1537 _equalExprFieldSelect(ExprFieldSelect *a, ExprFieldSelect *b)
1538 {
1539         if (!equal(a->arg, b->arg))
1540                 return false;
1541         if (!equal(a->fields, b->fields))
1542                 return false;
1543         if (!equal(a->indirection, b->indirection))
1544                 return false;
1545
1546         return true;
1547 }
1548
1549 static bool
1550 _equalResTarget(ResTarget *a, ResTarget *b)
1551 {
1552         if (!equalstr(a->name, b->name))
1553                 return false;
1554         if (!equal(a->indirection, b->indirection))
1555                 return false;
1556         if (!equal(a->val, b->val))
1557                 return false;
1558
1559         return true;
1560 }
1561
1562 static bool
1563 _equalTypeCast(TypeCast *a, TypeCast *b)
1564 {
1565         if (!equal(a->arg, b->arg))
1566                 return false;
1567         if (!equal(a->typename, b->typename))
1568                 return false;
1569
1570         return true;
1571 }
1572
1573 static bool
1574 _equalSortGroupBy(SortGroupBy *a, SortGroupBy *b)
1575 {
1576         if (!equal(a->useOp, b->useOp))
1577                 return false;
1578         if (!equal(a->node, b->node))
1579                 return false;
1580
1581         return true;
1582 }
1583
1584 static bool
1585 _equalAlias(Alias *a, Alias *b)
1586 {
1587         if (!equalstr(a->aliasname, b->aliasname))
1588                 return false;
1589         if (!equal(a->colnames, b->colnames))
1590                 return false;
1591
1592         return true;
1593 }
1594
1595 static bool
1596 _equalRangeVar(RangeVar *a, RangeVar *b)
1597 {
1598         if (!equalstr(a->catalogname, b->catalogname))
1599                 return false;
1600         if (!equalstr(a->schemaname, b->schemaname))
1601                 return false;
1602         if (!equalstr(a->relname, b->relname))
1603                 return false;
1604         if (a->inhOpt != b->inhOpt)
1605                 return false;
1606         if (a->istemp != b->istemp)
1607                 return false;
1608         if (!equal(a->alias, b->alias))
1609                 return false;
1610         if (!equal(a->coldeflist, b->coldeflist))
1611                 return false;
1612
1613         return true;
1614 }
1615
1616 static bool
1617 _equalRangeSubselect(RangeSubselect *a, RangeSubselect *b)
1618 {
1619         if (!equal(a->subquery, b->subquery))
1620                 return false;
1621         if (!equal(a->alias, b->alias))
1622                 return false;
1623
1624         return true;
1625 }
1626
1627 static bool
1628 _equalRangeFunction(RangeFunction *a, RangeFunction *b)
1629 {
1630         if (!equal(a->funccallnode, b->funccallnode))
1631                 return false;
1632         if (!equal(a->alias, b->alias))
1633                 return false;
1634
1635         return true;
1636 }
1637
1638 static bool
1639 _equalTypeName(TypeName *a, TypeName *b)
1640 {
1641         if (!equal(a->names, b->names))
1642                 return false;
1643         if (a->typeid != b->typeid)
1644                 return false;
1645         if (a->timezone != b->timezone)
1646                 return false;
1647         if (a->setof != b->setof)
1648                 return false;
1649         if (a->pct_type != b->pct_type)
1650                 return false;
1651         if (a->typmod != b->typmod)
1652                 return false;
1653         if (!equal(a->arrayBounds, b->arrayBounds))
1654                 return false;
1655
1656         return true;
1657 }
1658
1659 static bool
1660 _equalIndexElem(IndexElem *a, IndexElem *b)
1661 {
1662         if (!equalstr(a->name, b->name))
1663                 return false;
1664         if (!equal(a->funcname, b->funcname))
1665                 return false;
1666         if (!equal(a->args, b->args))
1667                 return false;
1668         if (!equal(a->opclass, b->opclass))
1669                 return false;
1670
1671         return true;
1672 }
1673
1674 static bool
1675 _equalColumnDef(ColumnDef *a, ColumnDef *b)
1676 {
1677         if (!equalstr(a->colname, b->colname))
1678                 return false;
1679         if (!equal(a->typename, b->typename))
1680                 return false;
1681         if (a->is_not_null != b->is_not_null)
1682                 return false;
1683         if (!equal(a->raw_default, b->raw_default))
1684                 return false;
1685         if (!equalstr(a->cooked_default, b->cooked_default))
1686                 return false;
1687         if (!equal(a->constraints, b->constraints))
1688                 return false;
1689         if (!equal(a->support, b->support))
1690                 return false;
1691
1692         return true;
1693 }
1694
1695 static bool
1696 _equalConstraint(Constraint *a, Constraint *b)
1697 {
1698         if (a->contype != b->contype)
1699                 return false;
1700         if (!equalstr(a->name, b->name))
1701                 return false;
1702         if (!equal(a->raw_expr, b->raw_expr))
1703                 return false;
1704         if (!equalstr(a->cooked_expr, b->cooked_expr))
1705                 return false;
1706         if (!equal(a->keys, b->keys))
1707                 return false;
1708
1709         return true;
1710 }
1711
1712 static bool
1713 _equalDefElem(DefElem *a, DefElem *b)
1714 {
1715         if (!equalstr(a->defname, b->defname))
1716                 return false;
1717         if (!equal(a->arg, b->arg))
1718                 return false;
1719
1720         return true;
1721 }
1722
1723 static bool
1724 _equalTargetEntry(TargetEntry *a, TargetEntry *b)
1725 {
1726         if (!equal(a->resdom, b->resdom))
1727                 return false;
1728         if (!equal(a->fjoin, b->fjoin))
1729                 return false;
1730         if (!equal(a->expr, b->expr))
1731                 return false;
1732
1733         return true;
1734 }
1735
1736 static bool
1737 _equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
1738 {
1739         if (a->rtekind != b->rtekind)
1740                 return false;
1741         if (a->relid != b->relid)
1742                 return false;
1743         if (!equal(a->subquery, b->subquery))
1744                 return false;
1745         if (!equal(a->funcexpr, b->funcexpr))
1746                 return false;
1747         if (!equal(a->coldeflist, b->coldeflist))
1748                 return false;
1749         if (a->jointype != b->jointype)
1750                 return false;
1751         if (!equal(a->joinaliasvars, b->joinaliasvars))
1752                 return false;
1753         if (!equal(a->alias, b->alias))
1754                 return false;
1755         if (!equal(a->eref, b->eref))
1756                 return false;
1757         if (a->inh != b->inh)
1758                 return false;
1759         if (a->inFromCl != b->inFromCl)
1760                 return false;
1761         if (a->checkForRead != b->checkForRead)
1762                 return false;
1763         if (a->checkForWrite != b->checkForWrite)
1764                 return false;
1765         if (a->checkAsUser != b->checkAsUser)
1766                 return false;
1767
1768         return true;
1769 }
1770
1771 static bool
1772 _equalSortClause(SortClause *a, SortClause *b)
1773 {
1774         if (a->tleSortGroupRef != b->tleSortGroupRef)
1775                 return false;
1776         if (a->sortop != b->sortop)
1777                 return false;
1778
1779         return true;
1780 }
1781
1782 static bool
1783 _equalFkConstraint(FkConstraint *a, FkConstraint *b)
1784 {
1785         if (!equalstr(a->constr_name, b->constr_name))
1786                 return false;
1787         if (!equal(a->pktable, b->pktable))
1788                 return false;
1789         if (!equal(a->fk_attrs, b->fk_attrs))
1790                 return false;
1791         if (!equal(a->pk_attrs, b->pk_attrs))
1792                 return false;
1793         if (a->fk_matchtype != b->fk_matchtype)
1794                 return false;
1795         if (a->fk_upd_action != b->fk_upd_action)
1796                 return false;
1797         if (a->fk_del_action != b->fk_del_action)
1798                 return false;
1799         if (a->deferrable != b->deferrable)
1800                 return false;
1801         if (a->initdeferred != b->initdeferred)
1802                 return false;
1803         if (a->skip_validation != b->skip_validation)
1804                 return false;
1805
1806         return true;
1807 }
1808
1809 static bool
1810 _equalCaseExpr(CaseExpr *a, CaseExpr *b)
1811 {
1812         if (a->casetype != b->casetype)
1813                 return false;
1814         if (!equal(a->arg, b->arg))
1815                 return false;
1816         if (!equal(a->args, b->args))
1817                 return false;
1818         if (!equal(a->defresult, b->defresult))
1819                 return false;
1820
1821         return true;
1822 }
1823
1824 static bool
1825 _equalCaseWhen(CaseWhen *a, CaseWhen *b)
1826 {
1827         if (!equal(a->expr, b->expr))
1828                 return false;
1829         if (!equal(a->result, b->result))
1830                 return false;
1831
1832         return true;
1833 }
1834
1835 static bool
1836 _equalNullTest(NullTest *a, NullTest *b)
1837 {
1838         if (!equal(a->arg, b->arg))
1839                 return false;
1840         if (a->nulltesttype != b->nulltesttype)
1841                 return false;
1842         return true;
1843 }
1844
1845 static bool
1846 _equalBooleanTest(BooleanTest *a, BooleanTest *b)
1847 {
1848         if (!equal(a->arg, b->arg))
1849                 return false;
1850         if (a->booltesttype != b->booltesttype)
1851                 return false;
1852         return true;
1853 }
1854
1855 /*
1856  * Stuff from pg_list.h
1857  */
1858
1859 static bool
1860 _equalValue(Value *a, Value *b)
1861 {
1862         if (a->type != b->type)
1863                 return false;
1864
1865         switch (a->type)
1866         {
1867                 case T_Integer:
1868                         return a->val.ival == b->val.ival;
1869                 case T_Float:
1870                 case T_String:
1871                 case T_BitString:
1872                         return strcmp(a->val.str, b->val.str) == 0;
1873                 default:
1874                         break;
1875         }
1876
1877         return true;
1878 }
1879
1880 /*
1881  * equal
1882  *        returns whether two nodes are equal
1883  */
1884 bool
1885 equal(void *a, void *b)
1886 {
1887         bool            retval = false;
1888
1889         if (a == b)
1890                 return true;
1891
1892         /*
1893          * note that a!=b, so only one of them can be NULL
1894          */
1895         if (a == NULL || b == NULL)
1896                 return false;
1897
1898         /*
1899          * are they the same type of nodes?
1900          */
1901         if (nodeTag(a) != nodeTag(b))
1902                 return false;
1903
1904         switch (nodeTag(a))
1905         {
1906                 case T_SubPlan:
1907                         retval = _equalSubPlan(a, b);
1908                         break;
1909
1910                 case T_Resdom:
1911                         retval = _equalResdom(a, b);
1912                         break;
1913                 case T_Fjoin:
1914                         retval = _equalFjoin(a, b);
1915                         break;
1916                 case T_Expr:
1917                         retval = _equalExpr(a, b);
1918                         break;
1919                 case T_Var:
1920                         retval = _equalVar(a, b);
1921                         break;
1922                 case T_Oper:
1923                         retval = _equalOper(a, b);
1924                         break;
1925                 case T_Const:
1926                         retval = _equalConst(a, b);
1927                         break;
1928                 case T_Param:
1929                         retval = _equalParam(a, b);
1930                         break;
1931                 case T_Aggref:
1932                         retval = _equalAggref(a, b);
1933                         break;
1934                 case T_SubLink:
1935                         retval = _equalSubLink(a, b);
1936                         break;
1937                 case T_Func:
1938                         retval = _equalFunc(a, b);
1939                         break;
1940                 case T_FieldSelect:
1941                         retval = _equalFieldSelect(a, b);
1942                         break;
1943                 case T_ArrayRef:
1944                         retval = _equalArrayRef(a, b);
1945                         break;
1946                 case T_RelabelType:
1947                         retval = _equalRelabelType(a, b);
1948                         break;
1949                 case T_RangeTblRef:
1950                         retval = _equalRangeTblRef(a, b);
1951                         break;
1952                 case T_FromExpr:
1953                         retval = _equalFromExpr(a, b);
1954                         break;
1955                 case T_JoinExpr:
1956                         retval = _equalJoinExpr(a, b);
1957                         break;
1958
1959                 case T_RelOptInfo:
1960                         retval = _equalRelOptInfo(a, b);
1961                         break;
1962                 case T_Path:
1963                         retval = _equalPath(a, b);
1964                         break;
1965                 case T_IndexPath:
1966                         retval = _equalIndexPath(a, b);
1967                         break;
1968                 case T_NestPath:
1969                         retval = _equalNestPath(a, b);
1970                         break;
1971                 case T_MergePath:
1972                         retval = _equalMergePath(a, b);
1973                         break;
1974                 case T_HashPath:
1975                         retval = _equalHashPath(a, b);
1976                         break;
1977                 case T_PathKeyItem:
1978                         retval = _equalPathKeyItem(a, b);
1979                         break;
1980                 case T_RestrictInfo:
1981                         retval = _equalRestrictInfo(a, b);
1982                         break;
1983                 case T_JoinInfo:
1984                         retval = _equalJoinInfo(a, b);
1985                         break;
1986                 case T_Stream:
1987                         retval = _equalStream(a, b);
1988                         break;
1989                 case T_TidPath:
1990                         retval = _equalTidPath(a, b);
1991                         break;
1992                 case T_AppendPath:
1993                         retval = _equalAppendPath(a, b);
1994                         break;
1995                 case T_IndexOptInfo:
1996                         retval = _equalIndexOptInfo(a, b);
1997                         break;
1998
1999                 case T_List:
2000                         {
2001                                 List       *la = (List *) a;
2002                                 List       *lb = (List *) b;
2003                                 List       *l;
2004
2005                                 /*
2006                                  * Try to reject by length check before we grovel through
2007                                  * all the elements...
2008                                  */
2009                                 if (length(la) != length(lb))
2010                                         return false;
2011                                 foreach(l, la)
2012                                 {
2013                                         if (!equal(lfirst(l), lfirst(lb)))
2014                                                 return false;
2015                                         lb = lnext(lb);
2016                                 }
2017                                 retval = true;
2018                         }
2019                         break;
2020                 case T_Integer:
2021                 case T_Float:
2022                 case T_String:
2023                 case T_BitString:
2024                         retval = _equalValue(a, b);
2025                         break;
2026
2027                 case T_Query:
2028                         retval = _equalQuery(a, b);
2029                         break;
2030                 case T_InsertStmt:
2031                         retval = _equalInsertStmt(a, b);
2032                         break;
2033                 case T_DeleteStmt:
2034                         retval = _equalDeleteStmt(a, b);
2035                         break;
2036                 case T_UpdateStmt:
2037                         retval = _equalUpdateStmt(a, b);
2038                         break;
2039                 case T_SelectStmt:
2040                         retval = _equalSelectStmt(a, b);
2041                         break;
2042                 case T_SetOperationStmt:
2043                         retval = _equalSetOperationStmt(a, b);
2044                         break;
2045                 case T_AlterTableStmt:
2046                         retval = _equalAlterTableStmt(a, b);
2047                         break;
2048                 case T_GrantStmt:
2049                         retval = _equalGrantStmt(a, b);
2050                         break;
2051                 case T_ClosePortalStmt:
2052                         retval = _equalClosePortalStmt(a, b);
2053                         break;
2054                 case T_ClusterStmt:
2055                         retval = _equalClusterStmt(a, b);
2056                         break;
2057                 case T_CopyStmt:
2058                         retval = _equalCopyStmt(a, b);
2059                         break;
2060                 case T_CreateStmt:
2061                         retval = _equalCreateStmt(a, b);
2062                         break;
2063                 case T_DefineStmt:
2064                         retval = _equalDefineStmt(a, b);
2065                         break;
2066                 case T_DropStmt:
2067                         retval = _equalDropStmt(a, b);
2068                         break;
2069                 case T_TruncateStmt:
2070                         retval = _equalTruncateStmt(a, b);
2071                         break;
2072                 case T_CommentStmt:
2073                         retval = _equalCommentStmt(a, b);
2074                         break;
2075                 case T_FetchStmt:
2076                         retval = _equalFetchStmt(a, b);
2077                         break;
2078                 case T_IndexStmt:
2079                         retval = _equalIndexStmt(a, b);
2080                         break;
2081                 case T_CreateFunctionStmt:
2082                         retval = _equalCreateFunctionStmt(a, b);
2083                         break;
2084                 case T_RemoveAggrStmt:
2085                         retval = _equalRemoveAggrStmt(a, b);
2086                         break;
2087                 case T_RemoveFuncStmt:
2088                         retval = _equalRemoveFuncStmt(a, b);
2089                         break;
2090                 case T_RemoveOperStmt:
2091                         retval = _equalRemoveOperStmt(a, b);
2092                         break;
2093                 case T_RemoveOpClassStmt:
2094                         retval = _equalRemoveOpClassStmt(a, b);
2095                         break;
2096                 case T_RenameStmt:
2097                         retval = _equalRenameStmt(a, b);
2098                         break;
2099                 case T_RuleStmt:
2100                         retval = _equalRuleStmt(a, b);
2101                         break;
2102                 case T_NotifyStmt:
2103                         retval = _equalNotifyStmt(a, b);
2104                         break;
2105                 case T_ListenStmt:
2106                         retval = _equalListenStmt(a, b);
2107                         break;
2108                 case T_UnlistenStmt:
2109                         retval = _equalUnlistenStmt(a, b);
2110                         break;
2111                 case T_TransactionStmt:
2112                         retval = _equalTransactionStmt(a, b);
2113                         break;
2114                 case T_ViewStmt:
2115                         retval = _equalViewStmt(a, b);
2116                         break;
2117                 case T_LoadStmt:
2118                         retval = _equalLoadStmt(a, b);
2119                         break;
2120                 case T_CreateDomainStmt:
2121                         retval = _equalCreateDomainStmt(a, b);
2122                         break;
2123                 case T_CreateOpClassStmt:
2124                         retval = _equalCreateOpClassStmt(a, b);
2125                         break;
2126                 case T_CreateOpClassItem:
2127                         retval = _equalCreateOpClassItem(a, b);
2128                         break;
2129                 case T_CreatedbStmt:
2130                         retval = _equalCreatedbStmt(a, b);
2131                         break;
2132                 case T_AlterDatabaseSetStmt:
2133                         retval = _equalAlterDatabaseSetStmt(a, b);
2134                         break;
2135                 case T_DropdbStmt:
2136                         retval = _equalDropdbStmt(a, b);
2137                         break;
2138                 case T_VacuumStmt:
2139                         retval = _equalVacuumStmt(a, b);
2140                         break;
2141                 case T_ExplainStmt:
2142                         retval = _equalExplainStmt(a, b);
2143                         break;
2144                 case T_CreateSeqStmt:
2145                         retval = _equalCreateSeqStmt(a, b);
2146                         break;
2147                 case T_VariableSetStmt:
2148                         retval = _equalVariableSetStmt(a, b);
2149                         break;
2150                 case T_VariableShowStmt:
2151                         retval = _equalVariableShowStmt(a, b);
2152                         break;
2153                 case T_VariableResetStmt:
2154                         retval = _equalVariableResetStmt(a, b);
2155                         break;
2156                 case T_CreateTrigStmt:
2157                         retval = _equalCreateTrigStmt(a, b);
2158                         break;
2159                 case T_DropPropertyStmt:
2160                         retval = _equalDropPropertyStmt(a, b);
2161                         break;
2162                 case T_CreatePLangStmt:
2163                         retval = _equalCreatePLangStmt(a, b);
2164                         break;
2165                 case T_DropPLangStmt:
2166                         retval = _equalDropPLangStmt(a, b);
2167                         break;
2168                 case T_CreateUserStmt:
2169                         retval = _equalCreateUserStmt(a, b);
2170                         break;
2171                 case T_AlterUserStmt:
2172                         retval = _equalAlterUserStmt(a, b);
2173                         break;
2174                 case T_AlterUserSetStmt:
2175                         retval = _equalAlterUserSetStmt(a, b);
2176                         break;
2177                 case T_DropUserStmt:
2178                         retval = _equalDropUserStmt(a, b);
2179                         break;
2180                 case T_LockStmt:
2181                         retval = _equalLockStmt(a, b);
2182                         break;
2183                 case T_ConstraintsSetStmt:
2184                         retval = _equalConstraintsSetStmt(a, b);
2185                         break;
2186                 case T_CreateGroupStmt:
2187                         retval = _equalCreateGroupStmt(a, b);
2188                         break;
2189                 case T_AlterGroupStmt:
2190                         retval = _equalAlterGroupStmt(a, b);
2191                         break;
2192                 case T_DropGroupStmt:
2193                         retval = _equalDropGroupStmt(a, b);
2194                         break;
2195                 case T_ReindexStmt:
2196                         retval = _equalReindexStmt(a, b);
2197                         break;
2198                 case T_CheckPointStmt:
2199                         retval = true;
2200                         break;
2201                 case T_CreateSchemaStmt:
2202                         retval = _equalCreateSchemaStmt(a, b);
2203                         break;
2204
2205                 case T_A_Expr:
2206                         retval = _equalAExpr(a, b);
2207                         break;
2208                 case T_ColumnRef:
2209                         retval = _equalColumnRef(a, b);
2210                         break;
2211                 case T_ParamRef:
2212                         retval = _equalParamRef(a, b);
2213                         break;
2214                 case T_A_Const:
2215                         retval = _equalAConst(a, b);
2216                         break;
2217                 case T_Ident:
2218                         retval = _equalIdent(a, b);
2219                         break;
2220                 case T_FuncCall:
2221                         retval = _equalFuncCall(a, b);
2222                         break;
2223                 case T_A_Indices:
2224                         retval = _equalAIndices(a, b);
2225                         break;
2226                 case T_ExprFieldSelect:
2227                         retval = _equalExprFieldSelect(a, b);
2228                         break;
2229                 case T_ResTarget:
2230                         retval = _equalResTarget(a, b);
2231                         break;
2232                 case T_TypeCast:
2233                         retval = _equalTypeCast(a, b);
2234                         break;
2235                 case T_SortGroupBy:
2236                         retval = _equalSortGroupBy(a, b);
2237                         break;
2238                 case T_Alias:
2239                         retval = _equalAlias(a, b);
2240                         break;
2241                 case T_RangeVar:
2242                         retval = _equalRangeVar(a, b);
2243                         break;
2244                 case T_RangeSubselect:
2245                         retval = _equalRangeSubselect(a, b);
2246                         break;
2247                 case T_RangeFunction:
2248                         retval = _equalRangeFunction(a, b);
2249                         break;
2250                 case T_TypeName:
2251                         retval = _equalTypeName(a, b);
2252                         break;
2253                 case T_IndexElem:
2254                         retval = _equalIndexElem(a, b);
2255                         break;
2256                 case T_ColumnDef:
2257                         retval = _equalColumnDef(a, b);
2258                         break;
2259                 case T_Constraint:
2260                         retval = _equalConstraint(a, b);
2261                         break;
2262                 case T_DefElem:
2263                         retval = _equalDefElem(a, b);
2264                         break;
2265                 case T_TargetEntry:
2266                         retval = _equalTargetEntry(a, b);
2267                         break;
2268                 case T_RangeTblEntry:
2269                         retval = _equalRangeTblEntry(a, b);
2270                         break;
2271                 case T_SortClause:
2272                         retval = _equalSortClause(a, b);
2273                         break;
2274                 case T_GroupClause:
2275                         /* GroupClause is equivalent to SortClause */
2276                         retval = _equalSortClause(a, b);
2277                         break;
2278                 case T_CaseExpr:
2279                         retval = _equalCaseExpr(a, b);
2280                         break;
2281                 case T_CaseWhen:
2282                         retval = _equalCaseWhen(a, b);
2283                         break;
2284                 case T_NullTest:
2285                         retval = _equalNullTest(a, b);
2286                         break;
2287                 case T_BooleanTest:
2288                         retval = _equalBooleanTest(a, b);
2289                         break;
2290                 case T_FkConstraint:
2291                         retval = _equalFkConstraint(a, b);
2292                         break;
2293                 case T_PrivGrantee:
2294                         retval = _equalPrivGrantee(a, b);
2295                         break;
2296                 case T_FuncWithArgs:
2297                         retval = _equalFuncWithArgs(a, b);
2298                         break;
2299                 case T_InsertDefault:
2300                         retval = _equalInsertDefault(a, b);
2301                         break;
2302
2303                 default:
2304                         elog(WARNING, "equal: don't know whether nodes of type %d are equal",
2305                                  nodeTag(a));
2306                         break;
2307         }
2308
2309         return retval;
2310 }