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