src/backend/nodes/copyfuncs.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * copyfuncs.c
   4  *        Copy functions for Postgres tree nodes.
   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  *
  14  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  15  * Portions Copyright (c) 1994, Regents of the University of California
  16  *
  17  * IDENTIFICATION
  18  *        $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.184 2002/05/12 23:43:02 tgl Exp $
  19  *
  20  *-------------------------------------------------------------------------
  21  */
  22
  23 #include "postgres.h"
  24
  25 #include "optimizer/clauses.h"
  26 #include "optimizer/planmain.h"
  27
  28
  29 /*
  30  * Node_Copy
  31  *        a macro to simplify calling of copyObject on the specified field
  32  */
  33 #define Node_Copy(from, newnode, field) \
  34         ((newnode)->field = copyObject((from)->field))
  35
  36
  37 /*
  38  * listCopy
  39  *        This copy function only copies the "cons-cells" of the list, not the
  40  *        pointed-to objects.  (Use copyObject if you want a "deep" copy.)
  41  *
  42  *        We also use this function for copying lists of integers, which is
  43  *        grotty but unlikely to break --- it could fail if sizeof(pointer)
  44  *        is less than sizeof(int), but I don't know any such machines...
  45  *
  46  *        Note that copyObject will surely coredump if applied to a list
  47  *        of integers!
  48  */
  49 List *
  50 listCopy(List *list)
  51 {
  52         List       *newlist,
  53                            *l,
  54                            *nl;
  55
  56         /* rather ugly coding for speed... */
  57         if (list == NIL)
  58                 return NIL;
  59
  60         newlist = nl = makeList1(lfirst(list));
  61
  62         foreach(l, lnext(list))
  63         {
  64                 lnext(nl) = makeList1(lfirst(l));
  65                 nl = lnext(nl);
  66         }
  67         return newlist;
  68 }
  69
  70 /* ****************************************************************
  71  *                                       plannodes.h copy functions
  72  * ****************************************************************
  73  */
  74
  75 /* ----------------
  76  *              CopyPlanFields
  77  *
  78  *              This function copies the fields of the Plan node.  It is used by
  79  *              all the copy functions for classes which inherit from Plan.
  80  * ----------------
  81  */
  82 static void
  83 CopyPlanFields(Plan *from, Plan *newnode)
  84 {
  85         newnode->startup_cost = from->startup_cost;
  86         newnode->total_cost = from->total_cost;
  87         newnode->plan_rows = from->plan_rows;
  88         newnode->plan_width = from->plan_width;
  89         /* state is NOT copied */
  90         Node_Copy(from, newnode, targetlist);
  91         Node_Copy(from, newnode, qual);
  92         Node_Copy(from, newnode, lefttree);
  93         Node_Copy(from, newnode, righttree);
  94         newnode->extParam = listCopy(from->extParam);
  95         newnode->locParam = listCopy(from->locParam);
  96         newnode->chgParam = listCopy(from->chgParam);
  97         Node_Copy(from, newnode, initPlan);
  98         /* subPlan list must point to subplans in the new subtree, not the old */
  99         if (from->subPlan != NIL)
 100                 newnode->subPlan = nconc(pull_subplans((Node *) newnode->targetlist),
 101                                                                  pull_subplans((Node *) newnode->qual));
 102         else
 103                 newnode->subPlan = NIL;
 104         newnode->nParamExec = from->nParamExec;
 105 }
 106
 107 /* ----------------
 108  *              _copyPlan
 109  * ----------------
 110  */
 111 static Plan *
 112 _copyPlan(Plan *from)
 113 {
 114         Plan       *newnode = makeNode(Plan);
 115
 116         /*
 117          * copy the node superclass fields
 118          */
 119         CopyPlanFields(from, newnode);
 120
 121         return newnode;
 122 }
 123
 124
 125 /* ----------------
 126  *              _copyResult
 127  * ----------------
 128  */
 129 static Result *
 130 _copyResult(Result *from)
 131 {
 132         Result     *newnode = makeNode(Result);
 133
 134         /*
 135          * copy node superclass fields
 136          */
 137         CopyPlanFields((Plan *) from, (Plan *) newnode);
 138
 139         /*
 140          * copy remainder of node
 141          */
 142         Node_Copy(from, newnode, resconstantqual);
 143
 144         /*
 145          * We must add subplans in resconstantqual to the new plan's subPlan
 146          * list
 147          */
 148         if (from->plan.subPlan != NIL)
 149                 newnode->plan.subPlan = nconc(newnode->plan.subPlan,
 150                                                                 pull_subplans(newnode->resconstantqual));
 151
 152         return newnode;
 153 }
 154
 155 /* ----------------
 156  *              _copyAppend
 157  * ----------------
 158  */
 159 static Append *
 160 _copyAppend(Append *from)
 161 {
 162         Append     *newnode = makeNode(Append);
 163
 164         /*
 165          * copy node superclass fields
 166          */
 167         CopyPlanFields((Plan *) from, (Plan *) newnode);
 168
 169         /*
 170          * copy remainder of node
 171          */
 172         Node_Copy(from, newnode, appendplans);
 173         newnode->isTarget = from->isTarget;
 174
 175         return newnode;
 176 }
 177
 178
 179 /* ----------------
 180  *              CopyScanFields
 181  *
 182  *              This function copies the fields of the Scan node.  It is used by
 183  *              all the copy functions for classes which inherit from Scan.
 184  * ----------------
 185  */
 186 static void
 187 CopyScanFields(Scan *from, Scan *newnode)
 188 {
 189         newnode->scanrelid = from->scanrelid;
 190         return;
 191 }
 192
 193 /* ----------------
 194  *              _copyScan
 195  * ----------------
 196  */
 197 static Scan *
 198 _copyScan(Scan *from)
 199 {
 200         Scan       *newnode = makeNode(Scan);
 201
 202         /*
 203          * copy node superclass fields
 204          */
 205         CopyPlanFields((Plan *) from, (Plan *) newnode);
 206         CopyScanFields((Scan *) from, (Scan *) newnode);
 207
 208         return newnode;
 209 }
 210
 211 /* ----------------
 212  *              _copySeqScan
 213  * ----------------
 214  */
 215 static SeqScan *
 216 _copySeqScan(SeqScan *from)
 217 {
 218         SeqScan    *newnode = makeNode(SeqScan);
 219
 220         /*
 221          * copy node superclass fields
 222          */
 223         CopyPlanFields((Plan *) from, (Plan *) newnode);
 224         CopyScanFields((Scan *) from, (Scan *) newnode);
 225
 226         return newnode;
 227 }
 228
 229 /* ----------------
 230  *              _copyIndexScan
 231  * ----------------
 232  */
 233 static IndexScan *
 234 _copyIndexScan(IndexScan *from)
 235 {
 236         IndexScan  *newnode = makeNode(IndexScan);
 237
 238         /*
 239          * copy node superclass fields
 240          */
 241         CopyPlanFields((Plan *) from, (Plan *) newnode);
 242         CopyScanFields((Scan *) from, (Scan *) newnode);
 243
 244         /*
 245          * copy remainder of node
 246          */
 247         newnode->indxid = listCopy(from->indxid);
 248         Node_Copy(from, newnode, indxqual);
 249         Node_Copy(from, newnode, indxqualorig);
 250         newnode->indxorderdir = from->indxorderdir;
 251
 252         /*
 253          * We must add subplans in index quals to the new plan's subPlan list
 254          */
 255         if (from->scan.plan.subPlan != NIL)
 256         {
 257                 newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan,
 258                                                           pull_subplans((Node *) newnode->indxqual));
 259                 newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan,
 260                                                   pull_subplans((Node *) newnode->indxqualorig));
 261         }
 262
 263         return newnode;
 264 }
 265
 266 /* ----------------
 267  *                              _copyTidScan
 268  * ----------------
 269  */
 270 static TidScan *
 271 _copyTidScan(TidScan *from)
 272 {
 273         TidScan    *newnode = makeNode(TidScan);
 274
 275         /*
 276          * copy node superclass fields
 277          */
 278         CopyPlanFields((Plan *) from, (Plan *) newnode);
 279         CopyScanFields((Scan *) from, (Scan *) newnode);
 280
 281         /*
 282          * copy remainder of node
 283          */
 284         newnode->needRescan = from->needRescan;
 285         Node_Copy(from, newnode, tideval);
 286
 287         return newnode;
 288 }
 289
 290 /* ----------------
 291  *              _copySubqueryScan
 292  * ----------------
 293  */
 294 static SubqueryScan *
 295 _copySubqueryScan(SubqueryScan *from)
 296 {
 297         SubqueryScan *newnode = makeNode(SubqueryScan);
 298
 299         /*
 300          * copy node superclass fields
 301          */
 302         CopyPlanFields((Plan *) from, (Plan *) newnode);
 303         CopyScanFields((Scan *) from, (Scan *) newnode);
 304
 305         /*
 306          * copy remainder of node
 307          */
 308         Node_Copy(from, newnode, subplan);
 309
 310         return newnode;
 311 }
 312
 313 /* ----------------
 314  *              _copyFunctionScan
 315  * ----------------
 316  */
 317 static FunctionScan *
 318 _copyFunctionScan(FunctionScan *from)
 319 {
 320         FunctionScan *newnode = makeNode(FunctionScan);
 321
 322         /*
 323          * copy node superclass fields
 324          */
 325         CopyPlanFields((Plan *) from, (Plan *) newnode);
 326         CopyScanFields((Scan *) from, (Scan *) newnode);
 327
 328         return newnode;
 329 }
 330
 331 /* ----------------
 332  *              CopyJoinFields
 333  *
 334  *              This function copies the fields of the Join node.  It is used by
 335  *              all the copy functions for classes which inherit from Join.
 336  * ----------------
 337  */
 338 static void
 339 CopyJoinFields(Join *from, Join *newnode)
 340 {
 341         newnode->jointype = from->jointype;
 342         Node_Copy(from, newnode, joinqual);
 343         /* subPlan list must point to subplans in the new subtree, not the old */
 344         if (from->plan.subPlan != NIL)
 345                 newnode->plan.subPlan = nconc(newnode->plan.subPlan,
 346                                                           pull_subplans((Node *) newnode->joinqual));
 347 }
 348
 349
 350 /* ----------------
 351  *              _copyJoin
 352  * ----------------
 353  */
 354 static Join *
 355 _copyJoin(Join *from)
 356 {
 357         Join       *newnode = makeNode(Join);
 358
 359         /*
 360          * copy node superclass fields
 361          */
 362         CopyPlanFields((Plan *) from, (Plan *) newnode);
 363         CopyJoinFields(from, newnode);
 364
 365         return newnode;
 366 }
 367
 368
 369 /* ----------------
 370  *              _copyNestLoop
 371  * ----------------
 372  */
 373 static NestLoop *
 374 _copyNestLoop(NestLoop *from)
 375 {
 376         NestLoop   *newnode = makeNode(NestLoop);
 377
 378         /*
 379          * copy node superclass fields
 380          */
 381         CopyPlanFields((Plan *) from, (Plan *) newnode);
 382         CopyJoinFields((Join *) from, (Join *) newnode);
 383
 384         return newnode;
 385 }
 386
 387
 388 /* ----------------
 389  *              _copyMergeJoin
 390  * ----------------
 391  */
 392 static MergeJoin *
 393 _copyMergeJoin(MergeJoin *from)
 394 {
 395         MergeJoin  *newnode = makeNode(MergeJoin);
 396
 397         /*
 398          * copy node superclass fields
 399          */
 400         CopyPlanFields((Plan *) from, (Plan *) newnode);
 401         CopyJoinFields((Join *) from, (Join *) newnode);
 402
 403         /*
 404          * copy remainder of node
 405          */
 406         Node_Copy(from, newnode, mergeclauses);
 407
 408         /*
 409          * We must add subplans in mergeclauses to the new plan's subPlan list
 410          */
 411         if (from->join.plan.subPlan != NIL)
 412                 newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan,
 413                                                   pull_subplans((Node *) newnode->mergeclauses));
 414
 415         return newnode;
 416 }
 417
 418 /* ----------------
 419  *              _copyHashJoin
 420  * ----------------
 421  */
 422 static HashJoin *
 423 _copyHashJoin(HashJoin *from)
 424 {
 425         HashJoin   *newnode = makeNode(HashJoin);
 426
 427         /*
 428          * copy node superclass fields
 429          */
 430         CopyPlanFields((Plan *) from, (Plan *) newnode);
 431         CopyJoinFields((Join *) from, (Join *) newnode);
 432
 433         /*
 434          * copy remainder of node
 435          */
 436         Node_Copy(from, newnode, hashclauses);
 437         newnode->hashjoinop = from->hashjoinop;
 438
 439         /*
 440          * We must add subplans in hashclauses to the new plan's subPlan list
 441          */
 442         if (from->join.plan.subPlan != NIL)
 443                 newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan,
 444                                                    pull_subplans((Node *) newnode->hashclauses));
 445
 446         return newnode;
 447 }
 448
 449
 450 /* ----------------
 451  *              _copyMaterial
 452  * ----------------
 453  */
 454 static Material *
 455 _copyMaterial(Material *from)
 456 {
 457         Material   *newnode = makeNode(Material);
 458
 459         /*
 460          * copy node superclass fields
 461          */
 462         CopyPlanFields((Plan *) from, (Plan *) newnode);
 463
 464         return newnode;
 465 }
 466
 467
 468 /* ----------------
 469  *              _copySort
 470  * ----------------
 471  */
 472 static Sort *
 473 _copySort(Sort *from)
 474 {
 475         Sort       *newnode = makeNode(Sort);
 476
 477         /*
 478          * copy node superclass fields
 479          */
 480         CopyPlanFields((Plan *) from, (Plan *) newnode);
 481
 482         newnode->keycount = from->keycount;
 483
 484         return newnode;
 485 }
 486
 487
 488 /* ----------------
 489  *              _copyGroup
 490  * ----------------
 491  */
 492 static Group *
 493 _copyGroup(Group *from)
 494 {
 495         Group      *newnode = makeNode(Group);
 496
 497         CopyPlanFields((Plan *) from, (Plan *) newnode);
 498
 499         newnode->tuplePerGroup = from->tuplePerGroup;
 500         newnode->numCols = from->numCols;
 501         newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber));
 502         memcpy(newnode->grpColIdx, from->grpColIdx, from->numCols * sizeof(AttrNumber));
 503
 504         return newnode;
 505 }
 506
 507 /* ---------------
 508  *      _copyAgg
 509  * --------------
 510  */
 511 static Agg *
 512 _copyAgg(Agg *from)
 513 {
 514         Agg                *newnode = makeNode(Agg);
 515
 516         CopyPlanFields((Plan *) from, (Plan *) newnode);
 517
 518         return newnode;
 519 }
 520
 521 /* ---------------
 522  *      _copyGroupClause
 523  * --------------
 524  */
 525 static GroupClause *
 526 _copyGroupClause(GroupClause *from)
 527 {
 528         GroupClause *newnode = makeNode(GroupClause);
 529
 530         newnode->tleSortGroupRef = from->tleSortGroupRef;
 531         newnode->sortop = from->sortop;
 532
 533         return newnode;
 534 }
 535
 536 /* ----------------
 537  *              _copyUnique
 538  * ----------------
 539  */
 540 static Unique *
 541 _copyUnique(Unique *from)
 542 {
 543         Unique     *newnode = makeNode(Unique);
 544
 545         /*
 546          * copy node superclass fields
 547          */
 548         CopyPlanFields((Plan *) from, (Plan *) newnode);
 549
 550         /*
 551          * copy remainder of node
 552          */
 553         newnode->numCols = from->numCols;
 554         newnode->uniqColIdx = palloc(from->numCols * sizeof(AttrNumber));
 555         memcpy(newnode->uniqColIdx, from->uniqColIdx, from->numCols * sizeof(AttrNumber));
 556
 557         return newnode;
 558 }
 559
 560 /* ----------------
 561  *              _copySetOp
 562  * ----------------
 563  */
 564 static SetOp *
 565 _copySetOp(SetOp *from)
 566 {
 567         SetOp      *newnode = makeNode(SetOp);
 568
 569         /*
 570          * copy node superclass fields
 571          */
 572         CopyPlanFields((Plan *) from, (Plan *) newnode);
 573
 574         /*
 575          * copy remainder of node
 576          */
 577         newnode->cmd = from->cmd;
 578         newnode->numCols = from->numCols;
 579         newnode->dupColIdx = palloc(from->numCols * sizeof(AttrNumber));
 580         memcpy(newnode->dupColIdx, from->dupColIdx, from->numCols * sizeof(AttrNumber));
 581         newnode->flagColIdx = from->flagColIdx;
 582
 583         return newnode;
 584 }
 585
 586 /* ----------------
 587  *              _copyLimit
 588  * ----------------
 589  */
 590 static Limit *
 591 _copyLimit(Limit *from)
 592 {
 593         Limit      *newnode = makeNode(Limit);
 594
 595         /*
 596          * copy node superclass fields
 597          */
 598         CopyPlanFields((Plan *) from, (Plan *) newnode);
 599
 600         /*
 601          * copy remainder of node
 602          */
 603         Node_Copy(from, newnode, limitOffset);
 604         Node_Copy(from, newnode, limitCount);
 605
 606         return newnode;
 607 }
 608
 609 /* ----------------
 610  *              _copyHash
 611  * ----------------
 612  */
 613 static Hash *
 614 _copyHash(Hash *from)
 615 {
 616         Hash       *newnode = makeNode(Hash);
 617
 618         /*
 619          * copy node superclass fields
 620          */
 621         CopyPlanFields((Plan *) from, (Plan *) newnode);
 622
 623         /*
 624          * copy remainder of node
 625          */
 626         Node_Copy(from, newnode, hashkey);
 627
 628         return newnode;
 629 }
 630
 631 static SubPlan *
 632 _copySubPlan(SubPlan *from)
 633 {
 634         SubPlan    *newnode = makeNode(SubPlan);
 635
 636         Node_Copy(from, newnode, plan);
 637         newnode->plan_id = from->plan_id;
 638         Node_Copy(from, newnode, rtable);
 639         newnode->setParam = listCopy(from->setParam);
 640         newnode->parParam = listCopy(from->parParam);
 641         Node_Copy(from, newnode, sublink);
 642
 643         /* do not copy execution state */
 644         newnode->needShutdown = false;
 645         newnode->curTuple = NULL;
 646
 647         return newnode;
 648 }
 649
 650 /* ****************************************************************
 651  *                                         primnodes.h copy functions
 652  * ****************************************************************
 653  */
 654
 655 /* ----------------
 656  *              _copyResdom
 657  * ----------------
 658  */
 659 static Resdom *
 660 _copyResdom(Resdom *from)
 661 {
 662         Resdom     *newnode = makeNode(Resdom);
 663
 664         newnode->resno = from->resno;
 665         newnode->restype = from->restype;
 666         newnode->restypmod = from->restypmod;
 667         if (from->resname != NULL)
 668                 newnode->resname = pstrdup(from->resname);
 669         newnode->ressortgroupref = from->ressortgroupref;
 670         newnode->reskey = from->reskey;
 671         newnode->reskeyop = from->reskeyop;
 672         newnode->resjunk = from->resjunk;
 673
 674         return newnode;
 675 }
 676
 677 static Fjoin *
 678 _copyFjoin(Fjoin *from)
 679 {
 680         Fjoin      *newnode = makeNode(Fjoin);
 681
 682         /*
 683          * copy node superclass fields
 684          */
 685
 686         newnode->fj_initialized = from->fj_initialized;
 687         newnode->fj_nNodes = from->fj_nNodes;
 688
 689         Node_Copy(from, newnode, fj_innerNode);
 690
 691         newnode->fj_results = (DatumPtr)
 692                 palloc((from->fj_nNodes) * sizeof(Datum));
 693         memmove(from->fj_results,
 694                         newnode->fj_results,
 695                         (from->fj_nNodes) * sizeof(Datum));
 696
 697         newnode->fj_alwaysDone = (BoolPtr)
 698                 palloc((from->fj_nNodes) * sizeof(bool));
 699         memmove(from->fj_alwaysDone,
 700                         newnode->fj_alwaysDone,
 701                         (from->fj_nNodes) * sizeof(bool));
 702
 703
 704         return newnode;
 705 }
 706
 707 /* ----------------
 708  *              _copyExpr
 709  * ----------------
 710  */
 711 static Expr *
 712 _copyExpr(Expr *from)
 713 {
 714         Expr       *newnode = makeNode(Expr);
 715
 716         /*
 717          * copy node superclass fields
 718          */
 719         newnode->typeOid = from->typeOid;
 720         newnode->opType = from->opType;
 721
 722         Node_Copy(from, newnode, oper);
 723         Node_Copy(from, newnode, args);
 724
 725         return newnode;
 726 }
 727
 728 /* ----------------
 729  *              _copyVar
 730  * ----------------
 731  */
 732 static Var *
 733 _copyVar(Var *from)
 734 {
 735         Var                *newnode = makeNode(Var);
 736
 737         /*
 738          * copy remainder of node
 739          */
 740         newnode->varno = from->varno;
 741         newnode->varattno = from->varattno;
 742         newnode->vartype = from->vartype;
 743         newnode->vartypmod = from->vartypmod;
 744         newnode->varlevelsup = from->varlevelsup;
 745
 746         newnode->varnoold = from->varnoold;
 747         newnode->varoattno = from->varoattno;
 748
 749         return newnode;
 750 }
 751
 752 /* ----------------
 753  *              _copyOper
 754  * ----------------
 755  */
 756 static Oper *
 757 _copyOper(Oper *from)
 758 {
 759         Oper       *newnode = makeNode(Oper);
 760
 761         /*
 762          * copy remainder of node
 763          */
 764         newnode->opno = from->opno;
 765         newnode->opid = from->opid;
 766         newnode->opresulttype = from->opresulttype;
 767         newnode->opretset = from->opretset;
 768         /* Do not copy the run-time state, if any */
 769         newnode->op_fcache = NULL;
 770
 771         return newnode;
 772 }
 773
 774 /* ----------------
 775  *              _copyConst
 776  * ----------------
 777  */
 778 static Const *
 779 _copyConst(Const *from)
 780 {
 781         Const      *newnode = makeNode(Const);
 782
 783         /*
 784          * copy remainder of node
 785          */
 786         newnode->consttype = from->consttype;
 787         newnode->constlen = from->constlen;
 788
 789         if (from->constbyval || from->constisnull)
 790         {
 791                 /*
 792                  * passed by value so just copy the datum. Also, don't try to copy
 793                  * struct when value is null!
 794                  *
 795                  */
 796                 newnode->constvalue = from->constvalue;
 797         }
 798         else
 799         {
 800                 /*
 801                  * not passed by value. datum contains a pointer.
 802                  */
 803                 int                     length = from->constlen;
 804
 805                 if (length == -1)               /* variable-length type? */
 806                         length = VARSIZE(from->constvalue);
 807                 newnode->constvalue = PointerGetDatum(palloc(length));
 808                 memcpy(DatumGetPointer(newnode->constvalue),
 809                            DatumGetPointer(from->constvalue),
 810                            length);
 811         }
 812
 813         newnode->constisnull = from->constisnull;
 814         newnode->constbyval = from->constbyval;
 815         newnode->constisset = from->constisset;
 816         newnode->constiscast = from->constiscast;
 817
 818         return newnode;
 819 }
 820
 821 /* ----------------
 822  *              _copyParam
 823  * ----------------
 824  */
 825 static Param *
 826 _copyParam(Param *from)
 827 {
 828         Param      *newnode = makeNode(Param);
 829
 830         /*
 831          * copy remainder of node
 832          */
 833         newnode->paramkind = from->paramkind;
 834         newnode->paramid = from->paramid;
 835
 836         if (from->paramname != NULL)
 837                 newnode->paramname = pstrdup(from->paramname);
 838         newnode->paramtype = from->paramtype;
 839
 840         return newnode;
 841 }
 842
 843 /* ----------------
 844  *              _copyFunc
 845  * ----------------
 846  */
 847 static Func *
 848 _copyFunc(Func *from)
 849 {
 850         Func       *newnode = makeNode(Func);
 851
 852         /*
 853          * copy remainder of node
 854          */
 855         newnode->funcid = from->funcid;
 856         newnode->funcresulttype = from->funcresulttype;
 857         newnode->funcretset = from->funcretset;
 858         /* Do not copy the run-time state, if any */
 859         newnode->func_fcache = NULL;
 860
 861         return newnode;
 862 }
 863
 864 /* ----------------
 865  *              _copyAggref
 866  * ----------------
 867  */
 868 static Aggref *
 869 _copyAggref(Aggref *from)
 870 {
 871         Aggref     *newnode = makeNode(Aggref);
 872
 873         newnode->aggfnoid = from->aggfnoid;
 874         newnode->aggtype = from->aggtype;
 875         Node_Copy(from, newnode, target);
 876         newnode->aggstar = from->aggstar;
 877         newnode->aggdistinct = from->aggdistinct;
 878         newnode->aggno = from->aggno;           /* probably not needed */
 879
 880         return newnode;
 881 }
 882
 883 /* ----------------
 884  *              _copySubLink
 885  * ----------------
 886  */
 887 static SubLink *
 888 _copySubLink(SubLink *from)
 889 {
 890         SubLink    *newnode = makeNode(SubLink);
 891
 892         /*
 893          * copy remainder of node
 894          */
 895         newnode->subLinkType = from->subLinkType;
 896         newnode->useor = from->useor;
 897         Node_Copy(from, newnode, lefthand);
 898         Node_Copy(from, newnode, oper);
 899         Node_Copy(from, newnode, subselect);
 900
 901         return newnode;
 902 }
 903
 904 /* ----------------
 905  *              _copyFieldSelect
 906  * ----------------
 907  */
 908 static FieldSelect *
 909 _copyFieldSelect(FieldSelect *from)
 910 {
 911         FieldSelect *newnode = makeNode(FieldSelect);
 912
 913         /*
 914          * copy remainder of node
 915          */
 916         Node_Copy(from, newnode, arg);
 917         newnode->fieldnum = from->fieldnum;
 918         newnode->resulttype = from->resulttype;
 919         newnode->resulttypmod = from->resulttypmod;
 920
 921         return newnode;
 922 }
 923
 924 /* ----------------
 925  *              _copyRelabelType
 926  * ----------------
 927  */
 928 static RelabelType *
 929 _copyRelabelType(RelabelType *from)
 930 {
 931         RelabelType *newnode = makeNode(RelabelType);
 932
 933         /*
 934          * copy remainder of node
 935          */
 936         Node_Copy(from, newnode, arg);
 937         newnode->resulttype = from->resulttype;
 938         newnode->resulttypmod = from->resulttypmod;
 939
 940         return newnode;
 941 }
 942
 943 static RangeTblRef *
 944 _copyRangeTblRef(RangeTblRef *from)
 945 {
 946         RangeTblRef *newnode = makeNode(RangeTblRef);
 947
 948         newnode->rtindex = from->rtindex;
 949
 950         return newnode;
 951 }
 952
 953 static FromExpr *
 954 _copyFromExpr(FromExpr *from)
 955 {
 956         FromExpr   *newnode = makeNode(FromExpr);
 957
 958         Node_Copy(from, newnode, fromlist);
 959         Node_Copy(from, newnode, quals);
 960
 961         return newnode;
 962 }
 963
 964 static JoinExpr *
 965 _copyJoinExpr(JoinExpr *from)
 966 {
 967         JoinExpr   *newnode = makeNode(JoinExpr);
 968
 969         newnode->jointype = from->jointype;
 970         newnode->isNatural = from->isNatural;
 971         Node_Copy(from, newnode, larg);
 972         Node_Copy(from, newnode, rarg);
 973         Node_Copy(from, newnode, using);
 974         Node_Copy(from, newnode, quals);
 975         Node_Copy(from, newnode, alias);
 976         newnode->rtindex = from->rtindex;
 977
 978         return newnode;
 979 }
 980
 981 /* ----------------
 982  *              _copyCaseExpr
 983  * ----------------
 984  */
 985 static CaseExpr *
 986 _copyCaseExpr(CaseExpr *from)
 987 {
 988         CaseExpr   *newnode = makeNode(CaseExpr);
 989
 990         /*
 991          * copy remainder of node
 992          */
 993         newnode->casetype = from->casetype;
 994
 995         Node_Copy(from, newnode, arg);
 996         Node_Copy(from, newnode, args);
 997         Node_Copy(from, newnode, defresult);
 998
 999         return newnode;
1000 }
1001
1002 /* ----------------
1003  *              _copyCaseWhen
1004  * ----------------
1005  */
1006 static CaseWhen *
1007 _copyCaseWhen(CaseWhen *from)
1008 {
1009         CaseWhen   *newnode = makeNode(CaseWhen);
1010
1011         /*
1012          * copy remainder of node
1013          */
1014         Node_Copy(from, newnode, expr);
1015         Node_Copy(from, newnode, result);
1016
1017         return newnode;
1018 }
1019
1020 /* ----------------
1021  *              _copyNullTest
1022  * ----------------
1023  */
1024 static NullTest *
1025 _copyNullTest(NullTest *from)
1026 {
1027         NullTest   *newnode = makeNode(NullTest);
1028
1029         /*
1030          * copy remainder of node
1031          */
1032         Node_Copy(from, newnode, arg);
1033         newnode->nulltesttype = from->nulltesttype;
1034
1035         return newnode;
1036 }
1037
1038 /* ----------------
1039  *              _copyBooleanTest
1040  * ----------------
1041  */
1042 static BooleanTest *
1043 _copyBooleanTest(BooleanTest *from)
1044 {
1045         BooleanTest *newnode = makeNode(BooleanTest);
1046
1047         /*
1048          * copy remainder of node
1049          */
1050         Node_Copy(from, newnode, arg);
1051         newnode->booltesttype = from->booltesttype;
1052
1053         return newnode;
1054 }
1055
1056 static ArrayRef *
1057 _copyArrayRef(ArrayRef *from)
1058 {
1059         ArrayRef   *newnode = makeNode(ArrayRef);
1060
1061         /*
1062          * copy remainder of node
1063          */
1064         newnode->refattrlength = from->refattrlength;
1065         newnode->refelemlength = from->refelemlength;
1066         newnode->refelemtype = from->refelemtype;
1067         newnode->refelembyval = from->refelembyval;
1068
1069         Node_Copy(from, newnode, refupperindexpr);
1070         Node_Copy(from, newnode, reflowerindexpr);
1071         Node_Copy(from, newnode, refexpr);
1072         Node_Copy(from, newnode, refassgnexpr);
1073
1074         return newnode;
1075 }
1076
1077 /* ****************************************************************
1078  *                                              relation.h copy functions
1079  * ****************************************************************
1080  */
1081
1082 /* ----------------
1083  *              _copyRelOptInfo
1084  * ----------------
1085  */
1086 static RelOptInfo *
1087 _copyRelOptInfo(RelOptInfo *from)
1088 {
1089         RelOptInfo *newnode = makeNode(RelOptInfo);
1090
1091         newnode->reloptkind = from->reloptkind;
1092
1093         newnode->relids = listCopy(from->relids);
1094
1095         newnode->rows = from->rows;
1096         newnode->width = from->width;
1097
1098         Node_Copy(from, newnode, targetlist);
1099         Node_Copy(from, newnode, pathlist);
1100         /* XXX cheapest-path fields should point to members of pathlist? */
1101         Node_Copy(from, newnode, cheapest_startup_path);
1102         Node_Copy(from, newnode, cheapest_total_path);
1103         newnode->pruneable = from->pruneable;
1104
1105         newnode->rtekind = from->rtekind;
1106         Node_Copy(from, newnode, indexlist);
1107         newnode->pages = from->pages;
1108         newnode->tuples = from->tuples;
1109         Node_Copy(from, newnode, subplan);
1110
1111         newnode->joinrti = from->joinrti;
1112         newnode->joinrteids = listCopy(from->joinrteids);
1113
1114         Node_Copy(from, newnode, baserestrictinfo);
1115         newnode->baserestrictcost = from->baserestrictcost;
1116         newnode->outerjoinset = listCopy(from->outerjoinset);
1117         Node_Copy(from, newnode, joininfo);
1118         Node_Copy(from, newnode, innerjoin);
1119
1120         return newnode;
1121 }
1122
1123 /* ----------------
1124  *              _copyIndexOptInfo
1125  * ----------------
1126  */
1127 static IndexOptInfo *
1128 _copyIndexOptInfo(IndexOptInfo *from)
1129 {
1130         IndexOptInfo *newnode = makeNode(IndexOptInfo);
1131         Size            len;
1132
1133         newnode->indexoid = from->indexoid;
1134         newnode->pages = from->pages;
1135         newnode->tuples = from->tuples;
1136
1137         newnode->ncolumns = from->ncolumns;
1138         newnode->nkeys = from->nkeys;
1139
1140         if (from->classlist)
1141         {
1142                 /* copy the trailing zero too */
1143                 len = (from->ncolumns + 1) * sizeof(Oid);
1144                 newnode->classlist = (Oid *) palloc(len);
1145                 memcpy(newnode->classlist, from->classlist, len);
1146         }
1147
1148         if (from->indexkeys)
1149         {
1150                 /* copy the trailing zero too */
1151                 len = (from->nkeys + 1) * sizeof(int);
1152                 newnode->indexkeys = (int *) palloc(len);
1153                 memcpy(newnode->indexkeys, from->indexkeys, len);
1154         }
1155
1156         if (from->ordering)
1157         {
1158                 /* copy the trailing zero too */
1159                 len = (from->ncolumns + 1) * sizeof(Oid);
1160                 newnode->ordering = (Oid *) palloc(len);
1161                 memcpy(newnode->ordering, from->ordering, len);
1162         }
1163
1164         newnode->relam = from->relam;
1165         newnode->amcostestimate = from->amcostestimate;
1166         newnode->indproc = from->indproc;
1167         Node_Copy(from, newnode, indpred);
1168         newnode->unique = from->unique;
1169
1170         return newnode;
1171 }
1172
1173 /* ----------------
1174  *              CopyPathFields
1175  *
1176  *              This function copies the fields of the Path node.  It is used by
1177  *              all the copy functions for classes which inherit from Path.
1178  * ----------------
1179  */
1180 static void
1181 CopyPathFields(Path *from, Path *newnode)
1182 {
1183         /*
1184          * Modify the next line, since it causes the copying to cycle (i.e.
1185          * the parent points right back here! -- JMH, 7/7/92. Old version:
1186          * Node_Copy(from, newnode, parent);
1187          */
1188         newnode->parent = from->parent;
1189
1190         newnode->startup_cost = from->startup_cost;
1191         newnode->total_cost = from->total_cost;
1192
1193         newnode->pathtype = from->pathtype;
1194
1195         Node_Copy(from, newnode, pathkeys);
1196 }
1197
1198 /* ----------------
1199  *              _copyPath
1200  * ----------------
1201  */
1202 static Path *
1203 _copyPath(Path *from)
1204 {
1205         Path       *newnode = makeNode(Path);
1206
1207         CopyPathFields(from, newnode);
1208
1209         return newnode;
1210 }
1211
1212 /* ----------------
1213  *              _copyIndexPath
1214  * ----------------
1215  */
1216 static IndexPath *
1217 _copyIndexPath(IndexPath *from)
1218 {
1219         IndexPath  *newnode = makeNode(IndexPath);
1220
1221         /*
1222          * copy the node superclass fields
1223          */
1224         CopyPathFields((Path *) from, (Path *) newnode);
1225
1226         /*
1227          * copy remainder of node
1228          */
1229         Node_Copy(from, newnode, indexinfo);
1230         Node_Copy(from, newnode, indexqual);
1231         newnode->indexscandir = from->indexscandir;
1232         newnode->joinrelids = listCopy(from->joinrelids);
1233         newnode->alljoinquals = from->alljoinquals;
1234         newnode->rows = from->rows;
1235
1236         return newnode;
1237 }
1238
1239 /* ----------------
1240  *                              _copyTidPath
1241  * ----------------
1242  */
1243 static TidPath *
1244 _copyTidPath(TidPath *from)
1245 {
1246         TidPath    *newnode = makeNode(TidPath);
1247
1248         /*
1249          * copy the node superclass fields
1250          */
1251         CopyPathFields((Path *) from, (Path *) newnode);
1252
1253         /*
1254          * copy remainder of node
1255          */
1256         Node_Copy(from, newnode, tideval);
1257         newnode->unjoined_relids = listCopy(from->unjoined_relids);
1258
1259         return newnode;
1260 }
1261
1262 /* ----------------
1263  *                              _copyAppendPath
1264  * ----------------
1265  */
1266 static AppendPath *
1267 _copyAppendPath(AppendPath *from)
1268 {
1269         AppendPath *newnode = makeNode(AppendPath);
1270
1271         /*
1272          * copy the node superclass fields
1273          */
1274         CopyPathFields((Path *) from, (Path *) newnode);
1275
1276         /*
1277          * copy remainder of node
1278          */
1279         Node_Copy(from, newnode, subpaths);
1280
1281         return newnode;
1282 }
1283
1284 /* ----------------
1285  *              CopyJoinPathFields
1286  *
1287  *              This function copies the fields of the JoinPath node.  It is used by
1288  *              all the copy functions for classes which inherit from JoinPath.
1289  * ----------------
1290  */
1291 static void
1292 CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
1293 {
1294         newnode->jointype = from->jointype;
1295         Node_Copy(from, newnode, outerjoinpath);
1296         Node_Copy(from, newnode, innerjoinpath);
1297         Node_Copy(from, newnode, joinrestrictinfo);
1298 }
1299
1300 /* ----------------
1301  *              _copyNestPath
1302  * ----------------
1303  */
1304 static NestPath *
1305 _copyNestPath(NestPath *from)
1306 {
1307         NestPath   *newnode = makeNode(NestPath);
1308
1309         /*
1310          * copy the node superclass fields
1311          */
1312         CopyPathFields((Path *) from, (Path *) newnode);
1313         CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1314
1315         return newnode;
1316 }
1317
1318 /* ----------------
1319  *              _copyMergePath
1320  * ----------------
1321  */
1322 static MergePath *
1323 _copyMergePath(MergePath *from)
1324 {
1325         MergePath  *newnode = makeNode(MergePath);
1326
1327         /*
1328          * copy the node superclass fields
1329          */
1330         CopyPathFields((Path *) from, (Path *) newnode);
1331         CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1332
1333         /*
1334          * copy the remainder of the node
1335          */
1336         Node_Copy(from, newnode, path_mergeclauses);
1337         Node_Copy(from, newnode, outersortkeys);
1338         Node_Copy(from, newnode, innersortkeys);
1339
1340         return newnode;
1341 }
1342
1343 /* ----------------
1344  *              _copyHashPath
1345  * ----------------
1346  */
1347 static HashPath *
1348 _copyHashPath(HashPath *from)
1349 {
1350         HashPath   *newnode = makeNode(HashPath);
1351
1352         /*
1353          * copy the node superclass fields
1354          */
1355         CopyPathFields((Path *) from, (Path *) newnode);
1356         CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1357
1358         /*
1359          * copy remainder of node
1360          */
1361         Node_Copy(from, newnode, path_hashclauses);
1362
1363         return newnode;
1364 }
1365
1366 /* ----------------
1367  *              _copyPathKeyItem
1368  * ----------------
1369  */
1370 static PathKeyItem *
1371 _copyPathKeyItem(PathKeyItem *from)
1372 {
1373         PathKeyItem *newnode = makeNode(PathKeyItem);
1374
1375         /*
1376          * copy remainder of node
1377          */
1378         Node_Copy(from, newnode, key);
1379         newnode->sortop = from->sortop;
1380
1381         return newnode;
1382 }
1383
1384 /* ----------------
1385  *              _copyRestrictInfo
1386  * ----------------
1387  */
1388 static RestrictInfo *
1389 _copyRestrictInfo(RestrictInfo *from)
1390 {
1391         RestrictInfo *newnode = makeNode(RestrictInfo);
1392
1393         /*
1394          * copy remainder of node
1395          */
1396         Node_Copy(from, newnode, clause);
1397         newnode->ispusheddown = from->ispusheddown;
1398         Node_Copy(from, newnode, subclauseindices);
1399         newnode->eval_cost = from->eval_cost;
1400         newnode->this_selec = from->this_selec;
1401         newnode->mergejoinoperator = from->mergejoinoperator;
1402         newnode->left_sortop = from->left_sortop;
1403         newnode->right_sortop = from->right_sortop;
1404
1405         /*
1406          * Do not copy pathkeys, since they'd not be canonical in a copied
1407          * query
1408          */
1409         newnode->left_pathkey = NIL;
1410         newnode->right_pathkey = NIL;
1411         newnode->left_mergescansel = from->left_mergescansel;
1412         newnode->right_mergescansel = from->right_mergescansel;
1413         newnode->hashjoinoperator = from->hashjoinoperator;
1414         newnode->left_bucketsize = from->left_bucketsize;
1415         newnode->right_bucketsize = from->right_bucketsize;
1416
1417         return newnode;
1418 }
1419
1420 /* ----------------
1421  *              _copyJoinInfo
1422  * ----------------
1423  */
1424 static JoinInfo *
1425 _copyJoinInfo(JoinInfo *from)
1426 {
1427         JoinInfo   *newnode = makeNode(JoinInfo);
1428
1429         /*
1430          * copy remainder of node
1431          */
1432         newnode->unjoined_relids = listCopy(from->unjoined_relids);
1433         Node_Copy(from, newnode, jinfo_restrictinfo);
1434
1435         return newnode;
1436 }
1437
1438 static Stream *
1439 _copyStream(Stream *from)
1440 {
1441         Stream     *newnode = makeNode(Stream);
1442
1443         newnode->pathptr = from->pathptr;
1444         newnode->cinfo = from->cinfo;
1445         newnode->clausetype = from->clausetype;
1446
1447         newnode->upstream = (StreamPtr) NULL;           /* only copy nodes
1448                                                                                                  * downwards! */
1449         Node_Copy(from, newnode, downstream);
1450         if (newnode->downstream)
1451                 ((Stream *) newnode->downstream)->upstream = (Stream *) newnode;
1452
1453         newnode->groupup = from->groupup;
1454         newnode->groupcost = from->groupcost;
1455         newnode->groupsel = from->groupsel;
1456
1457         return newnode;
1458 }
1459
1460 /* ****************************************************************
1461  *                                      parsenodes.h copy functions
1462  * ****************************************************************
1463  */
1464
1465 static TargetEntry *
1466 _copyTargetEntry(TargetEntry *from)
1467 {
1468         TargetEntry *newnode = makeNode(TargetEntry);
1469
1470         Node_Copy(from, newnode, resdom);
1471         Node_Copy(from, newnode, fjoin);
1472         Node_Copy(from, newnode, expr);
1473         return newnode;
1474 }
1475
1476 static RangeTblEntry *
1477 _copyRangeTblEntry(RangeTblEntry *from)
1478 {
1479         RangeTblEntry *newnode = makeNode(RangeTblEntry);
1480
1481         newnode->rtekind = from->rtekind;
1482         newnode->relid = from->relid;
1483         Node_Copy(from, newnode, subquery);
1484         Node_Copy(from, newnode, funcexpr);
1485         newnode->jointype = from->jointype;
1486         Node_Copy(from, newnode, joinaliasvars);
1487         Node_Copy(from, newnode, alias);
1488         Node_Copy(from, newnode, eref);
1489         newnode->inh = from->inh;
1490         newnode->inFromCl = from->inFromCl;
1491         newnode->checkForRead = from->checkForRead;
1492         newnode->checkForWrite = from->checkForWrite;
1493         newnode->checkAsUser = from->checkAsUser;
1494
1495         return newnode;
1496 }
1497
1498 static FkConstraint *
1499 _copyFkConstraint(FkConstraint *from)
1500 {
1501         FkConstraint *newnode = makeNode(FkConstraint);
1502
1503         if (from->constr_name)
1504                 newnode->constr_name = pstrdup(from->constr_name);
1505         Node_Copy(from, newnode, pktable);
1506         Node_Copy(from, newnode, fk_attrs);
1507         Node_Copy(from, newnode, pk_attrs);
1508         if (from->match_type)
1509                 newnode->match_type = pstrdup(from->match_type);
1510         newnode->actions = from->actions;
1511         newnode->deferrable = from->deferrable;
1512         newnode->initdeferred = from->initdeferred;
1513
1514         return newnode;
1515 }
1516
1517 static SortClause *
1518 _copySortClause(SortClause *from)
1519 {
1520         SortClause *newnode = makeNode(SortClause);
1521
1522         newnode->tleSortGroupRef = from->tleSortGroupRef;
1523         newnode->sortop = from->sortop;
1524
1525         return newnode;
1526 }
1527
1528 static A_Expr *
1529 _copyAExpr(A_Expr *from)
1530 {
1531         A_Expr     *newnode = makeNode(A_Expr);
1532
1533         newnode->oper = from->oper;
1534         Node_Copy(from, newnode, name);
1535         Node_Copy(from, newnode, lexpr);
1536         Node_Copy(from, newnode, rexpr);
1537
1538         return newnode;
1539 }
1540
1541 static ColumnRef *
1542 _copyColumnRef(ColumnRef *from)
1543 {
1544         ColumnRef          *newnode = makeNode(ColumnRef);
1545
1546         Node_Copy(from, newnode, fields);
1547         Node_Copy(from, newnode, indirection);
1548
1549         return newnode;
1550 }
1551
1552 static ParamRef *
1553 _copyParamRef(ParamRef *from)
1554 {
1555         ParamRef    *newnode = makeNode(ParamRef);
1556
1557         newnode->number = from->number;
1558         Node_Copy(from, newnode, fields);
1559         Node_Copy(from, newnode, indirection);
1560
1561         return newnode;
1562 }
1563
1564 static A_Const *
1565 _copyAConst(A_Const *from)
1566 {
1567         A_Const    *newnode = makeNode(A_Const);
1568
1569         newnode->val = *((Value *) (copyObject(&(from->val))));
1570         Node_Copy(from, newnode, typename);
1571
1572         return newnode;
1573 }
1574
1575 static Ident *
1576 _copyIdent(Ident *from)
1577 {
1578         Ident      *newnode = makeNode(Ident);
1579
1580         newnode->name = pstrdup(from->name);
1581
1582         return newnode;
1583 }
1584
1585 static FuncCall *
1586 _copyFuncCall(FuncCall *from)
1587 {
1588         FuncCall   *newnode = makeNode(FuncCall);
1589
1590         Node_Copy(from, newnode, funcname);
1591         Node_Copy(from, newnode, args);
1592         newnode->agg_star = from->agg_star;
1593         newnode->agg_distinct = from->agg_distinct;
1594
1595         return newnode;
1596 }
1597
1598 static A_Indices *
1599 _copyAIndices(A_Indices *from)
1600 {
1601         A_Indices  *newnode = makeNode(A_Indices);
1602
1603         Node_Copy(from, newnode, lidx);
1604         Node_Copy(from, newnode, uidx);
1605
1606         return newnode;
1607 }
1608
1609 static ExprFieldSelect *
1610 _copyExprFieldSelect(ExprFieldSelect *from)
1611 {
1612         ExprFieldSelect    *newnode = makeNode(ExprFieldSelect);
1613
1614         Node_Copy(from, newnode, arg);
1615         Node_Copy(from, newnode, fields);
1616         Node_Copy(from, newnode, indirection);
1617
1618         return newnode;
1619 }
1620
1621 static ResTarget *
1622 _copyResTarget(ResTarget *from)
1623 {
1624         ResTarget  *newnode = makeNode(ResTarget);
1625
1626         if (from->name)
1627                 newnode->name = pstrdup(from->name);
1628         Node_Copy(from, newnode, indirection);
1629         Node_Copy(from, newnode, val);
1630
1631         return newnode;
1632 }
1633
1634 static TypeName *
1635 _copyTypeName(TypeName *from)
1636 {
1637         TypeName   *newnode = makeNode(TypeName);
1638
1639         Node_Copy(from, newnode, names);
1640         newnode->typeid = from->typeid;
1641         newnode->timezone = from->timezone;
1642         newnode->setof = from->setof;
1643         newnode->pct_type = from->pct_type;
1644         newnode->typmod = from->typmod;
1645         Node_Copy(from, newnode, arrayBounds);
1646
1647         return newnode;
1648 }
1649
1650 static SortGroupBy *
1651 _copySortGroupBy(SortGroupBy *from)
1652 {
1653         SortGroupBy *newnode = makeNode(SortGroupBy);
1654
1655         Node_Copy(from, newnode, useOp);
1656         Node_Copy(from, newnode, node);
1657
1658         return newnode;
1659 }
1660
1661 static Alias *
1662 _copyAlias(Alias *from)
1663 {
1664         Alias      *newnode = makeNode(Alias);
1665
1666         if (from->aliasname)
1667                 newnode->aliasname = pstrdup(from->aliasname);
1668         Node_Copy(from, newnode, colnames);
1669
1670         return newnode;
1671 }
1672
1673 static RangeVar *
1674 _copyRangeVar(RangeVar *from)
1675 {
1676         RangeVar   *newnode = makeNode(RangeVar);
1677
1678         if (from->catalogname)
1679                 newnode->catalogname = pstrdup(from->catalogname);
1680         if (from->schemaname)
1681                 newnode->schemaname = pstrdup(from->schemaname);
1682         if (from->relname)
1683                 newnode->relname = pstrdup(from->relname);
1684         newnode->inhOpt = from->inhOpt;
1685         newnode->istemp = from->istemp;
1686         Node_Copy(from, newnode, alias);
1687
1688         return newnode;
1689 }
1690
1691 static RangeSubselect *
1692 _copyRangeSubselect(RangeSubselect *from)
1693 {
1694         RangeSubselect *newnode = makeNode(RangeSubselect);
1695
1696         Node_Copy(from, newnode, subquery);
1697         Node_Copy(from, newnode, alias);
1698
1699         return newnode;
1700 }
1701
1702 static RangeFunction *
1703 _copyRangeFunction(RangeFunction *from)
1704 {
1705         RangeFunction   *newnode = makeNode(RangeFunction);
1706
1707         Node_Copy(from, newnode, funccallnode);
1708         Node_Copy(from, newnode, alias);
1709
1710         return newnode;
1711 }
1712
1713 static TypeCast *
1714 _copyTypeCast(TypeCast *from)
1715 {
1716         TypeCast   *newnode = makeNode(TypeCast);
1717
1718         Node_Copy(from, newnode, arg);
1719         Node_Copy(from, newnode, typename);
1720
1721         return newnode;
1722 }
1723
1724 static IndexElem *
1725 _copyIndexElem(IndexElem *from)
1726 {
1727         IndexElem  *newnode = makeNode(IndexElem);
1728
1729         if (from->name)
1730                 newnode->name = pstrdup(from->name);
1731         Node_Copy(from, newnode, funcname);
1732         Node_Copy(from, newnode, args);
1733         Node_Copy(from, newnode, opclass);
1734
1735         return newnode;
1736 }
1737
1738 static ColumnDef *
1739 _copyColumnDef(ColumnDef *from)
1740 {
1741         ColumnDef  *newnode = makeNode(ColumnDef);
1742
1743         if (from->colname)
1744                 newnode->colname = pstrdup(from->colname);
1745         Node_Copy(from, newnode, typename);
1746         newnode->is_not_null = from->is_not_null;
1747         Node_Copy(from, newnode, raw_default);
1748         if (from->cooked_default)
1749                 newnode->cooked_default = pstrdup(from->cooked_default);
1750         Node_Copy(from, newnode, constraints);
1751
1752         return newnode;
1753 }
1754
1755 static Constraint *
1756 _copyConstraint(Constraint *from)
1757 {
1758         Constraint *newnode = makeNode(Constraint);
1759
1760         newnode->contype = from->contype;
1761         if (from->name)
1762                 newnode->name = pstrdup(from->name);
1763         Node_Copy(from, newnode, raw_expr);
1764         if (from->cooked_expr)
1765                 newnode->cooked_expr = pstrdup(from->cooked_expr);
1766         Node_Copy(from, newnode, keys);
1767
1768         return newnode;
1769 }
1770
1771 static DefElem *
1772 _copyDefElem(DefElem *from)
1773 {
1774         DefElem    *newnode = makeNode(DefElem);
1775
1776         if (from->defname)
1777                 newnode->defname = pstrdup(from->defname);
1778         Node_Copy(from, newnode, arg);
1779
1780         return newnode;
1781 }
1782
1783 static Query *
1784 _copyQuery(Query *from)
1785 {
1786         Query      *newnode = makeNode(Query);
1787
1788         newnode->commandType = from->commandType;
1789         Node_Copy(from, newnode, utilityStmt);
1790         newnode->resultRelation = from->resultRelation;
1791         Node_Copy(from, newnode, into);
1792         newnode->isPortal = from->isPortal;
1793         newnode->isBinary = from->isBinary;
1794         newnode->hasAggs = from->hasAggs;
1795         newnode->hasSubLinks = from->hasSubLinks;
1796         newnode->originalQuery = from->originalQuery;
1797
1798         Node_Copy(from, newnode, rtable);
1799         Node_Copy(from, newnode, jointree);
1800
1801         newnode->rowMarks = listCopy(from->rowMarks);
1802
1803         Node_Copy(from, newnode, targetList);
1804
1805         Node_Copy(from, newnode, groupClause);
1806         Node_Copy(from, newnode, havingQual);
1807         Node_Copy(from, newnode, distinctClause);
1808         Node_Copy(from, newnode, sortClause);
1809
1810         Node_Copy(from, newnode, limitOffset);
1811         Node_Copy(from, newnode, limitCount);
1812
1813         Node_Copy(from, newnode, setOperations);
1814
1815         newnode->resultRelations = listCopy(from->resultRelations);
1816
1817         /*
1818          * We do not copy the planner internal fields: base_rel_list,
1819          * other_rel_list, join_rel_list, equi_key_list, query_pathkeys. Not
1820          * entirely clear if this is right?
1821          */
1822
1823         return newnode;
1824 }
1825
1826 static InsertStmt *
1827 _copyInsertStmt(InsertStmt *from)
1828 {
1829         InsertStmt *newnode = makeNode(InsertStmt);
1830
1831         Node_Copy(from, newnode, relation);
1832         Node_Copy(from, newnode, cols);
1833         Node_Copy(from, newnode, targetList);
1834         Node_Copy(from, newnode, selectStmt);
1835
1836         return newnode;
1837 }
1838
1839 static DeleteStmt *
1840 _copyDeleteStmt(DeleteStmt *from)
1841 {
1842         DeleteStmt *newnode = makeNode(DeleteStmt);
1843
1844         Node_Copy(from, newnode, relation);
1845         Node_Copy(from, newnode, whereClause);
1846
1847         return newnode;
1848 }
1849
1850 static UpdateStmt *
1851 _copyUpdateStmt(UpdateStmt *from)
1852 {
1853         UpdateStmt *newnode = makeNode(UpdateStmt);
1854
1855         Node_Copy(from, newnode, relation);
1856         Node_Copy(from, newnode, targetList);
1857         Node_Copy(from, newnode, whereClause);
1858         Node_Copy(from, newnode, fromClause);
1859
1860         return newnode;
1861 }
1862
1863 static SelectStmt *
1864 _copySelectStmt(SelectStmt *from)
1865 {
1866         SelectStmt *newnode = makeNode(SelectStmt);
1867
1868         Node_Copy(from, newnode, distinctClause);
1869         Node_Copy(from, newnode, into);
1870         Node_Copy(from, newnode, intoColNames);
1871         Node_Copy(from, newnode, targetList);
1872         Node_Copy(from, newnode, fromClause);
1873         Node_Copy(from, newnode, whereClause);
1874         Node_Copy(from, newnode, groupClause);
1875         Node_Copy(from, newnode, havingClause);
1876         Node_Copy(from, newnode, sortClause);
1877         if (from->portalname)
1878                 newnode->portalname = pstrdup(from->portalname);
1879         newnode->binary = from->binary;
1880         Node_Copy(from, newnode, limitOffset);
1881         Node_Copy(from, newnode, limitCount);
1882         Node_Copy(from, newnode, forUpdate);
1883         newnode->op = from->op;
1884         newnode->all = from->all;
1885         Node_Copy(from, newnode, larg);
1886         Node_Copy(from, newnode, rarg);
1887
1888         return newnode;
1889 }
1890
1891 static SetOperationStmt *
1892 _copySetOperationStmt(SetOperationStmt *from)
1893 {
1894         SetOperationStmt *newnode = makeNode(SetOperationStmt);
1895
1896         newnode->op = from->op;
1897         newnode->all = from->all;
1898         Node_Copy(from, newnode, larg);
1899         Node_Copy(from, newnode, rarg);
1900         newnode->colTypes = listCopy(from->colTypes);
1901
1902         return newnode;
1903 }
1904
1905 static AlterTableStmt *
1906 _copyAlterTableStmt(AlterTableStmt *from)
1907 {
1908         AlterTableStmt *newnode = makeNode(AlterTableStmt);
1909
1910         newnode->subtype = from->subtype;
1911         Node_Copy(from, newnode, relation);
1912         if (from->name)
1913                 newnode->name = pstrdup(from->name);
1914         Node_Copy(from, newnode, def);
1915         newnode->behavior = from->behavior;
1916
1917         return newnode;
1918 }
1919
1920 static GrantStmt *
1921 _copyGrantStmt(GrantStmt *from)
1922 {
1923         GrantStmt  *newnode = makeNode(GrantStmt);
1924
1925         newnode->is_grant = from->is_grant;
1926         newnode->objtype = from->objtype;
1927         Node_Copy(from, newnode, objects);
1928         newnode->privileges = listCopy(from->privileges);
1929         Node_Copy(from, newnode, grantees);
1930
1931         return newnode;
1932 }
1933
1934 static PrivGrantee *
1935 _copyPrivGrantee(PrivGrantee *from)
1936 {
1937         PrivGrantee *newnode = makeNode(PrivGrantee);
1938
1939         if (from->username)
1940                 newnode->username = pstrdup(from->username);
1941         if (from->groupname)
1942                 newnode->groupname = pstrdup(from->groupname);
1943
1944         return newnode;
1945 }
1946
1947 static FuncWithArgs *
1948 _copyFuncWithArgs(FuncWithArgs *from)
1949 {
1950         FuncWithArgs *newnode = makeNode(FuncWithArgs);
1951
1952         Node_Copy(from, newnode, funcname);
1953         Node_Copy(from, newnode, funcargs);
1954
1955         return newnode;
1956 }
1957
1958 static InsertDefault *
1959 _copyInsertDefault(InsertDefault *from)
1960 {
1961         InsertDefault *newnode = makeNode(InsertDefault);
1962
1963         return newnode;
1964 }
1965
1966
1967 static ClosePortalStmt *
1968 _copyClosePortalStmt(ClosePortalStmt *from)
1969 {
1970         ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
1971
1972         if (from->portalname)
1973                 newnode->portalname = pstrdup(from->portalname);
1974
1975         return newnode;
1976 }
1977
1978 static ClusterStmt *
1979 _copyClusterStmt(ClusterStmt *from)
1980 {
1981         ClusterStmt *newnode = makeNode(ClusterStmt);
1982
1983         Node_Copy(from, newnode, relation);
1984         if (from->indexname)
1985                 newnode->indexname = pstrdup(from->indexname);
1986
1987         return newnode;
1988 }
1989
1990 static CopyStmt *
1991 _copyCopyStmt(CopyStmt *from)
1992 {
1993         CopyStmt   *newnode = makeNode(CopyStmt);
1994
1995         newnode->binary = from->binary;
1996         Node_Copy(from, newnode, relation);
1997         newnode->oids = from->oids;
1998         newnode->direction = from->direction;
1999         if (from->filename)
2000                 newnode->filename = pstrdup(from->filename);
2001         if (from->delimiter)
2002                 newnode->delimiter = pstrdup(from->delimiter);
2003         if (from->null_print)
2004                 newnode->null_print = pstrdup(from->null_print);
2005
2006         return newnode;
2007 }
2008
2009 static CreateStmt *
2010 _copyCreateStmt(CreateStmt *from)
2011 {
2012         CreateStmt *newnode = makeNode(CreateStmt);
2013
2014         Node_Copy(from, newnode, relation);
2015         Node_Copy(from, newnode, tableElts);
2016         Node_Copy(from, newnode, inhRelations);
2017         Node_Copy(from, newnode, constraints);
2018         newnode->hasoids = from->hasoids;
2019
2020         return newnode;
2021 }
2022
2023 static DefineStmt *
2024 _copyDefineStmt(DefineStmt *from)
2025 {
2026         DefineStmt *newnode = makeNode(DefineStmt);
2027
2028         newnode->defType = from->defType;
2029         Node_Copy(from, newnode, defnames);
2030         Node_Copy(from, newnode, definition);
2031
2032         return newnode;
2033 }
2034
2035 static DropStmt *
2036 _copyDropStmt(DropStmt *from)
2037 {
2038         DropStmt   *newnode = makeNode(DropStmt);
2039
2040         Node_Copy(from, newnode, objects);
2041         newnode->removeType = from->removeType;
2042         newnode->behavior = from->behavior;
2043
2044         return newnode;
2045 }
2046
2047 static TruncateStmt *
2048 _copyTruncateStmt(TruncateStmt *from)
2049 {
2050         TruncateStmt *newnode = makeNode(TruncateStmt);
2051
2052         Node_Copy(from, newnode, relation);
2053
2054         return newnode;
2055 }
2056
2057 static CommentStmt *
2058 _copyCommentStmt(CommentStmt *from)
2059 {
2060         CommentStmt *newnode = makeNode(CommentStmt);
2061
2062         newnode->objtype = from->objtype;
2063         Node_Copy(from, newnode, objname);
2064         Node_Copy(from, newnode, objargs);
2065         if (from->comment)
2066                 newnode->comment = pstrdup(from->comment);
2067
2068         return newnode;
2069 }
2070
2071 static FetchStmt *
2072 _copyFetchStmt(FetchStmt *from)
2073 {
2074         FetchStmt  *newnode = makeNode(FetchStmt);
2075
2076         newnode->direction = from->direction;
2077         newnode->howMany = from->howMany;
2078         newnode->portalname = pstrdup(from->portalname);
2079         newnode->ismove = from->ismove;
2080
2081         return newnode;
2082 }
2083
2084 static IndexStmt *
2085 _copyIndexStmt(IndexStmt *from)
2086 {
2087         IndexStmt  *newnode = makeNode(IndexStmt);
2088
2089         newnode->idxname = pstrdup(from->idxname);
2090         Node_Copy(from, newnode, relation);
2091         newnode->accessMethod = pstrdup(from->accessMethod);
2092         Node_Copy(from, newnode, indexParams);
2093         Node_Copy(from, newnode, whereClause);
2094         Node_Copy(from, newnode, rangetable);
2095         newnode->unique = from->unique;
2096         newnode->primary = from->primary;
2097
2098         return newnode;
2099 }
2100
2101 static ProcedureStmt *
2102 _copyProcedureStmt(ProcedureStmt *from)
2103 {
2104         ProcedureStmt *newnode = makeNode(ProcedureStmt);
2105
2106         newnode->replace = from->replace;
2107         Node_Copy(from, newnode, funcname);
2108         Node_Copy(from, newnode, argTypes);
2109         Node_Copy(from, newnode, returnType);
2110         Node_Copy(from, newnode, withClause);
2111         Node_Copy(from, newnode, as);
2112         newnode->language = pstrdup(from->language);
2113
2114         return newnode;
2115 }
2116
2117 static RemoveAggrStmt *
2118 _copyRemoveAggrStmt(RemoveAggrStmt *from)
2119 {
2120         RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
2121
2122         Node_Copy(from, newnode, aggname);
2123         Node_Copy(from, newnode, aggtype);
2124
2125         return newnode;
2126 }
2127
2128 static RemoveFuncStmt *
2129 _copyRemoveFuncStmt(RemoveFuncStmt *from)
2130 {
2131         RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
2132
2133         Node_Copy(from, newnode, funcname);
2134         Node_Copy(from, newnode, args);
2135
2136         return newnode;
2137 }
2138
2139 static RemoveOperStmt *
2140 _copyRemoveOperStmt(RemoveOperStmt *from)
2141 {
2142         RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
2143
2144         Node_Copy(from, newnode, opname);
2145         Node_Copy(from, newnode, args);
2146
2147         return newnode;
2148 }
2149
2150 static RenameStmt *
2151 _copyRenameStmt(RenameStmt *from)
2152 {
2153         RenameStmt *newnode = makeNode(RenameStmt);
2154
2155         Node_Copy(from, newnode, relation);
2156         if (from->oldname)
2157                 newnode->oldname = pstrdup(from->oldname);
2158         if (from->newname)
2159                 newnode->newname = pstrdup(from->newname);
2160         newnode->renameType = from->renameType;
2161
2162         return newnode;
2163 }
2164
2165 static RuleStmt *
2166 _copyRuleStmt(RuleStmt *from)
2167 {
2168         RuleStmt   *newnode = makeNode(RuleStmt);
2169
2170         Node_Copy(from, newnode, relation);
2171         newnode->rulename = pstrdup(from->rulename);
2172         Node_Copy(from, newnode, whereClause);
2173         newnode->event = from->event;
2174         newnode->instead = from->instead;
2175         Node_Copy(from, newnode, actions);
2176
2177         return newnode;
2178 }
2179
2180 static NotifyStmt *
2181 _copyNotifyStmt(NotifyStmt *from)
2182 {
2183         NotifyStmt *newnode = makeNode(NotifyStmt);
2184
2185         Node_Copy(from, newnode, relation);
2186
2187         return newnode;
2188 }
2189
2190 static ListenStmt *
2191 _copyListenStmt(ListenStmt *from)
2192 {
2193         ListenStmt *newnode = makeNode(ListenStmt);
2194
2195         Node_Copy(from, newnode, relation);
2196
2197         return newnode;
2198 }
2199
2200 static UnlistenStmt *
2201 _copyUnlistenStmt(UnlistenStmt *from)
2202 {
2203         UnlistenStmt *newnode = makeNode(UnlistenStmt);
2204
2205         Node_Copy(from, newnode, relation);
2206
2207         return newnode;
2208 }
2209
2210 static TransactionStmt *
2211 _copyTransactionStmt(TransactionStmt *from)
2212 {
2213         TransactionStmt *newnode = makeNode(TransactionStmt);
2214
2215         newnode->command = from->command;
2216
2217         return newnode;
2218 }
2219
2220 static ViewStmt *
2221 _copyViewStmt(ViewStmt *from)
2222 {
2223         ViewStmt   *newnode = makeNode(ViewStmt);
2224
2225         Node_Copy(from, newnode, view);
2226         Node_Copy(from, newnode, aliases);
2227         Node_Copy(from, newnode, query);
2228
2229         return newnode;
2230 }
2231
2232 static LoadStmt *
2233 _copyLoadStmt(LoadStmt *from)
2234 {
2235         LoadStmt   *newnode = makeNode(LoadStmt);
2236
2237         if (from->filename)
2238                 newnode->filename = pstrdup(from->filename);
2239
2240         return newnode;
2241 }
2242
2243 static CreateDomainStmt *
2244 _copyCreateDomainStmt(CreateDomainStmt *from)
2245 {
2246         CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
2247
2248         Node_Copy(from, newnode, domainname);
2249         Node_Copy(from, newnode, typename);
2250         Node_Copy(from, newnode, constraints);
2251
2252         return newnode;
2253 }
2254
2255 static CreatedbStmt *
2256 _copyCreatedbStmt(CreatedbStmt *from)
2257 {
2258         CreatedbStmt *newnode = makeNode(CreatedbStmt);
2259
2260         if (from->dbname)
2261                 newnode->dbname = pstrdup(from->dbname);
2262         if (from->dbowner)
2263                 newnode->dbowner = pstrdup(from->dbowner);
2264         if (from->dbpath)
2265                 newnode->dbpath = pstrdup(from->dbpath);
2266         if (from->dbtemplate)
2267                 newnode->dbtemplate = pstrdup(from->dbtemplate);
2268         newnode->encoding = from->encoding;
2269
2270         return newnode;
2271 }
2272
2273 static AlterDatabaseSetStmt *
2274 _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
2275 {
2276         AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
2277
2278         if (from->dbname)
2279                 newnode->dbname = pstrdup(from->dbname);
2280         if (from->variable)
2281                 newnode->variable = pstrdup(from->variable);
2282         Node_Copy(from, newnode, value);
2283
2284         return newnode;
2285 }
2286
2287 static DropdbStmt *
2288 _copyDropdbStmt(DropdbStmt *from)
2289 {
2290         DropdbStmt *newnode = makeNode(DropdbStmt);
2291
2292         if (from->dbname)
2293                 newnode->dbname = pstrdup(from->dbname);
2294
2295         return newnode;
2296 }
2297
2298 static VacuumStmt *
2299 _copyVacuumStmt(VacuumStmt *from)
2300 {
2301         VacuumStmt *newnode = makeNode(VacuumStmt);
2302
2303         newnode->vacuum = from->vacuum;
2304         newnode->full = from->full;
2305         newnode->analyze = from->analyze;
2306         newnode->freeze = from->freeze;
2307         newnode->verbose = from->verbose;
2308         Node_Copy(from, newnode, relation);
2309         Node_Copy(from, newnode, va_cols);
2310
2311         return newnode;
2312 }
2313
2314 static ExplainStmt *
2315 _copyExplainStmt(ExplainStmt *from)
2316 {
2317         ExplainStmt *newnode = makeNode(ExplainStmt);
2318
2319         Node_Copy(from, newnode, query);
2320         newnode->verbose = from->verbose;
2321         newnode->analyze = from->analyze;
2322
2323         return newnode;
2324 }
2325
2326 static CreateSeqStmt *
2327 _copyCreateSeqStmt(CreateSeqStmt *from)
2328 {
2329         CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
2330
2331         Node_Copy(from, newnode, sequence);
2332         Node_Copy(from, newnode, options);
2333
2334         return newnode;
2335 }
2336
2337 static VariableSetStmt *
2338 _copyVariableSetStmt(VariableSetStmt *from)
2339 {
2340         VariableSetStmt *newnode = makeNode(VariableSetStmt);
2341
2342         if (from->name)
2343                 newnode->name = pstrdup(from->name);
2344         Node_Copy(from, newnode, args);
2345
2346         return newnode;
2347 }
2348
2349 static VariableShowStmt *
2350 _copyVariableShowStmt(VariableShowStmt *from)
2351 {
2352         VariableShowStmt *newnode = makeNode(VariableShowStmt);
2353
2354         if (from->name)
2355                 newnode->name = pstrdup(from->name);
2356
2357         return newnode;
2358 }
2359
2360 static VariableResetStmt *
2361 _copyVariableResetStmt(VariableResetStmt *from)
2362 {
2363         VariableResetStmt *newnode = makeNode(VariableResetStmt);
2364
2365         if (from->name)
2366                 newnode->name = pstrdup(from->name);
2367
2368         return newnode;
2369 }
2370
2371 static CreateTrigStmt *
2372 _copyCreateTrigStmt(CreateTrigStmt *from)
2373 {
2374         CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
2375
2376         if (from->trigname)
2377                 newnode->trigname = pstrdup(from->trigname);
2378         Node_Copy(from, newnode, relation);
2379         Node_Copy(from, newnode, funcname);
2380         Node_Copy(from, newnode, args);
2381         newnode->before = from->before;
2382         newnode->row = from->row;
2383         memcpy(newnode->actions, from->actions, sizeof(from->actions));
2384         if (from->lang)
2385                 newnode->lang = pstrdup(from->lang);
2386         if (from->text)
2387                 newnode->text = pstrdup(from->text);
2388
2389         Node_Copy(from, newnode, attr);
2390         if (from->when)
2391                 newnode->when = pstrdup(from->when);
2392         newnode->isconstraint = from->isconstraint;
2393         newnode->deferrable = from->deferrable;
2394         newnode->initdeferred = from->initdeferred;
2395         Node_Copy(from, newnode, constrrel);
2396
2397         return newnode;
2398 }
2399
2400 static DropPropertyStmt *
2401 _copyDropPropertyStmt(DropPropertyStmt *from)
2402 {
2403         DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
2404
2405         Node_Copy(from, newnode, relation);
2406         if (from->property)
2407                 newnode->property = pstrdup(from->property);
2408         newnode->removeType = from->removeType;
2409
2410         return newnode;
2411 }
2412
2413 static CreatePLangStmt *
2414 _copyCreatePLangStmt(CreatePLangStmt *from)
2415 {
2416         CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
2417
2418         if (from->plname)
2419                 newnode->plname = pstrdup(from->plname);
2420         Node_Copy(from, newnode, plhandler);
2421         if (from->plcompiler)
2422                 newnode->plcompiler = pstrdup(from->plcompiler);
2423         newnode->pltrusted = from->pltrusted;
2424
2425         return newnode;
2426 }
2427
2428 static DropPLangStmt *
2429 _copyDropPLangStmt(DropPLangStmt *from)
2430 {
2431         DropPLangStmt *newnode = makeNode(DropPLangStmt);
2432
2433         if (from->plname)
2434                 newnode->plname = pstrdup(from->plname);
2435
2436         return newnode;
2437 }
2438
2439 static CreateUserStmt *
2440 _copyCreateUserStmt(CreateUserStmt *from)
2441 {
2442         CreateUserStmt *newnode = makeNode(CreateUserStmt);
2443
2444         if (from->user)
2445                 newnode->user = pstrdup(from->user);
2446         Node_Copy(from, newnode, options);
2447
2448         return newnode;
2449 }
2450
2451 static AlterUserStmt *
2452 _copyAlterUserStmt(AlterUserStmt *from)
2453 {
2454         AlterUserStmt *newnode = makeNode(AlterUserStmt);
2455
2456         if (from->user)
2457                 newnode->user = pstrdup(from->user);
2458         Node_Copy(from, newnode, options);
2459
2460         return newnode;
2461 }
2462
2463 static AlterUserSetStmt *
2464 _copyAlterUserSetStmt(AlterUserSetStmt *from)
2465 {
2466         AlterUserSetStmt *newnode = makeNode(AlterUserSetStmt);
2467
2468         if (from->user)
2469                 newnode->user = pstrdup(from->user);
2470         if (from->variable)
2471                 newnode->user = pstrdup(from->variable);
2472         Node_Copy(from, newnode, value);
2473
2474         return newnode;
2475 }
2476
2477 static DropUserStmt *
2478 _copyDropUserStmt(DropUserStmt *from)
2479 {
2480         DropUserStmt *newnode = makeNode(DropUserStmt);
2481
2482         Node_Copy(from, newnode, users);
2483
2484         return newnode;
2485 }
2486
2487 static LockStmt *
2488 _copyLockStmt(LockStmt *from)
2489 {
2490         LockStmt   *newnode = makeNode(LockStmt);
2491
2492         Node_Copy(from, newnode, relations);
2493
2494         newnode->mode = from->mode;
2495
2496         return newnode;
2497 }
2498
2499 static ConstraintsSetStmt *
2500 _copyConstraintsSetStmt(ConstraintsSetStmt *from)
2501 {
2502         ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
2503
2504         Node_Copy(from, newnode, constraints);
2505         newnode->deferred = from->deferred;
2506
2507         return newnode;
2508 }
2509
2510 static CreateGroupStmt *
2511 _copyCreateGroupStmt(CreateGroupStmt *from)
2512 {
2513         CreateGroupStmt *newnode = makeNode(CreateGroupStmt);
2514
2515         if (from->name)
2516                 newnode->name = pstrdup(from->name);
2517         Node_Copy(from, newnode, options);
2518
2519         return newnode;
2520 }
2521
2522 static AlterGroupStmt *
2523 _copyAlterGroupStmt(AlterGroupStmt *from)
2524 {
2525         AlterGroupStmt *newnode = makeNode(AlterGroupStmt);
2526
2527         if (from->name)
2528                 newnode->name = pstrdup(from->name);
2529         newnode->action = from->action;
2530         Node_Copy(from, newnode, listUsers);
2531
2532         return newnode;
2533 }
2534
2535 static DropGroupStmt *
2536 _copyDropGroupStmt(DropGroupStmt *from)
2537 {
2538         DropGroupStmt *newnode = makeNode(DropGroupStmt);
2539
2540         if (from->name)
2541                 newnode->name = pstrdup(from->name);
2542
2543         return newnode;
2544 }
2545
2546 static ReindexStmt *
2547 _copyReindexStmt(ReindexStmt *from)
2548 {
2549         ReindexStmt *newnode = makeNode(ReindexStmt);
2550
2551         newnode->reindexType = from->reindexType;
2552         Node_Copy(from, newnode, relation);
2553         if (from->name)
2554                 newnode->name = pstrdup(from->name);
2555         newnode->force = from->force;
2556         newnode->all = from->all;
2557
2558         return newnode;
2559 }
2560
2561 static CreateSchemaStmt *
2562 _copyCreateSchemaStmt(CreateSchemaStmt *from)
2563 {
2564         CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
2565
2566         newnode->schemaname = pstrdup(from->schemaname);
2567         if (from->authid)
2568                 newnode->authid = pstrdup(from->authid);
2569         Node_Copy(from, newnode, schemaElts);
2570
2571         return newnode;
2572 }
2573
2574
2575 /* ****************************************************************
2576  *                                      pg_list.h copy functions
2577  * ****************************************************************
2578  */
2579
2580 static Value *
2581 _copyValue(Value *from)
2582 {
2583         Value      *newnode = makeNode(Value);
2584
2585         newnode->type = from->type;
2586         switch (from->type)
2587         {
2588                 case T_Integer:
2589                         newnode->val.ival = from->val.ival;
2590                         break;
2591                 case T_Float:
2592                 case T_String:
2593                 case T_BitString:
2594                         newnode->val.str = pstrdup(from->val.str);
2595                         break;
2596                 default:
2597                         break;
2598         }
2599         return newnode;
2600 }
2601
2602 /* ----------------
2603  *              copyObject returns a copy of the node or list. If it is a list, it
2604  *              recursively copies its items.
2605  * ----------------
2606  */
2607 void *
2608 copyObject(void *from)
2609 {
2610         void       *retval;
2611
2612         if (from == NULL)
2613                 return NULL;
2614
2615         switch (nodeTag(from))
2616         {
2617                         /*
2618                          * PLAN NODES
2619                          */
2620                 case T_Plan:
2621                         retval = _copyPlan(from);
2622                         break;
2623                 case T_Result:
2624                         retval = _copyResult(from);
2625                         break;
2626                 case T_Append:
2627                         retval = _copyAppend(from);
2628                         break;
2629                 case T_Scan:
2630                         retval = _copyScan(from);
2631                         break;
2632                 case T_SeqScan:
2633                         retval = _copySeqScan(from);
2634                         break;
2635                 case T_IndexScan:
2636                         retval = _copyIndexScan(from);
2637                         break;
2638                 case T_TidScan:
2639                         retval = _copyTidScan(from);
2640                         break;
2641                 case T_SubqueryScan:
2642                         retval = _copySubqueryScan(from);
2643                         break;
2644                 case T_FunctionScan:
2645                         retval = _copyFunctionScan(from);
2646                         break;
2647                 case T_Join:
2648                         retval = _copyJoin(from);
2649                         break;
2650                 case T_NestLoop:
2651                         retval = _copyNestLoop(from);
2652                         break;
2653                 case T_MergeJoin:
2654                         retval = _copyMergeJoin(from);
2655                         break;
2656                 case T_HashJoin:
2657                         retval = _copyHashJoin(from);
2658                         break;
2659                 case T_Material:
2660                         retval = _copyMaterial(from);
2661                         break;
2662                 case T_Sort:
2663                         retval = _copySort(from);
2664                         break;
2665                 case T_Group:
2666                         retval = _copyGroup(from);
2667                         break;
2668                 case T_Agg:
2669                         retval = _copyAgg(from);
2670                         break;
2671                 case T_Unique:
2672                         retval = _copyUnique(from);
2673                         break;
2674                 case T_SetOp:
2675                         retval = _copySetOp(from);
2676                         break;
2677                 case T_Limit:
2678                         retval = _copyLimit(from);
2679                         break;
2680                 case T_Hash:
2681                         retval = _copyHash(from);
2682                         break;
2683                 case T_SubPlan:
2684                         retval = _copySubPlan(from);
2685                         break;
2686
2687                         /*
2688                          * PRIMITIVE NODES
2689                          */
2690                 case T_Resdom:
2691                         retval = _copyResdom(from);
2692                         break;
2693                 case T_Fjoin:
2694                         retval = _copyFjoin(from);
2695                         break;
2696                 case T_Expr:
2697                         retval = _copyExpr(from);
2698                         break;
2699                 case T_Var:
2700                         retval = _copyVar(from);
2701                         break;
2702                 case T_Oper:
2703                         retval = _copyOper(from);
2704                         break;
2705                 case T_Const:
2706                         retval = _copyConst(from);
2707                         break;
2708                 case T_Param:
2709                         retval = _copyParam(from);
2710                         break;
2711                 case T_Aggref:
2712                         retval = _copyAggref(from);
2713                         break;
2714                 case T_SubLink:
2715                         retval = _copySubLink(from);
2716                         break;
2717                 case T_Func:
2718                         retval = _copyFunc(from);
2719                         break;
2720                 case T_ArrayRef:
2721                         retval = _copyArrayRef(from);
2722                         break;
2723                 case T_FieldSelect:
2724                         retval = _copyFieldSelect(from);
2725                         break;
2726                 case T_RelabelType:
2727                         retval = _copyRelabelType(from);
2728                         break;
2729                 case T_RangeTblRef:
2730                         retval = _copyRangeTblRef(from);
2731                         break;
2732                 case T_FromExpr:
2733                         retval = _copyFromExpr(from);
2734                         break;
2735                 case T_JoinExpr:
2736                         retval = _copyJoinExpr(from);
2737                         break;
2738
2739                         /*
2740                          * RELATION NODES
2741                          */
2742                 case T_RelOptInfo:
2743                         retval = _copyRelOptInfo(from);
2744                         break;
2745                 case T_Path:
2746                         retval = _copyPath(from);
2747                         break;
2748                 case T_IndexPath:
2749                         retval = _copyIndexPath(from);
2750                         break;
2751                 case T_TidPath:
2752                         retval = _copyTidPath(from);
2753                         break;
2754                 case T_AppendPath:
2755                         retval = _copyAppendPath(from);
2756                         break;
2757                 case T_NestPath:
2758                         retval = _copyNestPath(from);
2759                         break;
2760                 case T_MergePath:
2761                         retval = _copyMergePath(from);
2762                         break;
2763                 case T_HashPath:
2764                         retval = _copyHashPath(from);
2765                         break;
2766                 case T_PathKeyItem:
2767                         retval = _copyPathKeyItem(from);
2768                         break;
2769                 case T_RestrictInfo:
2770                         retval = _copyRestrictInfo(from);
2771                         break;
2772                 case T_JoinInfo:
2773                         retval = _copyJoinInfo(from);
2774                         break;
2775                 case T_Stream:
2776                         retval = _copyStream(from);
2777                         break;
2778                 case T_IndexOptInfo:
2779                         retval = _copyIndexOptInfo(from);
2780                         break;
2781
2782                         /*
2783                          * VALUE NODES
2784                          */
2785                 case T_Integer:
2786                 case T_Float:
2787                 case T_String:
2788                 case T_BitString:
2789                         retval = _copyValue(from);
2790                         break;
2791                 case T_List:
2792                         {
2793                                 List       *list = from,
2794                                                    *l,
2795                                                    *nl;
2796
2797                                 /* rather ugly coding for speed... */
2798                                 /* Note the input list cannot be NIL if we got here. */
2799                                 nl = makeList1(copyObject(lfirst(list)));
2800                                 retval = nl;
2801
2802                                 foreach(l, lnext(list))
2803                                 {
2804                                         lnext(nl) = makeList1(copyObject(lfirst(l)));
2805                                         nl = lnext(nl);
2806                                 }
2807                         }
2808                         break;
2809
2810                         /*
2811                          * PARSE NODES
2812                          */
2813                 case T_Query:
2814                         retval = _copyQuery(from);
2815                         break;
2816                 case T_InsertStmt:
2817                         retval = _copyInsertStmt(from);
2818                         break;
2819                 case T_DeleteStmt:
2820                         retval = _copyDeleteStmt(from);
2821                         break;
2822                 case T_UpdateStmt:
2823                         retval = _copyUpdateStmt(from);
2824                         break;
2825                 case T_SelectStmt:
2826                         retval = _copySelectStmt(from);
2827                         break;
2828                 case T_SetOperationStmt:
2829                         retval = _copySetOperationStmt(from);
2830                         break;
2831                 case T_AlterTableStmt:
2832                         retval = _copyAlterTableStmt(from);
2833                         break;
2834                 case T_GrantStmt:
2835                         retval = _copyGrantStmt(from);
2836                         break;
2837                 case T_ClosePortalStmt:
2838                         retval = _copyClosePortalStmt(from);
2839                         break;
2840                 case T_ClusterStmt:
2841                         retval = _copyClusterStmt(from);
2842                         break;
2843                 case T_CopyStmt:
2844                         retval = _copyCopyStmt(from);
2845                         break;
2846                 case T_CreateStmt:
2847                         retval = _copyCreateStmt(from);
2848                         break;
2849                 case T_DefineStmt:
2850                         retval = _copyDefineStmt(from);
2851                         break;
2852                 case T_DropStmt:
2853                         retval = _copyDropStmt(from);
2854                         break;
2855                 case T_TruncateStmt:
2856                         retval = _copyTruncateStmt(from);
2857                         break;
2858                 case T_CommentStmt:
2859                         retval = _copyCommentStmt(from);
2860                         break;
2861                 case T_FetchStmt:
2862                         retval = _copyFetchStmt(from);
2863                         break;
2864                 case T_IndexStmt:
2865                         retval = _copyIndexStmt(from);
2866                         break;
2867                 case T_ProcedureStmt:
2868                         retval = _copyProcedureStmt(from);
2869                         break;
2870                 case T_RemoveAggrStmt:
2871                         retval = _copyRemoveAggrStmt(from);
2872                         break;
2873                 case T_RemoveFuncStmt:
2874                         retval = _copyRemoveFuncStmt(from);
2875                         break;
2876                 case T_RemoveOperStmt:
2877                         retval = _copyRemoveOperStmt(from);
2878                         break;
2879                 case T_RenameStmt:
2880                         retval = _copyRenameStmt(from);
2881                         break;
2882                 case T_RuleStmt:
2883                         retval = _copyRuleStmt(from);
2884                         break;
2885                 case T_NotifyStmt:
2886                         retval = _copyNotifyStmt(from);
2887                         break;
2888                 case T_ListenStmt:
2889                         retval = _copyListenStmt(from);
2890                         break;
2891                 case T_UnlistenStmt:
2892                         retval = _copyUnlistenStmt(from);
2893                         break;
2894                 case T_TransactionStmt:
2895                         retval = _copyTransactionStmt(from);
2896                         break;
2897                 case T_ViewStmt:
2898                         retval = _copyViewStmt(from);
2899                         break;
2900                 case T_LoadStmt:
2901                         retval = _copyLoadStmt(from);
2902                         break;
2903                 case T_CreateDomainStmt:
2904                         retval = _copyCreateDomainStmt(from);
2905                         break;
2906                 case T_CreatedbStmt:
2907                         retval = _copyCreatedbStmt(from);
2908                         break;
2909                 case T_AlterDatabaseSetStmt:
2910                         retval = _copyAlterDatabaseSetStmt(from);
2911                         break;
2912                 case T_DropdbStmt:
2913                         retval = _copyDropdbStmt(from);
2914                         break;
2915                 case T_VacuumStmt:
2916                         retval = _copyVacuumStmt(from);
2917                         break;
2918                 case T_ExplainStmt:
2919                         retval = _copyExplainStmt(from);
2920                         break;
2921                 case T_CreateSeqStmt:
2922                         retval = _copyCreateSeqStmt(from);
2923                         break;
2924                 case T_VariableSetStmt:
2925                         retval = _copyVariableSetStmt(from);
2926                         break;
2927                 case T_VariableShowStmt:
2928                         retval = _copyVariableShowStmt(from);
2929                         break;
2930                 case T_VariableResetStmt:
2931                         retval = _copyVariableResetStmt(from);
2932                         break;
2933                 case T_CreateTrigStmt:
2934                         retval = _copyCreateTrigStmt(from);
2935                         break;
2936                 case T_DropPropertyStmt:
2937                         retval = _copyDropPropertyStmt(from);
2938                         break;
2939                 case T_CreatePLangStmt:
2940                         retval = _copyCreatePLangStmt(from);
2941                         break;
2942                 case T_DropPLangStmt:
2943                         retval = _copyDropPLangStmt(from);
2944                         break;
2945                 case T_CreateUserStmt:
2946                         retval = _copyCreateUserStmt(from);
2947                         break;
2948                 case T_AlterUserStmt:
2949                         retval = _copyAlterUserStmt(from);
2950                         break;
2951                 case T_AlterUserSetStmt:
2952                         retval = _copyAlterUserSetStmt(from);
2953                         break;
2954                 case T_DropUserStmt:
2955                         retval = _copyDropUserStmt(from);
2956                         break;
2957                 case T_LockStmt:
2958                         retval = _copyLockStmt(from);
2959                         break;
2960                 case T_ConstraintsSetStmt:
2961                         retval = _copyConstraintsSetStmt(from);
2962                         break;
2963                 case T_CreateGroupStmt:
2964                         retval = _copyCreateGroupStmt(from);
2965                         break;
2966                 case T_AlterGroupStmt:
2967                         retval = _copyAlterGroupStmt(from);
2968                         break;
2969                 case T_DropGroupStmt:
2970                         retval = _copyDropGroupStmt(from);
2971                         break;
2972                 case T_ReindexStmt:
2973                         retval = _copyReindexStmt(from);
2974                         break;
2975                 case T_CheckPointStmt:
2976                         retval = (void *) makeNode(CheckPointStmt);
2977                         break;
2978                 case T_CreateSchemaStmt:
2979                         retval = _copyCreateSchemaStmt(from);
2980                         break;
2981
2982                 case T_A_Expr:
2983                         retval = _copyAExpr(from);
2984                         break;
2985                 case T_ColumnRef:
2986                         retval = _copyColumnRef(from);
2987                         break;
2988                 case T_ParamRef:
2989                         retval = _copyParamRef(from);
2990                         break;
2991                 case T_A_Const:
2992                         retval = _copyAConst(from);
2993                         break;
2994                 case T_Ident:
2995                         retval = _copyIdent(from);
2996                         break;
2997                 case T_FuncCall:
2998                         retval = _copyFuncCall(from);
2999                         break;
3000                 case T_A_Indices:
3001                         retval = _copyAIndices(from);
3002                         break;
3003                 case T_ExprFieldSelect:
3004                         retval = _copyExprFieldSelect(from);
3005                         break;
3006                 case T_ResTarget:
3007                         retval = _copyResTarget(from);
3008                         break;
3009                 case T_TypeCast:
3010                         retval = _copyTypeCast(from);
3011                         break;
3012                 case T_SortGroupBy:
3013                         retval = _copySortGroupBy(from);
3014                         break;
3015                 case T_Alias:
3016                         retval = _copyAlias(from);
3017                         break;
3018                 case T_RangeVar:
3019                         retval = _copyRangeVar(from);
3020                         break;
3021                 case T_RangeSubselect:
3022                         retval = _copyRangeSubselect(from);
3023                         break;
3024                 case T_RangeFunction:
3025                         retval = _copyRangeFunction(from);
3026                         break;
3027                 case T_TypeName:
3028                         retval = _copyTypeName(from);
3029                         break;
3030                 case T_IndexElem:
3031                         retval = _copyIndexElem(from);
3032                         break;
3033                 case T_ColumnDef:
3034                         retval = _copyColumnDef(from);
3035                         break;
3036                 case T_Constraint:
3037                         retval = _copyConstraint(from);
3038                         break;
3039                 case T_DefElem:
3040                         retval = _copyDefElem(from);
3041                         break;
3042                 case T_TargetEntry:
3043                         retval = _copyTargetEntry(from);
3044                         break;
3045                 case T_RangeTblEntry:
3046                         retval = _copyRangeTblEntry(from);
3047                         break;
3048                 case T_SortClause:
3049                         retval = _copySortClause(from);
3050                         break;
3051                 case T_GroupClause:
3052                         retval = _copyGroupClause(from);
3053                         break;
3054                 case T_CaseExpr:
3055                         retval = _copyCaseExpr(from);
3056                         break;
3057                 case T_CaseWhen:
3058                         retval = _copyCaseWhen(from);
3059                         break;
3060                 case T_NullTest:
3061                         retval = _copyNullTest(from);
3062                         break;
3063                 case T_BooleanTest:
3064                         retval = _copyBooleanTest(from);
3065                         break;
3066                 case T_FkConstraint:
3067                         retval = _copyFkConstraint(from);
3068                         break;
3069                 case T_PrivGrantee:
3070                         retval = _copyPrivGrantee(from);
3071                         break;
3072                 case T_FuncWithArgs:
3073                         retval = _copyFuncWithArgs(from);
3074                         break;
3075                 case T_InsertDefault:
3076                         retval = _copyInsertDefault(from);
3077                         break;
3078
3079                 default:
3080                         elog(ERROR, "copyObject: don't know how to copy node type %d",
3081                                  nodeTag(from));
3082                         retval = from;          /* keep compiler quiet */
3083                         break;
3084         }
3085         return retval;
3086 }