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