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