git.8kb.co.uk Git - pgpool-ii/pgpool-ii_2.2.5/blob - parser/copyfuncs.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * copyfuncs.c
   4  *        Copy functions for Postgres tree nodes.
   5  *
   6  * NOTE: we currently support copying all node types found in parse and
   7  * plan trees.  We do not support copying executor state trees; there
   8  * is no need for that, and no point in maintaining all the code that
   9  * would be needed.  We also do not support copying Path trees, mainly
  10  * because the circular linkages between RelOptInfo and Path nodes can't
  11  * be handled easily in a simple depth-first traversal.
  12  *
  13  *
  14  * Portions Copyright (c) 2003-2008, PgPool Global Development Group
  15  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  16  * Portions Copyright (c) 1994, Regents of the University of California
  17  *
  18  * IDENTIFICATION
  19  *        $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.382 2007/09/03 18:46:30 tgl Exp $
  20  *
  21  *-------------------------------------------------------------------------
  22  */
  23
  24 #include "pool.h"
  25
  26 #include <string.h>
  27 #include "pool_memory.h"
  28 #include "parsenodes.h"
  29
  30
  31 /*
  32  * Macros to simplify copying of different kinds of fields.  Use these
  33  * wherever possible to reduce the chance for silly typos.      Note that these
  34  * hard-wire the convention that the local variables in a Copy routine are
  35  * named 'newnode' and 'from'.
  36  */
  37
  38 /* Copy a simple scalar field (int, float, bool, enum, etc) */
  39 #define COPY_SCALAR_FIELD(fldname) \
  40         (newnode->fldname = from->fldname)
  41
  42 /* Copy a field that is a pointer to some kind of Node or Node tree */
  43 #define COPY_NODE_FIELD(fldname) \
  44         (newnode->fldname = copyObject(from->fldname))
  45
  46 /* Copy a field that is a pointer to a Bitmapset */
  47 #define COPY_BITMAPSET_FIELD(fldname) \
  48         (newnode->fldname = bms_copy(from->fldname))
  49
  50 /* Copy a field that is a pointer to a C string, or perhaps NULL */
  51 #define COPY_STRING_FIELD(fldname) \
  52         (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
  53
  54 /* Copy a field that is a pointer to a simple palloc'd object of size sz */
  55 #define COPY_POINTER_FIELD(fldname, sz) \
  56         do { \
  57                 Size    _size = (sz); \
  58                 newnode->fldname = palloc(_size); \
  59                 memcpy(newnode->fldname, from->fldname, _size); \
  60         } while (0)
  61
  62
  63 /* ****************************************************************
  64  *                                         primnodes.h copy functions
  65  * ****************************************************************
  66  */
  67
  68 /*
  69  * _copyAlias
  70  */
  71 static Alias *
  72 _copyAlias(Alias *from)
  73 {
  74         Alias      *newnode = makeNode(Alias);
  75
  76         COPY_STRING_FIELD(aliasname);
  77         COPY_NODE_FIELD(colnames);
  78
  79         return newnode;
  80 }
  81
  82 /*
  83  * _copyRangeVar
  84  */
  85 static RangeVar *
  86 _copyRangeVar(RangeVar *from)
  87 {
  88         RangeVar   *newnode = makeNode(RangeVar);
  89
  90         COPY_STRING_FIELD(catalogname);
  91         COPY_STRING_FIELD(schemaname);
  92         COPY_STRING_FIELD(relname);
  93         COPY_SCALAR_FIELD(inhOpt);
  94         COPY_SCALAR_FIELD(istemp);
  95         COPY_NODE_FIELD(alias);
  96
  97         return newnode;
  98 }
  99
 100 /*
 101  * _copyIntoClause
 102  */
 103 static IntoClause *
 104 _copyIntoClause(IntoClause *from)
 105 {
 106         IntoClause   *newnode = makeNode(IntoClause);
 107
 108         COPY_NODE_FIELD(rel);
 109         COPY_NODE_FIELD(colNames);
 110         COPY_NODE_FIELD(options);
 111         COPY_SCALAR_FIELD(onCommit);
 112         COPY_STRING_FIELD(tableSpaceName);
 113
 114         return newnode;
 115 }
 116
 117 /*
 118  * We don't need a _copyExpr because Expr is an abstract supertype which
 119  * should never actually get instantiated.      Also, since it has no common
 120  * fields except NodeTag, there's no need for a helper routine to factor
 121  * out copying the common fields...
 122  */
 123
 124 /*
 125  * _copyVar
 126  */
 127 static Var *
 128 _copyVar(Var *from)
 129 {
 130         Var                *newnode = makeNode(Var);
 131
 132         COPY_SCALAR_FIELD(varno);
 133         COPY_SCALAR_FIELD(varattno);
 134         COPY_SCALAR_FIELD(vartype);
 135         COPY_SCALAR_FIELD(vartypmod);
 136         COPY_SCALAR_FIELD(varlevelsup);
 137         COPY_SCALAR_FIELD(varnoold);
 138         COPY_SCALAR_FIELD(varoattno);
 139
 140         return newnode;
 141 }
 142
 143 /*
 144  * _copyConst
 145  */
 146 #if 0
 147 static Const *
 148 _copyConst(Const *from)
 149 {
 150         Const      *newnode = makeNode(Const);
 151
 152         COPY_SCALAR_FIELD(consttype);
 153         COPY_SCALAR_FIELD(consttypmod);
 154         COPY_SCALAR_FIELD(constlen);
 155
 156         if (from->constbyval || from->constisnull)
 157         {
 158                 /*
 159                  * passed by value so just copy the datum. Also, don't try to copy
 160                  * struct when value is null!
 161                  */
 162                 newnode->constvalue = from->constvalue;
 163         }
 164         else
 165         {
 166                 /*
 167                  * passed by reference.  We need a palloc'd copy.
 168                  */
 169                 newnode->constvalue = datumCopy(from->constvalue,
 170                                                                                 from->constbyval,
 171                                                                                 from->constlen);
 172         }
 173
 174         COPY_SCALAR_FIELD(constisnull);
 175         COPY_SCALAR_FIELD(constbyval);
 176
 177         return newnode;
 178 }
 179 #endif
 180
 181 /*
 182  * _copyParam
 183  */
 184 static Param *
 185 _copyParam(Param *from)
 186 {
 187         Param      *newnode = makeNode(Param);
 188
 189         COPY_SCALAR_FIELD(paramkind);
 190         COPY_SCALAR_FIELD(paramid);
 191         COPY_SCALAR_FIELD(paramtype);
 192         COPY_SCALAR_FIELD(paramtypmod);
 193
 194         return newnode;
 195 }
 196
 197 /*
 198  * _copyAggref
 199  */
 200 static Aggref *
 201 _copyAggref(Aggref *from)
 202 {
 203         Aggref     *newnode = makeNode(Aggref);
 204
 205         COPY_SCALAR_FIELD(aggfnoid);
 206         COPY_SCALAR_FIELD(aggtype);
 207         COPY_NODE_FIELD(args);
 208         COPY_SCALAR_FIELD(agglevelsup);
 209         COPY_SCALAR_FIELD(aggstar);
 210         COPY_SCALAR_FIELD(aggdistinct);
 211
 212         return newnode;
 213 }
 214
 215 /*
 216  * _copyArrayRef
 217  */
 218 static ArrayRef *
 219 _copyArrayRef(ArrayRef *from)
 220 {
 221         ArrayRef   *newnode = makeNode(ArrayRef);
 222
 223         COPY_SCALAR_FIELD(refarraytype);
 224         COPY_SCALAR_FIELD(refelemtype);
 225         COPY_SCALAR_FIELD(reftypmod);
 226         COPY_NODE_FIELD(refupperindexpr);
 227         COPY_NODE_FIELD(reflowerindexpr);
 228         COPY_NODE_FIELD(refexpr);
 229         COPY_NODE_FIELD(refassgnexpr);
 230
 231         return newnode;
 232 }
 233
 234 /*
 235  * _copyFuncExpr
 236  */
 237 static FuncExpr *
 238 _copyFuncExpr(FuncExpr *from)
 239 {
 240         FuncExpr   *newnode = makeNode(FuncExpr);
 241
 242         COPY_SCALAR_FIELD(funcid);
 243         COPY_SCALAR_FIELD(funcresulttype);
 244         COPY_SCALAR_FIELD(funcretset);
 245         COPY_SCALAR_FIELD(funcformat);
 246         COPY_NODE_FIELD(args);
 247
 248         return newnode;
 249 }
 250
 251 /*
 252  * _copyOpExpr
 253  */
 254 static OpExpr *
 255 _copyOpExpr(OpExpr *from)
 256 {
 257         OpExpr     *newnode = makeNode(OpExpr);
 258
 259         COPY_SCALAR_FIELD(opno);
 260         COPY_SCALAR_FIELD(opfuncid);
 261         COPY_SCALAR_FIELD(opresulttype);
 262         COPY_SCALAR_FIELD(opretset);
 263         COPY_NODE_FIELD(args);
 264
 265         return newnode;
 266 }
 267
 268 /*
 269  * _copyDistinctExpr (same as OpExpr)
 270  */
 271 static DistinctExpr *
 272 _copyDistinctExpr(DistinctExpr *from)
 273 {
 274         DistinctExpr *newnode = makeNode(DistinctExpr);
 275
 276         COPY_SCALAR_FIELD(opno);
 277         COPY_SCALAR_FIELD(opfuncid);
 278         COPY_SCALAR_FIELD(opresulttype);
 279         COPY_SCALAR_FIELD(opretset);
 280         COPY_NODE_FIELD(args);
 281
 282         return newnode;
 283 }
 284
 285 /*
 286  * _copyScalarArrayOpExpr
 287  */
 288 static ScalarArrayOpExpr *
 289 _copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
 290 {
 291         ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
 292
 293         COPY_SCALAR_FIELD(opno);
 294         COPY_SCALAR_FIELD(opfuncid);
 295         COPY_SCALAR_FIELD(useOr);
 296         COPY_NODE_FIELD(args);
 297
 298         return newnode;
 299 }
 300
 301 /*
 302  * _copyBoolExpr
 303  */
 304 static BoolExpr *
 305 _copyBoolExpr(BoolExpr *from)
 306 {
 307         BoolExpr   *newnode = makeNode(BoolExpr);
 308
 309         COPY_SCALAR_FIELD(boolop);
 310         COPY_NODE_FIELD(args);
 311
 312         return newnode;
 313 }
 314
 315 /*
 316  * _copySubLink
 317  */
 318 static SubLink *
 319 _copySubLink(SubLink *from)
 320 {
 321         SubLink    *newnode = makeNode(SubLink);
 322
 323         COPY_SCALAR_FIELD(subLinkType);
 324         COPY_NODE_FIELD(testexpr);
 325         COPY_NODE_FIELD(operName);
 326         COPY_NODE_FIELD(subselect);
 327
 328         return newnode;
 329 }
 330
 331 /*
 332  * _copySubPlan
 333  */
 334 static SubPlan *
 335 _copySubPlan(SubPlan *from)
 336 {
 337         SubPlan    *newnode = makeNode(SubPlan);
 338
 339         COPY_SCALAR_FIELD(subLinkType);
 340         COPY_NODE_FIELD(testexpr);
 341         COPY_NODE_FIELD(paramIds);
 342         COPY_SCALAR_FIELD(plan_id);
 343         COPY_SCALAR_FIELD(firstColType);
 344         COPY_SCALAR_FIELD(useHashTable);
 345         COPY_SCALAR_FIELD(unknownEqFalse);
 346         COPY_NODE_FIELD(setParam);
 347         COPY_NODE_FIELD(parParam);
 348         COPY_NODE_FIELD(args);
 349
 350         return newnode;
 351 }
 352
 353 /*
 354  * _copyFieldSelect
 355  */
 356 static FieldSelect *
 357 _copyFieldSelect(FieldSelect *from)
 358 {
 359         FieldSelect *newnode = makeNode(FieldSelect);
 360
 361         COPY_NODE_FIELD(arg);
 362         COPY_SCALAR_FIELD(fieldnum);
 363         COPY_SCALAR_FIELD(resulttype);
 364         COPY_SCALAR_FIELD(resulttypmod);
 365
 366         return newnode;
 367 }
 368
 369 /*
 370  * _copyFieldStore
 371  */
 372 static FieldStore *
 373 _copyFieldStore(FieldStore *from)
 374 {
 375         FieldStore *newnode = makeNode(FieldStore);
 376
 377         COPY_NODE_FIELD(arg);
 378         COPY_NODE_FIELD(newvals);
 379         COPY_NODE_FIELD(fieldnums);
 380         COPY_SCALAR_FIELD(resulttype);
 381
 382         return newnode;
 383 }
 384
 385 /*
 386  * _copyRelabelType
 387  */
 388 static RelabelType *
 389 _copyRelabelType(RelabelType *from)
 390 {
 391         RelabelType *newnode = makeNode(RelabelType);
 392
 393         COPY_NODE_FIELD(arg);
 394         COPY_SCALAR_FIELD(resulttype);
 395         COPY_SCALAR_FIELD(resulttypmod);
 396         COPY_SCALAR_FIELD(relabelformat);
 397
 398         return newnode;
 399 }
 400
 401 /*
 402  * _copyCoerceViaIO
 403  */
 404 static CoerceViaIO *
 405 _copyCoerceViaIO(CoerceViaIO *from)
 406 {
 407         CoerceViaIO   *newnode = makeNode(CoerceViaIO);
 408
 409         COPY_NODE_FIELD(arg);
 410         COPY_SCALAR_FIELD(resulttype);
 411         COPY_SCALAR_FIELD(coerceformat);
 412
 413         return newnode;
 414 }
 415
 416 /*
 417  * _copyArrayCoerceExpr
 418  */
 419 static ArrayCoerceExpr *
 420 _copyArrayCoerceExpr(ArrayCoerceExpr *from)
 421 {
 422         ArrayCoerceExpr   *newnode = makeNode(ArrayCoerceExpr);
 423
 424         COPY_NODE_FIELD(arg);
 425         COPY_SCALAR_FIELD(elemfuncid);
 426         COPY_SCALAR_FIELD(resulttype);
 427         COPY_SCALAR_FIELD(resulttypmod);
 428         COPY_SCALAR_FIELD(isExplicit);
 429         COPY_SCALAR_FIELD(coerceformat);
 430
 431         return newnode;
 432 }
 433
 434 /*
 435  * _copyConvertRowtypeExpr
 436  */
 437 static ConvertRowtypeExpr *
 438 _copyConvertRowtypeExpr(ConvertRowtypeExpr *from)
 439 {
 440         ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
 441
 442         COPY_NODE_FIELD(arg);
 443         COPY_SCALAR_FIELD(resulttype);
 444         COPY_SCALAR_FIELD(convertformat);
 445
 446         return newnode;
 447 }
 448
 449 /*
 450  * _copyCaseExpr
 451  */
 452 static CaseExpr *
 453 _copyCaseExpr(CaseExpr *from)
 454 {
 455         CaseExpr   *newnode = makeNode(CaseExpr);
 456
 457         COPY_SCALAR_FIELD(casetype);
 458         COPY_NODE_FIELD(arg);
 459         COPY_NODE_FIELD(args);
 460         COPY_NODE_FIELD(defresult);
 461
 462         return newnode;
 463 }
 464
 465 /*
 466  * _copyCaseWhen
 467  */
 468 static CaseWhen *
 469 _copyCaseWhen(CaseWhen *from)
 470 {
 471         CaseWhen   *newnode = makeNode(CaseWhen);
 472
 473         COPY_NODE_FIELD(expr);
 474         COPY_NODE_FIELD(result);
 475
 476         return newnode;
 477 }
 478
 479 /*
 480  * _copyCaseTestExpr
 481  */
 482 static CaseTestExpr *
 483 _copyCaseTestExpr(CaseTestExpr *from)
 484 {
 485         CaseTestExpr *newnode = makeNode(CaseTestExpr);
 486
 487         COPY_SCALAR_FIELD(typeId);
 488         COPY_SCALAR_FIELD(typeMod);
 489
 490         return newnode;
 491 }
 492
 493 /*
 494  * _copyArrayExpr
 495  */
 496 static ArrayExpr *
 497 _copyArrayExpr(ArrayExpr *from)
 498 {
 499         ArrayExpr  *newnode = makeNode(ArrayExpr);
 500
 501         COPY_SCALAR_FIELD(array_typeid);
 502         COPY_SCALAR_FIELD(element_typeid);
 503         COPY_NODE_FIELD(elements);
 504         COPY_SCALAR_FIELD(multidims);
 505
 506         return newnode;
 507 }
 508
 509 /*
 510  * _copyRowExpr
 511  */
 512 static RowExpr *
 513 _copyRowExpr(RowExpr *from)
 514 {
 515         RowExpr    *newnode = makeNode(RowExpr);
 516
 517         COPY_NODE_FIELD(args);
 518         COPY_SCALAR_FIELD(row_typeid);
 519         COPY_SCALAR_FIELD(row_format);
 520
 521         return newnode;
 522 }
 523
 524 /*
 525  * _copyRowCompareExpr
 526  */
 527 static RowCompareExpr *
 528 _copyRowCompareExpr(RowCompareExpr *from)
 529 {
 530         RowCompareExpr *newnode = makeNode(RowCompareExpr);
 531
 532         COPY_SCALAR_FIELD(rctype);
 533         COPY_NODE_FIELD(opnos);
 534         COPY_NODE_FIELD(opfamilies);
 535         COPY_NODE_FIELD(largs);
 536         COPY_NODE_FIELD(rargs);
 537
 538         return newnode;
 539 }
 540
 541 /*
 542  * _copyCoalesceExpr
 543  */
 544 static CoalesceExpr *
 545 _copyCoalesceExpr(CoalesceExpr *from)
 546 {
 547         CoalesceExpr *newnode = makeNode(CoalesceExpr);
 548
 549         COPY_SCALAR_FIELD(coalescetype);
 550         COPY_NODE_FIELD(args);
 551
 552         return newnode;
 553 }
 554
 555 /*
 556  * _copyMinMaxExpr
 557  */
 558 static MinMaxExpr *
 559 _copyMinMaxExpr(MinMaxExpr *from)
 560 {
 561         MinMaxExpr *newnode = makeNode(MinMaxExpr);
 562
 563         COPY_SCALAR_FIELD(minmaxtype);
 564         COPY_SCALAR_FIELD(op);
 565         COPY_NODE_FIELD(args);
 566
 567         return newnode;
 568 }
 569
 570 /*
 571  * _copyXmlExpr
 572  */
 573 static XmlExpr *
 574 _copyXmlExpr(XmlExpr *from)
 575 {
 576         XmlExpr *newnode = makeNode(XmlExpr);
 577
 578         COPY_SCALAR_FIELD(op);
 579         COPY_STRING_FIELD(name);
 580         COPY_NODE_FIELD(named_args);
 581         COPY_NODE_FIELD(arg_names);
 582         COPY_NODE_FIELD(args);
 583         COPY_SCALAR_FIELD(xmloption);
 584         COPY_SCALAR_FIELD(type);
 585         COPY_SCALAR_FIELD(typmod);
 586
 587         return newnode;
 588 }
 589
 590 /*
 591  * _copyNullIfExpr (same as OpExpr)
 592  */
 593 static NullIfExpr *
 594 _copyNullIfExpr(NullIfExpr *from)
 595 {
 596         NullIfExpr *newnode = makeNode(NullIfExpr);
 597
 598         COPY_SCALAR_FIELD(opno);
 599         COPY_SCALAR_FIELD(opfuncid);
 600         COPY_SCALAR_FIELD(opresulttype);
 601         COPY_SCALAR_FIELD(opretset);
 602         COPY_NODE_FIELD(args);
 603
 604         return newnode;
 605 }
 606
 607 /*
 608  * _copyNullTest
 609  */
 610 static NullTest *
 611 _copyNullTest(NullTest *from)
 612 {
 613         NullTest   *newnode = makeNode(NullTest);
 614
 615         COPY_NODE_FIELD(arg);
 616         COPY_SCALAR_FIELD(nulltesttype);
 617
 618         return newnode;
 619 }
 620
 621 /*
 622  * _copyBooleanTest
 623  */
 624 static BooleanTest *
 625 _copyBooleanTest(BooleanTest *from)
 626 {
 627         BooleanTest *newnode = makeNode(BooleanTest);
 628
 629         COPY_NODE_FIELD(arg);
 630         COPY_SCALAR_FIELD(booltesttype);
 631
 632         return newnode;
 633 }
 634
 635 /*
 636  * _copyCoerceToDomain
 637  */
 638 static CoerceToDomain *
 639 _copyCoerceToDomain(CoerceToDomain *from)
 640 {
 641         CoerceToDomain *newnode = makeNode(CoerceToDomain);
 642
 643         COPY_NODE_FIELD(arg);
 644         COPY_SCALAR_FIELD(resulttype);
 645         COPY_SCALAR_FIELD(resulttypmod);
 646         COPY_SCALAR_FIELD(coercionformat);
 647
 648         return newnode;
 649 }
 650
 651 /*
 652  * _copyCoerceToDomainValue
 653  */
 654 static CoerceToDomainValue *
 655 _copyCoerceToDomainValue(CoerceToDomainValue *from)
 656 {
 657         CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
 658
 659         COPY_SCALAR_FIELD(typeId);
 660         COPY_SCALAR_FIELD(typeMod);
 661
 662         return newnode;
 663 }
 664
 665 /*
 666  * _copySetToDefault
 667  */
 668 static SetToDefault *
 669 _copySetToDefault(SetToDefault *from)
 670 {
 671         SetToDefault *newnode = makeNode(SetToDefault);
 672
 673         COPY_SCALAR_FIELD(typeId);
 674         COPY_SCALAR_FIELD(typeMod);
 675
 676         return newnode;
 677 }
 678
 679 /*
 680  * _copyCurrentOfExpr
 681  */
 682 static CurrentOfExpr *
 683 _copyCurrentOfExpr(CurrentOfExpr *from)
 684 {
 685         CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
 686
 687         COPY_SCALAR_FIELD(cvarno);
 688         COPY_STRING_FIELD(cursor_name);
 689         COPY_SCALAR_FIELD(cursor_param);
 690
 691         return newnode;
 692 }
 693
 694 /*
 695  * _copyTargetEntry
 696  */
 697 static TargetEntry *
 698 _copyTargetEntry(TargetEntry *from)
 699 {
 700         TargetEntry *newnode = makeNode(TargetEntry);
 701
 702         COPY_NODE_FIELD(expr);
 703         COPY_SCALAR_FIELD(resno);
 704         COPY_STRING_FIELD(resname);
 705         COPY_SCALAR_FIELD(ressortgroupref);
 706         COPY_SCALAR_FIELD(resorigtbl);
 707         COPY_SCALAR_FIELD(resorigcol);
 708         COPY_SCALAR_FIELD(resjunk);
 709
 710         return newnode;
 711 }
 712
 713 /*
 714  * _copyRangeTblRef
 715  */
 716 static RangeTblRef *
 717 _copyRangeTblRef(RangeTblRef *from)
 718 {
 719         RangeTblRef *newnode = makeNode(RangeTblRef);
 720
 721         COPY_SCALAR_FIELD(rtindex);
 722
 723         return newnode;
 724 }
 725
 726 /*
 727  * _copyJoinExpr
 728  */
 729 static JoinExpr *
 730 _copyJoinExpr(JoinExpr *from)
 731 {
 732         JoinExpr   *newnode = makeNode(JoinExpr);
 733
 734         COPY_SCALAR_FIELD(jointype);
 735         COPY_SCALAR_FIELD(isNatural);
 736         COPY_NODE_FIELD(larg);
 737         COPY_NODE_FIELD(rarg);
 738         COPY_NODE_FIELD(using);
 739         COPY_NODE_FIELD(quals);
 740         COPY_NODE_FIELD(alias);
 741         COPY_SCALAR_FIELD(rtindex);
 742
 743         return newnode;
 744 }
 745
 746 /*
 747  * _copyFromExpr
 748  */
 749 static FromExpr *
 750 _copyFromExpr(FromExpr *from)
 751 {
 752         FromExpr   *newnode = makeNode(FromExpr);
 753
 754         COPY_NODE_FIELD(fromlist);
 755         COPY_NODE_FIELD(quals);
 756
 757         return newnode;
 758 }
 759
 760 /* ****************************************************************
 761  *                                      parsenodes.h copy functions
 762  * ****************************************************************
 763  */
 764
 765 static RangeTblEntry *
 766 _copyRangeTblEntry(RangeTblEntry *from)
 767 {
 768         RangeTblEntry *newnode = makeNode(RangeTblEntry);
 769
 770         COPY_SCALAR_FIELD(rtekind);
 771         COPY_SCALAR_FIELD(relid);
 772         COPY_NODE_FIELD(subquery);
 773         COPY_NODE_FIELD(funcexpr);
 774         COPY_NODE_FIELD(funccoltypes);
 775         COPY_NODE_FIELD(funccoltypmods);
 776         COPY_NODE_FIELD(values_lists);
 777         COPY_SCALAR_FIELD(jointype);
 778         COPY_NODE_FIELD(joinaliasvars);
 779         COPY_NODE_FIELD(alias);
 780         COPY_NODE_FIELD(eref);
 781         COPY_SCALAR_FIELD(inh);
 782         COPY_SCALAR_FIELD(inFromCl);
 783         COPY_SCALAR_FIELD(requiredPerms);
 784         COPY_SCALAR_FIELD(checkAsUser);
 785
 786         return newnode;
 787 }
 788
 789 static FkConstraint *
 790 _copyFkConstraint(FkConstraint *from)
 791 {
 792         FkConstraint *newnode = makeNode(FkConstraint);
 793
 794         COPY_STRING_FIELD(constr_name);
 795         COPY_NODE_FIELD(pktable);
 796         COPY_NODE_FIELD(fk_attrs);
 797         COPY_NODE_FIELD(pk_attrs);
 798         COPY_SCALAR_FIELD(fk_matchtype);
 799         COPY_SCALAR_FIELD(fk_upd_action);
 800         COPY_SCALAR_FIELD(fk_del_action);
 801         COPY_SCALAR_FIELD(deferrable);
 802         COPY_SCALAR_FIELD(initdeferred);
 803         COPY_SCALAR_FIELD(skip_validation);
 804
 805         return newnode;
 806 }
 807
 808 static SortClause *
 809 _copySortClause(SortClause *from)
 810 {
 811         SortClause *newnode = makeNode(SortClause);
 812
 813         COPY_SCALAR_FIELD(tleSortGroupRef);
 814         COPY_SCALAR_FIELD(sortop);
 815         COPY_SCALAR_FIELD(nulls_first);
 816
 817         return newnode;
 818 }
 819
 820 static GroupClause *
 821 _copyGroupClause(GroupClause *from)
 822 {
 823         GroupClause *newnode = makeNode(GroupClause);
 824
 825         COPY_SCALAR_FIELD(tleSortGroupRef);
 826         COPY_SCALAR_FIELD(sortop);
 827         COPY_SCALAR_FIELD(nulls_first);
 828
 829         return newnode;
 830 }
 831
 832 static RowMarkClause *
 833 _copyRowMarkClause(RowMarkClause *from)
 834 {
 835         RowMarkClause *newnode = makeNode(RowMarkClause);
 836
 837         COPY_SCALAR_FIELD(rti);
 838         COPY_SCALAR_FIELD(forUpdate);
 839         COPY_SCALAR_FIELD(noWait);
 840
 841         return newnode;
 842 }
 843
 844 static A_Expr *
 845 _copyAExpr(A_Expr *from)
 846 {
 847         A_Expr     *newnode = makeNode(A_Expr);
 848
 849         COPY_SCALAR_FIELD(kind);
 850         COPY_NODE_FIELD(name);
 851         COPY_NODE_FIELD(lexpr);
 852         COPY_NODE_FIELD(rexpr);
 853         COPY_SCALAR_FIELD(location);
 854
 855         return newnode;
 856 }
 857
 858 static ColumnRef *
 859 _copyColumnRef(ColumnRef *from)
 860 {
 861         ColumnRef  *newnode = makeNode(ColumnRef);
 862
 863         COPY_NODE_FIELD(fields);
 864         COPY_SCALAR_FIELD(location);
 865
 866         return newnode;
 867 }
 868
 869 static ParamRef *
 870 _copyParamRef(ParamRef *from)
 871 {
 872         ParamRef   *newnode = makeNode(ParamRef);
 873
 874         COPY_SCALAR_FIELD(number);
 875
 876         return newnode;
 877 }
 878
 879 static A_Const *
 880 _copyAConst(A_Const *from)
 881 {
 882         A_Const    *newnode = makeNode(A_Const);
 883
 884         /* This part must duplicate _copyValue */
 885         COPY_SCALAR_FIELD(val.type);
 886         switch (from->val.type)
 887         {
 888                 case T_Integer:
 889                         COPY_SCALAR_FIELD(val.val.ival);
 890                         break;
 891                 case T_Float:
 892                 case T_String:
 893                 case T_BitString:
 894                         COPY_STRING_FIELD(val.val.str);
 895                         break;
 896                 case T_Null:
 897                         /* nothing to do */
 898                         break;
 899                 default:
 900                         pool_error("unrecognized node type: %d",
 901                                  (int) from->val.type);
 902                         break;
 903         }
 904
 905         COPY_NODE_FIELD(typename);
 906
 907         return newnode;
 908 }
 909
 910 static FuncCall *
 911 _copyFuncCall(FuncCall *from)
 912 {
 913         FuncCall   *newnode = makeNode(FuncCall);
 914
 915         COPY_NODE_FIELD(funcname);
 916         COPY_NODE_FIELD(args);
 917         COPY_SCALAR_FIELD(agg_star);
 918         COPY_SCALAR_FIELD(agg_distinct);
 919         COPY_SCALAR_FIELD(location);
 920
 921         return newnode;
 922 }
 923
 924 static A_Indices *
 925 _copyAIndices(A_Indices *from)
 926 {
 927         A_Indices  *newnode = makeNode(A_Indices);
 928
 929         COPY_NODE_FIELD(lidx);
 930         COPY_NODE_FIELD(uidx);
 931
 932         return newnode;
 933 }
 934
 935 static A_Indirection *
 936 _copyA_Indirection(A_Indirection *from)
 937 {
 938         A_Indirection *newnode = makeNode(A_Indirection);
 939
 940         COPY_NODE_FIELD(arg);
 941         COPY_NODE_FIELD(indirection);
 942
 943         return newnode;
 944 }
 945
 946 static ResTarget *
 947 _copyResTarget(ResTarget *from)
 948 {
 949         ResTarget  *newnode = makeNode(ResTarget);
 950
 951         COPY_STRING_FIELD(name);
 952         COPY_NODE_FIELD(indirection);
 953         COPY_NODE_FIELD(val);
 954         COPY_SCALAR_FIELD(location);
 955
 956         return newnode;
 957 }
 958
 959 static TypeName *
 960 _copyTypeName(TypeName *from)
 961 {
 962         TypeName   *newnode = makeNode(TypeName);
 963
 964         COPY_NODE_FIELD(names);
 965         COPY_SCALAR_FIELD(typeid);
 966         COPY_SCALAR_FIELD(timezone);
 967         COPY_SCALAR_FIELD(setof);
 968         COPY_SCALAR_FIELD(pct_type);
 969         COPY_NODE_FIELD(typmods);
 970         COPY_SCALAR_FIELD(typemod);
 971         COPY_NODE_FIELD(arrayBounds);
 972         COPY_SCALAR_FIELD(location);
 973
 974         return newnode;
 975 }
 976
 977 static SortBy *
 978 _copySortBy(SortBy *from)
 979 {
 980         SortBy     *newnode = makeNode(SortBy);
 981
 982         COPY_SCALAR_FIELD(sortby_dir);
 983         COPY_SCALAR_FIELD(sortby_nulls);
 984         COPY_NODE_FIELD(useOp);
 985         COPY_NODE_FIELD(node);
 986
 987         return newnode;
 988 }
 989
 990 static RangeSubselect *
 991 _copyRangeSubselect(RangeSubselect *from)
 992 {
 993         RangeSubselect *newnode = makeNode(RangeSubselect);
 994
 995         COPY_NODE_FIELD(subquery);
 996         COPY_NODE_FIELD(alias);
 997
 998         return newnode;
 999 }
1000
1001 static RangeFunction *
1002 _copyRangeFunction(RangeFunction *from)
1003 {
1004         RangeFunction *newnode = makeNode(RangeFunction);
1005
1006         COPY_NODE_FIELD(funccallnode);
1007         COPY_NODE_FIELD(alias);
1008         COPY_NODE_FIELD(coldeflist);
1009
1010         return newnode;
1011 }
1012
1013 static TypeCast *
1014 _copyTypeCast(TypeCast *from)
1015 {
1016         TypeCast   *newnode = makeNode(TypeCast);
1017
1018         COPY_NODE_FIELD(arg);
1019         COPY_NODE_FIELD(typename);
1020
1021         return newnode;
1022 }
1023
1024 static IndexElem *
1025 _copyIndexElem(IndexElem *from)
1026 {
1027         IndexElem  *newnode = makeNode(IndexElem);
1028
1029         COPY_STRING_FIELD(name);
1030         COPY_NODE_FIELD(expr);
1031         COPY_NODE_FIELD(opclass);
1032         COPY_SCALAR_FIELD(ordering);
1033         COPY_SCALAR_FIELD(nulls_ordering);
1034
1035         return newnode;
1036 }
1037
1038 static ColumnDef *
1039 _copyColumnDef(ColumnDef *from)
1040 {
1041         ColumnDef  *newnode = makeNode(ColumnDef);
1042
1043         COPY_STRING_FIELD(colname);
1044         COPY_NODE_FIELD(typename);
1045         COPY_SCALAR_FIELD(inhcount);
1046         COPY_SCALAR_FIELD(is_local);
1047         COPY_SCALAR_FIELD(is_not_null);
1048         COPY_NODE_FIELD(raw_default);
1049         COPY_STRING_FIELD(cooked_default);
1050         COPY_NODE_FIELD(constraints);
1051
1052         return newnode;
1053 }
1054
1055 static Constraint *
1056 _copyConstraint(Constraint *from)
1057 {
1058         Constraint *newnode = makeNode(Constraint);
1059
1060         COPY_SCALAR_FIELD(contype);
1061         COPY_STRING_FIELD(name);
1062         COPY_NODE_FIELD(raw_expr);
1063         COPY_STRING_FIELD(cooked_expr);
1064         COPY_NODE_FIELD(keys);
1065         COPY_NODE_FIELD(options);
1066         COPY_STRING_FIELD(indexspace);
1067
1068         return newnode;
1069 }
1070
1071 static DefElem *
1072 _copyDefElem(DefElem *from)
1073 {
1074         DefElem    *newnode = makeNode(DefElem);
1075
1076         COPY_STRING_FIELD(defname);
1077         COPY_NODE_FIELD(arg);
1078
1079         return newnode;
1080 }
1081
1082 static LockingClause *
1083 _copyLockingClause(LockingClause *from)
1084 {
1085         LockingClause *newnode = makeNode(LockingClause);
1086
1087         COPY_NODE_FIELD(lockedRels);
1088         COPY_SCALAR_FIELD(forUpdate);
1089         COPY_SCALAR_FIELD(noWait);
1090
1091         return newnode;
1092 }
1093
1094 static XmlSerialize *
1095 _copyXmlSerialize(XmlSerialize *from)
1096 {
1097         XmlSerialize *newnode = makeNode(XmlSerialize);
1098
1099         COPY_SCALAR_FIELD(xmloption);
1100         COPY_NODE_FIELD(expr);
1101         COPY_NODE_FIELD(typename);
1102
1103         return newnode;
1104 }
1105
1106 static Query *
1107 _copyQuery(Query *from)
1108 {
1109         Query      *newnode = makeNode(Query);
1110
1111         COPY_SCALAR_FIELD(commandType);
1112         COPY_SCALAR_FIELD(querySource);
1113         COPY_SCALAR_FIELD(canSetTag);
1114         COPY_NODE_FIELD(utilityStmt);
1115         COPY_SCALAR_FIELD(resultRelation);
1116         COPY_NODE_FIELD(intoClause);
1117         COPY_SCALAR_FIELD(hasAggs);
1118         COPY_SCALAR_FIELD(hasSubLinks);
1119         COPY_NODE_FIELD(rtable);
1120         COPY_NODE_FIELD(jointree);
1121         COPY_NODE_FIELD(targetList);
1122         COPY_NODE_FIELD(returningList);
1123         COPY_NODE_FIELD(groupClause);
1124         COPY_NODE_FIELD(havingQual);
1125         COPY_NODE_FIELD(distinctClause);
1126         COPY_NODE_FIELD(sortClause);
1127         COPY_NODE_FIELD(limitOffset);
1128         COPY_NODE_FIELD(limitCount);
1129         COPY_NODE_FIELD(rowMarks);
1130         COPY_NODE_FIELD(setOperations);
1131
1132         return newnode;
1133 }
1134
1135 static InsertStmt *
1136 _copyInsertStmt(InsertStmt *from)
1137 {
1138         InsertStmt *newnode = makeNode(InsertStmt);
1139
1140         COPY_NODE_FIELD(relation);
1141         COPY_NODE_FIELD(cols);
1142         COPY_NODE_FIELD(selectStmt);
1143         COPY_NODE_FIELD(returningList);
1144
1145         return newnode;
1146 }
1147
1148 static DeleteStmt *
1149 _copyDeleteStmt(DeleteStmt *from)
1150 {
1151         DeleteStmt *newnode = makeNode(DeleteStmt);
1152
1153         COPY_NODE_FIELD(relation);
1154         COPY_NODE_FIELD(usingClause);
1155         COPY_NODE_FIELD(whereClause);
1156         COPY_NODE_FIELD(returningList);
1157
1158         return newnode;
1159 }
1160
1161 static UpdateStmt *
1162 _copyUpdateStmt(UpdateStmt *from)
1163 {
1164         UpdateStmt *newnode = makeNode(UpdateStmt);
1165
1166         COPY_NODE_FIELD(relation);
1167         COPY_NODE_FIELD(targetList);
1168         COPY_NODE_FIELD(whereClause);
1169         COPY_NODE_FIELD(fromClause);
1170         COPY_NODE_FIELD(returningList);
1171
1172         return newnode;
1173 }
1174
1175 static SelectStmt *
1176 _copySelectStmt(SelectStmt *from)
1177 {
1178         SelectStmt *newnode = makeNode(SelectStmt);
1179
1180         COPY_NODE_FIELD(distinctClause);
1181         COPY_NODE_FIELD(intoClause);
1182         COPY_NODE_FIELD(targetList);
1183         COPY_NODE_FIELD(fromClause);
1184         COPY_NODE_FIELD(whereClause);
1185         COPY_NODE_FIELD(groupClause);
1186         COPY_NODE_FIELD(havingClause);
1187         COPY_NODE_FIELD(valuesLists);
1188         COPY_NODE_FIELD(sortClause);
1189         COPY_NODE_FIELD(limitOffset);
1190         COPY_NODE_FIELD(limitCount);
1191         COPY_NODE_FIELD(lockingClause);
1192         COPY_SCALAR_FIELD(op);
1193         COPY_SCALAR_FIELD(all);
1194         COPY_NODE_FIELD(larg);
1195         COPY_NODE_FIELD(rarg);
1196
1197         return newnode;
1198 }
1199
1200 static SetOperationStmt *
1201 _copySetOperationStmt(SetOperationStmt *from)
1202 {
1203         SetOperationStmt *newnode = makeNode(SetOperationStmt);
1204
1205         COPY_SCALAR_FIELD(op);
1206         COPY_SCALAR_FIELD(all);
1207         COPY_NODE_FIELD(larg);
1208         COPY_NODE_FIELD(rarg);
1209         COPY_NODE_FIELD(colTypes);
1210         COPY_NODE_FIELD(colTypmods);
1211
1212         return newnode;
1213 }
1214
1215 static AlterTableStmt *
1216 _copyAlterTableStmt(AlterTableStmt *from)
1217 {
1218         AlterTableStmt *newnode = makeNode(AlterTableStmt);
1219
1220         COPY_NODE_FIELD(relation);
1221         COPY_NODE_FIELD(cmds);
1222         COPY_SCALAR_FIELD(relkind);
1223
1224         return newnode;
1225 }
1226
1227 static AlterTableCmd *
1228 _copyAlterTableCmd(AlterTableCmd *from)
1229 {
1230         AlterTableCmd *newnode = makeNode(AlterTableCmd);
1231
1232         COPY_SCALAR_FIELD(subtype);
1233         COPY_STRING_FIELD(name);
1234         COPY_NODE_FIELD(def);
1235         COPY_NODE_FIELD(transform);
1236         COPY_SCALAR_FIELD(behavior);
1237
1238         return newnode;
1239 }
1240
1241 static AlterDomainStmt *
1242 _copyAlterDomainStmt(AlterDomainStmt *from)
1243 {
1244         AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
1245
1246         COPY_SCALAR_FIELD(subtype);
1247         COPY_NODE_FIELD(typename);
1248         COPY_STRING_FIELD(name);
1249         COPY_NODE_FIELD(def);
1250         COPY_SCALAR_FIELD(behavior);
1251
1252         return newnode;
1253 }
1254
1255 static GrantStmt *
1256 _copyGrantStmt(GrantStmt *from)
1257 {
1258         GrantStmt  *newnode = makeNode(GrantStmt);
1259
1260         COPY_SCALAR_FIELD(is_grant);
1261         COPY_SCALAR_FIELD(objtype);
1262         COPY_NODE_FIELD(objects);
1263         COPY_NODE_FIELD(privileges);
1264         COPY_NODE_FIELD(grantees);
1265         COPY_SCALAR_FIELD(grant_option);
1266         COPY_SCALAR_FIELD(behavior);
1267
1268         return newnode;
1269 }
1270
1271 static PrivGrantee *
1272 _copyPrivGrantee(PrivGrantee *from)
1273 {
1274         PrivGrantee *newnode = makeNode(PrivGrantee);
1275
1276         COPY_STRING_FIELD(rolname);
1277
1278         return newnode;
1279 }
1280
1281 static FuncWithArgs *
1282 _copyFuncWithArgs(FuncWithArgs *from)
1283 {
1284         FuncWithArgs *newnode = makeNode(FuncWithArgs);
1285
1286         COPY_NODE_FIELD(funcname);
1287         COPY_NODE_FIELD(funcargs);
1288
1289         return newnode;
1290 }
1291
1292 static GrantRoleStmt *
1293 _copyGrantRoleStmt(GrantRoleStmt *from)
1294 {
1295         GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
1296
1297         COPY_NODE_FIELD(granted_roles);
1298         COPY_NODE_FIELD(grantee_roles);
1299         COPY_SCALAR_FIELD(is_grant);
1300         COPY_SCALAR_FIELD(admin_opt);
1301         COPY_STRING_FIELD(grantor);
1302         COPY_SCALAR_FIELD(behavior);
1303
1304         return newnode;
1305 }
1306
1307 static DeclareCursorStmt *
1308 _copyDeclareCursorStmt(DeclareCursorStmt *from)
1309 {
1310         DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
1311
1312         COPY_STRING_FIELD(portalname);
1313         COPY_SCALAR_FIELD(options);
1314         COPY_NODE_FIELD(query);
1315
1316         return newnode;
1317 }
1318
1319 static ClosePortalStmt *
1320 _copyClosePortalStmt(ClosePortalStmt *from)
1321 {
1322         ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
1323
1324         COPY_STRING_FIELD(portalname);
1325
1326         return newnode;
1327 }
1328
1329 static ClusterStmt *
1330 _copyClusterStmt(ClusterStmt *from)
1331 {
1332         ClusterStmt *newnode = makeNode(ClusterStmt);
1333
1334         COPY_NODE_FIELD(relation);
1335         COPY_STRING_FIELD(indexname);
1336
1337         return newnode;
1338 }
1339
1340 static CopyStmt *
1341 _copyCopyStmt(CopyStmt *from)
1342 {
1343         CopyStmt   *newnode = makeNode(CopyStmt);
1344
1345         COPY_NODE_FIELD(relation);
1346         COPY_NODE_FIELD(query);
1347         COPY_NODE_FIELD(attlist);
1348         COPY_SCALAR_FIELD(is_from);
1349         COPY_STRING_FIELD(filename);
1350         COPY_NODE_FIELD(options);
1351
1352         return newnode;
1353 }
1354
1355 static CreateStmt *
1356 _copyCreateStmt(CreateStmt *from)
1357 {
1358         CreateStmt *newnode = makeNode(CreateStmt);
1359
1360         COPY_NODE_FIELD(relation);
1361         COPY_NODE_FIELD(tableElts);
1362         COPY_NODE_FIELD(inhRelations);
1363         COPY_NODE_FIELD(constraints);
1364         COPY_NODE_FIELD(options);
1365         COPY_SCALAR_FIELD(oncommit);
1366         COPY_STRING_FIELD(tablespacename);
1367
1368         return newnode;
1369 }
1370
1371 static InhRelation *
1372 _copyInhRelation(InhRelation *from)
1373 {
1374         InhRelation *newnode = makeNode(InhRelation);
1375
1376         COPY_NODE_FIELD(relation);
1377         COPY_NODE_FIELD(options);
1378
1379         return newnode;
1380 }
1381
1382 static DefineStmt *
1383 _copyDefineStmt(DefineStmt *from)
1384 {
1385         DefineStmt *newnode = makeNode(DefineStmt);
1386
1387         COPY_SCALAR_FIELD(kind);
1388         COPY_SCALAR_FIELD(oldstyle);
1389         COPY_NODE_FIELD(defnames);
1390         COPY_NODE_FIELD(args);
1391         COPY_NODE_FIELD(definition);
1392
1393         return newnode;
1394 }
1395
1396 static DropStmt *
1397 _copyDropStmt(DropStmt *from)
1398 {
1399         DropStmt   *newnode = makeNode(DropStmt);
1400
1401         COPY_NODE_FIELD(objects);
1402         COPY_SCALAR_FIELD(removeType);
1403         COPY_SCALAR_FIELD(behavior);
1404         COPY_SCALAR_FIELD(missing_ok);
1405
1406         return newnode;
1407 }
1408
1409 static TruncateStmt *
1410 _copyTruncateStmt(TruncateStmt *from)
1411 {
1412         TruncateStmt *newnode = makeNode(TruncateStmt);
1413
1414         COPY_NODE_FIELD(relations);
1415         COPY_SCALAR_FIELD(behavior);
1416
1417         return newnode;
1418 }
1419
1420 static CommentStmt *
1421 _copyCommentStmt(CommentStmt *from)
1422 {
1423         CommentStmt *newnode = makeNode(CommentStmt);
1424
1425         COPY_SCALAR_FIELD(objtype);
1426         COPY_NODE_FIELD(objname);
1427         COPY_NODE_FIELD(objargs);
1428         COPY_STRING_FIELD(comment);
1429
1430         return newnode;
1431 }
1432
1433 static FetchStmt *
1434 _copyFetchStmt(FetchStmt *from)
1435 {
1436         FetchStmt  *newnode = makeNode(FetchStmt);
1437
1438         COPY_SCALAR_FIELD(direction);
1439         COPY_SCALAR_FIELD(howMany);
1440         COPY_STRING_FIELD(portalname);
1441         COPY_SCALAR_FIELD(ismove);
1442
1443         return newnode;
1444 }
1445
1446 static IndexStmt *
1447 _copyIndexStmt(IndexStmt *from)
1448 {
1449         IndexStmt  *newnode = makeNode(IndexStmt);
1450
1451         COPY_STRING_FIELD(idxname);
1452         COPY_NODE_FIELD(relation);
1453         COPY_STRING_FIELD(accessMethod);
1454         COPY_STRING_FIELD(tableSpace);
1455         COPY_NODE_FIELD(indexParams);
1456         COPY_NODE_FIELD(options);
1457         COPY_STRING_FIELD(src_options);
1458         COPY_NODE_FIELD(whereClause);
1459         COPY_SCALAR_FIELD(unique);
1460         COPY_SCALAR_FIELD(primary);
1461         COPY_SCALAR_FIELD(isconstraint);
1462         COPY_SCALAR_FIELD(concurrent);
1463
1464         return newnode;
1465 }
1466
1467 static CreateFunctionStmt *
1468 _copyCreateFunctionStmt(CreateFunctionStmt *from)
1469 {
1470         CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
1471
1472         COPY_SCALAR_FIELD(replace);
1473         COPY_NODE_FIELD(funcname);
1474         COPY_NODE_FIELD(parameters);
1475         COPY_NODE_FIELD(returnType);
1476         COPY_NODE_FIELD(options);
1477         COPY_NODE_FIELD(withClause);
1478
1479         return newnode;
1480 }
1481
1482 static FunctionParameter *
1483 _copyFunctionParameter(FunctionParameter *from)
1484 {
1485         FunctionParameter *newnode = makeNode(FunctionParameter);
1486
1487         COPY_STRING_FIELD(name);
1488         COPY_NODE_FIELD(argType);
1489         COPY_SCALAR_FIELD(mode);
1490
1491         return newnode;
1492 }
1493
1494 static AlterFunctionStmt *
1495 _copyAlterFunctionStmt(AlterFunctionStmt *from)
1496 {
1497         AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
1498
1499         COPY_NODE_FIELD(func);
1500         COPY_NODE_FIELD(actions);
1501
1502         return newnode;
1503 }
1504
1505 static RemoveFuncStmt *
1506 _copyRemoveFuncStmt(RemoveFuncStmt *from)
1507 {
1508         RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
1509
1510         COPY_SCALAR_FIELD(kind);
1511         COPY_NODE_FIELD(name);
1512         COPY_NODE_FIELD(args);
1513         COPY_SCALAR_FIELD(behavior);
1514         COPY_SCALAR_FIELD(missing_ok);
1515
1516         return newnode;
1517 }
1518
1519 static RemoveOpClassStmt *
1520 _copyRemoveOpClassStmt(RemoveOpClassStmt *from)
1521 {
1522         RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
1523
1524         COPY_NODE_FIELD(opclassname);
1525         COPY_STRING_FIELD(amname);
1526         COPY_SCALAR_FIELD(behavior);
1527         COPY_SCALAR_FIELD(missing_ok);
1528
1529         return newnode;
1530 }
1531
1532 static RemoveOpFamilyStmt *
1533 _copyRemoveOpFamilyStmt(RemoveOpFamilyStmt *from)
1534 {
1535         RemoveOpFamilyStmt *newnode = makeNode(RemoveOpFamilyStmt);
1536
1537         COPY_NODE_FIELD(opfamilyname);
1538         COPY_STRING_FIELD(amname);
1539         COPY_SCALAR_FIELD(behavior);
1540         COPY_SCALAR_FIELD(missing_ok);
1541
1542         return newnode;
1543 }
1544
1545 static RenameStmt *
1546 _copyRenameStmt(RenameStmt *from)
1547 {
1548         RenameStmt *newnode = makeNode(RenameStmt);
1549
1550         COPY_SCALAR_FIELD(renameType);
1551         COPY_NODE_FIELD(relation);
1552         COPY_NODE_FIELD(object);
1553         COPY_NODE_FIELD(objarg);
1554         COPY_STRING_FIELD(subname);
1555         COPY_STRING_FIELD(newname);
1556
1557         return newnode;
1558 }
1559
1560 static AlterObjectSchemaStmt *
1561 _copyAlterObjectSchemaStmt(AlterObjectSchemaStmt *from)
1562 {
1563         AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
1564
1565         COPY_SCALAR_FIELD(objectType);
1566         COPY_NODE_FIELD(relation);
1567         COPY_NODE_FIELD(object);
1568         COPY_NODE_FIELD(objarg);
1569         COPY_STRING_FIELD(addname);
1570         COPY_STRING_FIELD(newschema);
1571
1572         return newnode;
1573 }
1574
1575 static AlterOwnerStmt *
1576 _copyAlterOwnerStmt(AlterOwnerStmt *from)
1577 {
1578         AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
1579
1580         COPY_SCALAR_FIELD(objectType);
1581         COPY_NODE_FIELD(relation);
1582         COPY_NODE_FIELD(object);
1583         COPY_NODE_FIELD(objarg);
1584         COPY_STRING_FIELD(addname);
1585         COPY_STRING_FIELD(newowner);
1586
1587         return newnode;
1588 }
1589
1590 static RuleStmt *
1591 _copyRuleStmt(RuleStmt *from)
1592 {
1593         RuleStmt   *newnode = makeNode(RuleStmt);
1594
1595         COPY_NODE_FIELD(relation);
1596         COPY_STRING_FIELD(rulename);
1597         COPY_NODE_FIELD(whereClause);
1598         COPY_SCALAR_FIELD(event);
1599         COPY_SCALAR_FIELD(instead);
1600         COPY_NODE_FIELD(actions);
1601         COPY_SCALAR_FIELD(replace);
1602
1603         return newnode;
1604 }
1605
1606 static NotifyStmt *
1607 _copyNotifyStmt(NotifyStmt *from)
1608 {
1609         NotifyStmt *newnode = makeNode(NotifyStmt);
1610
1611         COPY_NODE_FIELD(relation);
1612
1613         return newnode;
1614 }
1615
1616 static ListenStmt *
1617 _copyListenStmt(ListenStmt *from)
1618 {
1619         ListenStmt *newnode = makeNode(ListenStmt);
1620
1621         COPY_NODE_FIELD(relation);
1622
1623         return newnode;
1624 }
1625
1626 static UnlistenStmt *
1627 _copyUnlistenStmt(UnlistenStmt *from)
1628 {
1629         UnlistenStmt *newnode = makeNode(UnlistenStmt);
1630
1631         COPY_NODE_FIELD(relation);
1632
1633         return newnode;
1634 }
1635
1636 static TransactionStmt *
1637 _copyTransactionStmt(TransactionStmt *from)
1638 {
1639         TransactionStmt *newnode = makeNode(TransactionStmt);
1640
1641         COPY_SCALAR_FIELD(kind);
1642         COPY_NODE_FIELD(options);
1643         COPY_STRING_FIELD(gid);
1644
1645         return newnode;
1646 }
1647
1648 static CompositeTypeStmt *
1649 _copyCompositeTypeStmt(CompositeTypeStmt *from)
1650 {
1651         CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
1652
1653         COPY_NODE_FIELD(typevar);
1654         COPY_NODE_FIELD(coldeflist);
1655
1656         return newnode;
1657 }
1658
1659 static CreateEnumStmt *
1660 _copyCreateEnumStmt(CreateEnumStmt *from)
1661 {
1662         CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
1663
1664         COPY_NODE_FIELD(typename);
1665         COPY_NODE_FIELD(vals);
1666
1667         return newnode;
1668 }
1669
1670 static ViewStmt *
1671 _copyViewStmt(ViewStmt *from)
1672 {
1673         ViewStmt   *newnode = makeNode(ViewStmt);
1674
1675         COPY_NODE_FIELD(view);
1676         COPY_NODE_FIELD(aliases);
1677         COPY_NODE_FIELD(query);
1678         COPY_SCALAR_FIELD(replace);
1679
1680         return newnode;
1681 }
1682
1683 static LoadStmt *
1684 _copyLoadStmt(LoadStmt *from)
1685 {
1686         LoadStmt   *newnode = makeNode(LoadStmt);
1687
1688         COPY_STRING_FIELD(filename);
1689
1690         return newnode;
1691 }
1692
1693 static CreateDomainStmt *
1694 _copyCreateDomainStmt(CreateDomainStmt *from)
1695 {
1696         CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
1697
1698         COPY_NODE_FIELD(domainname);
1699         COPY_NODE_FIELD(typename);
1700         COPY_NODE_FIELD(constraints);
1701
1702         return newnode;
1703 }
1704
1705 static CreateOpClassStmt *
1706 _copyCreateOpClassStmt(CreateOpClassStmt *from)
1707 {
1708         CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
1709
1710         COPY_NODE_FIELD(opclassname);
1711         COPY_NODE_FIELD(opfamilyname);
1712         COPY_STRING_FIELD(amname);
1713         COPY_NODE_FIELD(datatype);
1714         COPY_NODE_FIELD(items);
1715         COPY_SCALAR_FIELD(isDefault);
1716
1717         return newnode;
1718 }
1719
1720 static CreateOpClassItem *
1721 _copyCreateOpClassItem(CreateOpClassItem *from)
1722 {
1723         CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
1724
1725         COPY_SCALAR_FIELD(itemtype);
1726         COPY_NODE_FIELD(name);
1727         COPY_NODE_FIELD(args);
1728         COPY_SCALAR_FIELD(number);
1729         COPY_SCALAR_FIELD(recheck);
1730         COPY_NODE_FIELD(class_args);
1731         COPY_NODE_FIELD(storedtype);
1732
1733         return newnode;
1734 }
1735
1736 static CreateOpFamilyStmt *
1737 _copyCreateOpFamilyStmt(CreateOpFamilyStmt *from)
1738 {
1739         CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
1740
1741         COPY_NODE_FIELD(opfamilyname);
1742         COPY_STRING_FIELD(amname);
1743
1744         return newnode;
1745 }
1746
1747 static AlterOpFamilyStmt *
1748 _copyAlterOpFamilyStmt(AlterOpFamilyStmt *from)
1749 {
1750         AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
1751
1752         COPY_NODE_FIELD(opfamilyname);
1753         COPY_STRING_FIELD(amname);
1754         COPY_SCALAR_FIELD(isDrop);
1755         COPY_NODE_FIELD(items);
1756
1757         return newnode;
1758 }
1759
1760 static CreatedbStmt *
1761 _copyCreatedbStmt(CreatedbStmt *from)
1762 {
1763         CreatedbStmt *newnode = makeNode(CreatedbStmt);
1764
1765         COPY_STRING_FIELD(dbname);
1766         COPY_NODE_FIELD(options);
1767
1768         return newnode;
1769 }
1770
1771 static AlterDatabaseStmt *
1772 _copyAlterDatabaseStmt(AlterDatabaseStmt *from)
1773 {
1774         AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
1775
1776         COPY_STRING_FIELD(dbname);
1777         COPY_NODE_FIELD(options);
1778
1779         return newnode;
1780 }
1781
1782 static AlterDatabaseSetStmt *
1783 _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
1784 {
1785         AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
1786
1787         COPY_STRING_FIELD(dbname);
1788         COPY_NODE_FIELD(setstmt);
1789
1790         return newnode;
1791 }
1792
1793 static DropdbStmt *
1794 _copyDropdbStmt(DropdbStmt *from)
1795 {
1796         DropdbStmt *newnode = makeNode(DropdbStmt);
1797
1798         COPY_STRING_FIELD(dbname);
1799         COPY_SCALAR_FIELD(missing_ok);
1800
1801         return newnode;
1802 }
1803
1804 static VacuumStmt *
1805 _copyVacuumStmt(VacuumStmt *from)
1806 {
1807         VacuumStmt *newnode = makeNode(VacuumStmt);
1808
1809         COPY_SCALAR_FIELD(vacuum);
1810         COPY_SCALAR_FIELD(full);
1811         COPY_SCALAR_FIELD(analyze);
1812         COPY_SCALAR_FIELD(verbose);
1813         COPY_SCALAR_FIELD(freeze_min_age);
1814         COPY_NODE_FIELD(relation);
1815         COPY_NODE_FIELD(va_cols);
1816
1817         return newnode;
1818 }
1819
1820 static ExplainStmt *
1821 _copyExplainStmt(ExplainStmt *from)
1822 {
1823         ExplainStmt *newnode = makeNode(ExplainStmt);
1824
1825         COPY_NODE_FIELD(query);
1826         COPY_SCALAR_FIELD(verbose);
1827         COPY_SCALAR_FIELD(analyze);
1828
1829         return newnode;
1830 }
1831
1832 static CreateSeqStmt *
1833 _copyCreateSeqStmt(CreateSeqStmt *from)
1834 {
1835         CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
1836
1837         COPY_NODE_FIELD(sequence);
1838         COPY_NODE_FIELD(options);
1839
1840         return newnode;
1841 }
1842
1843 static AlterSeqStmt *
1844 _copyAlterSeqStmt(AlterSeqStmt *from)
1845 {
1846         AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
1847
1848         COPY_NODE_FIELD(sequence);
1849         COPY_NODE_FIELD(options);
1850
1851         return newnode;
1852 }
1853
1854 static VariableSetStmt *
1855 _copyVariableSetStmt(VariableSetStmt *from)
1856 {
1857         VariableSetStmt *newnode = makeNode(VariableSetStmt);
1858
1859         COPY_SCALAR_FIELD(kind);
1860         COPY_STRING_FIELD(name);
1861         COPY_NODE_FIELD(args);
1862         COPY_SCALAR_FIELD(is_local);
1863
1864         return newnode;
1865 }
1866
1867 static VariableShowStmt *
1868 _copyVariableShowStmt(VariableShowStmt *from)
1869 {
1870         VariableShowStmt *newnode = makeNode(VariableShowStmt);
1871
1872         COPY_STRING_FIELD(name);
1873
1874         return newnode;
1875 }
1876
1877 static DiscardStmt *
1878 _copyDiscardStmt(DiscardStmt *from)
1879 {
1880         DiscardStmt *newnode = makeNode(DiscardStmt);
1881
1882         COPY_SCALAR_FIELD(target);
1883
1884         return newnode;
1885 }
1886
1887 static CreateTableSpaceStmt *
1888 _copyCreateTableSpaceStmt(CreateTableSpaceStmt *from)
1889 {
1890         CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
1891
1892         COPY_STRING_FIELD(tablespacename);
1893         COPY_STRING_FIELD(owner);
1894         COPY_STRING_FIELD(location);
1895
1896         return newnode;
1897 }
1898
1899 static DropTableSpaceStmt *
1900 _copyDropTableSpaceStmt(DropTableSpaceStmt *from)
1901 {
1902         DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
1903
1904         COPY_STRING_FIELD(tablespacename);
1905         COPY_SCALAR_FIELD(missing_ok);
1906
1907         return newnode;
1908 }
1909
1910 static CreateTrigStmt *
1911 _copyCreateTrigStmt(CreateTrigStmt *from)
1912 {
1913         CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
1914
1915         COPY_STRING_FIELD(trigname);
1916         COPY_NODE_FIELD(relation);
1917         COPY_NODE_FIELD(funcname);
1918         COPY_NODE_FIELD(args);
1919         COPY_SCALAR_FIELD(before);
1920         COPY_SCALAR_FIELD(row);
1921         strcpy(newnode->actions, from->actions);        /* in-line string field */
1922         COPY_SCALAR_FIELD(isconstraint);
1923         COPY_SCALAR_FIELD(deferrable);
1924         COPY_SCALAR_FIELD(initdeferred);
1925         COPY_NODE_FIELD(constrrel);
1926
1927         return newnode;
1928 }
1929
1930 static DropPropertyStmt *
1931 _copyDropPropertyStmt(DropPropertyStmt *from)
1932 {
1933         DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
1934
1935         COPY_NODE_FIELD(relation);
1936         COPY_STRING_FIELD(property);
1937         COPY_SCALAR_FIELD(removeType);
1938         COPY_SCALAR_FIELD(behavior);
1939         COPY_SCALAR_FIELD(missing_ok);
1940
1941         return newnode;
1942 }
1943
1944 static CreatePLangStmt *
1945 _copyCreatePLangStmt(CreatePLangStmt *from)
1946 {
1947         CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
1948
1949         COPY_STRING_FIELD(plname);
1950         COPY_NODE_FIELD(plhandler);
1951         COPY_NODE_FIELD(plvalidator);
1952         COPY_SCALAR_FIELD(pltrusted);
1953
1954         return newnode;
1955 }
1956
1957 static DropPLangStmt *
1958 _copyDropPLangStmt(DropPLangStmt *from)
1959 {
1960         DropPLangStmt *newnode = makeNode(DropPLangStmt);
1961
1962         COPY_STRING_FIELD(plname);
1963         COPY_SCALAR_FIELD(behavior);
1964         COPY_SCALAR_FIELD(missing_ok);
1965
1966         return newnode;
1967 }
1968
1969 static CreateRoleStmt *
1970 _copyCreateRoleStmt(CreateRoleStmt *from)
1971 {
1972         CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
1973
1974         COPY_SCALAR_FIELD(stmt_type);
1975         COPY_STRING_FIELD(role);
1976         COPY_NODE_FIELD(options);
1977
1978         return newnode;
1979 }
1980
1981 static AlterRoleStmt *
1982 _copyAlterRoleStmt(AlterRoleStmt *from)
1983 {
1984         AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
1985
1986         COPY_STRING_FIELD(role);
1987         COPY_NODE_FIELD(options);
1988         COPY_SCALAR_FIELD(action);
1989
1990         return newnode;
1991 }
1992
1993 static AlterRoleSetStmt *
1994 _copyAlterRoleSetStmt(AlterRoleSetStmt *from)
1995 {
1996         AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
1997
1998         COPY_STRING_FIELD(role);
1999         COPY_NODE_FIELD(setstmt);
2000
2001         return newnode;
2002 }
2003
2004 static DropRoleStmt *
2005 _copyDropRoleStmt(DropRoleStmt *from)
2006 {
2007         DropRoleStmt *newnode = makeNode(DropRoleStmt);
2008
2009         COPY_NODE_FIELD(roles);
2010         COPY_SCALAR_FIELD(missing_ok);
2011
2012         return newnode;
2013 }
2014
2015 static LockStmt *
2016 _copyLockStmt(LockStmt *from)
2017 {
2018         LockStmt   *newnode = makeNode(LockStmt);
2019
2020         COPY_NODE_FIELD(relations);
2021         COPY_SCALAR_FIELD(mode);
2022         COPY_SCALAR_FIELD(nowait);
2023
2024         return newnode;
2025 }
2026
2027 static ConstraintsSetStmt *
2028 _copyConstraintsSetStmt(ConstraintsSetStmt *from)
2029 {
2030         ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
2031
2032         COPY_NODE_FIELD(constraints);
2033         COPY_SCALAR_FIELD(deferred);
2034
2035         return newnode;
2036 }
2037
2038 static ReindexStmt *
2039 _copyReindexStmt(ReindexStmt *from)
2040 {
2041         ReindexStmt *newnode = makeNode(ReindexStmt);
2042
2043         COPY_SCALAR_FIELD(kind);
2044         COPY_NODE_FIELD(relation);
2045         COPY_STRING_FIELD(name);
2046         COPY_SCALAR_FIELD(do_system);
2047         COPY_SCALAR_FIELD(do_user);
2048
2049         return newnode;
2050 }
2051
2052 static CreateSchemaStmt *
2053 _copyCreateSchemaStmt(CreateSchemaStmt *from)
2054 {
2055         CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
2056
2057         COPY_STRING_FIELD(schemaname);
2058         COPY_STRING_FIELD(authid);
2059         COPY_NODE_FIELD(schemaElts);
2060
2061         return newnode;
2062 }
2063
2064 static CreateConversionStmt *
2065 _copyCreateConversionStmt(CreateConversionStmt *from)
2066 {
2067         CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
2068
2069         COPY_NODE_FIELD(conversion_name);
2070         COPY_STRING_FIELD(for_encoding_name);
2071         COPY_STRING_FIELD(to_encoding_name);
2072         COPY_NODE_FIELD(func_name);
2073         COPY_SCALAR_FIELD(def);
2074
2075         return newnode;
2076 }
2077
2078 static CreateCastStmt *
2079 _copyCreateCastStmt(CreateCastStmt *from)
2080 {
2081         CreateCastStmt *newnode = makeNode(CreateCastStmt);
2082
2083         COPY_NODE_FIELD(sourcetype);
2084         COPY_NODE_FIELD(targettype);
2085         COPY_NODE_FIELD(func);
2086         COPY_SCALAR_FIELD(context);
2087
2088         return newnode;
2089 }
2090
2091 static DropCastStmt *
2092 _copyDropCastStmt(DropCastStmt *from)
2093 {
2094         DropCastStmt *newnode = makeNode(DropCastStmt);
2095
2096         COPY_NODE_FIELD(sourcetype);
2097         COPY_NODE_FIELD(targettype);
2098         COPY_SCALAR_FIELD(behavior);
2099         COPY_SCALAR_FIELD(missing_ok);
2100
2101         return newnode;
2102 }
2103
2104 static PrepareStmt *
2105 _copyPrepareStmt(PrepareStmt *from)
2106 {
2107         PrepareStmt *newnode = makeNode(PrepareStmt);
2108
2109         COPY_STRING_FIELD(name);
2110         COPY_NODE_FIELD(argtypes);
2111         COPY_NODE_FIELD(query);
2112
2113         return newnode;
2114 }
2115
2116 static ExecuteStmt *
2117 _copyExecuteStmt(ExecuteStmt *from)
2118 {
2119         ExecuteStmt *newnode = makeNode(ExecuteStmt);
2120
2121         COPY_STRING_FIELD(name);
2122         COPY_NODE_FIELD(into);
2123         COPY_NODE_FIELD(params);
2124
2125         return newnode;
2126 }
2127
2128 static DeallocateStmt *
2129 _copyDeallocateStmt(DeallocateStmt *from)
2130 {
2131         DeallocateStmt *newnode = makeNode(DeallocateStmt);
2132
2133         COPY_STRING_FIELD(name);
2134
2135         return newnode;
2136 }
2137
2138 static DropOwnedStmt *
2139 _copyDropOwnedStmt(DropOwnedStmt *from)
2140 {
2141         DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
2142
2143         COPY_NODE_FIELD(roles);
2144         COPY_SCALAR_FIELD(behavior);
2145
2146         return newnode;
2147 }
2148
2149 static ReassignOwnedStmt *
2150 _copyReassignOwnedStmt(ReassignOwnedStmt *from)
2151 {
2152         ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
2153
2154         COPY_NODE_FIELD(roles);
2155         COPY_SCALAR_FIELD(newrole);
2156
2157         return newnode;
2158 }
2159
2160 /* ****************************************************************
2161  *                                      pg_list.h copy functions
2162  * ****************************************************************
2163  */
2164
2165 /*
2166  * Perform a deep copy of the specified list, using copyObject(). The
2167  * list MUST be of type T_List; T_IntList and T_OidList nodes don't
2168  * need deep copies, so they should be copied via list_copy()
2169  */
2170 #define COPY_NODE_CELL(new, old)                                        \
2171         (new) = (ListCell *) palloc(sizeof(ListCell));  \
2172         lfirst(new) = copyObject(lfirst(old));
2173
2174 static List *
2175 _copyList(List *from)
2176 {
2177         List       *new;
2178         ListCell   *curr_old;
2179         ListCell   *prev_new;
2180
2181         new = makeNode(List);
2182         new->length = from->length;
2183
2184         COPY_NODE_CELL(new->head, from->head);
2185         prev_new = new->head;
2186         curr_old = lnext(from->head);
2187
2188         while (curr_old)
2189         {
2190                 COPY_NODE_CELL(prev_new->next, curr_old);
2191                 prev_new = prev_new->next;
2192                 curr_old = curr_old->next;
2193         }
2194         prev_new->next = NULL;
2195         new->tail = prev_new;
2196
2197         return new;
2198 }
2199
2200 /* ****************************************************************
2201  *                                      value.h copy functions
2202  * ****************************************************************
2203  */
2204 static Value *
2205 _copyValue(Value *from)
2206 {
2207         Value      *newnode = makeNode(Value);
2208
2209         /* See also _copyAConst when changing this code! */
2210
2211         COPY_SCALAR_FIELD(type);
2212         switch (from->type)
2213         {
2214                 case T_Integer:
2215                         COPY_SCALAR_FIELD(val.ival);
2216                         break;
2217                 case T_Float:
2218                 case T_String:
2219                 case T_BitString:
2220                         COPY_STRING_FIELD(val.str);
2221                         break;
2222                 case T_Null:
2223                         /* nothing to do */
2224                         break;
2225                 default:
2226                         pool_error("unrecognized node type: %d",
2227                                  (int) from->type);
2228                         break;
2229         }
2230         return newnode;
2231 }
2232
2233 /*
2234  * copyObject
2235  *
2236  * Create a copy of a Node tree or list.  This is a "deep" copy: all
2237  * substructure is copied too, recursively.
2238  */
2239 void *
2240 copyObject(void *from)
2241 {
2242         void       *retval;
2243
2244         if (from == NULL)
2245                 return NULL;
2246
2247         switch (nodeTag(from))
2248         {
2249                         /*
2250                          * PRIMITIVE NODES
2251                          */
2252                 case T_Alias:
2253                         retval = _copyAlias(from);
2254                         break;
2255                 case T_RangeVar:
2256                         retval = _copyRangeVar(from);
2257                         break;
2258                 case T_IntoClause:
2259                         retval = _copyIntoClause(from);
2260                         break;
2261                 case T_Var:
2262                         retval = _copyVar(from);
2263                         break;
2264                 case T_Param:
2265                         retval = _copyParam(from);
2266                         break;
2267                 case T_Aggref:
2268                         retval = _copyAggref(from);
2269                         break;
2270                 case T_ArrayRef:
2271                         retval = _copyArrayRef(from);
2272                         break;
2273                 case T_FuncExpr:
2274                         retval = _copyFuncExpr(from);
2275                         break;
2276                 case T_OpExpr:
2277                         retval = _copyOpExpr(from);
2278                         break;
2279                 case T_DistinctExpr:
2280                         retval = _copyDistinctExpr(from);
2281                         break;
2282                 case T_ScalarArrayOpExpr:
2283                         retval = _copyScalarArrayOpExpr(from);
2284                         break;
2285                 case T_BoolExpr:
2286                         retval = _copyBoolExpr(from);
2287                         break;
2288                 case T_SubLink:
2289                         retval = _copySubLink(from);
2290                         break;
2291                 case T_SubPlan:
2292                         retval = _copySubPlan(from);
2293                         break;
2294                 case T_FieldSelect:
2295                         retval = _copyFieldSelect(from);
2296                         break;
2297                 case T_FieldStore:
2298                         retval = _copyFieldStore(from);
2299                         break;
2300                 case T_RelabelType:
2301                         retval = _copyRelabelType(from);
2302                         break;
2303                 case T_CoerceViaIO:
2304                         retval = _copyCoerceViaIO(from);
2305                         break;
2306                 case T_ArrayCoerceExpr:
2307                         retval = _copyArrayCoerceExpr(from);
2308                         break;
2309                 case T_ConvertRowtypeExpr:
2310                         retval = _copyConvertRowtypeExpr(from);
2311                         break;
2312                 case T_CaseExpr:
2313                         retval = _copyCaseExpr(from);
2314                         break;
2315                 case T_CaseWhen:
2316                         retval = _copyCaseWhen(from);
2317                         break;
2318                 case T_CaseTestExpr:
2319                         retval = _copyCaseTestExpr(from);
2320                         break;
2321                 case T_ArrayExpr:
2322                         retval = _copyArrayExpr(from);
2323                         break;
2324                 case T_RowExpr:
2325                         retval = _copyRowExpr(from);
2326                         break;
2327                 case T_RowCompareExpr:
2328                         retval = _copyRowCompareExpr(from);
2329                         break;
2330                 case T_CoalesceExpr:
2331                         retval = _copyCoalesceExpr(from);
2332                         break;
2333                 case T_MinMaxExpr:
2334                         retval = _copyMinMaxExpr(from);
2335                         break;
2336                 case T_XmlExpr:
2337                         retval = _copyXmlExpr(from);
2338                         break;
2339                 case T_NullIfExpr:
2340                         retval = _copyNullIfExpr(from);
2341                         break;
2342                 case T_NullTest:
2343                         retval = _copyNullTest(from);
2344                         break;
2345                 case T_BooleanTest:
2346                         retval = _copyBooleanTest(from);
2347                         break;
2348                 case T_CoerceToDomain:
2349                         retval = _copyCoerceToDomain(from);
2350                         break;
2351                 case T_CoerceToDomainValue:
2352                         retval = _copyCoerceToDomainValue(from);
2353                         break;
2354                 case T_SetToDefault:
2355                         retval = _copySetToDefault(from);
2356                         break;
2357                 case T_CurrentOfExpr:
2358                         retval = _copyCurrentOfExpr(from);
2359                         break;
2360                 case T_TargetEntry:
2361                         retval = _copyTargetEntry(from);
2362                         break;
2363                 case T_RangeTblRef:
2364                         retval = _copyRangeTblRef(from);
2365                         break;
2366                 case T_JoinExpr:
2367                         retval = _copyJoinExpr(from);
2368                         break;
2369                 case T_FromExpr:
2370                         retval = _copyFromExpr(from);
2371                         break;
2372
2373                         /*
2374                          * VALUE NODES
2375                          */
2376                 case T_Integer:
2377                 case T_Float:
2378                 case T_String:
2379                 case T_BitString:
2380                 case T_Null:
2381                         retval = _copyValue(from);
2382                         break;
2383
2384                         /*
2385                          * LIST NODES
2386                          */
2387                 case T_List:
2388                         retval = _copyList(from);
2389                         break;
2390
2391                         /*
2392                          * Lists of integers and OIDs don't need to be deep-copied, so we
2393                          * perform a shallow copy via list_copy()
2394                          */
2395                 case T_IntList:
2396                 case T_OidList:
2397                         retval = list_copy(from);
2398                         break;
2399
2400                         /*
2401                          * PARSE NODES
2402                          */
2403                 case T_Query:
2404                         retval = _copyQuery(from);
2405                         break;
2406                 case T_InsertStmt:
2407                         retval = _copyInsertStmt(from);
2408                         break;
2409                 case T_DeleteStmt:
2410                         retval = _copyDeleteStmt(from);
2411                         break;
2412                 case T_UpdateStmt:
2413                         retval = _copyUpdateStmt(from);
2414                         break;
2415                 case T_SelectStmt:
2416                         retval = _copySelectStmt(from);
2417                         break;
2418                 case T_SetOperationStmt:
2419                         retval = _copySetOperationStmt(from);
2420                         break;
2421                 case T_AlterTableStmt:
2422                         retval = _copyAlterTableStmt(from);
2423                         break;
2424                 case T_AlterTableCmd:
2425                         retval = _copyAlterTableCmd(from);
2426                         break;
2427                 case T_AlterDomainStmt:
2428                         retval = _copyAlterDomainStmt(from);
2429                         break;
2430                 case T_GrantStmt:
2431                         retval = _copyGrantStmt(from);
2432                         break;
2433                 case T_GrantRoleStmt:
2434                         retval = _copyGrantRoleStmt(from);
2435                         break;
2436                 case T_DeclareCursorStmt:
2437                         retval = _copyDeclareCursorStmt(from);
2438                         break;
2439                 case T_ClosePortalStmt:
2440                         retval = _copyClosePortalStmt(from);
2441                         break;
2442                 case T_ClusterStmt:
2443                         retval = _copyClusterStmt(from);
2444                         break;
2445                 case T_CopyStmt:
2446                         retval = _copyCopyStmt(from);
2447                         break;
2448                 case T_CreateStmt:
2449                         retval = _copyCreateStmt(from);
2450                         break;
2451                 case T_InhRelation:
2452                         retval = _copyInhRelation(from);
2453                         break;
2454                 case T_DefineStmt:
2455                         retval = _copyDefineStmt(from);
2456                         break;
2457                 case T_DropStmt:
2458                         retval = _copyDropStmt(from);
2459                         break;
2460                 case T_TruncateStmt:
2461                         retval = _copyTruncateStmt(from);
2462                         break;
2463                 case T_CommentStmt:
2464                         retval = _copyCommentStmt(from);
2465                         break;
2466                 case T_FetchStmt:
2467                         retval = _copyFetchStmt(from);
2468                         break;
2469                 case T_IndexStmt:
2470                         retval = _copyIndexStmt(from);
2471                         break;
2472                 case T_CreateFunctionStmt:
2473                         retval = _copyCreateFunctionStmt(from);
2474                         break;
2475                 case T_FunctionParameter:
2476                         retval = _copyFunctionParameter(from);
2477                         break;
2478                 case T_AlterFunctionStmt:
2479                         retval = _copyAlterFunctionStmt(from);
2480                         break;
2481                 case T_RemoveFuncStmt:
2482                         retval = _copyRemoveFuncStmt(from);
2483                         break;
2484                 case T_RemoveOpClassStmt:
2485                         retval = _copyRemoveOpClassStmt(from);
2486                         break;
2487                 case T_RemoveOpFamilyStmt:
2488                         retval = _copyRemoveOpFamilyStmt(from);
2489                         break;
2490                 case T_RenameStmt:
2491                         retval = _copyRenameStmt(from);
2492                         break;
2493                 case T_AlterObjectSchemaStmt:
2494                         retval = _copyAlterObjectSchemaStmt(from);
2495                         break;
2496                 case T_AlterOwnerStmt:
2497                         retval = _copyAlterOwnerStmt(from);
2498                         break;
2499                 case T_RuleStmt:
2500                         retval = _copyRuleStmt(from);
2501                         break;
2502                 case T_NotifyStmt:
2503                         retval = _copyNotifyStmt(from);
2504                         break;
2505                 case T_ListenStmt:
2506                         retval = _copyListenStmt(from);
2507                         break;
2508                 case T_UnlistenStmt:
2509                         retval = _copyUnlistenStmt(from);
2510                         break;
2511                 case T_TransactionStmt:
2512                         retval = _copyTransactionStmt(from);
2513                         break;
2514                 case T_CompositeTypeStmt:
2515                         retval = _copyCompositeTypeStmt(from);
2516                         break;
2517                 case T_CreateEnumStmt:
2518                         retval = _copyCreateEnumStmt(from);
2519                         break;
2520                 case T_ViewStmt:
2521                         retval = _copyViewStmt(from);
2522                         break;
2523                 case T_LoadStmt:
2524                         retval = _copyLoadStmt(from);
2525                         break;
2526                 case T_CreateDomainStmt:
2527                         retval = _copyCreateDomainStmt(from);
2528                         break;
2529                 case T_CreateOpClassStmt:
2530                         retval = _copyCreateOpClassStmt(from);
2531                         break;
2532                 case T_CreateOpClassItem:
2533                         retval = _copyCreateOpClassItem(from);
2534                         break;
2535                 case T_CreateOpFamilyStmt:
2536                         retval = _copyCreateOpFamilyStmt(from);
2537                         break;
2538                 case T_AlterOpFamilyStmt:
2539                         retval = _copyAlterOpFamilyStmt(from);
2540                         break;
2541                 case T_CreatedbStmt:
2542                         retval = _copyCreatedbStmt(from);
2543                         break;
2544                 case T_AlterDatabaseStmt:
2545                         retval = _copyAlterDatabaseStmt(from);
2546                         break;
2547                 case T_AlterDatabaseSetStmt:
2548                         retval = _copyAlterDatabaseSetStmt(from);
2549                         break;
2550                 case T_DropdbStmt:
2551                         retval = _copyDropdbStmt(from);
2552                         break;
2553                 case T_VacuumStmt:
2554                         retval = _copyVacuumStmt(from);
2555                         break;
2556                 case T_ExplainStmt:
2557                         retval = _copyExplainStmt(from);
2558                         break;
2559                 case T_CreateSeqStmt:
2560                         retval = _copyCreateSeqStmt(from);
2561                         break;
2562                 case T_AlterSeqStmt:
2563                         retval = _copyAlterSeqStmt(from);
2564                         break;
2565                 case T_VariableSetStmt:
2566                         retval = _copyVariableSetStmt(from);
2567                         break;
2568                 case T_VariableShowStmt:
2569                         retval = _copyVariableShowStmt(from);
2570                         break;
2571                 case T_DiscardStmt:
2572                         retval = _copyDiscardStmt(from);
2573                         break;
2574                 case T_CreateTableSpaceStmt:
2575                         retval = _copyCreateTableSpaceStmt(from);
2576                         break;
2577                 case T_DropTableSpaceStmt:
2578                         retval = _copyDropTableSpaceStmt(from);
2579                         break;
2580                 case T_CreateTrigStmt:
2581                         retval = _copyCreateTrigStmt(from);
2582                         break;
2583                 case T_DropPropertyStmt:
2584                         retval = _copyDropPropertyStmt(from);
2585                         break;
2586                 case T_CreatePLangStmt:
2587                         retval = _copyCreatePLangStmt(from);
2588                         break;
2589                 case T_DropPLangStmt:
2590                         retval = _copyDropPLangStmt(from);
2591                         break;
2592                 case T_CreateRoleStmt:
2593                         retval = _copyCreateRoleStmt(from);
2594                         break;
2595                 case T_AlterRoleStmt:
2596                         retval = _copyAlterRoleStmt(from);
2597                         break;
2598                 case T_AlterRoleSetStmt:
2599                         retval = _copyAlterRoleSetStmt(from);
2600                         break;
2601                 case T_DropRoleStmt:
2602                         retval = _copyDropRoleStmt(from);
2603                         break;
2604                 case T_LockStmt:
2605                         retval = _copyLockStmt(from);
2606                         break;
2607                 case T_ConstraintsSetStmt:
2608                         retval = _copyConstraintsSetStmt(from);
2609                         break;
2610                 case T_ReindexStmt:
2611                         retval = _copyReindexStmt(from);
2612                         break;
2613                 case T_CheckPointStmt:
2614                         retval = (void *) makeNode(CheckPointStmt);
2615                         break;
2616                 case T_CreateSchemaStmt:
2617                         retval = _copyCreateSchemaStmt(from);
2618                         break;
2619                 case T_CreateConversionStmt:
2620                         retval = _copyCreateConversionStmt(from);
2621                         break;
2622                 case T_CreateCastStmt:
2623                         retval = _copyCreateCastStmt(from);
2624                         break;
2625                 case T_DropCastStmt:
2626                         retval = _copyDropCastStmt(from);
2627                         break;
2628                 case T_PrepareStmt:
2629                         retval = _copyPrepareStmt(from);
2630                         break;
2631                 case T_ExecuteStmt:
2632                         retval = _copyExecuteStmt(from);
2633                         break;
2634                 case T_DeallocateStmt:
2635                         retval = _copyDeallocateStmt(from);
2636                         break;
2637                 case T_DropOwnedStmt:
2638                         retval = _copyDropOwnedStmt(from);
2639                         break;
2640                 case T_ReassignOwnedStmt:
2641                         retval = _copyReassignOwnedStmt(from);
2642                         break;
2643
2644                 case T_A_Expr:
2645                         retval = _copyAExpr(from);
2646                         break;
2647                 case T_ColumnRef:
2648                         retval = _copyColumnRef(from);
2649                         break;
2650                 case T_ParamRef:
2651                         retval = _copyParamRef(from);
2652                         break;
2653                 case T_A_Const:
2654                         retval = _copyAConst(from);
2655                         break;
2656                 case T_FuncCall:
2657                         retval = _copyFuncCall(from);
2658                         break;
2659                 case T_A_Indices:
2660                         retval = _copyAIndices(from);
2661                         break;
2662                 case T_A_Indirection:
2663                         retval = _copyA_Indirection(from);
2664                         break;
2665                 case T_ResTarget:
2666                         retval = _copyResTarget(from);
2667                         break;
2668                 case T_TypeCast:
2669                         retval = _copyTypeCast(from);
2670                         break;
2671                 case T_SortBy:
2672                         retval = _copySortBy(from);
2673                         break;
2674                 case T_RangeSubselect:
2675                         retval = _copyRangeSubselect(from);
2676                         break;
2677                 case T_RangeFunction:
2678                         retval = _copyRangeFunction(from);
2679                         break;
2680                 case T_TypeName:
2681                         retval = _copyTypeName(from);
2682                         break;
2683                 case T_IndexElem:
2684                         retval = _copyIndexElem(from);
2685                         break;
2686                 case T_ColumnDef:
2687                         retval = _copyColumnDef(from);
2688                         break;
2689                 case T_Constraint:
2690                         retval = _copyConstraint(from);
2691                         break;
2692                 case T_DefElem:
2693                         retval = _copyDefElem(from);
2694                         break;
2695                 case T_LockingClause:
2696                         retval = _copyLockingClause(from);
2697                         break;
2698                 case T_RangeTblEntry:
2699                         retval = _copyRangeTblEntry(from);
2700                         break;
2701                 case T_SortClause:
2702                         retval = _copySortClause(from);
2703                         break;
2704                 case T_GroupClause:
2705                         retval = _copyGroupClause(from);
2706                         break;
2707                 case T_RowMarkClause:
2708                         retval = _copyRowMarkClause(from);
2709                         break;
2710                 case T_FkConstraint:
2711                         retval = _copyFkConstraint(from);
2712                         break;
2713                 case T_PrivGrantee:
2714                         retval = _copyPrivGrantee(from);
2715                         break;
2716                 case T_FuncWithArgs:
2717                         retval = _copyFuncWithArgs(from);
2718                         break;
2719                 case T_XmlSerialize:
2720                         retval = _copyXmlSerialize(from);
2721                         break;
2722
2723                 default:
2724                         pool_error("unrecognized node type: %d", (int) nodeTag(from));
2725                         retval = from;          /* keep compiler quiet */
2726                         break;
2727         }
2728
2729         return retval;
2730 }