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