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