LCOV - code coverage report
Current view: top level - src/backend/nodes - copyfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15devel Lines: 3179 3335 95.3 %
Date: 2021-12-09 04:09:06 Functions: 282 295 95.6 %
Legend: Lines: hit not hit

          Line data    Source code
       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) 1996-2021, PostgreSQL Global Development Group
      15             :  * Portions Copyright (c) 1994, Regents of the University of California
      16             :  *
      17             :  * IDENTIFICATION
      18             :  *    src/backend/nodes/copyfuncs.c
      19             :  *
      20             :  *-------------------------------------------------------------------------
      21             :  */
      22             : 
      23             : #include "postgres.h"
      24             : 
      25             : #include "miscadmin.h"
      26             : #include "nodes/extensible.h"
      27             : #include "nodes/pathnodes.h"
      28             : #include "nodes/plannodes.h"
      29             : #include "utils/datum.h"
      30             : #include "utils/rel.h"
      31             : 
      32             : 
      33             : /*
      34             :  * Macros to simplify copying of different kinds of fields.  Use these
      35             :  * wherever possible to reduce the chance for silly typos.  Note that these
      36             :  * hard-wire the convention that the local variables in a Copy routine are
      37             :  * named 'newnode' and 'from'.
      38             :  */
      39             : 
      40             : /* Copy a simple scalar field (int, float, bool, enum, etc) */
      41             : #define COPY_SCALAR_FIELD(fldname) \
      42             :     (newnode->fldname = from->fldname)
      43             : 
      44             : /* Copy a field that is a pointer to some kind of Node or Node tree */
      45             : #define COPY_NODE_FIELD(fldname) \
      46             :     (newnode->fldname = copyObjectImpl(from->fldname))
      47             : 
      48             : /* Copy a field that is a pointer to a Bitmapset */
      49             : #define COPY_BITMAPSET_FIELD(fldname) \
      50             :     (newnode->fldname = bms_copy(from->fldname))
      51             : 
      52             : /* Copy a field that is a pointer to a C string, or perhaps NULL */
      53             : #define COPY_STRING_FIELD(fldname) \
      54             :     (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
      55             : 
      56             : /* Copy a field that is an inline array */
      57             : #define COPY_ARRAY_FIELD(fldname) \
      58             :     memcpy(newnode->fldname, from->fldname, sizeof(newnode->fldname))
      59             : 
      60             : /* Copy a field that is a pointer to a simple palloc'd object of size sz */
      61             : #define COPY_POINTER_FIELD(fldname, sz) \
      62             :     do { \
      63             :         Size    _size = (sz); \
      64             :         if (_size > 0) \
      65             :         { \
      66             :             newnode->fldname = palloc(_size); \
      67             :             memcpy(newnode->fldname, from->fldname, _size); \
      68             :         } \
      69             :     } while (0)
      70             : 
      71             : /* Copy a parse location field (for Copy, this is same as scalar case) */
      72             : #define COPY_LOCATION_FIELD(fldname) \
      73             :     (newnode->fldname = from->fldname)
      74             : 
      75             : 
      76             : /* ****************************************************************
      77             :  *                   plannodes.h copy functions
      78             :  * ****************************************************************
      79             :  */
      80             : 
      81             : /*
      82             :  * _copyPlannedStmt
      83             :  */
      84             : static PlannedStmt *
      85      344448 : _copyPlannedStmt(const PlannedStmt *from)
      86             : {
      87      344448 :     PlannedStmt *newnode = makeNode(PlannedStmt);
      88             : 
      89      344448 :     COPY_SCALAR_FIELD(commandType);
      90      344448 :     COPY_SCALAR_FIELD(queryId);
      91      344448 :     COPY_SCALAR_FIELD(hasReturning);
      92      344448 :     COPY_SCALAR_FIELD(hasModifyingCTE);
      93      344448 :     COPY_SCALAR_FIELD(canSetTag);
      94      344448 :     COPY_SCALAR_FIELD(transientPlan);
      95      344448 :     COPY_SCALAR_FIELD(dependsOnRole);
      96      344448 :     COPY_SCALAR_FIELD(parallelModeNeeded);
      97      344448 :     COPY_SCALAR_FIELD(jitFlags);
      98      344448 :     COPY_NODE_FIELD(planTree);
      99      344448 :     COPY_NODE_FIELD(rtable);
     100      344448 :     COPY_NODE_FIELD(resultRelations);
     101      344448 :     COPY_NODE_FIELD(appendRelations);
     102      344448 :     COPY_NODE_FIELD(subplans);
     103      344448 :     COPY_BITMAPSET_FIELD(rewindPlanIDs);
     104      344448 :     COPY_NODE_FIELD(rowMarks);
     105      344448 :     COPY_NODE_FIELD(relationOids);
     106      344448 :     COPY_NODE_FIELD(invalItems);
     107      344448 :     COPY_NODE_FIELD(paramExecTypes);
     108      344448 :     COPY_NODE_FIELD(utilityStmt);
     109      344448 :     COPY_LOCATION_FIELD(stmt_location);
     110      344448 :     COPY_SCALAR_FIELD(stmt_len);
     111             : 
     112      344448 :     return newnode;
     113             : }
     114             : 
     115             : /*
     116             :  * CopyPlanFields
     117             :  *
     118             :  *      This function copies the fields of the Plan node.  It is used by
     119             :  *      all the copy functions for classes which inherit from Plan.
     120             :  */
     121             : static void
     122      712112 : CopyPlanFields(const Plan *from, Plan *newnode)
     123             : {
     124      712112 :     COPY_SCALAR_FIELD(startup_cost);
     125      712112 :     COPY_SCALAR_FIELD(total_cost);
     126      712112 :     COPY_SCALAR_FIELD(plan_rows);
     127      712112 :     COPY_SCALAR_FIELD(plan_width);
     128      712112 :     COPY_SCALAR_FIELD(parallel_aware);
     129      712112 :     COPY_SCALAR_FIELD(parallel_safe);
     130      712112 :     COPY_SCALAR_FIELD(async_capable);
     131      712112 :     COPY_SCALAR_FIELD(plan_node_id);
     132      712112 :     COPY_NODE_FIELD(targetlist);
     133      712112 :     COPY_NODE_FIELD(qual);
     134      712112 :     COPY_NODE_FIELD(lefttree);
     135      712112 :     COPY_NODE_FIELD(righttree);
     136      712112 :     COPY_NODE_FIELD(initPlan);
     137      712112 :     COPY_BITMAPSET_FIELD(extParam);
     138      712112 :     COPY_BITMAPSET_FIELD(allParam);
     139      712112 : }
     140             : 
     141             : /*
     142             :  * _copyPlan
     143             :  */
     144             : static Plan *
     145           0 : _copyPlan(const Plan *from)
     146             : {
     147           0 :     Plan       *newnode = makeNode(Plan);
     148             : 
     149             :     /*
     150             :      * copy node superclass fields
     151             :      */
     152           0 :     CopyPlanFields(from, newnode);
     153             : 
     154           0 :     return newnode;
     155             : }
     156             : 
     157             : 
     158             : /*
     159             :  * _copyResult
     160             :  */
     161             : static Result *
     162      168710 : _copyResult(const Result *from)
     163             : {
     164      168710 :     Result     *newnode = makeNode(Result);
     165             : 
     166             :     /*
     167             :      * copy node superclass fields
     168             :      */
     169      168710 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     170             : 
     171             :     /*
     172             :      * copy remainder of node
     173             :      */
     174      168710 :     COPY_NODE_FIELD(resconstantqual);
     175             : 
     176      168710 :     return newnode;
     177             : }
     178             : 
     179             : /*
     180             :  * _copyProjectSet
     181             :  */
     182             : static ProjectSet *
     183        4492 : _copyProjectSet(const ProjectSet *from)
     184             : {
     185        4492 :     ProjectSet *newnode = makeNode(ProjectSet);
     186             : 
     187             :     /*
     188             :      * copy node superclass fields
     189             :      */
     190        4492 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     191             : 
     192        4492 :     return newnode;
     193             : }
     194             : 
     195             : /*
     196             :  * _copyModifyTable
     197             :  */
     198             : static ModifyTable *
     199       83816 : _copyModifyTable(const ModifyTable *from)
     200             : {
     201       83816 :     ModifyTable *newnode = makeNode(ModifyTable);
     202             : 
     203             :     /*
     204             :      * copy node superclass fields
     205             :      */
     206       83816 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     207             : 
     208             :     /*
     209             :      * copy remainder of node
     210             :      */
     211       83816 :     COPY_SCALAR_FIELD(operation);
     212       83816 :     COPY_SCALAR_FIELD(canSetTag);
     213       83816 :     COPY_SCALAR_FIELD(nominalRelation);
     214       83816 :     COPY_SCALAR_FIELD(rootRelation);
     215       83816 :     COPY_SCALAR_FIELD(partColsUpdated);
     216       83816 :     COPY_NODE_FIELD(resultRelations);
     217       83816 :     COPY_NODE_FIELD(updateColnosLists);
     218       83816 :     COPY_NODE_FIELD(withCheckOptionLists);
     219       83816 :     COPY_NODE_FIELD(returningLists);
     220       83816 :     COPY_NODE_FIELD(fdwPrivLists);
     221       83816 :     COPY_BITMAPSET_FIELD(fdwDirectModifyPlans);
     222       83816 :     COPY_NODE_FIELD(rowMarks);
     223       83816 :     COPY_SCALAR_FIELD(epqParam);
     224       83816 :     COPY_SCALAR_FIELD(onConflictAction);
     225       83816 :     COPY_NODE_FIELD(arbiterIndexes);
     226       83816 :     COPY_NODE_FIELD(onConflictSet);
     227       83816 :     COPY_NODE_FIELD(onConflictCols);
     228       83816 :     COPY_NODE_FIELD(onConflictWhere);
     229       83816 :     COPY_SCALAR_FIELD(exclRelRTI);
     230       83816 :     COPY_NODE_FIELD(exclRelTlist);
     231             : 
     232       83816 :     return newnode;
     233             : }
     234             : 
     235             : /*
     236             :  * _copyAppend
     237             :  */
     238             : static Append *
     239        8526 : _copyAppend(const Append *from)
     240             : {
     241        8526 :     Append     *newnode = makeNode(Append);
     242             : 
     243             :     /*
     244             :      * copy node superclass fields
     245             :      */
     246        8526 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     247             : 
     248             :     /*
     249             :      * copy remainder of node
     250             :      */
     251        8526 :     COPY_BITMAPSET_FIELD(apprelids);
     252        8526 :     COPY_NODE_FIELD(appendplans);
     253        8526 :     COPY_SCALAR_FIELD(nasyncplans);
     254        8526 :     COPY_SCALAR_FIELD(first_partial_plan);
     255        8526 :     COPY_NODE_FIELD(part_prune_info);
     256             : 
     257        8526 :     return newnode;
     258             : }
     259             : 
     260             : /*
     261             :  * _copyMergeAppend
     262             :  */
     263             : static MergeAppend *
     264         256 : _copyMergeAppend(const MergeAppend *from)
     265             : {
     266         256 :     MergeAppend *newnode = makeNode(MergeAppend);
     267             : 
     268             :     /*
     269             :      * copy node superclass fields
     270             :      */
     271         256 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     272             : 
     273             :     /*
     274             :      * copy remainder of node
     275             :      */
     276         256 :     COPY_BITMAPSET_FIELD(apprelids);
     277         256 :     COPY_NODE_FIELD(mergeplans);
     278         256 :     COPY_SCALAR_FIELD(numCols);
     279         256 :     COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
     280         256 :     COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
     281         256 :     COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
     282         256 :     COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
     283         256 :     COPY_NODE_FIELD(part_prune_info);
     284             : 
     285         256 :     return newnode;
     286             : }
     287             : 
     288             : /*
     289             :  * _copyRecursiveUnion
     290             :  */
     291             : static RecursiveUnion *
     292         454 : _copyRecursiveUnion(const RecursiveUnion *from)
     293             : {
     294         454 :     RecursiveUnion *newnode = makeNode(RecursiveUnion);
     295             : 
     296             :     /*
     297             :      * copy node superclass fields
     298             :      */
     299         454 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     300             : 
     301             :     /*
     302             :      * copy remainder of node
     303             :      */
     304         454 :     COPY_SCALAR_FIELD(wtParam);
     305         454 :     COPY_SCALAR_FIELD(numCols);
     306         454 :     COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
     307         454 :     COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
     308         454 :     COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
     309         454 :     COPY_SCALAR_FIELD(numGroups);
     310             : 
     311         454 :     return newnode;
     312             : }
     313             : 
     314             : /*
     315             :  * _copyBitmapAnd
     316             :  */
     317             : static BitmapAnd *
     318          60 : _copyBitmapAnd(const BitmapAnd *from)
     319             : {
     320          60 :     BitmapAnd  *newnode = makeNode(BitmapAnd);
     321             : 
     322             :     /*
     323             :      * copy node superclass fields
     324             :      */
     325          60 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     326             : 
     327             :     /*
     328             :      * copy remainder of node
     329             :      */
     330          60 :     COPY_NODE_FIELD(bitmapplans);
     331             : 
     332          60 :     return newnode;
     333             : }
     334             : 
     335             : /*
     336             :  * _copyBitmapOr
     337             :  */
     338             : static BitmapOr *
     339         152 : _copyBitmapOr(const BitmapOr *from)
     340             : {
     341         152 :     BitmapOr   *newnode = makeNode(BitmapOr);
     342             : 
     343             :     /*
     344             :      * copy node superclass fields
     345             :      */
     346         152 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     347             : 
     348             :     /*
     349             :      * copy remainder of node
     350             :      */
     351         152 :     COPY_SCALAR_FIELD(isshared);
     352         152 :     COPY_NODE_FIELD(bitmapplans);
     353             : 
     354         152 :     return newnode;
     355             : }
     356             : 
     357             : /*
     358             :  * _copyGather
     359             :  */
     360             : static Gather *
     361         630 : _copyGather(const Gather *from)
     362             : {
     363         630 :     Gather     *newnode = makeNode(Gather);
     364             : 
     365             :     /*
     366             :      * copy node superclass fields
     367             :      */
     368         630 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     369             : 
     370             :     /*
     371             :      * copy remainder of node
     372             :      */
     373         630 :     COPY_SCALAR_FIELD(num_workers);
     374         630 :     COPY_SCALAR_FIELD(rescan_param);
     375         630 :     COPY_SCALAR_FIELD(single_copy);
     376         630 :     COPY_SCALAR_FIELD(invisible);
     377         630 :     COPY_BITMAPSET_FIELD(initParam);
     378             : 
     379         630 :     return newnode;
     380             : }
     381             : 
     382             : /*
     383             :  * _copyGatherMerge
     384             :  */
     385             : static GatherMerge *
     386         180 : _copyGatherMerge(const GatherMerge *from)
     387             : {
     388         180 :     GatherMerge *newnode = makeNode(GatherMerge);
     389             : 
     390             :     /*
     391             :      * copy node superclass fields
     392             :      */
     393         180 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     394             : 
     395             :     /*
     396             :      * copy remainder of node
     397             :      */
     398         180 :     COPY_SCALAR_FIELD(num_workers);
     399         180 :     COPY_SCALAR_FIELD(rescan_param);
     400         180 :     COPY_SCALAR_FIELD(numCols);
     401         180 :     COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
     402         180 :     COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
     403         180 :     COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
     404         180 :     COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
     405         180 :     COPY_BITMAPSET_FIELD(initParam);
     406             : 
     407         180 :     return newnode;
     408             : }
     409             : 
     410             : /*
     411             :  * CopyScanFields
     412             :  *
     413             :  *      This function copies the fields of the Scan node.  It is used by
     414             :  *      all the copy functions for classes which inherit from Scan.
     415             :  */
     416             : static void
     417      286900 : CopyScanFields(const Scan *from, Scan *newnode)
     418             : {
     419      286900 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     420             : 
     421      286900 :     COPY_SCALAR_FIELD(scanrelid);
     422      286900 : }
     423             : 
     424             : /*
     425             :  * _copyScan
     426             :  */
     427             : static Scan *
     428           0 : _copyScan(const Scan *from)
     429             : {
     430           0 :     Scan       *newnode = makeNode(Scan);
     431             : 
     432             :     /*
     433             :      * copy node superclass fields
     434             :      */
     435           0 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     436             : 
     437           0 :     return newnode;
     438             : }
     439             : 
     440             : /*
     441             :  * _copySeqScan
     442             :  */
     443             : static SeqScan *
     444      129258 : _copySeqScan(const SeqScan *from)
     445             : {
     446      129258 :     SeqScan    *newnode = makeNode(SeqScan);
     447             : 
     448             :     /*
     449             :      * copy node superclass fields
     450             :      */
     451      129258 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     452             : 
     453      129258 :     return newnode;
     454             : }
     455             : 
     456             : /*
     457             :  * _copySampleScan
     458             :  */
     459             : static SampleScan *
     460         184 : _copySampleScan(const SampleScan *from)
     461             : {
     462         184 :     SampleScan *newnode = makeNode(SampleScan);
     463             : 
     464             :     /*
     465             :      * copy node superclass fields
     466             :      */
     467         184 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     468             : 
     469             :     /*
     470             :      * copy remainder of node
     471             :      */
     472         184 :     COPY_NODE_FIELD(tablesample);
     473             : 
     474         184 :     return newnode;
     475             : }
     476             : 
     477             : /*
     478             :  * _copyIndexScan
     479             :  */
     480             : static IndexScan *
     481       77894 : _copyIndexScan(const IndexScan *from)
     482             : {
     483       77894 :     IndexScan  *newnode = makeNode(IndexScan);
     484             : 
     485             :     /*
     486             :      * copy node superclass fields
     487             :      */
     488       77894 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     489             : 
     490             :     /*
     491             :      * copy remainder of node
     492             :      */
     493       77894 :     COPY_SCALAR_FIELD(indexid);
     494       77894 :     COPY_NODE_FIELD(indexqual);
     495       77894 :     COPY_NODE_FIELD(indexqualorig);
     496       77894 :     COPY_NODE_FIELD(indexorderby);
     497       77894 :     COPY_NODE_FIELD(indexorderbyorig);
     498       77894 :     COPY_NODE_FIELD(indexorderbyops);
     499       77894 :     COPY_SCALAR_FIELD(indexorderdir);
     500             : 
     501       77894 :     return newnode;
     502             : }
     503             : 
     504             : /*
     505             :  * _copyIndexOnlyScan
     506             :  */
     507             : static IndexOnlyScan *
     508        9850 : _copyIndexOnlyScan(const IndexOnlyScan *from)
     509             : {
     510        9850 :     IndexOnlyScan *newnode = makeNode(IndexOnlyScan);
     511             : 
     512             :     /*
     513             :      * copy node superclass fields
     514             :      */
     515        9850 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     516             : 
     517             :     /*
     518             :      * copy remainder of node
     519             :      */
     520        9850 :     COPY_SCALAR_FIELD(indexid);
     521        9850 :     COPY_NODE_FIELD(indexqual);
     522        9850 :     COPY_NODE_FIELD(indexorderby);
     523        9850 :     COPY_NODE_FIELD(indextlist);
     524        9850 :     COPY_SCALAR_FIELD(indexorderdir);
     525             : 
     526        9850 :     return newnode;
     527             : }
     528             : 
     529             : /*
     530             :  * _copyBitmapIndexScan
     531             :  */
     532             : static BitmapIndexScan *
     533       15876 : _copyBitmapIndexScan(const BitmapIndexScan *from)
     534             : {
     535       15876 :     BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
     536             : 
     537             :     /*
     538             :      * copy node superclass fields
     539             :      */
     540       15876 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     541             : 
     542             :     /*
     543             :      * copy remainder of node
     544             :      */
     545       15876 :     COPY_SCALAR_FIELD(indexid);
     546       15876 :     COPY_SCALAR_FIELD(isshared);
     547       15876 :     COPY_NODE_FIELD(indexqual);
     548       15876 :     COPY_NODE_FIELD(indexqualorig);
     549             : 
     550       15876 :     return newnode;
     551             : }
     552             : 
     553             : /*
     554             :  * _copyBitmapHeapScan
     555             :  */
     556             : static BitmapHeapScan *
     557       15628 : _copyBitmapHeapScan(const BitmapHeapScan *from)
     558             : {
     559       15628 :     BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
     560             : 
     561             :     /*
     562             :      * copy node superclass fields
     563             :      */
     564       15628 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     565             : 
     566             :     /*
     567             :      * copy remainder of node
     568             :      */
     569       15628 :     COPY_NODE_FIELD(bitmapqualorig);
     570             : 
     571       15628 :     return newnode;
     572             : }
     573             : 
     574             : /*
     575             :  * _copyTidScan
     576             :  */
     577             : static TidScan *
     578         672 : _copyTidScan(const TidScan *from)
     579             : {
     580         672 :     TidScan    *newnode = makeNode(TidScan);
     581             : 
     582             :     /*
     583             :      * copy node superclass fields
     584             :      */
     585         672 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     586             : 
     587             :     /*
     588             :      * copy remainder of node
     589             :      */
     590         672 :     COPY_NODE_FIELD(tidquals);
     591             : 
     592         672 :     return newnode;
     593             : }
     594             : 
     595             : /*
     596             :  * _copyTidRangeScan
     597             :  */
     598             : static TidRangeScan *
     599         140 : _copyTidRangeScan(const TidRangeScan *from)
     600             : {
     601         140 :     TidRangeScan *newnode = makeNode(TidRangeScan);
     602             : 
     603             :     /*
     604             :      * copy node superclass fields
     605             :      */
     606         140 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     607             : 
     608             :     /*
     609             :      * copy remainder of node
     610             :      */
     611         140 :     COPY_NODE_FIELD(tidrangequals);
     612             : 
     613         140 :     return newnode;
     614             : }
     615             : 
     616             : /*
     617             :  * _copySubqueryScan
     618             :  */
     619             : static SubqueryScan *
     620        3250 : _copySubqueryScan(const SubqueryScan *from)
     621             : {
     622        3250 :     SubqueryScan *newnode = makeNode(SubqueryScan);
     623             : 
     624             :     /*
     625             :      * copy node superclass fields
     626             :      */
     627        3250 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     628             : 
     629             :     /*
     630             :      * copy remainder of node
     631             :      */
     632        3250 :     COPY_NODE_FIELD(subplan);
     633             : 
     634        3250 :     return newnode;
     635             : }
     636             : 
     637             : /*
     638             :  * _copyFunctionScan
     639             :  */
     640             : static FunctionScan *
     641       24630 : _copyFunctionScan(const FunctionScan *from)
     642             : {
     643       24630 :     FunctionScan *newnode = makeNode(FunctionScan);
     644             : 
     645             :     /*
     646             :      * copy node superclass fields
     647             :      */
     648       24630 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     649             : 
     650             :     /*
     651             :      * copy remainder of node
     652             :      */
     653       24630 :     COPY_NODE_FIELD(functions);
     654       24630 :     COPY_SCALAR_FIELD(funcordinality);
     655             : 
     656       24630 :     return newnode;
     657             : }
     658             : 
     659             : /*
     660             :  * _copyTableFuncScan
     661             :  */
     662             : static TableFuncScan *
     663         148 : _copyTableFuncScan(const TableFuncScan *from)
     664             : {
     665         148 :     TableFuncScan *newnode = makeNode(TableFuncScan);
     666             : 
     667             :     /*
     668             :      * copy node superclass fields
     669             :      */
     670         148 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     671             : 
     672             :     /*
     673             :      * copy remainder of node
     674             :      */
     675         148 :     COPY_NODE_FIELD(tablefunc);
     676             : 
     677         148 :     return newnode;
     678             : }
     679             : 
     680             : /*
     681             :  * _copyValuesScan
     682             :  */
     683             : static ValuesScan *
     684        4856 : _copyValuesScan(const ValuesScan *from)
     685             : {
     686        4856 :     ValuesScan *newnode = makeNode(ValuesScan);
     687             : 
     688             :     /*
     689             :      * copy node superclass fields
     690             :      */
     691        4856 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     692             : 
     693             :     /*
     694             :      * copy remainder of node
     695             :      */
     696        4856 :     COPY_NODE_FIELD(values_lists);
     697             : 
     698        4856 :     return newnode;
     699             : }
     700             : 
     701             : /*
     702             :  * _copyCteScan
     703             :  */
     704             : static CteScan *
     705        1728 : _copyCteScan(const CteScan *from)
     706             : {
     707        1728 :     CteScan    *newnode = makeNode(CteScan);
     708             : 
     709             :     /*
     710             :      * copy node superclass fields
     711             :      */
     712        1728 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     713             : 
     714             :     /*
     715             :      * copy remainder of node
     716             :      */
     717        1728 :     COPY_SCALAR_FIELD(ctePlanId);
     718        1728 :     COPY_SCALAR_FIELD(cteParam);
     719             : 
     720        1728 :     return newnode;
     721             : }
     722             : 
     723             : /*
     724             :  * _copyNamedTuplestoreScan
     725             :  */
     726             : static NamedTuplestoreScan *
     727         540 : _copyNamedTuplestoreScan(const NamedTuplestoreScan *from)
     728             : {
     729         540 :     NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan);
     730             : 
     731             :     /*
     732             :      * copy node superclass fields
     733             :      */
     734         540 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     735             : 
     736             :     /*
     737             :      * copy remainder of node
     738             :      */
     739         540 :     COPY_STRING_FIELD(enrname);
     740             : 
     741         540 :     return newnode;
     742             : }
     743             : 
     744             : /*
     745             :  * _copyWorkTableScan
     746             :  */
     747             : static WorkTableScan *
     748         454 : _copyWorkTableScan(const WorkTableScan *from)
     749             : {
     750         454 :     WorkTableScan *newnode = makeNode(WorkTableScan);
     751             : 
     752             :     /*
     753             :      * copy node superclass fields
     754             :      */
     755         454 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     756             : 
     757             :     /*
     758             :      * copy remainder of node
     759             :      */
     760         454 :     COPY_SCALAR_FIELD(wtParam);
     761             : 
     762         454 :     return newnode;
     763             : }
     764             : 
     765             : /*
     766             :  * _copyForeignScan
     767             :  */
     768             : static ForeignScan *
     769        1792 : _copyForeignScan(const ForeignScan *from)
     770             : {
     771        1792 :     ForeignScan *newnode = makeNode(ForeignScan);
     772             : 
     773             :     /*
     774             :      * copy node superclass fields
     775             :      */
     776        1792 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     777             : 
     778             :     /*
     779             :      * copy remainder of node
     780             :      */
     781        1792 :     COPY_SCALAR_FIELD(operation);
     782        1792 :     COPY_SCALAR_FIELD(resultRelation);
     783        1792 :     COPY_SCALAR_FIELD(fs_server);
     784        1792 :     COPY_NODE_FIELD(fdw_exprs);
     785        1792 :     COPY_NODE_FIELD(fdw_private);
     786        1792 :     COPY_NODE_FIELD(fdw_scan_tlist);
     787        1792 :     COPY_NODE_FIELD(fdw_recheck_quals);
     788        1792 :     COPY_BITMAPSET_FIELD(fs_relids);
     789        1792 :     COPY_SCALAR_FIELD(fsSystemCol);
     790             : 
     791        1792 :     return newnode;
     792             : }
     793             : 
     794             : /*
     795             :  * _copyCustomScan
     796             :  */
     797             : static CustomScan *
     798           0 : _copyCustomScan(const CustomScan *from)
     799             : {
     800           0 :     CustomScan *newnode = makeNode(CustomScan);
     801             : 
     802             :     /*
     803             :      * copy node superclass fields
     804             :      */
     805           0 :     CopyScanFields((const Scan *) from, (Scan *) newnode);
     806             : 
     807             :     /*
     808             :      * copy remainder of node
     809             :      */
     810           0 :     COPY_SCALAR_FIELD(flags);
     811           0 :     COPY_NODE_FIELD(custom_plans);
     812           0 :     COPY_NODE_FIELD(custom_exprs);
     813           0 :     COPY_NODE_FIELD(custom_private);
     814           0 :     COPY_NODE_FIELD(custom_scan_tlist);
     815           0 :     COPY_BITMAPSET_FIELD(custom_relids);
     816             : 
     817             :     /*
     818             :      * NOTE: The method field of CustomScan is required to be a pointer to a
     819             :      * static table of callback functions.  So we don't copy the table itself,
     820             :      * just reference the original one.
     821             :      */
     822           0 :     COPY_SCALAR_FIELD(methods);
     823             : 
     824           0 :     return newnode;
     825             : }
     826             : 
     827             : /*
     828             :  * CopyJoinFields
     829             :  *
     830             :  *      This function copies the fields of the Join node.  It is used by
     831             :  *      all the copy functions for classes which inherit from Join.
     832             :  */
     833             : static void
     834       63530 : CopyJoinFields(const Join *from, Join *newnode)
     835             : {
     836       63530 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     837             : 
     838       63530 :     COPY_SCALAR_FIELD(jointype);
     839       63530 :     COPY_SCALAR_FIELD(inner_unique);
     840       63530 :     COPY_NODE_FIELD(joinqual);
     841       63530 : }
     842             : 
     843             : 
     844             : /*
     845             :  * _copyJoin
     846             :  */
     847             : static Join *
     848           0 : _copyJoin(const Join *from)
     849             : {
     850           0 :     Join       *newnode = makeNode(Join);
     851             : 
     852             :     /*
     853             :      * copy node superclass fields
     854             :      */
     855           0 :     CopyJoinFields(from, newnode);
     856             : 
     857           0 :     return newnode;
     858             : }
     859             : 
     860             : 
     861             : /*
     862             :  * _copyNestLoop
     863             :  */
     864             : static NestLoop *
     865       41416 : _copyNestLoop(const NestLoop *from)
     866             : {
     867       41416 :     NestLoop   *newnode = makeNode(NestLoop);
     868             : 
     869             :     /*
     870             :      * copy node superclass fields
     871             :      */
     872       41416 :     CopyJoinFields((const Join *) from, (Join *) newnode);
     873             : 
     874             :     /*
     875             :      * copy remainder of node
     876             :      */
     877       41416 :     COPY_NODE_FIELD(nestParams);
     878             : 
     879       41416 :     return newnode;
     880             : }
     881             : 
     882             : 
     883             : /*
     884             :  * _copyMergeJoin
     885             :  */
     886             : static MergeJoin *
     887        3358 : _copyMergeJoin(const MergeJoin *from)
     888             : {
     889        3358 :     MergeJoin  *newnode = makeNode(MergeJoin);
     890             :     int         numCols;
     891             : 
     892             :     /*
     893             :      * copy node superclass fields
     894             :      */
     895        3358 :     CopyJoinFields((const Join *) from, (Join *) newnode);
     896             : 
     897             :     /*
     898             :      * copy remainder of node
     899             :      */
     900        3358 :     COPY_SCALAR_FIELD(skip_mark_restore);
     901        3358 :     COPY_NODE_FIELD(mergeclauses);
     902        3358 :     numCols = list_length(from->mergeclauses);
     903        3358 :     COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
     904        3358 :     COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
     905        3358 :     COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
     906        3358 :     COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
     907             : 
     908        3358 :     return newnode;
     909             : }
     910             : 
     911             : /*
     912             :  * _copyHashJoin
     913             :  */
     914             : static HashJoin *
     915       18756 : _copyHashJoin(const HashJoin *from)
     916             : {
     917       18756 :     HashJoin   *newnode = makeNode(HashJoin);
     918             : 
     919             :     /*
     920             :      * copy node superclass fields
     921             :      */
     922       18756 :     CopyJoinFields((const Join *) from, (Join *) newnode);
     923             : 
     924             :     /*
     925             :      * copy remainder of node
     926             :      */
     927       18756 :     COPY_NODE_FIELD(hashclauses);
     928       18756 :     COPY_NODE_FIELD(hashoperators);
     929       18756 :     COPY_NODE_FIELD(hashcollations);
     930       18756 :     COPY_NODE_FIELD(hashkeys);
     931             : 
     932       18756 :     return newnode;
     933             : }
     934             : 
     935             : 
     936             : /*
     937             :  * _copyMaterial
     938             :  */
     939             : static Material *
     940        2562 : _copyMaterial(const Material *from)
     941             : {
     942        2562 :     Material   *newnode = makeNode(Material);
     943             : 
     944             :     /*
     945             :      * copy node superclass fields
     946             :      */
     947        2562 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     948             : 
     949        2562 :     return newnode;
     950             : }
     951             : 
     952             : 
     953             : /*
     954             :  * _copyMemoize
     955             :  */
     956             : static Memoize *
     957         686 : _copyMemoize(const Memoize *from)
     958             : {
     959         686 :     Memoize    *newnode = makeNode(Memoize);
     960             : 
     961             :     /*
     962             :      * copy node superclass fields
     963             :      */
     964         686 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     965             : 
     966             :     /*
     967             :      * copy remainder of node
     968             :      */
     969         686 :     COPY_SCALAR_FIELD(numKeys);
     970         686 :     COPY_POINTER_FIELD(hashOperators, sizeof(Oid) * from->numKeys);
     971         686 :     COPY_POINTER_FIELD(collations, sizeof(Oid) * from->numKeys);
     972         686 :     COPY_NODE_FIELD(param_exprs);
     973         686 :     COPY_SCALAR_FIELD(singlerow);
     974         686 :     COPY_SCALAR_FIELD(binary_mode);
     975         686 :     COPY_SCALAR_FIELD(est_entries);
     976         686 :     COPY_BITMAPSET_FIELD(keyparamids);
     977             : 
     978         686 :     return newnode;
     979             : }
     980             : 
     981             : 
     982             : /*
     983             :  * CopySortFields
     984             :  *
     985             :  *      This function copies the fields of the Sort node.  It is used by
     986             :  *      all the copy functions for classes which inherit from Sort.
     987             :  */
     988             : static void
     989       32246 : CopySortFields(const Sort *from, Sort *newnode)
     990             : {
     991       32246 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
     992             : 
     993       32246 :     COPY_SCALAR_FIELD(numCols);
     994       32246 :     COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
     995       32246 :     COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
     996       32246 :     COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
     997       32246 :     COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
     998       32246 : }
     999             : 
    1000             : /*
    1001             :  * _copySort
    1002             :  */
    1003             : static Sort *
    1004       31990 : _copySort(const Sort *from)
    1005             : {
    1006       31990 :     Sort       *newnode = makeNode(Sort);
    1007             : 
    1008             :     /*
    1009             :      * copy node superclass fields
    1010             :      */
    1011       31990 :     CopySortFields(from, newnode);
    1012             : 
    1013       31990 :     return newnode;
    1014             : }
    1015             : 
    1016             : 
    1017             : /*
    1018             :  * _copyIncrementalSort
    1019             :  */
    1020             : static IncrementalSort *
    1021         256 : _copyIncrementalSort(const IncrementalSort *from)
    1022             : {
    1023         256 :     IncrementalSort *newnode = makeNode(IncrementalSort);
    1024             : 
    1025             :     /*
    1026             :      * copy node superclass fields
    1027             :      */
    1028         256 :     CopySortFields((const Sort *) from, (Sort *) newnode);
    1029             : 
    1030             :     /*
    1031             :      * copy remainder of node
    1032             :      */
    1033         256 :     COPY_SCALAR_FIELD(nPresortedCols);
    1034             : 
    1035         256 :     return newnode;
    1036             : }
    1037             : 
    1038             : 
    1039             : /*
    1040             :  * _copyGroup
    1041             :  */
    1042             : static Group *
    1043         152 : _copyGroup(const Group *from)
    1044             : {
    1045         152 :     Group      *newnode = makeNode(Group);
    1046             : 
    1047         152 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1048             : 
    1049         152 :     COPY_SCALAR_FIELD(numCols);
    1050         152 :     COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
    1051         152 :     COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
    1052         152 :     COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
    1053             : 
    1054         152 :     return newnode;
    1055             : }
    1056             : 
    1057             : /*
    1058             :  * _copyAgg
    1059             :  */
    1060             : static Agg *
    1061       25324 : _copyAgg(const Agg *from)
    1062             : {
    1063       25324 :     Agg        *newnode = makeNode(Agg);
    1064             : 
    1065       25324 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1066             : 
    1067       25324 :     COPY_SCALAR_FIELD(aggstrategy);
    1068       25324 :     COPY_SCALAR_FIELD(aggsplit);
    1069       25324 :     COPY_SCALAR_FIELD(numCols);
    1070       25324 :     COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
    1071       25324 :     COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
    1072       25324 :     COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
    1073       25324 :     COPY_SCALAR_FIELD(numGroups);
    1074       25324 :     COPY_SCALAR_FIELD(transitionSpace);
    1075       25324 :     COPY_BITMAPSET_FIELD(aggParams);
    1076       25324 :     COPY_NODE_FIELD(groupingSets);
    1077       25324 :     COPY_NODE_FIELD(chain);
    1078             : 
    1079       25324 :     return newnode;
    1080             : }
    1081             : 
    1082             : /*
    1083             :  * _copyWindowAgg
    1084             :  */
    1085             : static WindowAgg *
    1086        1236 : _copyWindowAgg(const WindowAgg *from)
    1087             : {
    1088        1236 :     WindowAgg  *newnode = makeNode(WindowAgg);
    1089             : 
    1090        1236 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1091             : 
    1092        1236 :     COPY_SCALAR_FIELD(winref);
    1093        1236 :     COPY_SCALAR_FIELD(partNumCols);
    1094        1236 :     COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
    1095        1236 :     COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
    1096        1236 :     COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
    1097        1236 :     COPY_SCALAR_FIELD(ordNumCols);
    1098        1236 :     COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
    1099        1236 :     COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
    1100        1236 :     COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
    1101        1236 :     COPY_SCALAR_FIELD(frameOptions);
    1102        1236 :     COPY_NODE_FIELD(startOffset);
    1103        1236 :     COPY_NODE_FIELD(endOffset);
    1104        1236 :     COPY_SCALAR_FIELD(startInRangeFunc);
    1105        1236 :     COPY_SCALAR_FIELD(endInRangeFunc);
    1106        1236 :     COPY_SCALAR_FIELD(inRangeColl);
    1107        1236 :     COPY_SCALAR_FIELD(inRangeAsc);
    1108        1236 :     COPY_SCALAR_FIELD(inRangeNullsFirst);
    1109             : 
    1110        1236 :     return newnode;
    1111             : }
    1112             : 
    1113             : /*
    1114             :  * _copyUnique
    1115             :  */
    1116             : static Unique *
    1117         686 : _copyUnique(const Unique *from)
    1118             : {
    1119         686 :     Unique     *newnode = makeNode(Unique);
    1120             : 
    1121             :     /*
    1122             :      * copy node superclass fields
    1123             :      */
    1124         686 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1125             : 
    1126             :     /*
    1127             :      * copy remainder of node
    1128             :      */
    1129         686 :     COPY_SCALAR_FIELD(numCols);
    1130         686 :     COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
    1131         686 :     COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid));
    1132         686 :     COPY_POINTER_FIELD(uniqCollations, from->numCols * sizeof(Oid));
    1133             : 
    1134         686 :     return newnode;
    1135             : }
    1136             : 
    1137             : /*
    1138             :  * _copyHash
    1139             :  */
    1140             : static Hash *
    1141       18756 : _copyHash(const Hash *from)
    1142             : {
    1143       18756 :     Hash       *newnode = makeNode(Hash);
    1144             : 
    1145             :     /*
    1146             :      * copy node superclass fields
    1147             :      */
    1148       18756 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1149             : 
    1150             :     /*
    1151             :      * copy remainder of node
    1152             :      */
    1153       18756 :     COPY_NODE_FIELD(hashkeys);
    1154       18756 :     COPY_SCALAR_FIELD(skewTable);
    1155       18756 :     COPY_SCALAR_FIELD(skewColumn);
    1156       18756 :     COPY_SCALAR_FIELD(skewInherit);
    1157       18756 :     COPY_SCALAR_FIELD(rows_total);
    1158             : 
    1159       18756 :     return newnode;
    1160             : }
    1161             : 
    1162             : /*
    1163             :  * _copySetOp
    1164             :  */
    1165             : static SetOp *
    1166         340 : _copySetOp(const SetOp *from)
    1167             : {
    1168         340 :     SetOp      *newnode = makeNode(SetOp);
    1169             : 
    1170             :     /*
    1171             :      * copy node superclass fields
    1172             :      */
    1173         340 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1174             : 
    1175             :     /*
    1176             :      * copy remainder of node
    1177             :      */
    1178         340 :     COPY_SCALAR_FIELD(cmd);
    1179         340 :     COPY_SCALAR_FIELD(strategy);
    1180         340 :     COPY_SCALAR_FIELD(numCols);
    1181         340 :     COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
    1182         340 :     COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
    1183         340 :     COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
    1184         340 :     COPY_SCALAR_FIELD(flagColIdx);
    1185         340 :     COPY_SCALAR_FIELD(firstFlag);
    1186         340 :     COPY_SCALAR_FIELD(numGroups);
    1187             : 
    1188         340 :     return newnode;
    1189             : }
    1190             : 
    1191             : /*
    1192             :  * _copyLockRows
    1193             :  */
    1194             : static LockRows *
    1195        8758 : _copyLockRows(const LockRows *from)
    1196             : {
    1197        8758 :     LockRows   *newnode = makeNode(LockRows);
    1198             : 
    1199             :     /*
    1200             :      * copy node superclass fields
    1201             :      */
    1202        8758 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1203             : 
    1204             :     /*
    1205             :      * copy remainder of node
    1206             :      */
    1207        8758 :     COPY_NODE_FIELD(rowMarks);
    1208        8758 :     COPY_SCALAR_FIELD(epqParam);
    1209             : 
    1210        8758 :     return newnode;
    1211             : }
    1212             : 
    1213             : /*
    1214             :  * _copyLimit
    1215             :  */
    1216             : static Limit *
    1217        3660 : _copyLimit(const Limit *from)
    1218             : {
    1219        3660 :     Limit      *newnode = makeNode(Limit);
    1220             : 
    1221             :     /*
    1222             :      * copy node superclass fields
    1223             :      */
    1224        3660 :     CopyPlanFields((const Plan *) from, (Plan *) newnode);
    1225             : 
    1226             :     /*
    1227             :      * copy remainder of node
    1228             :      */
    1229        3660 :     COPY_NODE_FIELD(limitOffset);
    1230        3660 :     COPY_NODE_FIELD(limitCount);
    1231        3660 :     COPY_SCALAR_FIELD(limitOption);
    1232        3660 :     COPY_SCALAR_FIELD(uniqNumCols);
    1233        3660 :     COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber));
    1234        3660 :     COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid));
    1235        3660 :     COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid));
    1236             : 
    1237        3660 :     return newnode;
    1238             : }
    1239             : 
    1240             : /*
    1241             :  * _copyNestLoopParam
    1242             :  */
    1243             : static NestLoopParam *
    1244       22622 : _copyNestLoopParam(const NestLoopParam *from)
    1245             : {
    1246       22622 :     NestLoopParam *newnode = makeNode(NestLoopParam);
    1247             : 
    1248       22622 :     COPY_SCALAR_FIELD(paramno);
    1249       22622 :     COPY_NODE_FIELD(paramval);
    1250             : 
    1251       22622 :     return newnode;
    1252             : }
    1253             : 
    1254             : /*
    1255             :  * _copyPlanRowMark
    1256             :  */
    1257             : static PlanRowMark *
    1258       23916 : _copyPlanRowMark(const PlanRowMark *from)
    1259             : {
    1260       23916 :     PlanRowMark *newnode = makeNode(PlanRowMark);
    1261             : 
    1262       23916 :     COPY_SCALAR_FIELD(rti);
    1263       23916 :     COPY_SCALAR_FIELD(prti);
    1264       23916 :     COPY_SCALAR_FIELD(rowmarkId);
    1265       23916 :     COPY_SCALAR_FIELD(markType);
    1266       23916 :     COPY_SCALAR_FIELD(allMarkTypes);
    1267       23916 :     COPY_SCALAR_FIELD(strength);
    1268       23916 :     COPY_SCALAR_FIELD(waitPolicy);
    1269       23916 :     COPY_SCALAR_FIELD(isParent);
    1270             : 
    1271       23916 :     return newnode;
    1272             : }
    1273             : 
    1274             : static PartitionPruneInfo *
    1275         432 : _copyPartitionPruneInfo(const PartitionPruneInfo *from)
    1276             : {
    1277         432 :     PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);
    1278             : 
    1279         432 :     COPY_NODE_FIELD(prune_infos);
    1280         432 :     COPY_BITMAPSET_FIELD(other_subplans);
    1281             : 
    1282         432 :     return newnode;
    1283             : }
    1284             : 
    1285             : static PartitionedRelPruneInfo *
    1286         960 : _copyPartitionedRelPruneInfo(const PartitionedRelPruneInfo *from)
    1287             : {
    1288         960 :     PartitionedRelPruneInfo *newnode = makeNode(PartitionedRelPruneInfo);
    1289             : 
    1290         960 :     COPY_SCALAR_FIELD(rtindex);
    1291         960 :     COPY_BITMAPSET_FIELD(present_parts);
    1292         960 :     COPY_SCALAR_FIELD(nparts);
    1293         960 :     COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int));
    1294         960 :     COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
    1295         960 :     COPY_POINTER_FIELD(relid_map, from->nparts * sizeof(Oid));
    1296         960 :     COPY_NODE_FIELD(initial_pruning_steps);
    1297         960 :     COPY_NODE_FIELD(exec_pruning_steps);
    1298         960 :     COPY_BITMAPSET_FIELD(execparamids);
    1299             : 
    1300         960 :     return newnode;
    1301             : }
    1302             : 
    1303             : /*
    1304             :  * _copyPartitionPruneStepOp
    1305             :  */
    1306             : static PartitionPruneStepOp *
    1307         890 : _copyPartitionPruneStepOp(const PartitionPruneStepOp *from)
    1308             : {
    1309         890 :     PartitionPruneStepOp *newnode = makeNode(PartitionPruneStepOp);
    1310             : 
    1311         890 :     COPY_SCALAR_FIELD(step.step_id);
    1312         890 :     COPY_SCALAR_FIELD(opstrategy);
    1313         890 :     COPY_NODE_FIELD(exprs);
    1314         890 :     COPY_NODE_FIELD(cmpfns);
    1315         890 :     COPY_BITMAPSET_FIELD(nullkeys);
    1316             : 
    1317         890 :     return newnode;
    1318             : }
    1319             : 
    1320             : /*
    1321             :  * _copyPartitionPruneStepCombine
    1322             :  */
    1323             : static PartitionPruneStepCombine *
    1324         198 : _copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from)
    1325             : {
    1326         198 :     PartitionPruneStepCombine *newnode = makeNode(PartitionPruneStepCombine);
    1327             : 
    1328         198 :     COPY_SCALAR_FIELD(step.step_id);
    1329         198 :     COPY_SCALAR_FIELD(combineOp);
    1330         198 :     COPY_NODE_FIELD(source_stepids);
    1331             : 
    1332         198 :     return newnode;
    1333             : }
    1334             : 
    1335             : /*
    1336             :  * _copyPlanInvalItem
    1337             :  */
    1338             : static PlanInvalItem *
    1339      109978 : _copyPlanInvalItem(const PlanInvalItem *from)
    1340             : {
    1341      109978 :     PlanInvalItem *newnode = makeNode(PlanInvalItem);
    1342             : 
    1343      109978 :     COPY_SCALAR_FIELD(cacheId);
    1344      109978 :     COPY_SCALAR_FIELD(hashValue);
    1345             : 
    1346      109978 :     return newnode;
    1347             : }
    1348             : 
    1349             : /* ****************************************************************
    1350             :  *                     primnodes.h copy functions
    1351             :  * ****************************************************************
    1352             :  */
    1353             : 
    1354             : /*
    1355             :  * _copyAlias
    1356             :  */
    1357             : static Alias *
    1358     3100808 : _copyAlias(const Alias *from)
    1359             : {
    1360     3100808 :     Alias      *newnode = makeNode(Alias);
    1361             : 
    1362     3100808 :     COPY_STRING_FIELD(aliasname);
    1363     3100808 :     COPY_NODE_FIELD(colnames);
    1364             : 
    1365     3100808 :     return newnode;
    1366             : }
    1367             : 
    1368             : /*
    1369             :  * _copyRangeVar
    1370             :  */
    1371             : static RangeVar *
    1372     1288856 : _copyRangeVar(const RangeVar *from)
    1373             : {
    1374     1288856 :     RangeVar   *newnode = makeNode(RangeVar);
    1375             : 
    1376     1288856 :     COPY_STRING_FIELD(catalogname);
    1377     1288856 :     COPY_STRING_FIELD(schemaname);
    1378     1288856 :     COPY_STRING_FIELD(relname);
    1379     1288856 :     COPY_SCALAR_FIELD(inh);
    1380     1288856 :     COPY_SCALAR_FIELD(relpersistence);
    1381     1288856 :     COPY_NODE_FIELD(alias);
    1382     1288856 :     COPY_LOCATION_FIELD(location);
    1383             : 
    1384     1288856 :     return newnode;
    1385             : }
    1386             : 
    1387             : /*
    1388             :  * _copyTableFunc
    1389             :  */
    1390             : static TableFunc *
    1391         348 : _copyTableFunc(const TableFunc *from)
    1392             : {
    1393         348 :     TableFunc  *newnode = makeNode(TableFunc);
    1394             : 
    1395         348 :     COPY_NODE_FIELD(ns_uris);
    1396         348 :     COPY_NODE_FIELD(ns_names);
    1397         348 :     COPY_NODE_FIELD(docexpr);
    1398         348 :     COPY_NODE_FIELD(rowexpr);
    1399         348 :     COPY_NODE_FIELD(colnames);
    1400         348 :     COPY_NODE_FIELD(coltypes);
    1401         348 :     COPY_NODE_FIELD(coltypmods);
    1402         348 :     COPY_NODE_FIELD(colcollations);
    1403         348 :     COPY_NODE_FIELD(colexprs);
    1404         348 :     COPY_NODE_FIELD(coldefexprs);
    1405         348 :     COPY_BITMAPSET_FIELD(notnulls);
    1406         348 :     COPY_SCALAR_FIELD(ordinalitycol);
    1407         348 :     COPY_LOCATION_FIELD(location);
    1408             : 
    1409         348 :     return newnode;
    1410             : }
    1411             : 
    1412             : /*
    1413             :  * _copyIntoClause
    1414             :  */
    1415             : static IntoClause *
    1416        2522 : _copyIntoClause(const IntoClause *from)
    1417             : {
    1418        2522 :     IntoClause *newnode = makeNode(IntoClause);
    1419             : 
    1420        2522 :     COPY_NODE_FIELD(rel);
    1421        2522 :     COPY_NODE_FIELD(colNames);
    1422        2522 :     COPY_STRING_FIELD(accessMethod);
    1423        2522 :     COPY_NODE_FIELD(options);
    1424        2522 :     COPY_SCALAR_FIELD(onCommit);
    1425        2522 :     COPY_STRING_FIELD(tableSpaceName);
    1426        2522 :     COPY_NODE_FIELD(viewQuery);
    1427        2522 :     COPY_SCALAR_FIELD(skipData);
    1428             : 
    1429        2522 :     return newnode;
    1430             : }
    1431             : 
    1432             : /*
    1433             :  * We don't need a _copyExpr because Expr is an abstract supertype which
    1434             :  * should never actually get instantiated.  Also, since it has no common
    1435             :  * fields except NodeTag, there's no need for a helper routine to factor
    1436             :  * out copying the common fields...
    1437             :  */
    1438             : 
    1439             : /*
    1440             :  * _copyVar
    1441             :  */
    1442             : static Var *
    1443    13754958 : _copyVar(const Var *from)
    1444             : {
    1445    13754958 :     Var        *newnode = makeNode(Var);
    1446             : 
    1447    13754958 :     COPY_SCALAR_FIELD(varno);
    1448    13754958 :     COPY_SCALAR_FIELD(varattno);
    1449    13754958 :     COPY_SCALAR_FIELD(vartype);
    1450    13754958 :     COPY_SCALAR_FIELD(vartypmod);
    1451    13754958 :     COPY_SCALAR_FIELD(varcollid);
    1452    13754958 :     COPY_SCALAR_FIELD(varlevelsup);
    1453    13754958 :     COPY_SCALAR_FIELD(varnosyn);
    1454    13754958 :     COPY_SCALAR_FIELD(varattnosyn);
    1455    13754958 :     COPY_LOCATION_FIELD(location);
    1456             : 
    1457    13754958 :     return newnode;
    1458             : }
    1459             : 
    1460             : /*
    1461             :  * _copyConst
    1462             :  */
    1463             : static Const *
    1464     2887856 : _copyConst(const Const *from)
    1465             : {
    1466     2887856 :     Const      *newnode = makeNode(Const);
    1467             : 
    1468     2887856 :     COPY_SCALAR_FIELD(consttype);
    1469     2887856 :     COPY_SCALAR_FIELD(consttypmod);
    1470     2887856 :     COPY_SCALAR_FIELD(constcollid);
    1471     2887856 :     COPY_SCALAR_FIELD(constlen);
    1472             : 
    1473     2887856 :     if (from->constbyval || from->constisnull)
    1474             :     {
    1475             :         /*
    1476             :          * passed by value so just copy the datum. Also, don't try to copy
    1477             :          * struct when value is null!
    1478             :          */
    1479     2009798 :         newnode->constvalue = from->constvalue;
    1480             :     }
    1481             :     else
    1482             :     {
    1483             :         /*
    1484             :          * passed by reference.  We need a palloc'd copy.
    1485             :          */
    1486      878058 :         newnode->constvalue = datumCopy(from->constvalue,
    1487      878058 :                                         from->constbyval,
    1488             :                                         from->constlen);
    1489             :     }
    1490             : 
    1491     2887856 :     COPY_SCALAR_FIELD(constisnull);
    1492     2887856 :     COPY_SCALAR_FIELD(constbyval);
    1493     2887856 :     COPY_LOCATION_FIELD(location);
    1494             : 
    1495     2887856 :     return newnode;
    1496             : }
    1497             : 
    1498             : /*
    1499             :  * _copyParam
    1500             :  */
    1501             : static Param *
    1502      884494 : _copyParam(const Param *from)
    1503             : {
    1504      884494 :     Param      *newnode = makeNode(Param);
    1505             : 
    1506      884494 :     COPY_SCALAR_FIELD(paramkind);
    1507      884494 :     COPY_SCALAR_FIELD(paramid);
    1508      884494 :     COPY_SCALAR_FIELD(paramtype);
    1509      884494 :     COPY_SCALAR_FIELD(paramtypmod);
    1510      884494 :     COPY_SCALAR_FIELD(paramcollid);
    1511      884494 :     COPY_LOCATION_FIELD(location);
    1512             : 
    1513      884494 :     return newnode;
    1514             : }
    1515             : 
    1516             : /*
    1517             :  * _copyAggref
    1518             :  */
    1519             : static Aggref *
    1520       79020 : _copyAggref(const Aggref *from)
    1521             : {
    1522       79020 :     Aggref     *newnode = makeNode(Aggref);
    1523             : 
    1524       79020 :     COPY_SCALAR_FIELD(aggfnoid);
    1525       79020 :     COPY_SCALAR_FIELD(aggtype);
    1526       79020 :     COPY_SCALAR_FIELD(aggcollid);
    1527       79020 :     COPY_SCALAR_FIELD(inputcollid);
    1528       79020 :     COPY_SCALAR_FIELD(aggtranstype);
    1529       79020 :     COPY_NODE_FIELD(aggargtypes);
    1530       79020 :     COPY_NODE_FIELD(aggdirectargs);
    1531       79020 :     COPY_NODE_FIELD(args);
    1532       79020 :     COPY_NODE_FIELD(aggorder);
    1533       79020 :     COPY_NODE_FIELD(aggdistinct);
    1534       79020 :     COPY_NODE_FIELD(aggfilter);
    1535       79020 :     COPY_SCALAR_FIELD(aggstar);
    1536       79020 :     COPY_SCALAR_FIELD(aggvariadic);
    1537       79020 :     COPY_SCALAR_FIELD(aggkind);
    1538       79020 :     COPY_SCALAR_FIELD(agglevelsup);
    1539       79020 :     COPY_SCALAR_FIELD(aggsplit);
    1540       79020 :     COPY_SCALAR_FIELD(aggno);
    1541       79020 :     COPY_SCALAR_FIELD(aggtransno);
    1542       79020 :     COPY_LOCATION_FIELD(location);
    1543             : 
    1544       79020 :     return newnode;
    1545             : }
    1546             : 
    1547             : /*
    1548             :  * _copyGroupingFunc
    1549             :  */
    1550             : static GroupingFunc *
    1551         664 : _copyGroupingFunc(const GroupingFunc *from)
    1552             : {
    1553         664 :     GroupingFunc *newnode = makeNode(GroupingFunc);
    1554             : 
    1555         664 :     COPY_NODE_FIELD(args);
    1556         664 :     COPY_NODE_FIELD(refs);
    1557         664 :     COPY_NODE_FIELD(cols);
    1558         664 :     COPY_SCALAR_FIELD(agglevelsup);
    1559         664 :     COPY_LOCATION_FIELD(location);
    1560             : 
    1561         664 :     return newnode;
    1562             : }
    1563             : 
    1564             : /*
    1565             :  * _copyWindowFunc
    1566             :  */
    1567             : static WindowFunc *
    1568        3842 : _copyWindowFunc(const WindowFunc *from)
    1569             : {
    1570        3842 :     WindowFunc *newnode = makeNode(WindowFunc);
    1571             : 
    1572        3842 :     COPY_SCALAR_FIELD(winfnoid);
    1573        3842 :     COPY_SCALAR_FIELD(wintype);
    1574        3842 :     COPY_SCALAR_FIELD(wincollid);
    1575        3842 :     COPY_SCALAR_FIELD(inputcollid);
    1576        3842 :     COPY_NODE_FIELD(args);
    1577        3842 :     COPY_NODE_FIELD(aggfilter);
    1578        3842 :     COPY_SCALAR_FIELD(winref);
    1579        3842 :     COPY_SCALAR_FIELD(winstar);
    1580        3842 :     COPY_SCALAR_FIELD(winagg);
    1581        3842 :     COPY_LOCATION_FIELD(location);
    1582             : 
    1583        3842 :     return newnode;
    1584             : }
    1585             : 
    1586             : /*
    1587             :  * _copySubscriptingRef
    1588             :  */
    1589             : static SubscriptingRef *
    1590       17628 : _copySubscriptingRef(const SubscriptingRef *from)
    1591             : {
    1592       17628 :     SubscriptingRef *newnode = makeNode(SubscriptingRef);
    1593             : 
    1594       17628 :     COPY_SCALAR_FIELD(refcontainertype);
    1595       17628 :     COPY_SCALAR_FIELD(refelemtype);
    1596       17628 :     COPY_SCALAR_FIELD(refrestype);
    1597       17628 :     COPY_SCALAR_FIELD(reftypmod);
    1598       17628 :     COPY_SCALAR_FIELD(refcollid);
    1599       17628 :     COPY_NODE_FIELD(refupperindexpr);
    1600       17628 :     COPY_NODE_FIELD(reflowerindexpr);
    1601       17628 :     COPY_NODE_FIELD(refexpr);
    1602       17628 :     COPY_NODE_FIELD(refassgnexpr);
    1603             : 
    1604       17628 :     return newnode;
    1605             : }
    1606             : 
    1607             : /*
    1608             :  * _copyFuncExpr
    1609             :  */
    1610             : static FuncExpr *
    1611      893216 : _copyFuncExpr(const FuncExpr *from)
    1612             : {
    1613      893216 :     FuncExpr   *newnode = makeNode(FuncExpr);
    1614             : 
    1615      893216 :     COPY_SCALAR_FIELD(funcid);
    1616      893216 :     COPY_SCALAR_FIELD(funcresulttype);
    1617      893216 :     COPY_SCALAR_FIELD(funcretset);
    1618      893216 :     COPY_SCALAR_FIELD(funcvariadic);
    1619      893216 :     COPY_SCALAR_FIELD(funcformat);
    1620      893216 :     COPY_SCALAR_FIELD(funccollid);
    1621      893216 :     COPY_SCALAR_FIELD(inputcollid);
    1622      893216 :     COPY_NODE_FIELD(args);
    1623      893216 :     COPY_LOCATION_FIELD(location);
    1624             : 
    1625      893216 :     return newnode;
    1626             : }
    1627             : 
    1628             : /*
    1629             :  * _copyNamedArgExpr *
    1630             :  */
    1631             : static NamedArgExpr *
    1632       67234 : _copyNamedArgExpr(const NamedArgExpr *from)
    1633             : {
    1634       67234 :     NamedArgExpr *newnode = makeNode(NamedArgExpr);
    1635             : 
    1636       67234 :     COPY_NODE_FIELD(arg);
    1637       67234 :     COPY_STRING_FIELD(name);
    1638       67234 :     COPY_SCALAR_FIELD(argnumber);
    1639       67234 :     COPY_LOCATION_FIELD(location);
    1640             : 
    1641       67234 :     return newnode;
    1642             : }
    1643             : 
    1644             : /*
    1645             :  * _copyOpExpr
    1646             :  */
    1647             : static OpExpr *
    1648     1377872 : _copyOpExpr(const OpExpr *from)
    1649             : {
    1650     1377872 :     OpExpr     *newnode = makeNode(OpExpr);
    1651             : 
    1652     1377872 :     COPY_SCALAR_FIELD(opno);
    1653     1377872 :     COPY_SCALAR_FIELD(opfuncid);
    1654     1377872 :     COPY_SCALAR_FIELD(opresulttype);
    1655     1377872 :     COPY_SCALAR_FIELD(opretset);
    1656     1377872 :     COPY_SCALAR_FIELD(opcollid);
    1657     1377872 :     COPY_SCALAR_FIELD(inputcollid);
    1658     1377872 :     COPY_NODE_FIELD(args);
    1659     1377872 :     COPY_LOCATION_FIELD(location);
    1660             : 
    1661     1377872 :     return newnode;
    1662             : }
    1663             : 
    1664             : /*
    1665             :  * _copyDistinctExpr (same as OpExpr)
    1666             :  */
    1667             : static DistinctExpr *
    1668        1068 : _copyDistinctExpr(const DistinctExpr *from)
    1669             : {
    1670        1068 :     DistinctExpr *newnode = makeNode(DistinctExpr);
    1671             : 
    1672        1068 :     COPY_SCALAR_FIELD(opno);
    1673        1068 :     COPY_SCALAR_FIELD(opfuncid);
    1674        1068 :     COPY_SCALAR_FIELD(opresulttype);
    1675        1068 :     COPY_SCALAR_FIELD(opretset);
    1676        1068 :     COPY_SCALAR_FIELD(opcollid);
    1677        1068 :     COPY_SCALAR_FIELD(inputcollid);
    1678        1068 :     COPY_NODE_FIELD(args);
    1679        1068 :     COPY_LOCATION_FIELD(location);
    1680             : 
    1681        1068 :     return newnode;
    1682             : }
    1683             : 
    1684             : /*
    1685             :  * _copyNullIfExpr (same as OpExpr)
    1686             :  */
    1687             : static NullIfExpr *
    1688        1014 : _copyNullIfExpr(const NullIfExpr *from)
    1689             : {
    1690        1014 :     NullIfExpr *newnode = makeNode(NullIfExpr);
    1691             : 
    1692        1014 :     COPY_SCALAR_FIELD(opno);
    1693        1014 :     COPY_SCALAR_FIELD(opfuncid);
    1694        1014 :     COPY_SCALAR_FIELD(opresulttype);
    1695        1014 :     COPY_SCALAR_FIELD(opretset);
    1696        1014 :     COPY_SCALAR_FIELD(opcollid);
    1697        1014 :     COPY_SCALAR_FIELD(inputcollid);
    1698        1014 :     COPY_NODE_FIELD(args);
    1699        1014 :     COPY_LOCATION_FIELD(location);
    1700             : 
    1701        1014 :     return newnode;
    1702             : }
    1703             : 
    1704             : /*
    1705             :  * _copyScalarArrayOpExpr
    1706             :  */
    1707             : static ScalarArrayOpExpr *
    1708       74370 : _copyScalarArrayOpExpr(const ScalarArrayOpExpr *from)
    1709             : {
    1710       74370 :     ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
    1711             : 
    1712       74370 :     COPY_SCALAR_FIELD(opno);
    1713       74370 :     COPY_SCALAR_FIELD(opfuncid);
    1714       74370 :     COPY_SCALAR_FIELD(hashfuncid);
    1715       74370 :     COPY_SCALAR_FIELD(negfuncid);
    1716       74370 :     COPY_SCALAR_FIELD(useOr);
    1717       74370 :     COPY_SCALAR_FIELD(inputcollid);
    1718       74370 :     COPY_NODE_FIELD(args);
    1719       74370 :     COPY_LOCATION_FIELD(location);
    1720             : 
    1721       74370 :     return newnode;
    1722             : }
    1723             : 
    1724             : /*
    1725             :  * _copyBoolExpr
    1726             :  */
    1727             : static BoolExpr *
    1728      547268 : _copyBoolExpr(const BoolExpr *from)
    1729             : {
    1730      547268 :     BoolExpr   *newnode = makeNode(BoolExpr);
    1731             : 
    1732      547268 :     COPY_SCALAR_FIELD(boolop);
    1733      547268 :     COPY_NODE_FIELD(args);
    1734      547268 :     COPY_LOCATION_FIELD(location);
    1735             : 
    1736      547268 :     return newnode;
    1737             : }
    1738             : 
    1739             : /*
    1740             :  * _copySubLink
    1741             :  */
    1742             : static SubLink *
    1743      120994 : _copySubLink(const SubLink *from)
    1744             : {
    1745      120994 :     SubLink    *newnode = makeNode(SubLink);
    1746             : 
    1747      120994 :     COPY_SCALAR_FIELD(subLinkType);
    1748      120994 :     COPY_SCALAR_FIELD(subLinkId);
    1749      120994 :     COPY_NODE_FIELD(testexpr);
    1750      120994 :     COPY_NODE_FIELD(operName);
    1751      120994 :     COPY_NODE_FIELD(subselect);
    1752      120994 :     COPY_LOCATION_FIELD(location);
    1753             : 
    1754      120994 :     return newnode;
    1755             : }
    1756             : 
    1757             : /*
    1758             :  * _copySubPlan
    1759             :  */
    1760             : static SubPlan *
    1761       28962 : _copySubPlan(const SubPlan *from)
    1762             : {
    1763       28962 :     SubPlan    *newnode = makeNode(SubPlan);
    1764             : 
    1765       28962 :     COPY_SCALAR_FIELD(subLinkType);
    1766       28962 :     COPY_NODE_FIELD(testexpr);
    1767       28962 :     COPY_NODE_FIELD(paramIds);
    1768       28962 :     COPY_SCALAR_FIELD(plan_id);
    1769       28962 :     COPY_STRING_FIELD(plan_name);
    1770       28962 :     COPY_SCALAR_FIELD(firstColType);
    1771       28962 :     COPY_SCALAR_FIELD(firstColTypmod);
    1772       28962 :     COPY_SCALAR_FIELD(firstColCollation);
    1773       28962 :     COPY_SCALAR_FIELD(useHashTable);
    1774       28962 :     COPY_SCALAR_FIELD(unknownEqFalse);
    1775       28962 :     COPY_SCALAR_FIELD(parallel_safe);
    1776       28962 :     COPY_NODE_FIELD(setParam);
    1777       28962 :     COPY_NODE_FIELD(parParam);
    1778       28962 :     COPY_NODE_FIELD(args);
    1779       28962 :     COPY_SCALAR_FIELD(startup_cost);
    1780       28962 :     COPY_SCALAR_FIELD(per_call_cost);
    1781             : 
    1782       28962 :     return newnode;
    1783             : }
    1784             : 
    1785             : /*
    1786             :  * _copyAlternativeSubPlan
    1787             :  */
    1788             : static AlternativeSubPlan *
    1789           0 : _copyAlternativeSubPlan(const AlternativeSubPlan *from)
    1790             : {
    1791           0 :     AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
    1792             : 
    1793           0 :     COPY_NODE_FIELD(subplans);
    1794             : 
    1795           0 :     return newnode;
    1796             : }
    1797             : 
    1798             : /*
    1799             :  * _copyFieldSelect
    1800             :  */
    1801             : static FieldSelect *
    1802       73388 : _copyFieldSelect(const FieldSelect *from)
    1803             : {
    1804       73388 :     FieldSelect *newnode = makeNode(FieldSelect);
    1805             : 
    1806       73388 :     COPY_NODE_FIELD(arg);
    1807       73388 :     COPY_SCALAR_FIELD(fieldnum);
    1808       73388 :     COPY_SCALAR_FIELD(resulttype);
    1809       73388 :     COPY_SCALAR_FIELD(resulttypmod);
    1810       73388 :     COPY_SCALAR_FIELD(resultcollid);
    1811             : 
    1812       73388 :     return newnode;
    1813             : }
    1814             : 
    1815             : /*
    1816             :  * _copyFieldStore
    1817             :  */
    1818             : static FieldStore *
    1819         398 : _copyFieldStore(const FieldStore *from)
    1820             : {
    1821         398 :     FieldStore *newnode = makeNode(FieldStore);
    1822             : 
    1823         398 :     COPY_NODE_FIELD(arg);
    1824         398 :     COPY_NODE_FIELD(newvals);
    1825         398 :     COPY_NODE_FIELD(fieldnums);
    1826         398 :     COPY_SCALAR_FIELD(resulttype);
    1827             : 
    1828         398 :     return newnode;
    1829             : }
    1830             : 
    1831             : /*
    1832             :  * _copyRelabelType
    1833             :  */
    1834             : static RelabelType *
    1835      234898 : _copyRelabelType(const RelabelType *from)
    1836             : {
    1837      234898 :     RelabelType *newnode = makeNode(RelabelType);
    1838             : 
    1839      234898 :     COPY_NODE_FIELD(arg);
    1840      234898 :     COPY_SCALAR_FIELD(resulttype);
    1841      234898 :     COPY_SCALAR_FIELD(resulttypmod);
    1842      234898 :     COPY_SCALAR_FIELD(resultcollid);
    1843      234898 :     COPY_SCALAR_FIELD(relabelformat);
    1844      234898 :     COPY_LOCATION_FIELD(location);
    1845             : 
    1846      234898 :     return newnode;
    1847             : }
    1848             : 
    1849             : /*
    1850             :  * _copyCoerceViaIO
    1851             :  */
    1852             : static CoerceViaIO *
    1853       45244 : _copyCoerceViaIO(const CoerceViaIO *from)
    1854             : {
    1855       45244 :     CoerceViaIO *newnode = makeNode(CoerceViaIO);
    1856             : 
    1857       45244 :     COPY_NODE_FIELD(arg);
    1858       45244 :     COPY_SCALAR_FIELD(resulttype);
    1859       45244 :     COPY_SCALAR_FIELD(resultcollid);
    1860       45244 :     COPY_SCALAR_FIELD(coerceformat);
    1861       45244 :     COPY_LOCATION_FIELD(location);
    1862             : 
    1863       45244 :     return newnode;
    1864             : }
    1865             : 
    1866             : /*
    1867             :  * _copyArrayCoerceExpr
    1868             :  */
    1869             : static ArrayCoerceExpr *
    1870        2830 : _copyArrayCoerceExpr(const ArrayCoerceExpr *from)
    1871             : {
    1872        2830 :     ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
    1873             : 
    1874        2830 :     COPY_NODE_FIELD(arg);
    1875        2830 :     COPY_NODE_FIELD(elemexpr);
    1876        2830 :     COPY_SCALAR_FIELD(resulttype);
    1877        2830 :     COPY_SCALAR_FIELD(resulttypmod);
    1878        2830 :     COPY_SCALAR_FIELD(resultcollid);
    1879        2830 :     COPY_SCALAR_FIELD(coerceformat);
    1880        2830 :     COPY_LOCATION_FIELD(location);
    1881             : 
    1882        2830 :     return newnode;
    1883             : }
    1884             : 
    1885             : /*
    1886             :  * _copyConvertRowtypeExpr
    1887             :  */
    1888             : static ConvertRowtypeExpr *
    1889         538 : _copyConvertRowtypeExpr(const ConvertRowtypeExpr *from)
    1890             : {
    1891         538 :     ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
    1892             : 
    1893         538 :     COPY_NODE_FIELD(arg);
    1894         538 :     COPY_SCALAR_FIELD(resulttype);
    1895         538 :     COPY_SCALAR_FIELD(convertformat);
    1896         538 :     COPY_LOCATION_FIELD(location);
    1897             : 
    1898         538 :     return newnode;
    1899             : }
    1900             : 
    1901             : /*
    1902             :  * _copyCollateExpr
    1903             :  */
    1904             : static CollateExpr *
    1905        3312 : _copyCollateExpr(const CollateExpr *from)
    1906             : {
    1907        3312 :     CollateExpr *newnode = makeNode(CollateExpr);
    1908             : 
    1909        3312 :     COPY_NODE_FIELD(arg);
    1910        3312 :     COPY_SCALAR_FIELD(collOid);
    1911        3312 :     COPY_LOCATION_FIELD(location);
    1912             : 
    1913        3312 :     return newnode;
    1914             : }
    1915             : 
    1916             : /*
    1917             :  * _copyCaseExpr
    1918             :  */
    1919             : static CaseExpr *
    1920      237556 : _copyCaseExpr(const CaseExpr *from)
    1921             : {
    1922      237556 :     CaseExpr   *newnode = makeNode(CaseExpr);
    1923             : 
    1924      237556 :     COPY_SCALAR_FIELD(casetype);
    1925      237556 :     COPY_SCALAR_FIELD(casecollid);
    1926      237556 :     COPY_NODE_FIELD(arg);
    1927      237556 :     COPY_NODE_FIELD(args);
    1928      237556 :     COPY_NODE_FIELD(defresult);
    1929      237556 :     COPY_LOCATION_FIELD(location);
    1930             : 
    1931      237556 :     return newnode;
    1932             : }
    1933             : 
    1934             : /*
    1935             :  * _copyCaseWhen
    1936             :  */
    1937             : static CaseWhen *
    1938      481530 : _copyCaseWhen(const CaseWhen *from)
    1939             : {
    1940      481530 :     CaseWhen   *newnode = makeNode(CaseWhen);
    1941             : 
    1942      481530 :     COPY_NODE_FIELD(expr);
    1943      481530 :     COPY_NODE_FIELD(result);
    1944      481530 :     COPY_LOCATION_FIELD(location);
    1945             : 
    1946      481530 :     return newnode;
    1947             : }
    1948             : 
    1949             : /*
    1950             :  * _copyCaseTestExpr
    1951             :  */
    1952             : static CaseTestExpr *
    1953       80498 : _copyCaseTestExpr(const CaseTestExpr *from)
    1954             : {
    1955       80498 :     CaseTestExpr *newnode = makeNode(CaseTestExpr);
    1956             : 
    1957       80498 :     COPY_SCALAR_FIELD(typeId);
    1958       80498 :     COPY_SCALAR_FIELD(typeMod);
    1959       80498 :     COPY_SCALAR_FIELD(collation);
    1960             : 
    1961       80498 :     return newnode;
    1962             : }
    1963             : 
    1964             : /*
    1965             :  * _copyArrayExpr
    1966             :  */
    1967             : static ArrayExpr *
    1968       56142 : _copyArrayExpr(const ArrayExpr *from)
    1969             : {
    1970       56142 :     ArrayExpr  *newnode = makeNode(ArrayExpr);
    1971             : 
    1972       56142 :     COPY_SCALAR_FIELD(array_typeid);
    1973       56142 :     COPY_SCALAR_FIELD(array_collid);
    1974       56142 :     COPY_SCALAR_FIELD(element_typeid);
    1975       56142 :     COPY_NODE_FIELD(elements);
    1976       56142 :     COPY_SCALAR_FIELD(multidims);
    1977       56142 :     COPY_LOCATION_FIELD(location);
    1978             : 
    1979       56142 :     return newnode;
    1980             : }
    1981             : 
    1982             : /*
    1983             :  * _copyRowExpr
    1984             :  */
    1985             : static RowExpr *
    1986       19774 : _copyRowExpr(const RowExpr *from)
    1987             : {
    1988       19774 :     RowExpr    *newnode = makeNode(RowExpr);
    1989             : 
    1990       19774 :     COPY_NODE_FIELD(args);
    1991       19774 :     COPY_SCALAR_FIELD(row_typeid);
    1992       19774 :     COPY_SCALAR_FIELD(row_format);
    1993       19774 :     COPY_NODE_FIELD(colnames);
    1994       19774 :     COPY_LOCATION_FIELD(location);
    1995             : 
    1996       19774 :     return newnode;
    1997             : }
    1998             : 
    1999             : /*
    2000             :  * _copyRowCompareExpr
    2001             :  */
    2002             : static RowCompareExpr *
    2003         252 : _copyRowCompareExpr(const RowCompareExpr *from)
    2004             : {
    2005         252 :     RowCompareExpr *newnode = makeNode(RowCompareExpr);
    2006             : 
    2007         252 :     COPY_SCALAR_FIELD(rctype);
    2008         252 :     COPY_NODE_FIELD(opnos);
    2009         252 :     COPY_NODE_FIELD(opfamilies);
    2010         252 :     COPY_NODE_FIELD(inputcollids);
    2011         252 :     COPY_NODE_FIELD(largs);
    2012         252 :     COPY_NODE_FIELD(rargs);
    2013             : 
    2014         252 :     return newnode;
    2015             : }
    2016             : 
    2017             : /*
    2018             :  * _copyCoalesceExpr
    2019             :  */
    2020             : static CoalesceExpr *
    2021       69104 : _copyCoalesceExpr(const CoalesceExpr *from)
    2022             : {
    2023       69104 :     CoalesceExpr *newnode = makeNode(CoalesceExpr);
    2024             : 
    2025       69104 :     COPY_SCALAR_FIELD(coalescetype);
    2026       69104 :     COPY_SCALAR_FIELD(coalescecollid);
    2027       69104 :     COPY_NODE_FIELD(args);
    2028       69104 :     COPY_LOCATION_FIELD(location);
    2029             : 
    2030       69104 :     return newnode;
    2031             : }
    2032             : 
    2033             : /*
    2034             :  * _copyMinMaxExpr
    2035             :  */
    2036             : static MinMaxExpr *
    2037         688 : _copyMinMaxExpr(const MinMaxExpr *from)
    2038             : {
    2039         688 :     MinMaxExpr *newnode = makeNode(MinMaxExpr);
    2040             : 
    2041         688 :     COPY_SCALAR_FIELD(minmaxtype);
    2042         688 :     COPY_SCALAR_FIELD(minmaxcollid);
    2043         688 :     COPY_SCALAR_FIELD(inputcollid);
    2044         688 :     COPY_SCALAR_FIELD(op);
    2045         688 :     COPY_NODE_FIELD(args);
    2046         688 :     COPY_LOCATION_FIELD(location);
    2047             : 
    2048         688 :     return newnode;
    2049             : }
    2050             : 
    2051             : /*
    2052             :  * _copySQLValueFunction
    2053             :  */
    2054             : static SQLValueFunction *
    2055       21376 : _copySQLValueFunction(const SQLValueFunction *from)
    2056             : {
    2057       21376 :     SQLValueFunction *newnode = makeNode(SQLValueFunction);
    2058             : 
    2059       21376 :     COPY_SCALAR_FIELD(op);
    2060       21376 :     COPY_SCALAR_FIELD(type);
    2061       21376 :     COPY_SCALAR_FIELD(typmod);
    2062       21376 :     COPY_LOCATION_FIELD(location);
    2063             : 
    2064       21376 :     return newnode;
    2065             : }
    2066             : 
    2067             : /*
    2068             :  * _copyXmlExpr
    2069             :  */
    2070             : static XmlExpr *
    2071        1330 : _copyXmlExpr(const XmlExpr *from)
    2072             : {
    2073        1330 :     XmlExpr    *newnode = makeNode(XmlExpr);
    2074             : 
    2075        1330 :     COPY_SCALAR_FIELD(op);
    2076        1330 :     COPY_STRING_FIELD(name);
    2077        1330 :     COPY_NODE_FIELD(named_args);
    2078        1330 :     COPY_NODE_FIELD(arg_names);
    2079        1330 :     COPY_NODE_FIELD(args);
    2080        1330 :     COPY_SCALAR_FIELD(xmloption);
    2081        1330 :     COPY_SCALAR_FIELD(type);
    2082        1330 :     COPY_SCALAR_FIELD(typmod);
    2083        1330 :     COPY_LOCATION_FIELD(location);
    2084             : 
    2085        1330 :     return newnode;
    2086             : }
    2087             : 
    2088             : /*
    2089             :  * _copyNullTest
    2090             :  */
    2091             : static NullTest *
    2092       82960 : _copyNullTest(const NullTest *from)
    2093             : {
    2094       82960 :     NullTest   *newnode = makeNode(NullTest);
    2095             : 
    2096       82960 :     COPY_NODE_FIELD(arg);
    2097       82960 :     COPY_SCALAR_FIELD(nulltesttype);
    2098       82960 :     COPY_SCALAR_FIELD(argisrow);
    2099       82960 :     COPY_LOCATION_FIELD(location);
    2100             : 
    2101       82960 :     return newnode;
    2102             : }
    2103             : 
    2104             : /*
    2105             :  * _copyBooleanTest
    2106             :  */
    2107             : static BooleanTest *
    2108        1056 : _copyBooleanTest(const BooleanTest *from)
    2109             : {
    2110        1056 :     BooleanTest *newnode = makeNode(BooleanTest);
    2111             : 
    2112        1056 :     COPY_NODE_FIELD(arg);
    2113        1056 :     COPY_SCALAR_FIELD(booltesttype);
    2114        1056 :     COPY_LOCATION_FIELD(location);
    2115             : 
    2116        1056 :     return newnode;
    2117             : }
    2118             : 
    2119             : /*
    2120             :  * _copyCoerceToDomain
    2121             :  */
    2122             : static CoerceToDomain *
    2123      489398 : _copyCoerceToDomain(const CoerceToDomain *from)
    2124             : {
    2125      489398 :     CoerceToDomain *newnode = makeNode(CoerceToDomain);
    2126             : 
    2127      489398 :     COPY_NODE_FIELD(arg);
    2128      489398 :     COPY_SCALAR_FIELD(resulttype);
    2129      489398 :     COPY_SCALAR_FIELD(resulttypmod);
    2130      489398 :     COPY_SCALAR_FIELD(resultcollid);
    2131      489398 :     COPY_SCALAR_FIELD(coercionformat);
    2132      489398 :     COPY_LOCATION_FIELD(location);
    2133             : 
    2134      489398 :     return newnode;
    2135             : }
    2136             : 
    2137             : /*
    2138             :  * _copyCoerceToDomainValue
    2139             :  */
    2140             : static CoerceToDomainValue *
    2141        2966 : _copyCoerceToDomainValue(const CoerceToDomainValue *from)
    2142             : {
    2143        2966 :     CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
    2144             : 
    2145        2966 :     COPY_SCALAR_FIELD(typeId);
    2146        2966 :     COPY_SCALAR_FIELD(typeMod);
    2147        2966 :     COPY_SCALAR_FIELD(collation);
    2148        2966 :     COPY_LOCATION_FIELD(location);
    2149             : 
    2150        2966 :     return newnode;
    2151             : }
    2152             : 
    2153             : /*
    2154             :  * _copySetToDefault
    2155             :  */
    2156             : static SetToDefault *
    2157         970 : _copySetToDefault(const SetToDefault *from)
    2158             : {
    2159         970 :     SetToDefault *newnode = makeNode(SetToDefault);
    2160             : 
    2161         970 :     COPY_SCALAR_FIELD(typeId);
    2162         970 :     COPY_SCALAR_FIELD(typeMod);
    2163         970 :     COPY_SCALAR_FIELD(collation);
    2164         970 :     COPY_LOCATION_FIELD(location);
    2165             : 
    2166         970 :     return newnode;
    2167             : }
    2168             : 
    2169             : /*
    2170             :  * _copyCurrentOfExpr
    2171             :  */
    2172             : static CurrentOfExpr *
    2173        1150 : _copyCurrentOfExpr(const CurrentOfExpr *from)
    2174             : {
    2175        1150 :     CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
    2176             : 
    2177        1150 :     COPY_SCALAR_FIELD(cvarno);
    2178        1150 :     COPY_STRING_FIELD(cursor_name);
    2179        1150 :     COPY_SCALAR_FIELD(cursor_param);
    2180             : 
    2181        1150 :     return newnode;
    2182             : }
    2183             : 
    2184             :  /*
    2185             :   * _copyNextValueExpr
    2186             :   */
    2187             : static NextValueExpr *
    2188         630 : _copyNextValueExpr(const NextValueExpr *from)
    2189             : {
    2190         630 :     NextValueExpr *newnode = makeNode(NextValueExpr);
    2191             : 
    2192         630 :     COPY_SCALAR_FIELD(seqid);
    2193         630 :     COPY_SCALAR_FIELD(typeId);
    2194             : 
    2195         630 :     return newnode;
    2196             : }
    2197             : 
    2198             : /*
    2199             :  * _copyInferenceElem
    2200             :  */
    2201             : static InferenceElem *
    2202        1078 : _copyInferenceElem(const InferenceElem *from)
    2203             : {
    2204        1078 :     InferenceElem *newnode = makeNode(InferenceElem);
    2205             : 
    2206        1078 :     COPY_NODE_FIELD(expr);
    2207        1078 :     COPY_SCALAR_FIELD(infercollid);
    2208        1078 :     COPY_SCALAR_FIELD(inferopclass);
    2209             : 
    2210        1078 :     return newnode;
    2211             : }
    2212             : 
    2213             : /*
    2214             :  * _copyTargetEntry
    2215             :  */
    2216             : static TargetEntry *
    2217     5436960 : _copyTargetEntry(const TargetEntry *from)
    2218             : {
    2219     5436960 :     TargetEntry *newnode = makeNode(TargetEntry);
    2220             : 
    2221     5436960 :     COPY_NODE_FIELD(expr);
    2222     5436960 :     COPY_SCALAR_FIELD(resno);
    2223     5436960 :     COPY_STRING_FIELD(resname);
    2224     5436960 :     COPY_SCALAR_FIELD(ressortgroupref);
    2225     5436960 :     COPY_SCALAR_FIELD(resorigtbl);
    2226     5436960 :     COPY_SCALAR_FIELD(resorigcol);
    2227     5436960 :     COPY_SCALAR_FIELD(resjunk);
    2228             : 
    2229     5436960 :     return newnode;
    2230             : }
    2231             : 
    2232             : /*
    2233             :  * _copyRangeTblRef
    2234             :  */
    2235             : static RangeTblRef *
    2236      773604 : _copyRangeTblRef(const RangeTblRef *from)
    2237             : {
    2238      773604 :     RangeTblRef *newnode = makeNode(RangeTblRef);
    2239             : 
    2240      773604 :     COPY_SCALAR_FIELD(rtindex);
    2241             : 
    2242      773604 :     return newnode;
    2243             : }
    2244             : 
    2245             : /*
    2246             :  * _copyJoinExpr
    2247             :  */
    2248             : static JoinExpr *
    2249      319202 : _copyJoinExpr(const JoinExpr *from)
    2250             : {
    2251      319202 :     JoinExpr   *newnode = makeNode(JoinExpr);
    2252             : 
    2253      319202 :     COPY_SCALAR_FIELD(jointype);
    2254      319202 :     COPY_SCALAR_FIELD(isNatural);
    2255      319202 :     COPY_NODE_FIELD(larg);
    2256      319202 :     COPY_NODE_FIELD(rarg);
    2257      319202 :     COPY_NODE_FIELD(usingClause);
    2258      319202 :     COPY_NODE_FIELD(join_using_alias);
    2259      319202 :     COPY_NODE_FIELD(quals);
    2260      319202 :     COPY_NODE_FIELD(alias);
    2261      319202 :     COPY_SCALAR_FIELD(rtindex);
    2262             : 
    2263      319202 :     return newnode;
    2264             : }
    2265             : 
    2266             : /*
    2267             :  * _copyFromExpr
    2268             :  */
    2269             : static FromExpr *
    2270      703724 : _copyFromExpr(const FromExpr *from)
    2271             : {
    2272      703724 :     FromExpr   *newnode = makeNode(FromExpr);
    2273             : 
    2274      703724 :     COPY_NODE_FIELD(fromlist);
    2275      703724 :     COPY_NODE_FIELD(quals);
    2276             : 
    2277      703724 :     return newnode;
    2278             : }
    2279             : 
    2280             : /*
    2281             :  * _copyOnConflictExpr
    2282             :  */
    2283             : static OnConflictExpr *
    2284        1050 : _copyOnConflictExpr(const OnConflictExpr *from)
    2285             : {
    2286        1050 :     OnConflictExpr *newnode = makeNode(OnConflictExpr);
    2287             : 
    2288        1050 :     COPY_SCALAR_FIELD(action);
    2289        1050 :     COPY_NODE_FIELD(arbiterElems);
    2290        1050 :     COPY_NODE_FIELD(arbiterWhere);
    2291        1050 :     COPY_SCALAR_FIELD(constraint);
    2292        1050 :     COPY_NODE_FIELD(onConflictSet);
    2293        1050 :     COPY_NODE_FIELD(onConflictWhere);
    2294        1050 :     COPY_SCALAR_FIELD(exclRelIndex);
    2295        1050 :     COPY_NODE_FIELD(exclRelTlist);
    2296             : 
    2297        1050 :     return newnode;
    2298             : }
    2299             : 
    2300             : /* ****************************************************************
    2301             :  *                      pathnodes.h copy functions
    2302             :  *
    2303             :  * We don't support copying RelOptInfo, IndexOptInfo, or Path nodes.
    2304             :  * There are some subsidiary structs that are useful to copy, though.
    2305             :  * ****************************************************************
    2306             :  */
    2307             : 
    2308             : /*
    2309             :  * _copyPathKey
    2310             :  */
    2311             : static PathKey *
    2312           0 : _copyPathKey(const PathKey *from)
    2313             : {
    2314           0 :     PathKey    *newnode = makeNode(PathKey);
    2315             : 
    2316             :     /* EquivalenceClasses are never moved, so just shallow-copy the pointer */
    2317           0 :     COPY_SCALAR_FIELD(pk_eclass);
    2318           0 :     COPY_SCALAR_FIELD(pk_opfamily);
    2319           0 :     COPY_SCALAR_FIELD(pk_strategy);
    2320           0 :     COPY_SCALAR_FIELD(pk_nulls_first);
    2321             : 
    2322           0 :     return newnode;
    2323             : }
    2324             : 
    2325             : /*
    2326             :  * _copyRestrictInfo
    2327             :  */
    2328             : static RestrictInfo *
    2329           0 : _copyRestrictInfo(const RestrictInfo *from)
    2330             : {
    2331           0 :     RestrictInfo *newnode = makeNode(RestrictInfo);
    2332             : 
    2333           0 :     COPY_NODE_FIELD(clause);
    2334           0 :     COPY_SCALAR_FIELD(is_pushed_down);
    2335           0 :     COPY_SCALAR_FIELD(outerjoin_delayed);
    2336           0 :     COPY_SCALAR_FIELD(can_join);
    2337           0 :     COPY_SCALAR_FIELD(pseudoconstant);
    2338           0 :     COPY_SCALAR_FIELD(leakproof);
    2339           0 :     COPY_SCALAR_FIELD(has_volatile);
    2340           0 :     COPY_SCALAR_FIELD(security_level);
    2341           0 :     COPY_BITMAPSET_FIELD(clause_relids);
    2342           0 :     COPY_BITMAPSET_FIELD(required_relids);
    2343           0 :     COPY_BITMAPSET_FIELD(outer_relids);
    2344           0 :     COPY_BITMAPSET_FIELD(nullable_relids);
    2345           0 :     COPY_BITMAPSET_FIELD(left_relids);
    2346           0 :     COPY_BITMAPSET_FIELD(right_relids);
    2347           0 :     COPY_NODE_FIELD(orclause);
    2348             :     /* EquivalenceClasses are never copied, so shallow-copy the pointers */
    2349           0 :     COPY_SCALAR_FIELD(parent_ec);
    2350           0 :     COPY_SCALAR_FIELD(eval_cost);
    2351           0 :     COPY_SCALAR_FIELD(norm_selec);
    2352           0 :     COPY_SCALAR_FIELD(outer_selec);
    2353           0 :     COPY_NODE_FIELD(mergeopfamilies);
    2354             :     /* EquivalenceClasses are never copied, so shallow-copy the pointers */
    2355           0 :     COPY_SCALAR_FIELD(left_ec);
    2356           0 :     COPY_SCALAR_FIELD(right_ec);
    2357           0 :     COPY_SCALAR_FIELD(left_em);
    2358           0 :     COPY_SCALAR_FIELD(right_em);
    2359             :     /* MergeScanSelCache isn't a Node, so hard to copy; just reset cache */
    2360           0 :     newnode->scansel_cache = NIL;
    2361           0 :     COPY_SCALAR_FIELD(outer_is_left);
    2362           0 :     COPY_SCALAR_FIELD(hashjoinoperator);
    2363           0 :     COPY_SCALAR_FIELD(left_bucketsize);
    2364           0 :     COPY_SCALAR_FIELD(right_bucketsize);
    2365           0 :     COPY_SCALAR_FIELD(left_mcvfreq);
    2366           0 :     COPY_SCALAR_FIELD(right_mcvfreq);
    2367           0 :     COPY_SCALAR_FIELD(left_hasheqoperator);
    2368           0 :     COPY_SCALAR_FIELD(right_hasheqoperator);
    2369             : 
    2370           0 :     return newnode;
    2371             : }
    2372             : 
    2373             : /*
    2374             :  * _copyPlaceHolderVar
    2375             :  */
    2376             : static PlaceHolderVar *
    2377        3910 : _copyPlaceHolderVar(const PlaceHolderVar *from)
    2378             : {
    2379        3910 :     PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
    2380             : 
    2381        3910 :     COPY_NODE_FIELD(phexpr);
    2382        3910 :     COPY_BITMAPSET_FIELD(phrels);
    2383        3910 :     COPY_SCALAR_FIELD(phid);
    2384        3910 :     COPY_SCALAR_FIELD(phlevelsup);
    2385             : 
    2386        3910 :     return newnode;
    2387             : }
    2388             : 
    2389             : /*
    2390             :  * _copySpecialJoinInfo
    2391             :  */
    2392             : static SpecialJoinInfo *
    2393           0 : _copySpecialJoinInfo(const SpecialJoinInfo *from)
    2394             : {
    2395           0 :     SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);
    2396             : 
    2397           0 :     COPY_BITMAPSET_FIELD(min_lefthand);
    2398           0 :     COPY_BITMAPSET_FIELD(min_righthand);
    2399           0 :     COPY_BITMAPSET_FIELD(syn_lefthand);
    2400           0 :     COPY_BITMAPSET_FIELD(syn_righthand);
    2401           0 :     COPY_SCALAR_FIELD(jointype);
    2402           0 :     COPY_SCALAR_FIELD(lhs_strict);
    2403           0 :     COPY_SCALAR_FIELD(delay_upper_joins);
    2404           0 :     COPY_SCALAR_FIELD(semi_can_btree);
    2405           0 :     COPY_SCALAR_FIELD(semi_can_hash);
    2406           0 :     COPY_NODE_FIELD(semi_operators);
    2407           0 :     COPY_NODE_FIELD(semi_rhs_exprs);
    2408             : 
    2409           0 :     return newnode;
    2410             : }
    2411             : 
    2412             : /*
    2413             :  * _copyAppendRelInfo
    2414             :  */
    2415             : static AppendRelInfo *
    2416       30152 : _copyAppendRelInfo(const AppendRelInfo *from)
    2417             : {
    2418       30152 :     AppendRelInfo *newnode = makeNode(AppendRelInfo);
    2419             : 
    2420       30152 :     COPY_SCALAR_FIELD(parent_relid);
    2421       30152 :     COPY_SCALAR_FIELD(child_relid);
    2422       30152 :     COPY_SCALAR_FIELD(parent_reltype);
    2423       30152 :     COPY_SCALAR_FIELD(child_reltype);
    2424       30152 :     COPY_NODE_FIELD(translated_vars);
    2425       30152 :     COPY_SCALAR_FIELD(num_child_cols);
    2426       30152 :     COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber));
    2427       30152 :     COPY_SCALAR_FIELD(parent_reloid);
    2428             : 
    2429       30152 :     return newnode;
    2430             : }
    2431             : 
    2432             : /*
    2433             :  * _copyPlaceHolderInfo
    2434             :  */
    2435             : static PlaceHolderInfo *
    2436           0 : _copyPlaceHolderInfo(const PlaceHolderInfo *from)
    2437             : {
    2438           0 :     PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);
    2439             : 
    2440           0 :     COPY_SCALAR_FIELD(phid);
    2441           0 :     COPY_NODE_FIELD(ph_var);
    2442           0 :     COPY_BITMAPSET_FIELD(ph_eval_at);
    2443           0 :     COPY_BITMAPSET_FIELD(ph_lateral);
    2444           0 :     COPY_BITMAPSET_FIELD(ph_needed);
    2445           0 :     COPY_SCALAR_FIELD(ph_width);
    2446             : 
    2447           0 :     return newnode;
    2448             : }
    2449             : 
    2450             : /* ****************************************************************
    2451             :  *                  parsenodes.h copy functions
    2452             :  * ****************************************************************
    2453             :  */
    2454             : 
    2455             : static RangeTblEntry *
    2456     1708618 : _copyRangeTblEntry(const RangeTblEntry *from)
    2457             : {
    2458     1708618 :     RangeTblEntry *newnode = makeNode(RangeTblEntry);
    2459             : 
    2460     1708618 :     COPY_SCALAR_FIELD(rtekind);
    2461     1708618 :     COPY_SCALAR_FIELD(relid);
    2462     1708618 :     COPY_SCALAR_FIELD(relkind);
    2463     1708618 :     COPY_SCALAR_FIELD(rellockmode);
    2464     1708618 :     COPY_NODE_FIELD(tablesample);
    2465     1708618 :     COPY_NODE_FIELD(subquery);
    2466     1708618 :     COPY_SCALAR_FIELD(security_barrier);
    2467     1708618 :     COPY_SCALAR_FIELD(jointype);
    2468     1708618 :     COPY_SCALAR_FIELD(joinmergedcols);
    2469     1708618 :     COPY_NODE_FIELD(joinaliasvars);
    2470     1708618 :     COPY_NODE_FIELD(joinleftcols);
    2471     1708618 :     COPY_NODE_FIELD(joinrightcols);
    2472     1708618 :     COPY_NODE_FIELD(join_using_alias);
    2473     1708618 :     COPY_NODE_FIELD(functions);
    2474     1708618 :     COPY_SCALAR_FIELD(funcordinality);
    2475     1708618 :     COPY_NODE_FIELD(tablefunc);
    2476     1708618 :     COPY_NODE_FIELD(values_lists);
    2477     1708618 :     COPY_STRING_FIELD(ctename);
    2478     1708618 :     COPY_SCALAR_FIELD(ctelevelsup);
    2479     1708618 :     COPY_SCALAR_FIELD(self_reference);
    2480     1708618 :     COPY_NODE_FIELD(coltypes);
    2481     1708618 :     COPY_NODE_FIELD(coltypmods);
    2482     1708618 :     COPY_NODE_FIELD(colcollations);
    2483     1708618 :     COPY_STRING_FIELD(enrname);
    2484     1708618 :     COPY_SCALAR_FIELD(enrtuples);
    2485     1708618 :     COPY_NODE_FIELD(alias);
    2486     1708618 :     COPY_NODE_FIELD(eref);
    2487     1708618 :     COPY_SCALAR_FIELD(lateral);
    2488     1708618 :     COPY_SCALAR_FIELD(inh);
    2489     1708618 :     COPY_SCALAR_FIELD(inFromCl);
    2490     1708618 :     COPY_SCALAR_FIELD(requiredPerms);
    2491     1708618 :     COPY_SCALAR_FIELD(checkAsUser);
    2492     1708618 :     COPY_BITMAPSET_FIELD(selectedCols);
    2493     1708618 :     COPY_BITMAPSET_FIELD(insertedCols);
    2494     1708618 :     COPY_BITMAPSET_FIELD(updatedCols);
    2495     1708618 :     COPY_BITMAPSET_FIELD(extraUpdatedCols);
    2496     1708618 :     COPY_NODE_FIELD(securityQuals);
    2497             : 
    2498     1708618 :     return newnode;
    2499             : }
    2500             : 
    2501             : static RangeTblFunction *
    2502       83952 : _copyRangeTblFunction(const RangeTblFunction *from)
    2503             : {
    2504       83952 :     RangeTblFunction *newnode = makeNode(RangeTblFunction);
    2505             : 
    2506       83952 :     COPY_NODE_FIELD(funcexpr);
    2507       83952 :     COPY_SCALAR_FIELD(funccolcount);
    2508       83952 :     COPY_NODE_FIELD(funccolnames);
    2509       83952 :     COPY_NODE_FIELD(funccoltypes);
    2510       83952 :     COPY_NODE_FIELD(funccoltypmods);
    2511       83952 :     COPY_NODE_FIELD(funccolcollations);
    2512       83952 :     COPY_BITMAPSET_FIELD(funcparams);
    2513             : 
    2514       83952 :     return newnode;
    2515             : }
    2516             : 
    2517             : static TableSampleClause *
    2518         438 : _copyTableSampleClause(const TableSampleClause *from)
    2519             : {
    2520         438 :     TableSampleClause *newnode = makeNode(TableSampleClause);
    2521             : 
    2522         438 :     COPY_SCALAR_FIELD(tsmhandler);
    2523         438 :     COPY_NODE_FIELD(args);
    2524         438 :     COPY_NODE_FIELD(repeatable);
    2525             : 
    2526         438 :     return newnode;
    2527             : }
    2528             : 
    2529             : static WithCheckOption *
    2530        2256 : _copyWithCheckOption(const WithCheckOption *from)
    2531             : {
    2532        2256 :     WithCheckOption *newnode = makeNode(WithCheckOption);
    2533             : 
    2534        2256 :     COPY_SCALAR_FIELD(kind);
    2535        2256 :     COPY_STRING_FIELD(relname);
    2536        2256 :     COPY_STRING_FIELD(polname);
    2537        2256 :     COPY_NODE_FIELD(qual);
    2538        2256 :     COPY_SCALAR_FIELD(cascaded);
    2539             : 
    2540        2256 :     return newnode;
    2541             : }
    2542             : 
    2543             : static SortGroupClause *
    2544      151154 : _copySortGroupClause(const SortGroupClause *from)
    2545             : {
    2546      151154 :     SortGroupClause *newnode = makeNode(SortGroupClause);
    2547             : 
    2548      151154 :     COPY_SCALAR_FIELD(tleSortGroupRef);
    2549      151154 :     COPY_SCALAR_FIELD(eqop);
    2550      151154 :     COPY_SCALAR_FIELD(sortop);
    2551      151154 :     COPY_SCALAR_FIELD(nulls_first);
    2552      151154 :     COPY_SCALAR_FIELD(hashable);
    2553             : 
    2554      151154 :     return newnode;
    2555             : }
    2556             : 
    2557             : static GroupingSet *
    2558        2612 : _copyGroupingSet(const GroupingSet *from)
    2559             : {
    2560        2612 :     GroupingSet *newnode = makeNode(GroupingSet);
    2561             : 
    2562        2612 :     COPY_SCALAR_FIELD(kind);
    2563        2612 :     COPY_NODE_FIELD(content);
    2564        2612 :     COPY_LOCATION_FIELD(location);
    2565             : 
    2566        2612 :     return newnode;
    2567             : }
    2568             : 
    2569             : static WindowClause *
    2570        2014 : _copyWindowClause(const WindowClause *from)
    2571             : {
    2572        2014 :     WindowClause *newnode = makeNode(WindowClause);
    2573             : 
    2574        2014 :     COPY_STRING_FIELD(name);
    2575        2014 :     COPY_STRING_FIELD(refname);
    2576        2014 :     COPY_NODE_FIELD(partitionClause);
    2577        2014 :     COPY_NODE_FIELD(orderClause);
    2578        2014 :     COPY_SCALAR_FIELD(frameOptions);
    2579        2014 :     COPY_NODE_FIELD(startOffset);
    2580        2014 :     COPY_NODE_FIELD(endOffset);
    2581        2014 :     COPY_SCALAR_FIELD(startInRangeFunc);
    2582        2014 :     COPY_SCALAR_FIELD(endInRangeFunc);
    2583        2014 :     COPY_SCALAR_FIELD(inRangeColl);
    2584        2014 :     COPY_SCALAR_FIELD(inRangeAsc);
    2585        2014 :     COPY_SCALAR_FIELD(inRangeNullsFirst);
    2586        2014 :     COPY_SCALAR_FIELD(winref);
    2587        2014 :     COPY_SCALAR_FIELD(copiedOrder);
    2588             : 
    2589        2014 :     return newnode;
    2590             : }
    2591             : 
    2592             : static RowMarkClause *
    2593       10170 : _copyRowMarkClause(const RowMarkClause *from)
    2594             : {
    2595       10170 :     RowMarkClause *newnode = makeNode(RowMarkClause);
    2596             : 
    2597       10170 :     COPY_SCALAR_FIELD(rti);
    2598       10170 :     COPY_SCALAR_FIELD(strength);
    2599       10170 :     COPY_SCALAR_FIELD(waitPolicy);
    2600       10170 :     COPY_SCALAR_FIELD(pushedDown);
    2601             : 
    2602       10170 :     return newnode;
    2603             : }
    2604             : 
    2605             : static WithClause *
    2606        2052 : _copyWithClause(const WithClause *from)
    2607             : {
    2608        2052 :     WithClause *newnode = makeNode(WithClause);
    2609             : 
    2610        2052 :     COPY_NODE_FIELD(ctes);
    2611        2052 :     COPY_SCALAR_FIELD(recursive);
    2612        2052 :     COPY_LOCATION_FIELD(location);
    2613             : 
    2614        2052 :     return newnode;
    2615             : }
    2616             : 
    2617             : static InferClause *
    2618         896 : _copyInferClause(const InferClause *from)
    2619             : {
    2620         896 :     InferClause *newnode = makeNode(InferClause);
    2621             : 
    2622         896 :     COPY_NODE_FIELD(indexElems);
    2623         896 :     COPY_NODE_FIELD(whereClause);
    2624         896 :     COPY_STRING_FIELD(conname);
    2625         896 :     COPY_LOCATION_FIELD(location);
    2626             : 
    2627         896 :     return newnode;
    2628             : }
    2629             : 
    2630             : static OnConflictClause *
    2631        1042 : _copyOnConflictClause(const OnConflictClause *from)
    2632             : {
    2633        1042 :     OnConflictClause *newnode = makeNode(OnConflictClause);
    2634             : 
    2635        1042 :     COPY_SCALAR_FIELD(action);
    2636        1042 :     COPY_NODE_FIELD(infer);
    2637        1042 :     COPY_NODE_FIELD(targetList);
    2638        1042 :     COPY_NODE_FIELD(whereClause);
    2639        1042 :     COPY_LOCATION_FIELD(location);
    2640             : 
    2641        1042 :     return newnode;
    2642             : }
    2643             : 
    2644             : static CTESearchClause *
    2645         152 : _copyCTESearchClause(const CTESearchClause *from)
    2646             : {
    2647         152 :     CTESearchClause *newnode = makeNode(CTESearchClause);
    2648             : 
    2649         152 :     COPY_NODE_FIELD(search_col_list);
    2650         152 :     COPY_SCALAR_FIELD(search_breadth_first);
    2651         152 :     COPY_STRING_FIELD(search_seq_column);
    2652         152 :     COPY_LOCATION_FIELD(location);
    2653             : 
    2654         152 :     return newnode;
    2655             : }
    2656             : 
    2657             : static CTECycleClause *
    2658         176 : _copyCTECycleClause(const CTECycleClause *from)
    2659             : {
    2660         176 :     CTECycleClause *newnode = makeNode(CTECycleClause);
    2661             : 
    2662         176 :     COPY_NODE_FIELD(cycle_col_list);
    2663         176 :     COPY_STRING_FIELD(cycle_mark_column);
    2664         176 :     COPY_NODE_FIELD(cycle_mark_value);
    2665         176 :     COPY_NODE_FIELD(cycle_mark_default);
    2666         176 :     COPY_STRING_FIELD(cycle_path_column);
    2667         176 :     COPY_LOCATION_FIELD(location);
    2668         176 :     COPY_SCALAR_FIELD(cycle_mark_type);
    2669         176 :     COPY_SCALAR_FIELD(cycle_mark_typmod);
    2670         176 :     COPY_SCALAR_FIELD(cycle_mark_collation);
    2671         176 :     COPY_SCALAR_FIELD(cycle_mark_neop);
    2672             : 
    2673         176 :     return newnode;
    2674             : }
    2675             : 
    2676             : static CommonTableExpr *
    2677        5796 : _copyCommonTableExpr(const CommonTableExpr *from)
    2678             : {
    2679        5796 :     CommonTableExpr *newnode = makeNode(CommonTableExpr);
    2680             : 
    2681        5796 :     COPY_STRING_FIELD(ctename);
    2682        5796 :     COPY_NODE_FIELD(aliascolnames);
    2683        5796 :     COPY_SCALAR_FIELD(ctematerialized);
    2684        5796 :     COPY_NODE_FIELD(ctequery);
    2685        5796 :     COPY_NODE_FIELD(search_clause);
    2686        5796 :     COPY_NODE_FIELD(cycle_clause);
    2687        5796 :     COPY_LOCATION_FIELD(location);
    2688        5796 :     COPY_SCALAR_FIELD(cterecursive);
    2689        5796 :     COPY_SCALAR_FIELD(cterefcount);
    2690        5796 :     COPY_NODE_FIELD(ctecolnames);
    2691        5796 :     COPY_NODE_FIELD(ctecoltypes);
    2692        5796 :     COPY_NODE_FIELD(ctecoltypmods);
    2693        5796 :     COPY_NODE_FIELD(ctecolcollations);
    2694             : 
    2695        5796 :     return newnode;
    2696             : }
    2697             : 
    2698             : static A_Expr *
    2699     1046334 : _copyA_Expr(const A_Expr *from)
    2700             : {
    2701     1046334 :     A_Expr     *newnode = makeNode(A_Expr);
    2702             : 
    2703     1046334 :     COPY_SCALAR_FIELD(kind);
    2704     1046334 :     COPY_NODE_FIELD(name);
    2705     1046334 :     COPY_NODE_FIELD(lexpr);
    2706     1046334 :     COPY_NODE_FIELD(rexpr);
    2707     1046334 :     COPY_LOCATION_FIELD(location);
    2708             : 
    2709     1046334 :     return newnode;
    2710             : }
    2711             : 
    2712             : static ColumnRef *
    2713     3329062 : _copyColumnRef(const ColumnRef *from)
    2714             : {
    2715     3329062 :     ColumnRef  *newnode = makeNode(ColumnRef);
    2716             : 
    2717     3329062 :     COPY_NODE_FIELD(fields);
    2718     3329062 :     COPY_LOCATION_FIELD(location);
    2719             : 
    2720     3329062 :     return newnode;
    2721             : }
    2722             : 
    2723             : static ParamRef *
    2724      471508 : _copyParamRef(const ParamRef *from)
    2725             : {
    2726      471508 :     ParamRef   *newnode = makeNode(ParamRef);
    2727             : 
    2728      471508 :     COPY_SCALAR_FIELD(number);
    2729      471508 :     COPY_LOCATION_FIELD(location);
    2730             : 
    2731      471508 :     return newnode;
    2732             : }
    2733             : 
    2734             : static A_Const *
    2735     2024674 : _copyA_Const(const A_Const *from)
    2736             : {
    2737     2024674 :     A_Const    *newnode = makeNode(A_Const);
    2738             : 
    2739     2024674 :     COPY_SCALAR_FIELD(isnull);
    2740     2024674 :     if (!from->isnull)
    2741             :     {
    2742             :         /* This part must duplicate other _copy*() functions. */
    2743     1787056 :         COPY_SCALAR_FIELD(val.node.type);
    2744     1787056 :         switch (nodeTag(&from->val))
    2745             :         {
    2746      580616 :             case T_Integer:
    2747      580616 :                 COPY_SCALAR_FIELD(val.ival.val);
    2748      580616 :                 break;
    2749        8258 :             case T_Float:
    2750        8258 :                 COPY_STRING_FIELD(val.fval.val);
    2751        8258 :                 break;
    2752     1195458 :             case T_String:
    2753     1195458 :                 COPY_STRING_FIELD(val.sval.val);
    2754     1195458 :                 break;
    2755        2724 :             case T_BitString:
    2756        2724 :                 COPY_STRING_FIELD(val.bsval.val);
    2757        2724 :                 break;
    2758           0 :             default:
    2759           0 :                 elog(ERROR, "unrecognized node type: %d",
    2760             :                      (int) nodeTag(&from->val));
    2761             :                 break;
    2762             :         }
    2763      237618 :     }
    2764             : 
    2765     2024674 :     COPY_LOCATION_FIELD(location);
    2766             : 
    2767     2024674 :     return newnode;
    2768             : }
    2769             : 
    2770             : static FuncCall *
    2771      754608 : _copyFuncCall(const FuncCall *from)
    2772             : {
    2773      754608 :     FuncCall   *newnode = makeNode(FuncCall);
    2774             : 
    2775      754608 :     COPY_NODE_FIELD(funcname);
    2776      754608 :     COPY_NODE_FIELD(args);
    2777      754608 :     COPY_NODE_FIELD(agg_order);
    2778      754608 :     COPY_NODE_FIELD(agg_filter);
    2779      754608 :     COPY_NODE_FIELD(over);
    2780      754608 :     COPY_SCALAR_FIELD(agg_within_group);
    2781      754608 :     COPY_SCALAR_FIELD(agg_star);
    2782      754608 :     COPY_SCALAR_FIELD(agg_distinct);
    2783      754608 :     COPY_SCALAR_FIELD(func_variadic);
    2784      754608 :     COPY_SCALAR_FIELD(funcformat);
    2785      754608 :     COPY_LOCATION_FIELD(location);
    2786             : 
    2787      754608 :     return newnode;
    2788             : }
    2789             : 
    2790             : static A_Star *
    2791       72178 : _copyA_Star(const A_Star *from)
    2792             : {
    2793       72178 :     A_Star     *newnode = makeNode(A_Star);
    2794             : 
    2795       72178 :     return newnode;
    2796             : }
    2797             : 
    2798             : static A_Indices *
    2799       21892 : _copyA_Indices(const A_Indices *from)
    2800             : {
    2801       21892 :     A_Indices  *newnode = makeNode(A_Indices);
    2802             : 
    2803       21892 :     COPY_SCALAR_FIELD(is_slice);
    2804       21892 :     COPY_NODE_FIELD(lidx);
    2805       21892 :     COPY_NODE_FIELD(uidx);
    2806             : 
    2807       21892 :     return newnode;
    2808             : }
    2809             : 
    2810             : static A_Indirection *
    2811      131988 : _copyA_Indirection(const A_Indirection *from)
    2812             : {
    2813      131988 :     A_Indirection *newnode = makeNode(A_Indirection);
    2814             : 
    2815      131988 :     COPY_NODE_FIELD(arg);
    2816      131988 :     COPY_NODE_FIELD(indirection);
    2817             : 
    2818      131988 :     return newnode;
    2819             : }
    2820             : 
    2821             : static A_ArrayExpr *
    2822        5166 : _copyA_ArrayExpr(const A_ArrayExpr *from)
    2823             : {
    2824        5166 :     A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
    2825             : 
    2826        5166 :     COPY_NODE_FIELD(elements);
    2827        5166 :     COPY_LOCATION_FIELD(location);
    2828             : 
    2829        5166 :     return newnode;
    2830             : }
    2831             : 
    2832             : static ResTarget *
    2833     2106814 : _copyResTarget(const ResTarget *from)
    2834             : {
    2835     2106814 :     ResTarget  *newnode = makeNode(ResTarget);
    2836             : 
    2837     2106814 :     COPY_STRING_FIELD(name);
    2838     2106814 :     COPY_NODE_FIELD(indirection);
    2839     2106814 :     COPY_NODE_FIELD(val);
    2840     2106814 :     COPY_LOCATION_FIELD(location);
    2841             : 
    2842     2106814 :     return newnode;
    2843             : }
    2844             : 
    2845             : static MultiAssignRef *
    2846         226 : _copyMultiAssignRef(const MultiAssignRef *from)
    2847             : {
    2848         226 :     MultiAssignRef *newnode = makeNode(MultiAssignRef);
    2849             : 
    2850         226 :     COPY_NODE_FIELD(source);
    2851         226 :     COPY_SCALAR_FIELD(colno);
    2852         226 :     COPY_SCALAR_FIELD(ncolumns);
    2853             : 
    2854         226 :     return newnode;
    2855             : }
    2856             : 
    2857             : static TypeName *
    2858     1677948 : _copyTypeName(const TypeName *from)
    2859             : {
    2860     1677948 :     TypeName   *newnode = makeNode(TypeName);
    2861             : 
    2862     1677948 :     COPY_NODE_FIELD(names);
    2863     1677948 :     COPY_SCALAR_FIELD(typeOid);
    2864     1677948 :     COPY_SCALAR_FIELD(setof);
    2865     1677948 :     COPY_SCALAR_FIELD(pct_type);
    2866     1677948 :     COPY_NODE_FIELD(typmods);
    2867     1677948 :     COPY_SCALAR_FIELD(typemod);
    2868     1677948 :     COPY_NODE_FIELD(arrayBounds);
    2869     1677948 :     COPY_LOCATION_FIELD(location);
    2870             : 
    2871     1677948 :     return newnode;
    2872             : }
    2873             : 
    2874             : static SortBy *
    2875       59494 : _copySortBy(const SortBy *from)
    2876             : {
    2877       59494 :     SortBy     *newnode = makeNode(SortBy);
    2878             : 
    2879       59494 :     COPY_NODE_FIELD(node);
    2880       59494 :     COPY_SCALAR_FIELD(sortby_dir);
    2881       59494 :     COPY_SCALAR_FIELD(sortby_nulls);
    2882       59494 :     COPY_NODE_FIELD(useOp);
    2883       59494 :     COPY_LOCATION_FIELD(location);
    2884             : 
    2885       59494 :     return newnode;
    2886             : }
    2887             : 
    2888             : static WindowDef *
    2889        2908 : _copyWindowDef(const WindowDef *from)
    2890             : {
    2891        2908 :     WindowDef  *newnode = makeNode(WindowDef);
    2892             : 
    2893        2908 :     COPY_STRING_FIELD(name);
    2894        2908 :     COPY_STRING_FIELD(refname);
    2895        2908 :     COPY_NODE_FIELD(partitionClause);
    2896        2908 :     COPY_NODE_FIELD(orderClause);
    2897        2908 :     COPY_SCALAR_FIELD(frameOptions);
    2898        2908 :     COPY_NODE_FIELD(startOffset);
    2899        2908 :     COPY_NODE_FIELD(endOffset);
    2900        2908 :     COPY_LOCATION_FIELD(location);
    2901             : 
    2902        2908 :     return newnode;
    2903             : }
    2904             : 
    2905             : static RangeSubselect *
    2906       37888 : _copyRangeSubselect(const RangeSubselect *from)
    2907             : {
    2908       37888 :     RangeSubselect *newnode = makeNode(RangeSubselect);
    2909             : 
    2910       37888 :     COPY_SCALAR_FIELD(lateral);
    2911       37888 :     COPY_NODE_FIELD(subquery);
    2912       37888 :     COPY_NODE_FIELD(alias);
    2913             : 
    2914       37888 :     return newnode;
    2915             : }
    2916             : 
    2917             : static RangeFunction *
    2918       62562 : _copyRangeFunction(const RangeFunction *from)
    2919             : {
    2920       62562 :     RangeFunction *newnode = makeNode(RangeFunction);
    2921             : 
    2922       62562 :     COPY_SCALAR_FIELD(lateral);
    2923       62562 :     COPY_SCALAR_FIELD(ordinality);
    2924       62562 :     COPY_SCALAR_FIELD(is_rowsfrom);
    2925       62562 :     COPY_NODE_FIELD(functions);
    2926       62562 :     COPY_NODE_FIELD(alias);
    2927       62562 :     COPY_NODE_FIELD(coldeflist);
    2928             : 
    2929       62562 :     return newnode;
    2930             : }
    2931             : 
    2932             : static RangeTableSample *
    2933         192 : _copyRangeTableSample(const RangeTableSample *from)
    2934             : {
    2935         192 :     RangeTableSample *newnode = makeNode(RangeTableSample);
    2936             : 
    2937         192 :     COPY_NODE_FIELD(relation);
    2938         192 :     COPY_NODE_FIELD(method);
    2939         192 :     COPY_NODE_FIELD(args);
    2940         192 :     COPY_NODE_FIELD(repeatable);
    2941         192 :     COPY_LOCATION_FIELD(location);
    2942             : 
    2943         192 :     return newnode;
    2944             : }
    2945             : 
    2946             : static RangeTableFunc *
    2947         160 : _copyRangeTableFunc(const RangeTableFunc *from)
    2948             : {
    2949         160 :     RangeTableFunc *newnode = makeNode(RangeTableFunc);
    2950             : 
    2951         160 :     COPY_SCALAR_FIELD(lateral);
    2952         160 :     COPY_NODE_FIELD(docexpr);
    2953         160 :     COPY_NODE_FIELD(rowexpr);
    2954         160 :     COPY_NODE_FIELD(namespaces);
    2955         160 :     COPY_NODE_FIELD(columns);
    2956         160 :     COPY_NODE_FIELD(alias);
    2957         160 :     COPY_LOCATION_FIELD(location);
    2958             : 
    2959         160 :     return newnode;
    2960             : }
    2961             : 
    2962             : static RangeTableFuncCol *
    2963         612 : _copyRangeTableFuncCol(const RangeTableFuncCol *from)
    2964             : {
    2965         612 :     RangeTableFuncCol *newnode = makeNode(RangeTableFuncCol);
    2966             : 
    2967         612 :     COPY_STRING_FIELD(colname);
    2968         612 :     COPY_NODE_FIELD(typeName);
    2969         612 :     COPY_SCALAR_FIELD(for_ordinality);
    2970         612 :     COPY_SCALAR_FIELD(is_not_null);
    2971         612 :     COPY_NODE_FIELD(colexpr);
    2972         612 :     COPY_NODE_FIELD(coldefexpr);
    2973         612 :     COPY_LOCATION_FIELD(location);
    2974             : 
    2975         612 :     return newnode;
    2976             : }
    2977             : 
    2978             : static TypeCast *
    2979      909098 : _copyTypeCast(const TypeCast *from)
    2980             : {
    2981      909098 :     TypeCast   *newnode = makeNode(TypeCast);
    2982             : 
    2983      909098 :     COPY_NODE_FIELD(arg);
    2984      909098 :     COPY_NODE_FIELD(typeName);
    2985      909098 :     COPY_LOCATION_FIELD(location);
    2986             : 
    2987      909098 :     return newnode;
    2988             : }
    2989             : 
    2990             : static CollateClause *
    2991        5620 : _copyCollateClause(const CollateClause *from)
    2992             : {
    2993        5620 :     CollateClause *newnode = makeNode(CollateClause);
    2994             : 
    2995        5620 :     COPY_NODE_FIELD(arg);
    2996        5620 :     COPY_NODE_FIELD(collname);
    2997        5620 :     COPY_LOCATION_FIELD(location);
    2998             : 
    2999        5620 :     return newnode;
    3000             : }
    3001             : 
    3002             : static IndexElem *
    3003       12290 : _copyIndexElem(const IndexElem *from)
    3004             : {
    3005       12290 :     IndexElem  *newnode = makeNode(IndexElem);
    3006             : 
    3007       12290 :     COPY_STRING_FIELD(name);
    3008       12290 :     COPY_NODE_FIELD(expr);
    3009       12290 :     COPY_STRING_FIELD(indexcolname);
    3010       12290 :     COPY_NODE_FIELD(collation);
    3011       12290 :     COPY_NODE_FIELD(opclass);
    3012       12290 :     COPY_NODE_FIELD(opclassopts);
    3013       12290 :     COPY_SCALAR_FIELD(ordering);
    3014       12290 :     COPY_SCALAR_FIELD(nulls_ordering);
    3015             : 
    3016       12290 :     return newnode;
    3017             : }
    3018             : 
    3019             : static StatsElem *
    3020        1772 : _copyStatsElem(const StatsElem *from)
    3021             : {
    3022        1772 :     StatsElem  *newnode = makeNode(StatsElem);
    3023             : 
    3024        1772 :     COPY_STRING_FIELD(name);
    3025        1772 :     COPY_NODE_FIELD(expr);
    3026             : 
    3027        1772 :     return newnode;
    3028             : }
    3029             : 
    3030             : static ColumnDef *
    3031      110974 : _copyColumnDef(const ColumnDef *from)
    3032             : {
    3033      110974 :     ColumnDef  *newnode = makeNode(ColumnDef);
    3034             : 
    3035      110974 :     COPY_STRING_FIELD(colname);
    3036      110974 :     COPY_NODE_FIELD(typeName);
    3037      110974 :     COPY_STRING_FIELD(compression);
    3038      110974 :     COPY_SCALAR_FIELD(inhcount);
    3039      110974 :     COPY_SCALAR_FIELD(is_local);
    3040      110974 :     COPY_SCALAR_FIELD(is_not_null);
    3041      110974 :     COPY_SCALAR_FIELD(is_from_type);
    3042      110974 :     COPY_SCALAR_FIELD(storage);
    3043      110974 :     COPY_NODE_FIELD(raw_default);
    3044      110974 :     COPY_NODE_FIELD(cooked_default);
    3045      110974 :     COPY_SCALAR_FIELD(identity);
    3046      110974 :     COPY_NODE_FIELD(identitySequence);
    3047      110974 :     COPY_SCALAR_FIELD(generated);
    3048      110974 :     COPY_NODE_FIELD(collClause);
    3049      110974 :     COPY_SCALAR_FIELD(collOid);
    3050      110974 :     COPY_NODE_FIELD(constraints);
    3051      110974 :     COPY_NODE_FIELD(fdwoptions);
    3052      110974 :     COPY_LOCATION_FIELD(location);
    3053             : 
    3054      110974 :     return newnode;
    3055             : }
    3056             : 
    3057             : static Constraint *
    3058      191590 : _copyConstraint(const Constraint *from)
    3059             : {
    3060      191590 :     Constraint *newnode = makeNode(Constraint);
    3061             : 
    3062      191590 :     COPY_SCALAR_FIELD(contype);
    3063      191590 :     COPY_STRING_FIELD(conname);
    3064      191590 :     COPY_SCALAR_FIELD(deferrable);
    3065      191590 :     COPY_SCALAR_FIELD(initdeferred);
    3066      191590 :     COPY_LOCATION_FIELD(location);
    3067      191590 :     COPY_SCALAR_FIELD(is_no_inherit);
    3068      191590 :     COPY_NODE_FIELD(raw_expr);
    3069      191590 :     COPY_STRING_FIELD(cooked_expr);
    3070      191590 :     COPY_SCALAR_FIELD(generated_when);
    3071      191590 :     COPY_NODE_FIELD(keys);
    3072      191590 :     COPY_NODE_FIELD(including);
    3073      191590 :     COPY_NODE_FIELD(exclusions);
    3074      191590 :     COPY_NODE_FIELD(options);
    3075      191590 :     COPY_STRING_FIELD(indexname);
    3076      191590 :     COPY_STRING_FIELD(indexspace);
    3077      191590 :     COPY_SCALAR_FIELD(reset_default_tblspc);
    3078      191590 :     COPY_STRING_FIELD(access_method);
    3079      191590 :     COPY_NODE_FIELD(where_clause);
    3080      191590 :     COPY_NODE_FIELD(pktable);
    3081      191590 :     COPY_NODE_FIELD(fk_attrs);
    3082      191590 :     COPY_NODE_FIELD(pk_attrs);
    3083      191590 :     COPY_SCALAR_FIELD(fk_matchtype);
    3084      191590 :     COPY_SCALAR_FIELD(fk_upd_action);
    3085      191590 :     COPY_SCALAR_FIELD(fk_del_action);
    3086      191590 :     COPY_NODE_FIELD(fk_del_set_cols);
    3087      191590 :     COPY_NODE_FIELD(old_conpfeqop);
    3088      191590 :     COPY_SCALAR_FIELD(old_pktable_oid);
    3089      191590 :     COPY_SCALAR_FIELD(skip_validation);
    3090      191590 :     COPY_SCALAR_FIELD(initially_valid);
    3091             : 
    3092      191590 :     return newnode;
    3093             : }
    3094             : 
    3095             : static DefElem *
    3096      653768 : _copyDefElem(const DefElem *from)
    3097             : {
    3098      653768 :     DefElem    *newnode = makeNode(DefElem);
    3099             : 
    3100      653768 :     COPY_STRING_FIELD(defnamespace);
    3101      653768 :     COPY_STRING_FIELD(defname);
    3102      653768 :     COPY_NODE_FIELD(arg);
    3103      653768 :     COPY_SCALAR_FIELD(defaction);
    3104      653768 :     COPY_LOCATION_FIELD(location);
    3105             : 
    3106      653768 :     return newnode;
    3107             : }
    3108             : 
    3109             : static LockingClause *
    3110        4154 : _copyLockingClause(const LockingClause *from)
    3111             : {
    3112        4154 :     LockingClause *newnode = makeNode(LockingClause);
    3113             : 
    3114        4154 :     COPY_NODE_FIELD(lockedRels);
    3115        4154 :     COPY_SCALAR_FIELD(strength);
    3116        4154 :     COPY_SCALAR_FIELD(waitPolicy);
    3117             : 
    3118        4154 :     return newnode;
    3119             : }
    3120             : 
    3121             : static XmlSerialize *
    3122          36 : _copyXmlSerialize(const XmlSerialize *from)
    3123             : {
    3124          36 :     XmlSerialize *newnode = makeNode(XmlSerialize);
    3125             : 
    3126          36 :     COPY_SCALAR_FIELD(xmloption);
    3127          36 :     COPY_NODE_FIELD(expr);
    3128          36 :     COPY_NODE_FIELD(typeName);
    3129          36 :     COPY_LOCATION_FIELD(location);
    3130             : 
    3131          36 :     return newnode;
    3132             : }
    3133             : 
    3134             : static RoleSpec *
    3135      166166 : _copyRoleSpec(const RoleSpec *from)
    3136             : {
    3137      166166 :     RoleSpec   *newnode = makeNode(RoleSpec);
    3138             : 
    3139      166166 :     COPY_SCALAR_FIELD(roletype);
    3140      166166 :     COPY_STRING_FIELD(rolename);
    3141      166166 :     COPY_LOCATION_FIELD(location);
    3142             : 
    3143      166166 :     return newnode;
    3144             : }
    3145             : 
    3146             : static TriggerTransition *
    3147         724 : _copyTriggerTransition(const TriggerTransition *from)
    3148             : {
    3149         724 :     TriggerTransition *newnode = makeNode(TriggerTransition);
    3150             : 
    3151         724 :     COPY_STRING_FIELD(name);
    3152         724 :     COPY_SCALAR_FIELD(isNew);
    3153         724 :     COPY_SCALAR_FIELD(isTable);
    3154             : 
    3155         724 :     return newnode;
    3156             : }
    3157             : 
    3158             : static Query *
    3159     1243706 : _copyQuery(const Query *from)
    3160             : {
    3161     1243706 :     Query      *newnode = makeNode(Query);
    3162             : 
    3163     1243706 :     COPY_SCALAR_FIELD(commandType);
    3164     1243706 :     COPY_SCALAR_FIELD(querySource);
    3165     1243706 :     COPY_SCALAR_FIELD(queryId);
    3166     1243706 :     COPY_SCALAR_FIELD(canSetTag);
    3167     1243706 :     COPY_NODE_FIELD(utilityStmt);
    3168     1243706 :     COPY_SCALAR_FIELD(resultRelation);
    3169     1243706 :     COPY_SCALAR_FIELD(hasAggs);
    3170     1243706 :     COPY_SCALAR_FIELD(hasWindowFuncs);
    3171     1243706 :     COPY_SCALAR_FIELD(hasTargetSRFs);
    3172     1243706 :     COPY_SCALAR_FIELD(hasSubLinks);
    3173     1243706 :     COPY_SCALAR_FIELD(hasDistinctOn);
    3174     1243706 :     COPY_SCALAR_FIELD(hasRecursive);
    3175     1243706 :     COPY_SCALAR_FIELD(hasModifyingCTE);
    3176     1243706 :     COPY_SCALAR_FIELD(hasForUpdate);
    3177     1243706 :     COPY_SCALAR_FIELD(hasRowSecurity);
    3178     1243706 :     COPY_SCALAR_FIELD(isReturn);
    3179     1243706 :     COPY_NODE_FIELD(cteList);
    3180     1243706 :     COPY_NODE_FIELD(rtable);
    3181     1243706 :     COPY_NODE_FIELD(jointree);
    3182     1243706 :     COPY_NODE_FIELD(targetList);
    3183     1243706 :     COPY_SCALAR_FIELD(override);
    3184     1243706 :     COPY_NODE_FIELD(onConflict);
    3185     1243706 :     COPY_NODE_FIELD(returningList);
    3186     1243706 :     COPY_NODE_FIELD(groupClause);
    3187     1243706 :     COPY_SCALAR_FIELD(groupDistinct);
    3188     1243706 :     COPY_NODE_FIELD(groupingSets);
    3189     1243706 :     COPY_NODE_FIELD(havingQual);
    3190     1243706 :     COPY_NODE_FIELD(windowClause);
    3191     1243706 :     COPY_NODE_FIELD(distinctClause);
    3192     1243706 :     COPY_NODE_FIELD(sortClause);
    3193     1243706 :     COPY_NODE_FIELD(limitOffset);
    3194     1243706 :     COPY_NODE_FIELD(limitCount);
    3195     1243706 :     COPY_SCALAR_FIELD(limitOption);
    3196     1243706 :     COPY_NODE_FIELD(rowMarks);
    3197     1243706 :     COPY_NODE_FIELD(setOperations);
    3198     1243706 :     COPY_NODE_FIELD(constraintDeps);
    3199     1243706 :     COPY_NODE_FIELD(withCheckOptions);
    3200     1243706 :     COPY_LOCATION_FIELD(stmt_location);
    3201     1243706 :     COPY_SCALAR_FIELD(stmt_len);
    3202             : 
    3203     1243706 :     return newnode;
    3204             : }
    3205             : 
    3206             : static RawStmt *
    3207      794816 : _copyRawStmt(const RawStmt *from)
    3208             : {
    3209      794816 :     RawStmt    *newnode = makeNode(RawStmt);
    3210             : 
    3211      794816 :     COPY_NODE_FIELD(stmt);
    3212      794816 :     COPY_LOCATION_FIELD(stmt_location);
    3213      794816 :     COPY_SCALAR_FIELD(stmt_len);
    3214             : 
    3215      794816 :     return newnode;
    3216             : }
    3217             : 
    3218             : static InsertStmt *
    3219       68924 : _copyInsertStmt(const InsertStmt *from)
    3220             : {
    3221       68924 :     InsertStmt *newnode = makeNode(InsertStmt);
    3222             : 
    3223       68924 :     COPY_NODE_FIELD(relation);
    3224       68924 :     COPY_NODE_FIELD(cols);
    3225       68924 :     COPY_NODE_FIELD(selectStmt);
    3226       68924 :     COPY_NODE_FIELD(onConflictClause);
    3227       68924 :     COPY_NODE_FIELD(returningList);
    3228       68924 :     COPY_NODE_FIELD(withClause);
    3229       68924 :     COPY_SCALAR_FIELD(override);
    3230             : 
    3231       68924 :     return newnode;
    3232             : }
    3233             : 
    3234             : static DeleteStmt *
    3235        2972 : _copyDeleteStmt(const DeleteStmt *from)
    3236             : {
    3237        2972 :     DeleteStmt *newnode = makeNode(DeleteStmt);
    3238             : 
    3239        2972 :     COPY_NODE_FIELD(relation);
    3240        2972 :     COPY_NODE_FIELD(usingClause);
    3241        2972 :     COPY_NODE_FIELD(whereClause);
    3242        2972 :     COPY_NODE_FIELD(returningList);
    3243        2972 :     COPY_NODE_FIELD(withClause);
    3244             : 
    3245        2972 :     return newnode;
    3246             : }
    3247             : 
    3248             : static UpdateStmt *
    3249       11578 : _copyUpdateStmt(const UpdateStmt *from)
    3250             : {
    3251       11578 :     UpdateStmt *newnode = makeNode(UpdateStmt);
    3252             : 
    3253       11578 :     COPY_NODE_FIELD(relation);
    3254       11578 :     COPY_NODE_FIELD(targetList);
    3255       11578 :     COPY_NODE_FIELD(whereClause);
    3256       11578 :     COPY_NODE_FIELD(fromClause);
    3257       11578 :     COPY_NODE_FIELD(returningList);
    3258       11578 :     COPY_NODE_FIELD(withClause);
    3259             : 
    3260       11578 :     return newnode;
    3261             : }
    3262             : 
    3263             : static SelectStmt *
    3264      606250 : _copySelectStmt(const SelectStmt *from)
    3265             : {
    3266      606250 :     SelectStmt *newnode = makeNode(SelectStmt);
    3267             : 
    3268      606250 :     COPY_NODE_FIELD(distinctClause);
    3269      606250 :     COPY_NODE_FIELD(intoClause);
    3270      606250 :     COPY_NODE_FIELD(targetList);
    3271      606250 :     COPY_NODE_FIELD(fromClause);
    3272      606250 :     COPY_NODE_FIELD(whereClause);
    3273      606250 :     COPY_NODE_FIELD(groupClause);
    3274      606250 :     COPY_SCALAR_FIELD(groupDistinct);
    3275      606250 :     COPY_NODE_FIELD(havingClause);
    3276      606250 :     COPY_NODE_FIELD(windowClause);
    3277      606250 :     COPY_NODE_FIELD(valuesLists);
    3278      606250 :     COPY_NODE_FIELD(sortClause);
    3279      606250 :     COPY_NODE_FIELD(limitOffset);
    3280      606250 :     COPY_NODE_FIELD(limitCount);
    3281      606250 :     COPY_SCALAR_FIELD(limitOption);
    3282      606250 :     COPY_NODE_FIELD(lockingClause);
    3283      606250 :     COPY_NODE_FIELD(withClause);
    3284      606250 :     COPY_SCALAR_FIELD(op);
    3285      606250 :     COPY_SCALAR_FIELD(all);
    3286      606250 :     COPY_NODE_FIELD(larg);
    3287      606250 :     COPY_NODE_FIELD(rarg);
    3288             : 
    3289      606250 :     return newnode;
    3290             : }
    3291             : 
    3292             : static SetOperationStmt *
    3293       28426 : _copySetOperationStmt(const SetOperationStmt *from)
    3294             : {
    3295       28426 :     SetOperationStmt *newnode = makeNode(SetOperationStmt);
    3296             : 
    3297       28426 :     COPY_SCALAR_FIELD(op);
    3298       28426 :     COPY_SCALAR_FIELD(all);
    3299       28426 :     COPY_NODE_FIELD(larg);
    3300       28426 :     COPY_NODE_FIELD(rarg);
    3301       28426 :     COPY_NODE_FIELD(colTypes);
    3302       28426 :     COPY_NODE_FIELD(colTypmods);
    3303       28426 :     COPY_NODE_FIELD(colCollations);
    3304       28426 :     COPY_NODE_FIELD(groupClauses);
    3305             : 
    3306       28426 :     return newnode;
    3307             : }
    3308             : 
    3309             : static ReturnStmt *
    3310       47324 : _copyReturnStmt(const ReturnStmt *from)
    3311             : {
    3312       47324 :     ReturnStmt *newnode = makeNode(ReturnStmt);
    3313             : 
    3314       47324 :     COPY_NODE_FIELD(returnval);
    3315             : 
    3316       47324 :     return newnode;
    3317             : }
    3318             : 
    3319             : static PLAssignStmt *
    3320        3788 : _copyPLAssignStmt(const PLAssignStmt *from)
    3321             : {
    3322        3788 :     PLAssignStmt *newnode = makeNode(PLAssignStmt);
    3323             : 
    3324        3788 :     COPY_STRING_FIELD(name);
    3325        3788 :     COPY_NODE_FIELD(indirection);
    3326        3788 :     COPY_SCALAR_FIELD(nnames);
    3327        3788 :     COPY_NODE_FIELD(val);
    3328        3788 :     COPY_LOCATION_FIELD(location);
    3329             : 
    3330        3788 :     return newnode;
    3331             : }
    3332             : 
    3333             : static AlterTableStmt *
    3334      125886 : _copyAlterTableStmt(const AlterTableStmt *from)
    3335             : {
    3336      125886 :     AlterTableStmt *newnode = makeNode(AlterTableStmt);
    3337             : 
    3338      125886 :     COPY_NODE_FIELD(relation);
    3339      125886 :     COPY_NODE_FIELD(cmds);
    3340      125886 :     COPY_SCALAR_FIELD(objtype);
    3341      125886 :     COPY_SCALAR_FIELD(missing_ok);
    3342             : 
    3343      125886 :     return newnode;
    3344             : }
    3345             : 
    3346             : static AlterTableCmd *
    3347      193622 : _copyAlterTableCmd(const AlterTableCmd *from)
    3348             : {
    3349      193622 :     AlterTableCmd *newnode = makeNode(AlterTableCmd);
    3350             : 
    3351      193622 :     COPY_SCALAR_FIELD(subtype);
    3352      193622 :     COPY_STRING_FIELD(name);
    3353      193622 :     COPY_SCALAR_FIELD(num);
    3354      193622 :     COPY_NODE_FIELD(newowner);
    3355      193622 :     COPY_NODE_FIELD(def);
    3356      193622 :     COPY_SCALAR_FIELD(behavior);
    3357      193622 :     COPY_SCALAR_FIELD(missing_ok);
    3358             : 
    3359      193622 :     return newnode;
    3360             : }
    3361             : 
    3362             : static AlterCollationStmt *
    3363           0 : _copyAlterCollationStmt(const AlterCollationStmt *from)
    3364             : {
    3365           0 :     AlterCollationStmt *newnode = makeNode(AlterCollationStmt);
    3366             : 
    3367           0 :     COPY_NODE_FIELD(collname);
    3368             : 
    3369           0 :     return newnode;
    3370             : }
    3371             : 
    3372             : static AlterDomainStmt *
    3373         304 : _copyAlterDomainStmt(const AlterDomainStmt *from)
    3374             : {
    3375         304 :     AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
    3376             : 
    3377         304 :     COPY_SCALAR_FIELD(subtype);
    3378         304 :     COPY_NODE_FIELD(typeName);
    3379         304 :     COPY_STRING_FIELD(name);
    3380         304 :     COPY_NODE_FIELD(def);
    3381         304 :     COPY_SCALAR_FIELD(behavior);
    3382         304 :     COPY_SCALAR_FIELD(missing_ok);
    3383             : 
    3384         304 :     return newnode;
    3385             : }
    3386             : 
    3387             : static GrantStmt *
    3388      150398 : _copyGrantStmt(const GrantStmt *from)
    3389             : {
    3390      150398 :     GrantStmt  *newnode = makeNode(GrantStmt);
    3391             : 
    3392      150398 :     COPY_SCALAR_FIELD(is_grant);
    3393      150398 :     COPY_SCALAR_FIELD(targtype);
    3394      150398 :     COPY_SCALAR_FIELD(objtype);
    3395      150398 :     COPY_NODE_FIELD(objects);
    3396      150398 :     COPY_NODE_FIELD(privileges);
    3397      150398 :     COPY_NODE_FIELD(grantees);
    3398      150398 :     COPY_SCALAR_FIELD(grant_option);
    3399      150398 :     COPY_NODE_FIELD(grantor);
    3400      150398 :     COPY_SCALAR_FIELD(behavior);
    3401             : 
    3402      150398 :     return newnode;
    3403             : }
    3404             : 
    3405             : static ObjectWithArgs *
    3406       83278 : _copyObjectWithArgs(const ObjectWithArgs *from)
    3407             : {
    3408       83278 :     ObjectWithArgs *newnode = makeNode(ObjectWithArgs);
    3409             : 
    3410       83278 :     COPY_NODE_FIELD(objname);
    3411       83278 :     COPY_NODE_FIELD(objargs);
    3412       83278 :     COPY_NODE_FIELD(objfuncargs);
    3413       83278 :     COPY_SCALAR_FIELD(args_unspecified);
    3414             : 
    3415       83278 :     return newnode;
    3416             : }
    3417             : 
    3418             : static AccessPriv *
    3419      142956 : _copyAccessPriv(const AccessPriv *from)
    3420             : {
    3421      142956 :     AccessPriv *newnode = makeNode(AccessPriv);
    3422             : 
    3423      142956 :     COPY_STRING_FIELD(priv_name);
    3424      142956 :     COPY_NODE_FIELD(cols);
    3425             : 
    3426      142956 :     return newnode;
    3427             : }
    3428             : 
    3429             : static GrantRoleStmt *
    3430        3248 : _copyGrantRoleStmt(const GrantRoleStmt *from)
    3431             : {
    3432        3248 :     GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
    3433             : 
    3434        3248 :     COPY_NODE_FIELD(granted_roles);
    3435        3248 :     COPY_NODE_FIELD(grantee_roles);
    3436        3248 :     COPY_SCALAR_FIELD(is_grant);
    3437        3248 :     COPY_SCALAR_FIELD(admin_opt);
    3438        3248 :     COPY_NODE_FIELD(grantor);
    3439        3248 :     COPY_SCALAR_FIELD(behavior);
    3440             : 
    3441        3248 :     return newnode;
    3442             : }
    3443             : 
    3444             : static AlterDefaultPrivilegesStmt *
    3445         226 : _copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from)
    3446             : {
    3447         226 :     AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);
    3448             : 
    3449         226 :     COPY_NODE_FIELD(options);
    3450         226 :     COPY_NODE_FIELD(action);
    3451             : 
    3452         226 :     return newnode;
    3453             : }
    3454             : 
    3455             : static DeclareCursorStmt *
    3456       10796 : _copyDeclareCursorStmt(const DeclareCursorStmt *from)
    3457             : {
    3458       10796 :     DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
    3459             : 
    3460       10796 :     COPY_STRING_FIELD(portalname);
    3461       10796 :     COPY_SCALAR_FIELD(options);
    3462       10796 :     COPY_NODE_FIELD(query);
    3463             : 
    3464       10796 :     return newnode;
    3465             : }
    3466             : 
    3467             : static ClosePortalStmt *
    3468        3892 : _copyClosePortalStmt(const ClosePortalStmt *from)
    3469             : {
    3470        3892 :     ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
    3471             : 
    3472        3892 :     COPY_STRING_FIELD(portalname);
    3473             : 
    3474        3892 :     return newnode;
    3475             : }
    3476             : 
    3477             : static CallStmt *
    3478         998 : _copyCallStmt(const CallStmt *from)
    3479             : {
    3480         998 :     CallStmt   *newnode = makeNode(CallStmt);
    3481             : 
    3482         998 :     COPY_NODE_FIELD(funccall);
    3483         998 :     COPY_NODE_FIELD(funcexpr);
    3484         998 :     COPY_NODE_FIELD(outargs);
    3485             : 
    3486         998 :     return newnode;
    3487             : }
    3488             : 
    3489             : static ClusterStmt *
    3490         228 : _copyClusterStmt(const ClusterStmt *from)
    3491             : {
    3492         228 :     ClusterStmt *newnode = makeNode(ClusterStmt);
    3493             : 
    3494         228 :     COPY_NODE_FIELD(relation);
    3495         228 :     COPY_STRING_FIELD(indexname);
    3496         228 :     COPY_NODE_FIELD(params);
    3497             : 
    3498         228 :     return newnode;
    3499             : }
    3500             : 
    3501             : static CopyStmt *
    3502        9928 : _copyCopyStmt(const CopyStmt *from)
    3503             : {
    3504        9928 :     CopyStmt   *newnode = makeNode(CopyStmt);
    3505             : 
    3506        9928 :     COPY_NODE_FIELD(relation);
    3507        9928 :     COPY_NODE_FIELD(query);
    3508        9928 :     COPY_NODE_FIELD(attlist);
    3509        9928 :     COPY_SCALAR_FIELD(is_from);
    3510        9928 :     COPY_SCALAR_FIELD(is_program);
    3511        9928 :     COPY_STRING_FIELD(filename);
    3512        9928 :     COPY_NODE_FIELD(options);
    3513        9928 :     COPY_NODE_FIELD(whereClause);
    3514             : 
    3515        9928 :     return newnode;
    3516             : }
    3517             : 
    3518             : /*
    3519             :  * CopyCreateStmtFields
    3520             :  *
    3521             :  *      This function copies the fields of the CreateStmt node.  It is used by
    3522             :  *      copy functions for classes which inherit from CreateStmt.
    3523             :  */
    3524             : static void
    3525       49054 : CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode)
    3526             : {
    3527       49054 :     COPY_NODE_FIELD(relation);
    3528       49054 :     COPY_NODE_FIELD(tableElts);
    3529       49054 :     COPY_NODE_FIELD(inhRelations);
    3530       49054 :     COPY_NODE_FIELD(partspec);
    3531       49054 :     COPY_NODE_FIELD(partbound);
    3532       49054 :     COPY_NODE_FIELD(ofTypename);
    3533       49054 :     COPY_NODE_FIELD(constraints);
    3534       49054 :     COPY_NODE_FIELD(options);
    3535       49054 :     COPY_SCALAR_FIELD(oncommit);
    3536       49054 :     COPY_STRING_FIELD(tablespacename);
    3537       49054 :     COPY_STRING_FIELD(accessMethod);
    3538       49054 :     COPY_SCALAR_FIELD(if_not_exists);
    3539       49054 : }
    3540             : 
    3541             : static CreateStmt *
    3542       48394 : _copyCreateStmt(const CreateStmt *from)
    3543             : {
    3544       48394 :     CreateStmt *newnode = makeNode(CreateStmt);
    3545             : 
    3546       48394 :     CopyCreateStmtFields(from, newnode);
    3547             : 
    3548       48394 :     return newnode;
    3549             : }
    3550             : 
    3551             : static TableLikeClause *
    3552         900 : _copyTableLikeClause(const TableLikeClause *from)
    3553             : {
    3554         900 :     TableLikeClause *newnode = makeNode(TableLikeClause);
    3555             : 
    3556         900 :     COPY_NODE_FIELD(relation);
    3557         900 :     COPY_SCALAR_FIELD(options);
    3558         900 :     COPY_SCALAR_FIELD(relationOid);
    3559             : 
    3560         900 :     return newnode;
    3561             : }
    3562             : 
    3563             : static DefineStmt *
    3564       60038 : _copyDefineStmt(const DefineStmt *from)
    3565             : {
    3566       60038 :     DefineStmt *newnode = makeNode(DefineStmt);
    3567             : 
    3568       60038 :     COPY_SCALAR_FIELD(kind);
    3569       60038 :     COPY_SCALAR_FIELD(oldstyle);
    3570       60038 :     COPY_NODE_FIELD(defnames);
    3571       60038 :     COPY_NODE_FIELD(args);
    3572       60038 :     COPY_NODE_FIELD(definition);
    3573       60038 :     COPY_SCALAR_FIELD(if_not_exists);
    3574       60038 :     COPY_SCALAR_FIELD(replace);
    3575             : 
    3576       60038 :     return newnode;
    3577             : }
    3578             : 
    3579             : static DropStmt *
    3580       30612 : _copyDropStmt(const DropStmt *from)
    3581             : {
    3582       30612 :     DropStmt   *newnode = makeNode(DropStmt);
    3583             : 
    3584       30612 :     COPY_NODE_FIELD(objects);
    3585       30612 :     COPY_SCALAR_FIELD(removeType);
    3586       30612 :     COPY_SCALAR_FIELD(behavior);
    3587       30612 :     COPY_SCALAR_FIELD(missing_ok);
    3588       30612 :     COPY_SCALAR_FIELD(concurrent);
    3589             : 
    3590       30612 :     return newnode;
    3591             : }
    3592             : 
    3593             : static TruncateStmt *
    3594        1848 : _copyTruncateStmt(const TruncateStmt *from)
    3595             : {
    3596        1848 :     TruncateStmt *newnode = makeNode(TruncateStmt);
    3597             : 
    3598        1848 :     COPY_NODE_FIELD(relations);
    3599        1848 :     COPY_SCALAR_FIELD(restart_seqs);
    3600        1848 :     COPY_SCALAR_FIELD(behavior);
    3601             : 
    3602        1848 :     return newnode;
    3603             : }
    3604             : 
    3605             : static CommentStmt *
    3606       59254 : _copyCommentStmt(const CommentStmt *from)
    3607             : {
    3608       59254 :     CommentStmt *newnode = makeNode(CommentStmt);
    3609             : 
    3610       59254 :     COPY_SCALAR_FIELD(objtype);
    3611       59254 :     COPY_NODE_FIELD(object);
    3612       59254 :     COPY_STRING_FIELD(comment);
    3613             : 
    3614       59254 :     return newnode;
    3615             : }
    3616             : 
    3617             : static SecLabelStmt *
    3618         170 : _copySecLabelStmt(const SecLabelStmt *from)
    3619             : {
    3620         170 :     SecLabelStmt *newnode = makeNode(SecLabelStmt);
    3621             : 
    3622         170 :     COPY_SCALAR_FIELD(objtype);
    3623         170 :     COPY_NODE_FIELD(object);
    3624         170 :     COPY_STRING_FIELD(provider);
    3625         170 :     COPY_STRING_FIELD(label);
    3626             : 
    3627         170 :     return newnode;
    3628             : }
    3629             : 
    3630             : static FetchStmt *
    3631       10276 : _copyFetchStmt(const FetchStmt *from)
    3632             : {
    3633       10276 :     FetchStmt  *newnode = makeNode(FetchStmt);
    3634             : 
    3635       10276 :     COPY_SCALAR_FIELD(direction);
    3636       10276 :     COPY_SCALAR_FIELD(howMany);
    3637       10276 :     COPY_STRING_FIELD(portalname);
    3638       10276 :     COPY_SCALAR_FIELD(ismove);
    3639             : 
    3640       10276 :     return newnode;
    3641             : }
    3642             : 
    3643             : static IndexStmt *
    3644        8282 : _copyIndexStmt(const IndexStmt *from)
    3645             : {
    3646        8282 :     IndexStmt  *newnode = makeNode(IndexStmt);
    3647             : 
    3648        8282 :     COPY_STRING_FIELD(idxname);
    3649        8282 :     COPY_NODE_FIELD(relation);
    3650        8282 :     COPY_STRING_FIELD(accessMethod);
    3651        8282 :     COPY_STRING_FIELD(tableSpace);
    3652        8282 :     COPY_NODE_FIELD(indexParams);
    3653        8282 :     COPY_NODE_FIELD(indexIncludingParams);
    3654        8282 :     COPY_NODE_FIELD(options);
    3655        8282 :     COPY_NODE_FIELD(whereClause);
    3656        8282 :     COPY_NODE_FIELD(excludeOpNames);
    3657        8282 :     COPY_STRING_FIELD(idxcomment);
    3658        8282 :     COPY_SCALAR_FIELD(indexOid);
    3659        8282 :     COPY_SCALAR_FIELD(oldNode);
    3660        8282 :     COPY_SCALAR_FIELD(oldCreateSubid);
    3661        8282 :     COPY_SCALAR_FIELD(oldFirstRelfilenodeSubid);
    3662        8282 :     COPY_SCALAR_FIELD(unique);
    3663        8282 :     COPY_SCALAR_FIELD(primary);
    3664        8282 :     COPY_SCALAR_FIELD(isconstraint);
    3665        8282 :     COPY_SCALAR_FIELD(deferrable);
    3666        8282 :     COPY_SCALAR_FIELD(initdeferred);
    3667        8282 :     COPY_SCALAR_FIELD(transformed);
    3668        8282 :     COPY_SCALAR_FIELD(concurrent);
    3669        8282 :     COPY_SCALAR_FIELD(if_not_exists);
    3670        8282 :     COPY_SCALAR_FIELD(reset_default_tblspc);
    3671             : 
    3672        8282 :     return newnode;
    3673             : }
    3674             : 
    3675             : static CreateStatsStmt *
    3676         684 : _copyCreateStatsStmt(const CreateStatsStmt *from)
    3677             : {
    3678         684 :     CreateStatsStmt *newnode = makeNode(CreateStatsStmt);
    3679             : 
    3680         684 :     COPY_NODE_FIELD(defnames);
    3681         684 :     COPY_NODE_FIELD(stat_types);
    3682         684 :     COPY_NODE_FIELD(exprs);
    3683         684 :     COPY_NODE_FIELD(relations);
    3684         684 :     COPY_STRING_FIELD(stxcomment);
    3685         684 :     COPY_SCALAR_FIELD(transformed);
    3686         684 :     COPY_SCALAR_FIELD(if_not_exists);
    3687             : 
    3688         684 :     return newnode;
    3689             : }
    3690             : 
    3691             : static AlterStatsStmt *
    3692          36 : _copyAlterStatsStmt(const AlterStatsStmt *from)
    3693             : {
    3694          36 :     AlterStatsStmt *newnode = makeNode(AlterStatsStmt);
    3695             : 
    3696          36 :     COPY_NODE_FIELD(defnames);
    3697          36 :     COPY_SCALAR_FIELD(stxstattarget);
    3698          36 :     COPY_SCALAR_FIELD(missing_ok);
    3699             : 
    3700          36 :     return newnode;
    3701             : }
    3702             : 
    3703             : static CreateFunctionStmt *
    3704      107530 : _copyCreateFunctionStmt(const CreateFunctionStmt *from)
    3705             : {
    3706      107530 :     CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
    3707             : 
    3708      107530 :     COPY_SCALAR_FIELD(is_procedure);
    3709      107530 :     COPY_SCALAR_FIELD(replace);
    3710      107530 :     COPY_NODE_FIELD(funcname);
    3711      107530 :     COPY_NODE_FIELD(parameters);
    3712      107530 :     COPY_NODE_FIELD(returnType);
    3713      107530 :     COPY_NODE_FIELD(options);
    3714      107530 :     COPY_NODE_FIELD(sql_body);
    3715             : 
    3716      107530 :     return newnode;
    3717             : }
    3718             : 
    3719             : static FunctionParameter *
    3720      363812 : _copyFunctionParameter(const FunctionParameter *from)
    3721             : {
    3722      363812 :     FunctionParameter *newnode = makeNode(FunctionParameter);
    3723             : 
    3724      363812 :     COPY_STRING_FIELD(name);
    3725      363812 :     COPY_NODE_FIELD(argType);
    3726      363812 :     COPY_SCALAR_FIELD(mode);
    3727      363812 :     COPY_NODE_FIELD(defexpr);
    3728             : 
    3729      363812 :     return newnode;
    3730             : }
    3731             : 
    3732             : static AlterFunctionStmt *
    3733         934 : _copyAlterFunctionStmt(const AlterFunctionStmt *from)
    3734             : {
    3735         934 :     AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
    3736             : 
    3737         934 :     COPY_SCALAR_FIELD(objtype);
    3738         934 :     COPY_NODE_FIELD(func);
    3739         934 :     COPY_NODE_FIELD(actions);
    3740             : 
    3741         934 :     return newnode;
    3742             : }
    3743             : 
    3744             : static DoStmt *
    3745        1632 : _copyDoStmt(const DoStmt *from)
    3746             : {
    3747        1632 :     DoStmt     *newnode = makeNode(DoStmt);
    3748             : 
    3749        1632 :     COPY_NODE_FIELD(args);
    3750             : 
    3751        1632 :     return newnode;
    3752             : }
    3753             : 
    3754             : static RenameStmt *
    3755        2084 : _copyRenameStmt(const RenameStmt *from)
    3756             : {
    3757        2084 :     RenameStmt *newnode = makeNode(RenameStmt);
    3758             : 
    3759        2084 :     COPY_SCALAR_FIELD(renameType);
    3760        2084 :     COPY_SCALAR_FIELD(relationType);
    3761        2084 :     COPY_NODE_FIELD(relation);
    3762        2084 :     COPY_NODE_FIELD(object);
    3763        2084 :     COPY_STRING_FIELD(subname);
    3764        2084 :     COPY_STRING_FIELD(newname);
    3765        2084 :     COPY_SCALAR_FIELD(behavior);
    3766        2084 :     COPY_SCALAR_FIELD(missing_ok);
    3767             : 
    3768        2084 :     return newnode;
    3769             : }
    3770             : 
    3771             : static AlterObjectDependsStmt *
    3772          92 : _copyAlterObjectDependsStmt(const AlterObjectDependsStmt *from)
    3773             : {
    3774          92 :     AlterObjectDependsStmt *newnode = makeNode(AlterObjectDependsStmt);
    3775             : 
    3776          92 :     COPY_SCALAR_FIELD(objectType);
    3777          92 :     COPY_NODE_FIELD(relation);
    3778          92 :     COPY_NODE_FIELD(object);
    3779          92 :     COPY_NODE_FIELD(extname);
    3780          92 :     COPY_SCALAR_FIELD(remove);
    3781             : 
    3782          92 :     return newnode;
    3783             : }
    3784             : 
    3785             : static AlterObjectSchemaStmt *
    3786         504 : _copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from)
    3787             : {
    3788         504 :     AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
    3789             : 
    3790         504 :     COPY_SCALAR_FIELD(objectType);
    3791         504 :     COPY_NODE_FIELD(relation);
    3792         504 :     COPY_NODE_FIELD(object);
    3793         504 :     COPY_STRING_FIELD(newschema);
    3794         504 :     COPY_SCALAR_FIELD(missing_ok);
    3795             : 
    3796         504 :     return newnode;
    3797             : }
    3798             : 
    3799             : static AlterOwnerStmt *
    3800        3376 : _copyAlterOwnerStmt(const AlterOwnerStmt *from)
    3801             : {
    3802        3376 :     AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
    3803             : 
    3804        3376 :     COPY_SCALAR_FIELD(objectType);
    3805        3376 :     COPY_NODE_FIELD(relation);
    3806        3376 :     COPY_NODE_FIELD(object);
    3807        3376 :     COPY_NODE_FIELD(newowner);
    3808             : 
    3809        3376 :     return newnode;
    3810             : }
    3811             : 
    3812             : static AlterOperatorStmt *
    3813         968 : _copyAlterOperatorStmt(const AlterOperatorStmt *from)
    3814             : {
    3815         968 :     AlterOperatorStmt *newnode = makeNode(AlterOperatorStmt);
    3816             : 
    3817         968 :     COPY_NODE_FIELD(opername);
    3818         968 :     COPY_NODE_FIELD(options);
    3819             : 
    3820         968 :     return newnode;
    3821             : }
    3822             : 
    3823             : static AlterTypeStmt *
    3824          96 : _copyAlterTypeStmt(const AlterTypeStmt *from)
    3825             : {
    3826          96 :     AlterTypeStmt *newnode = makeNode(AlterTypeStmt);
    3827             : 
    3828          96 :     COPY_NODE_FIELD(typeName);
    3829          96 :     COPY_NODE_FIELD(options);
    3830             : 
    3831          96 :     return newnode;
    3832             : }
    3833             : 
    3834             : static RuleStmt *
    3835        3050 : _copyRuleStmt(const RuleStmt *from)
    3836             : {
    3837        3050 :     RuleStmt   *newnode = makeNode(RuleStmt);
    3838             : 
    3839        3050 :     COPY_NODE_FIELD(relation);
    3840        3050 :     COPY_STRING_FIELD(rulename);
    3841        3050 :     COPY_NODE_FIELD(whereClause);
    3842        3050 :     COPY_SCALAR_FIELD(event);
    3843        3050 :     COPY_SCALAR_FIELD(instead);
    3844        3050 :     COPY_NODE_FIELD(actions);
    3845        3050 :     COPY_SCALAR_FIELD(replace);
    3846             : 
    3847        3050 :     return newnode;
    3848             : }
    3849             : 
    3850             : static NotifyStmt *
    3851         224 : _copyNotifyStmt(const NotifyStmt *from)
    3852             : {
    3853         224 :     NotifyStmt *newnode = makeNode(NotifyStmt);
    3854             : 
    3855         224 :     COPY_STRING_FIELD(conditionname);
    3856         224 :     COPY_STRING_FIELD(payload);
    3857             : 
    3858         224 :     return newnode;
    3859             : }
    3860             : 
    3861             : static ListenStmt *
    3862          84 : _copyListenStmt(const ListenStmt *from)
    3863             : {
    3864          84 :     ListenStmt *newnode = makeNode(ListenStmt);
    3865             : 
    3866          84 :     COPY_STRING_FIELD(conditionname);
    3867             : 
    3868          84 :     return newnode;
    3869             : }
    3870             : 
    3871             : static UnlistenStmt *
    3872          68 : _copyUnlistenStmt(const UnlistenStmt *from)
    3873             : {
    3874          68 :     UnlistenStmt *newnode = makeNode(UnlistenStmt);
    3875             : 
    3876          68 :     COPY_STRING_FIELD(conditionname);
    3877             : 
    3878          68 :     return newnode;
    3879             : }
    3880             : 
    3881             : static TransactionStmt *
    3882       56438 : _copyTransactionStmt(const TransactionStmt *from)
    3883             : {
    3884       56438 :     TransactionStmt *newnode = makeNode(TransactionStmt);
    3885             : 
    3886       56438 :     COPY_SCALAR_FIELD(kind);
    3887       56438 :     COPY_NODE_FIELD(options);
    3888       56438 :     COPY_STRING_FIELD(savepoint_name);
    3889       56438 :     COPY_STRING_FIELD(gid);
    3890       56438 :     COPY_SCALAR_FIELD(chain);
    3891             : 
    3892       56438 :     return newnode;
    3893             : }
    3894             : 
    3895             : static CompositeTypeStmt *
    3896         920 : _copyCompositeTypeStmt(const CompositeTypeStmt *from)
    3897             : {
    3898         920 :     CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
    3899             : 
    3900         920 :     COPY_NODE_FIELD(typevar);
    3901         920 :     COPY_NODE_FIELD(coldeflist);
    3902             : 
    3903         920 :     return newnode;
    3904             : }
    3905             : 
    3906             : static CreateEnumStmt *
    3907         548 : _copyCreateEnumStmt(const CreateEnumStmt *from)
    3908             : {
    3909         548 :     CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
    3910             : 
    3911         548 :     COPY_NODE_FIELD(typeName);
    3912         548 :     COPY_NODE_FIELD(vals);
    3913             : 
    3914         548 :     return newnode;
    3915             : }
    3916             : 
    3917             : static CreateRangeStmt *
    3918         182 : _copyCreateRangeStmt(const CreateRangeStmt *from)
    3919             : {
    3920         182 :     CreateRangeStmt *newnode = makeNode(CreateRangeStmt);
    3921             : 
    3922         182 :     COPY_NODE_FIELD(typeName);
    3923         182 :     COPY_NODE_FIELD(params);
    3924             : 
    3925         182 :     return newnode;
    3926             : }
    3927             : 
    3928             : static AlterEnumStmt *
    3929         564 : _copyAlterEnumStmt(const AlterEnumStmt *from)
    3930             : {
    3931         564 :     AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
    3932             : 
    3933         564 :     COPY_NODE_FIELD(typeName);
    3934         564 :     COPY_STRING_FIELD(oldVal);
    3935         564 :     COPY_STRING_FIELD(newVal);
    3936         564 :     COPY_STRING_FIELD(newValNeighbor);
    3937         564 :     COPY_SCALAR_FIELD(newValIsAfter);
    3938         564 :     COPY_SCALAR_FIELD(skipIfNewValExists);
    3939             : 
    3940         564 :     return newnode;
    3941             : }
    3942             : 
    3943             : static ViewStmt *
    3944      136402 : _copyViewStmt(const ViewStmt *from)
    3945             : {
    3946      136402 :     ViewStmt   *newnode = makeNode(ViewStmt);
    3947             : 
    3948      136402 :     COPY_NODE_FIELD(view);
    3949      136402 :     COPY_NODE_FIELD(aliases);
    3950      136402 :     COPY_NODE_FIELD(query);
    3951      136402 :     COPY_SCALAR_FIELD(replace);
    3952      136402 :     COPY_NODE_FIELD(options);
    3953      136402 :     COPY_SCALAR_FIELD(withCheckOption);
    3954             : 
    3955      136402 :     return newnode;
    3956             : }
    3957             : 
    3958             : static LoadStmt *
    3959          68 : _copyLoadStmt(const LoadStmt *from)
    3960             : {
    3961          68 :     LoadStmt   *newnode = makeNode(LoadStmt);
    3962             : 
    3963          68 :     COPY_STRING_FIELD(filename);
    3964             : 
    3965          68 :     return newnode;
    3966             : }
    3967             : 
    3968             : static CreateDomainStmt *
    3969        5728 : _copyCreateDomainStmt(const CreateDomainStmt *from)
    3970             : {
    3971        5728 :     CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
    3972             : 
    3973        5728 :     COPY_NODE_FIELD(domainname);
    3974        5728 :     COPY_NODE_FIELD(typeName);
    3975        5728 :     COPY_NODE_FIELD(collClause);
    3976        5728 :     COPY_NODE_FIELD(constraints);
    3977             : 
    3978        5728 :     return newnode;
    3979             : }
    3980             : 
    3981             : static CreateOpClassStmt *
    3982         654 : _copyCreateOpClassStmt(const CreateOpClassStmt *from)
    3983             : {
    3984         654 :     CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
    3985             : 
    3986         654 :     COPY_NODE_FIELD(opclassname);
    3987         654 :     COPY_NODE_FIELD(opfamilyname);
    3988         654 :     COPY_STRING_FIELD(amname);
    3989         654 :     COPY_NODE_FIELD(datatype);
    3990         654 :     COPY_NODE_FIELD(items);
    3991         654 :     COPY_SCALAR_FIELD(isDefault);
    3992             : 
    3993         654 :     return newnode;
    3994             : }
    3995             : 
    3996             : static CreateOpClassItem *
    3997        7064 : _copyCreateOpClassItem(const CreateOpClassItem *from)
    3998             : {
    3999        7064 :     CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
    4000             : 
    4001        7064 :     COPY_SCALAR_FIELD(itemtype);
    4002        7064 :     COPY_NODE_FIELD(name);
    4003        7064 :     COPY_SCALAR_FIELD(number);
    4004        7064 :     COPY_NODE_FIELD(order_family);
    4005        7064 :     COPY_NODE_FIELD(class_args);
    4006        7064 :     COPY_NODE_FIELD(storedtype);
    4007             : 
    4008        7064 :     return newnode;
    4009             : }
    4010             : 
    4011             : static CreateOpFamilyStmt *
    4012         208 : _copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from)
    4013             : {
    4014         208 :     CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
    4015             : 
    4016         208 :     COPY_NODE_FIELD(opfamilyname);
    4017         208 :     COPY_STRING_FIELD(amname);
    4018             : 
    4019         208 :     return newnode;
    4020             : }
    4021             : 
    4022             : static AlterOpFamilyStmt *
    4023         714 : _copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from)
    4024             : {
    4025         714 :     AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
    4026             : 
    4027         714 :     COPY_NODE_FIELD(opfamilyname);
    4028         714 :     COPY_STRING_FIELD(amname);
    4029         714 :     COPY_SCALAR_FIELD(isDrop);
    4030         714 :     COPY_NODE_FIELD(items);
    4031             : 
    4032         714 :     return newnode;
    4033             : }
    4034             : 
    4035             : static CreatedbStmt *
    4036        2524 : _copyCreatedbStmt(const CreatedbStmt *from)
    4037             : {
    4038        2524 :     CreatedbStmt *newnode = makeNode(CreatedbStmt);
    4039             : 
    4040        2524 :     COPY_STRING_FIELD(dbname);
    4041        2524 :     COPY_NODE_FIELD(options);
    4042             : 
    4043        2524 :     return newnode;
    4044             : }
    4045             : 
    4046             : static AlterDatabaseStmt *
    4047          12 : _copyAlterDatabaseStmt(const AlterDatabaseStmt *from)
    4048             : {
    4049          12 :     AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
    4050             : 
    4051          12 :     COPY_STRING_FIELD(dbname);
    4052          12 :     COPY_NODE_FIELD(options);
    4053             : 
    4054          12 :     return newnode;
    4055             : }
    4056             : 
    4057             : static AlterDatabaseSetStmt *
    4058        1800 : _copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from)
    4059             : {
    4060        1800 :     AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
    4061             : 
    4062        1800 :     COPY_STRING_FIELD(dbname);
    4063        1800 :     COPY_NODE_FIELD(setstmt);
    4064             : 
    4065        1800 :     return newnode;
    4066             : }
    4067             : 
    4068             : static DropdbStmt *
    4069          80 : _copyDropdbStmt(const DropdbStmt *from)
    4070             : {
    4071          80 :     DropdbStmt *newnode = makeNode(DropdbStmt);
    4072             : 
    4073          80 :     COPY_STRING_FIELD(dbname);
    4074          80 :     COPY_SCALAR_FIELD(missing_ok);
    4075          80 :     COPY_NODE_FIELD(options);
    4076             : 
    4077          80 :     return newnode;
    4078             : }
    4079             : 
    4080             : static VacuumStmt *
    4081       16384 : _copyVacuumStmt(const VacuumStmt *from)
    4082             : {
    4083       16384 :     VacuumStmt *newnode = makeNode(VacuumStmt);
    4084             : 
    4085       16384 :     COPY_NODE_FIELD(options);
    4086       16384 :     COPY_NODE_FIELD(rels);
    4087       16384 :     COPY_SCALAR_FIELD(is_vacuumcmd);
    4088             : 
    4089       16384 :     return newnode;
    4090             : }
    4091             : 
    4092             : static VacuumRelation *
    4093       14604 : _copyVacuumRelation(const VacuumRelation *from)
    4094             : {
    4095       14604 :     VacuumRelation *newnode = makeNode(VacuumRelation);
    4096             : 
    4097       14604 :     COPY_NODE_FIELD(relation);
    4098       14604 :     COPY_SCALAR_FIELD(oid);
    4099       14604 :     COPY_NODE_FIELD(va_cols);
    4100             : 
    4101       14604 :     return newnode;
    4102             : }
    4103             : 
    4104             : static ExplainStmt *
    4105       47320 : _copyExplainStmt(const ExplainStmt *from)
    4106             : {
    4107       47320 :     ExplainStmt *newnode = makeNode(ExplainStmt);
    4108             : 
    4109       47320 :     COPY_NODE_FIELD(query);
    4110       47320 :     COPY_NODE_FIELD(options);
    4111             : 
    4112       47320 :     return newnode;
    4113             : }
    4114             : 
    4115             : static CreateTableAsStmt *
    4116        2432 : _copyCreateTableAsStmt(const CreateTableAsStmt *from)
    4117             : {
    4118        2432 :     CreateTableAsStmt *newnode = makeNode(CreateTableAsStmt);
    4119             : 
    4120        2432 :     COPY_NODE_FIELD(query);
    4121        2432 :     COPY_NODE_FIELD(into);
    4122        2432 :     COPY_SCALAR_FIELD(objtype);
    4123        2432 :     COPY_SCALAR_FIELD(is_select_into);
    4124        2432 :     COPY_SCALAR_FIELD(if_not_exists);
    4125             : 
    4126        2432 :     return newnode;
    4127             : }
    4128             : 
    4129             : static RefreshMatViewStmt *
    4130         266 : _copyRefreshMatViewStmt(const RefreshMatViewStmt *from)
    4131             : {
    4132         266 :     RefreshMatViewStmt *newnode = makeNode(RefreshMatViewStmt);
    4133             : 
    4134         266 :     COPY_SCALAR_FIELD(concurrent);
    4135         266 :     COPY_SCALAR_FIELD(skipData);
    4136         266 :     COPY_NODE_FIELD(relation);
    4137             : 
    4138         266 :     return newnode;
    4139             : }
    4140             : 
    4141             : static ReplicaIdentityStmt *
    4142         318 : _copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
    4143             : {
    4144         318 :     ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);
    4145             : 
    4146         318 :     COPY_SCALAR_FIELD(identity_type);
    4147         318 :     COPY_STRING_FIELD(name);
    4148             : 
    4149         318 :     return newnode;
    4150             : }
    4151             : 
    4152             : static AlterSystemStmt *
    4153         116 : _copyAlterSystemStmt(const AlterSystemStmt *from)
    4154             : {
    4155         116 :     AlterSystemStmt *newnode = makeNode(AlterSystemStmt);
    4156             : 
    4157         116 :     COPY_NODE_FIELD(setstmt);
    4158             : 
    4159         116 :     return newnode;
    4160             : }
    4161             : 
    4162             : static CreateSeqStmt *
    4163         930 : _copyCreateSeqStmt(const CreateSeqStmt *from)
    4164             : {
    4165         930 :     CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
    4166             : 
    4167         930 :     COPY_NODE_FIELD(sequence);
    4168         930 :     COPY_NODE_FIELD(options);
    4169         930 :     COPY_SCALAR_FIELD(ownerId);
    4170         930 :     COPY_SCALAR_FIELD(for_identity);
    4171         930 :     COPY_SCALAR_FIELD(if_not_exists);
    4172             : 
    4173         930 :     return newnode;
    4174             : }
    4175             : 
    4176             : static AlterSeqStmt *
    4177         326 : _copyAlterSeqStmt(const AlterSeqStmt *from)
    4178             : {
    4179         326 :     AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
    4180             : 
    4181         326 :     COPY_NODE_FIELD(sequence);
    4182         326 :     COPY_NODE_FIELD(options);
    4183         326 :     COPY_SCALAR_FIELD(for_identity);
    4184         326 :     COPY_SCALAR_FIELD(missing_ok);
    4185             : 
    4186         326 :     return newnode;
    4187             : }
    4188             : 
    4189             : static VariableSetStmt *
    4190       38352 : _copyVariableSetStmt(const VariableSetStmt *from)
    4191             : {
    4192       38352 :     VariableSetStmt *newnode = makeNode(VariableSetStmt);
    4193             : 
    4194       38352 :     COPY_SCALAR_FIELD(kind);
    4195       38352 :     COPY_STRING_FIELD(name);
    4196       38352 :     COPY_NODE_FIELD(args);
    4197       38352 :     COPY_SCALAR_FIELD(is_local);
    4198             : 
    4199       38352 :     return newnode;
    4200             : }
    4201             : 
    4202             : static VariableShowStmt *
    4203        1056 : _copyVariableShowStmt(const VariableShowStmt *from)
    4204             : {
    4205        1056 :     VariableShowStmt *newnode = makeNode(VariableShowStmt);
    4206             : 
    4207        1056 :     COPY_STRING_FIELD(name);
    4208             : 
    4209        1056 :     return newnode;
    4210             : }
    4211             : 
    4212             : static DiscardStmt *
    4213          40 : _copyDiscardStmt(const DiscardStmt *from)
    4214             : {
    4215          40 :     DiscardStmt *newnode = makeNode(DiscardStmt);
    4216             : 
    4217          40 :     COPY_SCALAR_FIELD(target);
    4218             : 
    4219          40 :     return newnode;
    4220             : }
    4221             : 
    4222             : static CreateTableSpaceStmt *
    4223          72 : _copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from)
    4224             : {
    4225          72 :     CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
    4226             : 
    4227          72 :     COPY_STRING_FIELD(tablespacename);
    4228          72 :     COPY_NODE_FIELD(owner);
    4229          72 :     COPY_STRING_FIELD(location);
    4230          72 :     COPY_NODE_FIELD(options);
    4231             : 
    4232          72 :     return newnode;
    4233             : }
    4234             : 
    4235             : static DropTableSpaceStmt *
    4236          48 : _copyDropTableSpaceStmt(const DropTableSpaceStmt *from)
    4237             : {
    4238          48 :     DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
    4239             : 
    4240          48 :     COPY_STRING_FIELD(tablespacename);
    4241          48 :     COPY_SCALAR_FIELD(missing_ok);
    4242             : 
    4243          48 :     return newnode;
    4244             : }
    4245             : 
    4246             : static AlterTableSpaceOptionsStmt *
    4247          32 : _copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from)
    4248             : {
    4249          32 :     AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);
    4250             : 
    4251          32 :     COPY_STRING_FIELD(tablespacename);
    4252          32 :     COPY_NODE_FIELD(options);
    4253          32 :     COPY_SCALAR_FIELD(isReset);
    4254             : 
    4255          32 :     return newnode;
    4256             : }
    4257             : 
    4258             : static AlterTableMoveAllStmt *
    4259          24 : _copyAlterTableMoveAllStmt(const AlterTableMoveAllStmt *from)
    4260             : {
    4261          24 :     AlterTableMoveAllStmt *newnode = makeNode(AlterTableMoveAllStmt);
    4262             : 
    4263          24 :     COPY_STRING_FIELD(orig_tablespacename);
    4264          24 :     COPY_SCALAR_FIELD(objtype);
    4265          24 :     COPY_NODE_FIELD(roles);
    4266          24 :     COPY_STRING_FIELD(new_tablespacename);
    4267          24 :     COPY_SCALAR_FIELD(nowait);
    4268             : 
    4269          24 :     return newnode;
    4270             : }
    4271             : 
    4272             : static CreateExtensionStmt *
    4273        1426 : _copyCreateExtensionStmt(const CreateExtensionStmt *from)
    4274             : {
    4275        1426 :     CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);
    4276             : 
    4277        1426 :     COPY_STRING_FIELD(extname);
    4278        1426 :     COPY_SCALAR_FIELD(if_not_exists);
    4279        1426 :     COPY_NODE_FIELD(options);
    4280             : 
    4281        1426 :     return newnode;
    4282             : }
    4283             : 
    4284             : static AlterExtensionStmt *
    4285          30 : _copyAlterExtensionStmt(const AlterExtensionStmt *from)
    4286             : {
    4287          30 :     AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);
    4288             : 
    4289          30 :     COPY_STRING_FIELD(extname);
    4290          30 :     COPY_NODE_FIELD(options);
    4291             : 
    4292          30 :     return newnode;
    4293             : }
    4294             : 
    4295             : static AlterExtensionContentsStmt *
    4296         294 : _copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from)
    4297             : {
    4298         294 :     AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);
    4299             : 
    4300         294 :     COPY_STRING_FIELD(extname);
    4301         294 :     COPY_SCALAR_FIELD(action);
    4302         294 :     COPY_SCALAR_FIELD(objtype);
    4303         294 :     COPY_NODE_FIELD(object);
    4304             : 
    4305         294 :     return newnode;
    4306             : }
    4307             : 
    4308             : static CreateFdwStmt *
    4309         248 : _copyCreateFdwStmt(const CreateFdwStmt *from)
    4310             : {
    4311         248 :     CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
    4312             : 
    4313         248 :     COPY_STRING_FIELD(fdwname);
    4314         248 :     COPY_NODE_FIELD(func_options);
    4315         248 :     COPY_NODE_FIELD(options);
    4316             : 
    4317         248 :     return newnode;
    4318             : }
    4319             : 
    4320             : static AlterFdwStmt *
    4321         168 : _copyAlterFdwStmt(const AlterFdwStmt *from)
    4322             : {
    4323         168 :     AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
    4324             : 
    4325         168 :     COPY_STRING_FIELD(fdwname);
    4326         168 :     COPY_NODE_FIELD(func_options);
    4327         168 :     COPY_NODE_FIELD(options);
    4328             : 
    4329         168 :     return newnode;
    4330             : }
    4331             : 
    4332             : static CreateForeignServerStmt *
    4333         380 : _copyCreateForeignServerStmt(const CreateForeignServerStmt *from)
    4334             : {
    4335         380 :     CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
    4336             : 
    4337         380 :     COPY_STRING_FIELD(servername);
    4338         380 :     COPY_STRING_FIELD(servertype);
    4339         380 :     COPY_STRING_FIELD(version);
    4340         380 :     COPY_STRING_FIELD(fdwname);
    4341         380 :     COPY_SCALAR_FIELD(if_not_exists);
    4342         380 :     COPY_NODE_FIELD(options);
    4343             : 
    4344         380 :     return newnode;
    4345             : }
    4346             : 
    4347             : static AlterForeignServerStmt *
    4348         252 : _copyAlterForeignServerStmt(const AlterForeignServerStmt *from)
    4349             : {
    4350         252 :     AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
    4351             : 
    4352         252 :     COPY_STRING_FIELD(servername);
    4353         252 :     COPY_STRING_FIELD(version);
    4354         252 :     COPY_NODE_FIELD(options);
    4355         252 :     COPY_SCALAR_FIELD(has_version);
    4356             : 
    4357         252 :     return newnode;
    4358             : }
    4359             : 
    4360             : static CreateUserMappingStmt *
    4361         368 : _copyCreateUserMappingStmt(const CreateUserMappingStmt *from)
    4362             : {
    4363         368 :     CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
    4364             : 
    4365         368 :     COPY_NODE_FIELD(user);
    4366         368 :     COPY_STRING_FIELD(servername);
    4367         368 :     COPY_SCALAR_FIELD(if_not_exists);
    4368         368 :     COPY_NODE_FIELD(options);
    4369             : 
    4370         368 :     return newnode;
    4371             : }
    4372             : 
    4373             : static AlterUserMappingStmt *
    4374         176 : _copyAlterUserMappingStmt(const AlterUserMappingStmt *from)
    4375             : {
    4376         176 :     AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
    4377             : 
    4378         176 :     COPY_NODE_FIELD(user);
    4379         176 :     COPY_STRING_FIELD(servername);
    4380         176 :     COPY_NODE_FIELD(options);
    4381             : 
    4382         176 :     return newnode;
    4383             : }
    4384             : 
    4385             : static DropUserMappingStmt *
    4386         200 : _copyDropUserMappingStmt(const DropUserMappingStmt *from)
    4387             : {
    4388         200 :     DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
    4389             : 
    4390         200 :     COPY_NODE_FIELD(user);
    4391         200 :     COPY_STRING_FIELD(servername);
    4392         200 :     COPY_SCALAR_FIELD(missing_ok);
    4393             : 
    4394         200 :     return newnode;
    4395             : }
    4396             : 
    4397             : static CreateForeignTableStmt *
    4398         660 : _copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
    4399             : {
    4400         660 :     CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
    4401             : 
    4402         660 :     CopyCreateStmtFields((const CreateStmt *) from, (CreateStmt *) newnode);
    4403             : 
    4404         660 :     COPY_STRING_FIELD(servername);
    4405         660 :     COPY_NODE_FIELD(options);
    4406             : 
    4407         660 :     return newnode;
    4408             : }
    4409             : 
    4410             : static ImportForeignSchemaStmt *
    4411          72 : _copyImportForeignSchemaStmt(const ImportForeignSchemaStmt *from)
    4412             : {
    4413          72 :     ImportForeignSchemaStmt *newnode = makeNode(ImportForeignSchemaStmt);
    4414             : 
    4415          72 :     COPY_STRING_FIELD(server_name);
    4416          72 :     COPY_STRING_FIELD(remote_schema);
    4417          72 :     COPY_STRING_FIELD(local_schema);
    4418          72 :     COPY_SCALAR_FIELD(list_type);
    4419          72 :     COPY_NODE_FIELD(table_list);
    4420          72 :     COPY_NODE_FIELD(options);
    4421             : 
    4422          72 :     return newnode;
    4423             : }
    4424             : 
    4425             : static CreateTransformStmt *
    4426          98 : _copyCreateTransformStmt(const CreateTransformStmt *from)
    4427             : {
    4428          98 :     CreateTransformStmt *newnode = makeNode(CreateTransformStmt);
    4429             : 
    4430          98 :     COPY_SCALAR_FIELD(replace);
    4431          98 :     COPY_NODE_FIELD(type_name);
    4432          98 :     COPY_STRING_FIELD(lang);
    4433          98 :     COPY_NODE_FIELD(fromsql);
    4434          98 :     COPY_NODE_FIELD(tosql);
    4435             : 
    4436          98 :     return newnode;
    4437             : }
    4438             : 
    4439             : static CreateAmStmt *
    4440          92 : _copyCreateAmStmt(const CreateAmStmt *from)
    4441             : {
    4442          92 :     CreateAmStmt *newnode = makeNode(CreateAmStmt);
    4443             : 
    4444          92 :     COPY_STRING_FIELD(amname);
    4445          92 :     COPY_NODE_FIELD(handler_name);
    4446          92 :     COPY_SCALAR_FIELD(amtype);
    4447             : 
    4448          92 :     return newnode;
    4449             : }
    4450             : 
    4451             : static CreateTrigStmt *
    4452        4590 : _copyCreateTrigStmt(const CreateTrigStmt *from)
    4453             : {
    4454        4590 :     CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
    4455             : 
    4456        4590 :     COPY_SCALAR_FIELD(replace);
    4457        4590 :     COPY_SCALAR_FIELD(isconstraint);
    4458        4590 :     COPY_STRING_FIELD(trigname);
    4459        4590 :     COPY_NODE_FIELD(relation);
    4460        4590 :     COPY_NODE_FIELD(funcname);
    4461        4590 :     COPY_NODE_FIELD(args);
    4462        4590 :     COPY_SCALAR_FIELD(row);
    4463        4590 :     COPY_SCALAR_FIELD(timing);
    4464        4590 :     COPY_SCALAR_FIELD(events);
    4465        4590 :     COPY_NODE_FIELD(columns);
    4466        4590 :     COPY_NODE_FIELD(whenClause);
    4467        4590 :     COPY_NODE_FIELD(transitionRels);
    4468        4590 :     COPY_SCALAR_FIELD(deferrable);
    4469        4590 :     COPY_SCALAR_FIELD(initdeferred);
    4470        4590 :     COPY_NODE_FIELD(constrrel);
    4471             : 
    4472        4590 :     return newnode;
    4473             : }
    4474             : 
    4475             : static CreateEventTrigStmt *
    4476         228 : _copyCreateEventTrigStmt(const CreateEventTrigStmt *from)
    4477             : {
    4478         228 :     CreateEventTrigStmt *newnode = makeNode(CreateEventTrigStmt);
    4479             : 
    4480         228 :     COPY_STRING_FIELD(trigname);
    4481         228 :     COPY_STRING_FIELD(eventname);
    4482         228 :     COPY_NODE_FIELD(whenclause);
    4483         228 :     COPY_NODE_FIELD(funcname);
    4484             : 
    4485         228 :     return newnode;
    4486             : }
    4487             : 
    4488             : static AlterEventTrigStmt *
    4489          44 : _copyAlterEventTrigStmt(const AlterEventTrigStmt *from)
    4490             : {
    4491          44 :     AlterEventTrigStmt *newnode = makeNode(AlterEventTrigStmt);
    4492             : 
    4493          44 :     COPY_STRING_FIELD(trigname);
    4494          44 :     COPY_SCALAR_FIELD(tgenabled);
    4495             : 
    4496          44 :     return newnode;
    4497             : }
    4498             : 
    4499             : static CreatePLangStmt *
    4500        1048 : _copyCreatePLangStmt(const CreatePLangStmt *from)
    4501             : {
    4502        1048 :     CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
    4503             : 
    4504        1048 :     COPY_SCALAR_FIELD(replace);
    4505        1048 :     COPY_STRING_FIELD(plname);
    4506        1048 :     COPY_NODE_FIELD(plhandler);
    4507        1048 :     COPY_NODE_FIELD(plinline);
    4508        1048 :     COPY_NODE_FIELD(plvalidator);
    4509        1048 :     COPY_SCALAR_FIELD(pltrusted);
    4510             : 
    4511        1048 :     return newnode;
    4512             : }
    4513             : 
    4514             : static CreateRoleStmt *
    4515        1648 : _copyCreateRoleStmt(const CreateRoleStmt *from)
    4516             : {
    4517        1648 :     CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
    4518             : 
    4519        1648 :     COPY_SCALAR_FIELD(stmt_type);
    4520        1648 :     COPY_STRING_FIELD(role);
    4521        1648 :     COPY_NODE_FIELD(options);
    4522             : 
    4523        1648 :     return newnode;
    4524             : }
    4525             : 
    4526             : static AlterRoleStmt *
    4527         468 : _copyAlterRoleStmt(const AlterRoleStmt *from)
    4528             : {
    4529         468 :     AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
    4530             : 
    4531         468 :     COPY_NODE_FIELD(role);
    4532         468 :     COPY_NODE_FIELD(options);
    4533         468 :     COPY_SCALAR_FIELD(action);
    4534             : 
    4535         468 :     return newnode;
    4536             : }
    4537             : 
    4538             : static AlterRoleSetStmt *
    4539         128 : _copyAlterRoleSetStmt(const AlterRoleSetStmt *from)
    4540             : {
    4541         128 :     AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
    4542             : 
    4543         128 :     COPY_NODE_FIELD(role);
    4544         128 :     COPY_STRING_FIELD(database);
    4545         128 :     COPY_NODE_FIELD(setstmt);
    4546             : 
    4547         128 :     return newnode;
    4548             : }
    4549             : 
    4550             : static DropRoleStmt *
    4551        1648 : _copyDropRoleStmt(const DropRoleStmt *from)
    4552             : {
    4553        1648 :     DropRoleStmt *newnode = makeNode(DropRoleStmt);
    4554             : 
    4555        1648 :     COPY_NODE_FIELD(roles);
    4556        1648 :     COPY_SCALAR_FIELD(missing_ok);
    4557             : 
    4558        1648 :     return newnode;
    4559             : }
    4560             : 
    4561             : static LockStmt *
    4562       11268 : _copyLockStmt(const LockStmt *from)
    4563             : {
    4564       11268 :     LockStmt   *newnode = makeNode(LockStmt);
    4565             : 
    4566       11268 :     COPY_NODE_FIELD(relations);
    4567       11268 :     COPY_SCALAR_FIELD(mode);
    4568       11268 :     COPY_SCALAR_FIELD(nowait);
    4569             : 
    4570       11268 :     return newnode;
    4571             : }
    4572             : 
    4573             : static ConstraintsSetStmt *
    4574         148 : _copyConstraintsSetStmt(const ConstraintsSetStmt *from)
    4575             : {
    4576         148 :     ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
    4577             : 
    4578         148 :     COPY_NODE_FIELD(constraints);
    4579         148 :     COPY_SCALAR_FIELD(deferred);
    4580             : 
    4581         148 :     return newnode;
    4582             : }
    4583             : 
    4584             : static ReindexStmt *
    4585        1196 : _copyReindexStmt(const ReindexStmt *from)
    4586             : {
    4587        1196 :     ReindexStmt *newnode = makeNode(ReindexStmt);
    4588             : 
    4589        1196 :     COPY_SCALAR_FIELD(kind);
    4590        1196 :     COPY_NODE_FIELD(relation);
    4591        1196 :     COPY_STRING_FIELD(name);
    4592        1196 :     COPY_NODE_FIELD(params);
    4593             : 
    4594        1196 :     return newnode;
    4595             : }
    4596             : 
    4597             : static CreateSchemaStmt *
    4598        1916 : _copyCreateSchemaStmt(const CreateSchemaStmt *from)
    4599             : {
    4600        1916 :     CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
    4601             : 
    4602        1916 :     COPY_STRING_FIELD(schemaname);
    4603        1916 :     COPY_NODE_FIELD(authrole);
    4604        1916 :     COPY_NODE_FIELD(schemaElts);
    4605        1916 :     COPY_SCALAR_FIELD(if_not_exists);
    4606             : 
    4607        1916 :     return newnode;
    4608             : }
    4609             : 
    4610             : static CreateConversionStmt *
    4611          90 : _copyCreateConversionStmt(const CreateConversionStmt *from)
    4612             : {
    4613          90 :     CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
    4614             : 
    4615          90 :     COPY_NODE_FIELD(conversion_name);
    4616          90 :     COPY_STRING_FIELD(for_encoding_name);
    4617          90 :     COPY_STRING_FIELD(to_encoding_name);
    4618          90 :     COPY_NODE_FIELD(func_name);
    4619          90 :     COPY_SCALAR_FIELD(def);
    4620             : 
    4621          90 :     return newnode;
    4622             : }
    4623             : 
    4624             : static CreateCastStmt *
    4625         420 : _copyCreateCastStmt(const CreateCastStmt *from)
    4626             : {
    4627         420 :     CreateCastStmt *newnode = makeNode(CreateCastStmt);
    4628             : 
    4629         420 :     COPY_NODE_FIELD(sourcetype);
    4630         420 :     COPY_NODE_FIELD(targettype);
    4631         420 :     COPY_NODE_FIELD(func);
    4632         420 :     COPY_SCALAR_FIELD(context);
    4633         420 :     COPY_SCALAR_FIELD(inout);
    4634             : 
    4635         420 :     return newnode;
    4636             : }
    4637             : 
    4638             : static PrepareStmt *
    4639        2236 : _copyPrepareStmt(const PrepareStmt *from)
    4640             : {
    4641        2236 :     PrepareStmt *newnode = makeNode(PrepareStmt);
    4642             : 
    4643        2236 :     COPY_STRING_FIELD(name);
    4644        2236 :     COPY_NODE_FIELD(argtypes);
    4645        2236 :     COPY_NODE_FIELD(query);
    4646             : 
    4647        2236 :     return newnode;
    4648             : }
    4649             : 
    4650             : static ExecuteStmt *
    4651       12120 : _copyExecuteStmt(const ExecuteStmt *from)
    4652             : {
    4653       12120 :     ExecuteStmt *newnode = makeNode(ExecuteStmt);
    4654             : 
    4655       12120 :     COPY_STRING_FIELD(name);
    4656       12120 :     COPY_NODE_FIELD(params);
    4657             : 
    4658       12120 :     return newnode;
    4659             : }
    4660             : 
    4661             : static DeallocateStmt *
    4662        7736 : _copyDeallocateStmt(const DeallocateStmt *from)
    4663             : {
    4664        7736 :     DeallocateStmt *newnode = makeNode(DeallocateStmt);
    4665             : 
    4666        7736 :     COPY_STRING_FIELD(name);
    4667             : 
    4668        7736 :     return newnode;
    4669             : }
    4670             : 
    4671             : static DropOwnedStmt *
    4672         180 : _copyDropOwnedStmt(const DropOwnedStmt *from)
    4673             : {
    4674         180 :     DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
    4675             : 
    4676         180 :     COPY_NODE_FIELD(roles);
    4677         180 :     COPY_SCALAR_FIELD(behavior);
    4678             : 
    4679         180 :     return newnode;
    4680             : }
    4681             : 
    4682             : static ReassignOwnedStmt *
    4683          32 : _copyReassignOwnedStmt(const ReassignOwnedStmt *from)
    4684             : {
    4685          32 :     ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
    4686             : 
    4687          32 :     COPY_NODE_FIELD(roles);
    4688          32 :     COPY_NODE_FIELD(newrole);
    4689             : 
    4690          32 :     return newnode;
    4691             : }
    4692             : 
    4693             : static AlterTSDictionaryStmt *
    4694          68 : _copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from)
    4695             : {
    4696          68 :     AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);
    4697             : 
    4698          68 :     COPY_NODE_FIELD(dictname);
    4699          68 :     COPY_NODE_FIELD(options);
    4700             : 
    4701          68 :     return newnode;
    4702             : }
    4703             : 
    4704             : static AlterTSConfigurationStmt *
    4705       81338 : _copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from)
    4706             : {
    4707       81338 :     AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);
    4708             : 
    4709       81338 :     COPY_SCALAR_FIELD(kind);
    4710       81338 :     COPY_NODE_FIELD(cfgname);
    4711       81338 :     COPY_NODE_FIELD(tokentype);
    4712       81338 :     COPY_NODE_FIELD(dicts);
    4713       81338 :     COPY_SCALAR_FIELD(override);
    4714       81338 :     COPY_SCALAR_FIELD(replace);
    4715       81338 :     COPY_SCALAR_FIELD(missing_ok);
    4716             : 
    4717       81338 :     return newnode;
    4718             : }
    4719             : 
    4720             : static CreatePolicyStmt *
    4721         812 : _copyCreatePolicyStmt(const CreatePolicyStmt *from)
    4722             : {
    4723         812 :     CreatePolicyStmt *newnode = makeNode(CreatePolicyStmt);
    4724             : 
    4725         812 :     COPY_STRING_FIELD(policy_name);
    4726         812 :     COPY_NODE_FIELD(table);
    4727         812 :     COPY_STRING_FIELD(cmd_name);
    4728         812 :     COPY_SCALAR_FIELD(permissive);
    4729         812 :     COPY_NODE_FIELD(roles);
    4730         812 :     COPY_NODE_FIELD(qual);
    4731         812 :     COPY_NODE_FIELD(with_check);
    4732             : 
    4733         812 :     return newnode;
    4734             : }
    4735             : 
    4736             : static AlterPolicyStmt *
    4737         116 : _copyAlterPolicyStmt(const AlterPolicyStmt *from)
    4738             : {
    4739         116 :     AlterPolicyStmt *newnode = makeNode(AlterPolicyStmt);
    4740             : 
    4741         116 :     COPY_STRING_FIELD(policy_name);
    4742         116 :     COPY_NODE_FIELD(table);
    4743         116 :     COPY_NODE_FIELD(roles);
    4744         116 :     COPY_NODE_FIELD(qual);
    4745         116 :     COPY_NODE_FIELD(with_check);
    4746             : 
    4747         116 :     return newnode;
    4748             : }
    4749             : 
    4750             : static PartitionElem *
    4751        6490 : _copyPartitionElem(const PartitionElem *from)
    4752             : {
    4753        6490 :     PartitionElem *newnode = makeNode(PartitionElem);
    4754             : 
    4755        6490 :     COPY_STRING_FIELD(name);
    4756        6490 :     COPY_NODE_FIELD(expr);
    4757        6490 :     COPY_NODE_FIELD(collation);
    4758        6490 :     COPY_NODE_FIELD(opclass);
    4759        6490 :     COPY_LOCATION_FIELD(location);
    4760             : 
    4761        6490 :     return newnode;
    4762             : }
    4763             : 
    4764             : static PartitionSpec *
    4765        5766 : _copyPartitionSpec(const PartitionSpec *from)
    4766             : {
    4767        5766 :     PartitionSpec *newnode = makeNode(PartitionSpec);
    4768             : 
    4769        5766 :     COPY_STRING_FIELD(strategy);
    4770        5766 :     COPY_NODE_FIELD(partParams);
    4771        5766 :     COPY_LOCATION_FIELD(location);
    4772             : 
    4773        5766 :     return newnode;
    4774             : }
    4775             : 
    4776             : static PartitionBoundSpec *
    4777       19810 : _copyPartitionBoundSpec(const PartitionBoundSpec *from)
    4778             : {
    4779       19810 :     PartitionBoundSpec *newnode = makeNode(PartitionBoundSpec);
    4780             : 
    4781       19810 :     COPY_SCALAR_FIELD(strategy);
    4782       19810 :     COPY_SCALAR_FIELD(is_default);
    4783       19810 :     COPY_SCALAR_FIELD(modulus);
    4784       19810 :     COPY_SCALAR_FIELD(remainder);
    4785       19810 :     COPY_NODE_FIELD(listdatums);
    4786       19810 :     COPY_NODE_FIELD(lowerdatums);
    4787       19810 :     COPY_NODE_FIELD(upperdatums);
    4788       19810 :     COPY_LOCATION_FIELD(location);
    4789             : 
    4790       19810 :     return newnode;
    4791             : }
    4792             : 
    4793             : static PartitionRangeDatum *
    4794           0 : _copyPartitionRangeDatum(const PartitionRangeDatum *from)
    4795             : {
    4796           0 :     PartitionRangeDatum *newnode = makeNode(PartitionRangeDatum);
    4797             : 
    4798           0 :     COPY_SCALAR_FIELD(kind);
    4799           0 :     COPY_NODE_FIELD(value);
    4800           0 :     COPY_LOCATION_FIELD(location);
    4801             : 
    4802           0 :     return newnode;
    4803             : }
    4804             : 
    4805             : static PartitionCmd *
    4806        6030 : _copyPartitionCmd(const PartitionCmd *from)
    4807             : {
    4808        6030 :     PartitionCmd *newnode = makeNode(PartitionCmd);
    4809             : 
    4810        6030 :     COPY_NODE_FIELD(name);
    4811        6030 :     COPY_NODE_FIELD(bound);
    4812        6030 :     COPY_SCALAR_FIELD(concurrent);
    4813             : 
    4814        6030 :     return newnode;
    4815             : }
    4816             : 
    4817             : static PublicationObjSpec *
    4818         932 : _copyPublicationObject(const PublicationObjSpec *from)
    4819             : {
    4820         932 :     PublicationObjSpec *newnode = makeNode(PublicationObjSpec);
    4821             : 
    4822         932 :     COPY_SCALAR_FIELD(pubobjtype);
    4823         932 :     COPY_STRING_FIELD(name);
    4824         932 :     COPY_NODE_FIELD(pubtable);
    4825         932 :     COPY_LOCATION_FIELD(location);
    4826             : 
    4827         932 :     return newnode;
    4828             : }
    4829             : 
    4830             : static PublicationTable *
    4831         516 : _copyPublicationTable(const PublicationTable *from)
    4832             : {
    4833         516 :     PublicationTable *newnode = makeNode(PublicationTable);
    4834             : 
    4835         516 :     COPY_NODE_FIELD(relation);
    4836             : 
    4837         516 :     return newnode;
    4838             : }
    4839             : 
    4840             : static CreatePublicationStmt *
    4841         580 : _copyCreatePublicationStmt(const CreatePublicationStmt *from)
    4842             : {
    4843         580 :     CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);
    4844             : 
    4845         580 :     COPY_STRING_FIELD(pubname);
    4846         580 :     COPY_NODE_FIELD(options);
    4847         580 :     COPY_NODE_FIELD(pubobjects);
    4848         580 :     COPY_SCALAR_FIELD(for_all_tables);
    4849             : 
    4850         580 :     return newnode;
    4851             : }
    4852             : 
    4853             : static AlterPublicationStmt *
    4854         432 : _copyAlterPublicationStmt(const AlterPublicationStmt *from)
    4855             : {
    4856         432 :     AlterPublicationStmt *newnode = makeNode(AlterPublicationStmt);
    4857             : 
    4858         432 :     COPY_STRING_FIELD(pubname);
    4859         432 :     COPY_NODE_FIELD(options);
    4860         432 :     COPY_NODE_FIELD(pubobjects);
    4861         432 :     COPY_SCALAR_FIELD(for_all_tables);
    4862         432 :     COPY_SCALAR_FIELD(action);
    4863             : 
    4864         432 :     return newnode;
    4865             : }
    4866             : 
    4867             : static CreateSubscriptionStmt *
    4868         372 : _copyCreateSubscriptionStmt(const CreateSubscriptionStmt *from)
    4869             : {
    4870         372 :     CreateSubscriptionStmt *newnode = makeNode(CreateSubscriptionStmt);
    4871             : 
    4872         372 :     COPY_STRING_FIELD(subname);
    4873         372 :     COPY_STRING_FIELD(conninfo);
    4874         372 :     COPY_NODE_FIELD(publication);
    4875         372 :     COPY_NODE_FIELD(options);
    4876             : 
    4877         372 :     return newnode;
    4878             : }
    4879             : 
    4880             : static AlterSubscriptionStmt *
    4881         384 : _copyAlterSubscriptionStmt(const AlterSubscriptionStmt *from)
    4882             : {
    4883         384 :     AlterSubscriptionStmt *newnode = makeNode(AlterSubscriptionStmt);
    4884             : 
    4885         384 :     COPY_SCALAR_FIELD(kind);
    4886         384 :     COPY_STRING_FIELD(subname);
    4887         384 :     COPY_STRING_FIELD(conninfo);
    4888         384 :     COPY_NODE_FIELD(publication);
    4889         384 :     COPY_NODE_FIELD(options);
    4890             : 
    4891         384 :     return newnode;
    4892             : }
    4893             : 
    4894             : static DropSubscriptionStmt *
    4895         164 : _copyDropSubscriptionStmt(const DropSubscriptionStmt *from)
    4896             : {
    4897         164 :     DropSubscriptionStmt *newnode = makeNode(DropSubscriptionStmt);
    4898             : 
    4899         164 :     COPY_STRING_FIELD(subname);
    4900         164 :     COPY_SCALAR_FIELD(missing_ok);
    4901         164 :     COPY_SCALAR_FIELD(behavior);
    4902             : 
    4903         164 :     return newnode;
    4904             : }
    4905             : 
    4906             : /* ****************************************************************
    4907             :  *                  extensible.h copy functions
    4908             :  * ****************************************************************
    4909             :  */
    4910             : static ExtensibleNode *
    4911           0 : _copyExtensibleNode(const ExtensibleNode *from)
    4912             : {
    4913             :     ExtensibleNode *newnode;
    4914             :     const ExtensibleNodeMethods *methods;
    4915             : 
    4916           0 :     methods = GetExtensibleNodeMethods(from->extnodename, false);
    4917           0 :     newnode = (ExtensibleNode *) newNode(methods->node_size,
    4918             :                                          T_ExtensibleNode);
    4919           0 :     COPY_STRING_FIELD(extnodename);
    4920             : 
    4921             :     /* copy the private fields */
    4922           0 :     methods->nodeCopy(newnode, from);
    4923             : 
    4924           0 :     return newnode;
    4925             : }
    4926             : 
    4927             : /* ****************************************************************
    4928             :  *                  value.h copy functions
    4929             :  * ****************************************************************
    4930             :  */
    4931             : static Integer *
    4932      159728 : _copyInteger(const Integer *from)
    4933             : {
    4934      159728 :     Integer    *newnode = makeNode(Integer);
    4935             : 
    4936      159728 :     COPY_SCALAR_FIELD(val);
    4937             : 
    4938      159728 :     return newnode;
    4939             : }
    4940             : 
    4941             : static Float *
    4942         178 : _copyFloat(const Float *from)
    4943             : {
    4944         178 :     Float      *newnode = makeNode(Float);
    4945             : 
    4946         178 :     COPY_STRING_FIELD(val);
    4947             : 
    4948         178 :     return newnode;
    4949             : }
    4950             : 
    4951             : static String *
    4952    33734174 : _copyString(const String *from)
    4953             : {
    4954    33734174 :     String     *newnode = makeNode(String);
    4955             : 
    4956    33734174 :     COPY_STRING_FIELD(val);
    4957             : 
    4958    33734174 :     return newnode;
    4959             : }
    4960             : 
    4961             : static BitString *
    4962           0 : _copyBitString(const BitString *from)
    4963             : {
    4964           0 :     BitString   *newnode = makeNode(BitString);
    4965             : 
    4966           0 :     COPY_STRING_FIELD(val);
    4967             : 
    4968           0 :     return newnode;
    4969             : }
    4970             : 
    4971             : 
    4972             : static ForeignKeyCacheInfo *
    4973        1934 : _copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from)
    4974             : {
    4975        1934 :     ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo);
    4976             : 
    4977        1934 :     COPY_SCALAR_FIELD(conoid);
    4978        1934 :     COPY_SCALAR_FIELD(conrelid);
    4979        1934 :     COPY_SCALAR_FIELD(confrelid);
    4980        1934 :     COPY_SCALAR_FIELD(nkeys);
    4981        1934 :     COPY_ARRAY_FIELD(conkey);
    4982        1934 :     COPY_ARRAY_FIELD(confkey);
    4983        1934 :     COPY_ARRAY_FIELD(conpfeqop);
    4984             : 
    4985        1934 :     return newnode;
    4986             : }
    4987             : 
    4988             : /*
    4989             :  * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
    4990             :  *
    4991             :  * Create a copy of a Node tree or list.  This is a "deep" copy: all
    4992             :  * substructure is copied too, recursively.
    4993             :  */
    4994             : void *
    4995   189983646 : copyObjectImpl(const void *from)
    4996             : {
    4997             :     void       *retval;
    4998             : 
    4999   189983646 :     if (from == NULL)
    5000    76733908 :         return NULL;
    5001             : 
    5002             :     /* Guard against stack overflow due to overly complex expressions */
    5003   113249738 :     check_stack_depth();
    5004             : 
    5005   113249738 :     switch (nodeTag(from))
    5006             :     {
    5007             :             /*
    5008             :              * PLAN NODES
    5009             :              */
    5010      344448 :         case T_PlannedStmt:
    5011      344448 :             retval = _copyPlannedStmt(from);
    5012      344448 :             break;
    5013           0 :         case T_Plan:
    5014           0 :             retval = _copyPlan(from);
    5015           0 :             break;
    5016      168710 :         case T_Result:
    5017      168710 :             retval = _copyResult(from);
    5018      168710 :             break;
    5019        4492 :         case T_ProjectSet:
    5020        4492 :             retval = _copyProjectSet(from);
    5021        4492 :             break;
    5022       83816 :         case T_ModifyTable:
    5023       83816 :             retval = _copyModifyTable(from);
    5024       83816 :             break;
    5025        8526 :         case T_Append:
    5026        8526 :             retval = _copyAppend(from);
    5027        8526 :             break;
    5028         256 :         case T_MergeAppend:
    5029         256 :             retval = _copyMergeAppend(from);
    5030         256 :             break;
    5031         454 :         case T_RecursiveUnion:
    5032         454 :             retval = _copyRecursiveUnion(from);
    5033         454 :             break;
    5034          60 :         case T_BitmapAnd:
    5035          60 :             retval = _copyBitmapAnd(from);
    5036          60 :             break;
    5037         152 :         case T_BitmapOr:
    5038         152 :             retval = _copyBitmapOr(from);
    5039         152 :             break;
    5040           0 :         case T_Scan:
    5041           0 :             retval = _copyScan(from);
    5042           0 :             break;
    5043         630 :         case T_Gather:
    5044         630 :             retval = _copyGather(from);
    5045         630 :             break;
    5046         180 :         case T_GatherMerge:
    5047         180 :             retval = _copyGatherMerge(from);
    5048         180 :             break;
    5049      129258 :         case T_SeqScan:
    5050      129258 :             retval = _copySeqScan(from);
    5051      129258 :             break;
    5052         184 :         case T_SampleScan:
    5053         184 :             retval = _copySampleScan(from);
    5054         184 :             break;
    5055       77894 :         case T_IndexScan:
    5056       77894 :             retval = _copyIndexScan(from);
    5057       77894 :             break;
    5058        9850 :         case T_IndexOnlyScan:
    5059        9850 :             retval = _copyIndexOnlyScan(from);
    5060        9850 :             break;
    5061       15876 :         case T_BitmapIndexScan:
    5062       15876 :             retval = _copyBitmapIndexScan(from);
    5063       15876 :             break;
    5064       15628 :         case T_BitmapHeapScan:
    5065       15628 :             retval = _copyBitmapHeapScan(from);
    5066       15628 :             break;
    5067         672 :         case T_TidScan:
    5068         672 :             retval = _copyTidScan(from);
    5069         672 :             break;
    5070         140 :         case T_TidRangeScan:
    5071         140 :             retval = _copyTidRangeScan(from);
    5072         140 :             break;
    5073        3250 :         case T_SubqueryScan:
    5074        3250 :             retval = _copySubqueryScan(from);
    5075        3250 :             break;
    5076       24630 :         case T_FunctionScan:
    5077       24630 :             retval = _copyFunctionScan(from);
    5078       24630 :             break;
    5079         148 :         case T_TableFuncScan:
    5080         148 :             retval = _copyTableFuncScan(from);
    5081         148 :             break;
    5082        4856 :         case T_ValuesScan:
    5083        4856 :             retval = _copyValuesScan(from);
    5084        4856 :             break;
    5085        1728 :         case T_CteScan:
    5086        1728 :             retval = _copyCteScan(from);
    5087        1728 :             break;
    5088         540 :         case T_NamedTuplestoreScan:
    5089         540 :             retval = _copyNamedTuplestoreScan(from);
    5090         540 :             break;
    5091         454 :         case T_WorkTableScan:
    5092         454 :             retval = _copyWorkTableScan(from);
    5093         454 :             break;
    5094        1792 :         case T_ForeignScan:
    5095        1792 :             retval = _copyForeignScan(from);
    5096        1792 :             break;
    5097           0 :         case T_CustomScan:
    5098           0 :             retval = _copyCustomScan(from);
    5099           0 :             break;
    5100           0 :         case T_Join:
    5101           0 :             retval = _copyJoin(from);
    5102           0 :             break;
    5103       41416 :         case T_NestLoop:
    5104       41416 :             retval = _copyNestLoop(from);
    5105       41416 :             break;
    5106        3358 :         case T_MergeJoin:
    5107        3358 :             retval = _copyMergeJoin(from);
    5108        3358 :             break;
    5109       18756 :         case T_HashJoin:
    5110       18756 :             retval = _copyHashJoin(from);
    5111       18756 :             break;
    5112        2562 :         case T_Material:
    5113        2562 :             retval = _copyMaterial(from);
    5114        2562 :             break;
    5115         686 :         case T_Memoize:
    5116         686 :             retval = _copyMemoize(from);
    5117         686 :             break;
    5118       31990 :         case T_Sort:
    5119       31990 :             retval = _copySort(from);
    5120       31990 :             break;
    5121         256 :         case T_IncrementalSort:
    5122         256 :             retval = _copyIncrementalSort(from);
    5123         256 :             break;
    5124         152 :         case T_Group:
    5125         152 :             retval = _copyGroup(from);
    5126         152 :             break;
    5127       25324 :         case T_Agg:
    5128       25324 :             retval = _copyAgg(from);
    5129       25324 :             break;
    5130        1236 :         case T_WindowAgg:
    5131        1236 :             retval = _copyWindowAgg(from);
    5132        1236 :             break;
    5133         686 :         case T_Unique:
    5134         686 :             retval = _copyUnique(from);
    5135         686 :             break;
    5136       18756 :         case T_Hash:
    5137       18756 :             retval = _copyHash(from);
    5138       18756 :             break;
    5139         340 :         case T_SetOp:
    5140         340 :             retval = _copySetOp(from);
    5141         340 :             break;
    5142        8758 :         case T_LockRows:
    5143        8758 :             retval = _copyLockRows(from);
    5144        8758 :             break;
    5145        3660 :         case T_Limit:
    5146        3660 :             retval = _copyLimit(from);
    5147        3660 :             break;
    5148       22622 :         case T_NestLoopParam:
    5149       22622 :             retval = _copyNestLoopParam(from);
    5150       22622 :             break;
    5151       23916 :         case T_PlanRowMark:
    5152       23916 :             retval = _copyPlanRowMark(from);
    5153       23916 :             break;
    5154         432 :         case T_PartitionPruneInfo:
    5155         432 :             retval = _copyPartitionPruneInfo(from);
    5156         432 :             break;
    5157         960 :         case T_PartitionedRelPruneInfo:
    5158         960 :             retval = _copyPartitionedRelPruneInfo(from);
    5159         960 :             break;
    5160         890 :         case T_PartitionPruneStepOp:
    5161         890 :             retval = _copyPartitionPruneStepOp(from);
    5162         890 :             break;
    5163         198 :         case T_PartitionPruneStepCombine:
    5164         198 :             retval = _copyPartitionPruneStepCombine(from);
    5165         198 :             break;
    5166      109978 :         case T_PlanInvalItem:
    5167      109978 :             retval = _copyPlanInvalItem(from);
    5168      109978 :             break;
    5169             : 
    5170             :             /*
    5171             :              * PRIMITIVE NODES
    5172             :              */
    5173     3100808 :         case T_Alias:
    5174     3100808 :             retval = _copyAlias(from);
    5175     3100808 :             break;
    5176     1288856 :         case T_RangeVar:
    5177     1288856 :             retval = _copyRangeVar(from);
    5178     1288856 :             break;
    5179         348 :         case T_TableFunc:
    5180         348 :             retval = _copyTableFunc(from);
    5181         348 :             break;
    5182        2522 :         case T_IntoClause:
    5183        2522 :             retval = _copyIntoClause(from);
    5184        2522 :             break;
    5185    13754958 :         case T_Var:
    5186    13754958 :             retval = _copyVar(from);
    5187    13754958 :             break;
    5188     2887856 :         case T_Const:
    5189     2887856 :             retval = _copyConst(from);
    5190     2887856 :             break;
    5191      884494 :         case T_Param:
    5192      884494 :             retval = _copyParam(from);
    5193      884494 :             break;
    5194       79020 :         case T_Aggref:
    5195       79020 :             retval = _copyAggref(from);
    5196       79020 :             break;
    5197         664 :         case T_GroupingFunc:
    5198         664 :             retval = _copyGroupingFunc(from);
    5199         664 :             break;
    5200        3842 :         case T_WindowFunc:
    5201        3842 :             retval = _copyWindowFunc(from);
    5202        3842 :             break;
    5203       17628 :         case T_SubscriptingRef:
    5204       17628 :             retval = _copySubscriptingRef(from);
    5205       17628 :             break;
    5206      893216 :         case T_FuncExpr:
    5207      893216 :             retval = _copyFuncExpr(from);
    5208      893216 :             break;
    5209       67234 :         case T_NamedArgExpr:
    5210       67234 :             retval = _copyNamedArgExpr(from);
    5211       67234 :             break;
    5212     1377872 :         case T_OpExpr:
    5213     1377872 :             retval = _copyOpExpr(from);
    5214     1377872 :             break;
    5215        1068 :         case T_DistinctExpr:
    5216        1068 :             retval = _copyDistinctExpr(from);
    5217        1068 :             break;
    5218        1014 :         case T_NullIfExpr:
    5219        1014 :             retval = _copyNullIfExpr(from);
    5220        1014 :             break;
    5221       74370 :         case T_ScalarArrayOpExpr:
    5222       74370 :             retval = _copyScalarArrayOpExpr(from);
    5223       74370 :             break;
    5224      547268 :         case T_BoolExpr:
    5225      547268 :             retval = _copyBoolExpr(from);
    5226      547268 :             break;
    5227      120994 :         case T_SubLink:
    5228      120994 :             retval = _copySubLink(from);
    5229      120994 :             break;
    5230       28962 :         case T_SubPlan:
    5231       28962 :             retval = _copySubPlan(from);
    5232       28962 :             break;
    5233           0 :         case T_AlternativeSubPlan:
    5234           0 :             retval = _copyAlternativeSubPlan(from);
    5235           0 :             break;
    5236       73388 :         case T_FieldSelect:
    5237       73388 :             retval = _copyFieldSelect(from);
    5238       73388 :             break;
    5239         398 :         case T_FieldStore:
    5240         398 :             retval = _copyFieldStore(from);
    5241         398 :             break;
    5242      234898 :         case T_RelabelType:
    5243      234898 :             retval = _copyRelabelType(from);
    5244      234898 :             break;
    5245       45244 :         case T_CoerceViaIO:
    5246       45244 :             retval = _copyCoerceViaIO(from);
    5247       45244 :             break;
    5248        2830 :         case T_ArrayCoerceExpr:
    5249        2830 :             retval = _copyArrayCoerceExpr(from);
    5250        2830 :             break;
    5251         538 :         case T_ConvertRowtypeExpr:
    5252         538 :             retval = _copyConvertRowtypeExpr(from);
    5253         538 :             break;
    5254        3312 :         case T_CollateExpr:
    5255        3312 :             retval = _copyCollateExpr(from);
    5256        3312 :             break;
    5257      237556 :         case T_CaseExpr:
    5258      237556 :             retval = _copyCaseExpr(from);
    5259      237556 :             break;
    5260      481530 :         case T_CaseWhen:
    5261      481530 :             retval = _copyCaseWhen(from);
    5262      481530 :             break;
    5263       80498 :         case T_CaseTestExpr:
    5264       80498 :             retval = _copyCaseTestExpr(from);
    5265       80498 :             break;
    5266       56142 :         case T_ArrayExpr:
    5267       56142 :             retval = _copyArrayExpr(from);
    5268       56142 :             break;
    5269       19774 :         case T_RowExpr:
    5270       19774 :             retval = _copyRowExpr(from);
    5271       19774 :             break;
    5272         252 :         case T_RowCompareExpr:
    5273         252 :             retval = _copyRowCompareExpr(from);
    5274         252 :             break;
    5275       69104 :         case T_CoalesceExpr:
    5276       69104 :             retval = _copyCoalesceExpr(from);
    5277       69104 :             break;
    5278         688 :         case T_MinMaxExpr:
    5279         688 :             retval = _copyMinMaxExpr(from);
    5280         688 :             break;
    5281       21376 :         case T_SQLValueFunction:
    5282       21376 :             retval = _copySQLValueFunction(from);
    5283       21376 :             break;
    5284        1330 :         case T_XmlExpr:
    5285        1330 :             retval = _copyXmlExpr(from);
    5286        1330 :             break;
    5287       82960 :         case T_NullTest:
    5288       82960 :             retval = _copyNullTest(from);
    5289       82960 :             break;
    5290        1056 :         case T_BooleanTest:
    5291        1056 :             retval = _copyBooleanTest(from);
    5292        1056 :             break;
    5293      489398 :         case T_CoerceToDomain:
    5294      489398 :             retval = _copyCoerceToDomain(from);
    5295      489398 :             break;
    5296        2966 :         case T_CoerceToDomainValue:
    5297        2966 :             retval = _copyCoerceToDomainValue(from);
    5298        2966 :             break;
    5299         970 :         case T_SetToDefault:
    5300         970 :             retval = _copySetToDefault(from);
    5301         970 :             break;
    5302        1150 :         case T_CurrentOfExpr:
    5303        1150 :             retval = _copyCurrentOfExpr(from);
    5304        1150 :             break;
    5305         630 :         case T_NextValueExpr:
    5306         630 :             retval = _copyNextValueExpr(from);
    5307         630 :             break;
    5308        1078 :         case T_InferenceElem:
    5309        1078 :             retval = _copyInferenceElem(from);
    5310        1078 :             break;
    5311     5436960 :         case T_TargetEntry:
    5312     5436960 :             retval = _copyTargetEntry(from);
    5313     5436960 :             break;
    5314      773604 :         case T_RangeTblRef:
    5315      773604 :             retval = _copyRangeTblRef(from);
    5316      773604 :             break;
    5317      319202 :         case T_JoinExpr:
    5318      319202 :             retval = _copyJoinExpr(from);
    5319      319202 :             break;
    5320      703724 :         case T_FromExpr:
    5321      703724 :             retval = _copyFromExpr(from);
    5322      703724 :             break;
    5323        1050 :         case T_OnConflictExpr:
    5324        1050 :             retval = _copyOnConflictExpr(from);
    5325        1050 :             break;
    5326             : 
    5327             :             /*
    5328             :              * RELATION NODES
    5329             :              */
    5330           0 :         case T_PathKey:
    5331           0 :             retval = _copyPathKey(from);
    5332           0 :             break;
    5333           0 :         case T_RestrictInfo:
    5334           0 :             retval = _copyRestrictInfo(from);
    5335           0 :             break;
    5336        3910 :         case T_PlaceHolderVar:
    5337        3910 :             retval = _copyPlaceHolderVar(from);
    5338        3910 :             break;
    5339           0 :         case T_SpecialJoinInfo:
    5340           0 :             retval = _copySpecialJoinInfo(from);
    5341           0 :             break;
    5342       30152 :         case T_AppendRelInfo:
    5343       30152 :             retval = _copyAppendRelInfo(from);
    5344       30152 :             break;
    5345           0 :         case T_PlaceHolderInfo:
    5346           0 :             retval = _copyPlaceHolderInfo(from);
    5347           0 :             break;
    5348             : 
    5349             :             /*
    5350             :              * VALUE NODES
    5351             :              */
    5352      159728 :         case T_Integer:
    5353      159728 :             retval = _copyInteger(from);
    5354      159728 :             break;
    5355         178 :         case T_Float:
    5356         178 :             retval = _copyFloat(from);
    5357         178 :             break;
    5358    33734174 :         case T_String:
    5359    33734174 :             retval = _copyString(from);
    5360    33734174 :             break;
    5361           0 :         case T_BitString:
    5362           0 :             retval = _copyBitString(from);
    5363           0 :             break;
    5364             : 
    5365             :             /*
    5366             :              * LIST NODES
    5367             :              */
    5368    22132302 :         case T_List:
    5369    22132302 :             retval = list_copy_deep(from);
    5370    22132302 :             break;
    5371             : 
    5372             :             /*
    5373             :              * Lists of integers and OIDs don't need to be deep-copied, so we
    5374             :              * perform a shallow copy via list_copy()
    5375             :              */
    5376     1111074 :         case T_IntList:
    5377             :         case T_OidList:
    5378     1111074 :             retval = list_copy(from);
    5379     1111074 :             break;
    5380             : 
    5381             :             /*
    5382             :              * EXTENSIBLE NODES
    5383             :              */
    5384           0 :         case T_ExtensibleNode:
    5385           0 :             retval = _copyExtensibleNode(from);
    5386           0 :             break;
    5387             : 
    5388             :             /*
    5389             :              * PARSE NODES
    5390             :              */
    5391     1243706 :         case T_Query:
    5392     1243706 :             retval = _copyQuery(from);
    5393     1243706 :             break;
    5394      794816 :         case T_RawStmt:
    5395      794816 :             retval = _copyRawStmt(from);
    5396      794816 :             break;
    5397       68924 :         case T_InsertStmt:
    5398       68924 :             retval = _copyInsertStmt(from);
    5399       68924 :             break;
    5400        2972 :         case T_DeleteStmt:
    5401        2972 :             retval = _copyDeleteStmt(from);
    5402        2972 :             break;
    5403       11578 :         case T_UpdateStmt:
    5404       11578 :             retval = _copyUpdateStmt(from);
    5405       11578 :             break;
    5406      606250 :         case T_SelectStmt:
    5407      606250 :             retval = _copySelectStmt(from);
    5408      606250 :             break;
    5409       28426 :         case T_SetOperationStmt:
    5410       28426 :             retval = _copySetOperationStmt(from);
    5411       28426 :             break;
    5412       47324 :         case T_ReturnStmt:
    5413       47324 :             retval = _copyReturnStmt(from);
    5414       47324 :             break;
    5415        3788 :         case T_PLAssignStmt:
    5416        3788 :             retval = _copyPLAssignStmt(from);
    5417        3788 :             break;
    5418      125886 :         case T_AlterTableStmt:
    5419      125886 :             retval = _copyAlterTableStmt(from);
    5420      125886 :             break;
    5421      193622 :         case T_AlterTableCmd:
    5422      193622 :             retval = _copyAlterTableCmd(from);
    5423      193622 :             break;
    5424           0 :         case T_AlterCollationStmt:
    5425           0 :             retval = _copyAlterCollationStmt(from);
    5426           0 :             break;
    5427         304 :         case T_AlterDomainStmt:
    5428         304 :             retval = _copyAlterDomainStmt(from);
    5429         304 :             break;
    5430      150398 :         case T_GrantStmt:
    5431      150398 :             retval = _copyGrantStmt(from);
    5432      150398 :             break;
    5433        3248 :         case T_GrantRoleStmt:
    5434        3248 :             retval = _copyGrantRoleStmt(from);
    5435        3248 :             break;
    5436         226 :         case T_AlterDefaultPrivilegesStmt:
    5437         226 :             retval = _copyAlterDefaultPrivilegesStmt(from);
    5438         226 :             break;
    5439       10796 :         case T_DeclareCursorStmt:
    5440       10796 :             retval = _copyDeclareCursorStmt(from);
    5441       10796 :             break;
    5442        3892 :         case T_ClosePortalStmt:
    5443        3892 :             retval = _copyClosePortalStmt(from);
    5444        3892 :             break;
    5445         998 :         case T_CallStmt:
    5446         998 :             retval = _copyCallStmt(from);
    5447         998 :             break;
    5448         228 :         case T_ClusterStmt:
    5449         228 :             retval = _copyClusterStmt(from);
    5450         228 :             break;
    5451        9928 :         case T_CopyStmt:
    5452        9928 :             retval = _copyCopyStmt(from);
    5453        9928 :             break;
    5454       48394 :         case T_CreateStmt:
    5455       48394 :             retval = _copyCreateStmt(from);
    5456       48394 :             break;
    5457         900 :         case T_TableLikeClause:
    5458         900 :             retval = _copyTableLikeClause(from);
    5459         900 :             break;
    5460       60038 :         case T_DefineStmt:
    5461       60038 :             retval = _copyDefineStmt(from);
    5462       60038 :             break;
    5463       30612 :         case T_DropStmt:
    5464       30612 :             retval = _copyDropStmt(from);
    5465       30612 :             break;
    5466        1848 :         case T_TruncateStmt:
    5467        1848 :             retval = _copyTruncateStmt(from);
    5468        1848 :             break;
    5469       59254 :         case T_CommentStmt:
    5470       59254 :             retval = _copyCommentStmt(from);
    5471       59254 :             break;
    5472         170 :         case T_SecLabelStmt:
    5473         170 :             retval = _copySecLabelStmt(from);
    5474         170 :             break;
    5475       10276 :         case T_FetchStmt:
    5476       10276 :             retval = _copyFetchStmt(from);
    5477       10276 :             break;
    5478        8282 :         case T_IndexStmt:
    5479        8282 :             retval = _copyIndexStmt(from);
    5480        8282 :             break;
    5481         684 :         case T_CreateStatsStmt:
    5482         684 :             retval = _copyCreateStatsStmt(from);
    5483         684 :             break;
    5484          36 :         case T_AlterStatsStmt:
    5485          36 :             retval = _copyAlterStatsStmt(from);
    5486          36 :             break;
    5487      107530 :         case T_CreateFunctionStmt:
    5488      107530 :             retval = _copyCreateFunctionStmt(from);
    5489      107530 :             break;
    5490      363812 :         case T_FunctionParameter:
    5491      363812 :             retval = _copyFunctionParameter(from);
    5492      363812 :             break;
    5493         934 :         case T_AlterFunctionStmt:
    5494         934 :             retval = _copyAlterFunctionStmt(from);
    5495         934 :             break;
    5496        1632 :         case T_DoStmt:
    5497        1632 :             retval = _copyDoStmt(from);
    5498        1632 :             break;
    5499        2084 :         case T_RenameStmt:
    5500        2084 :             retval = _copyRenameStmt(from);
    5501        2084 :             break;
    5502          92 :         case T_AlterObjectDependsStmt:
    5503          92 :             retval = _copyAlterObjectDependsStmt(from);
    5504          92 :             break;
    5505         504 :         case T_AlterObjectSchemaStmt:
    5506         504 :             retval = _copyAlterObjectSchemaStmt(from);
    5507         504 :             break;
    5508        3376 :         case T_AlterOwnerStmt:
    5509        3376 :             retval = _copyAlterOwnerStmt(from);
    5510        3376 :             break;
    5511         968 :         case T_AlterOperatorStmt:
    5512         968 :             retval = _copyAlterOperatorStmt(from);
    5513         968 :             break;
    5514          96 :         case T_AlterTypeStmt:
    5515          96 :             retval = _copyAlterTypeStmt(from);
    5516          96 :             break;
    5517        3050 :         case T_RuleStmt:
    5518        3050 :             retval = _copyRuleStmt(from);
    5519        3050 :             break;
    5520         224 :         case T_NotifyStmt:
    5521         224 :             retval = _copyNotifyStmt(from);
    5522         224 :             break;
    5523          84 :         case T_ListenStmt:
    5524          84 :             retval = _copyListenStmt(from);
    5525          84 :             break;
    5526          68 :         case T_UnlistenStmt:
    5527          68 :             retval = _copyUnlistenStmt(from);
    5528          68 :             break;
    5529       56438 :         case T_TransactionStmt:
    5530       56438 :             retval = _copyTransactionStmt(from);
    5531       56438 :             break;
    5532         920 :         case T_CompositeTypeStmt:
    5533         920 :             retval = _copyCompositeTypeStmt(from);
    5534         920 :             break;
    5535         548 :         case T_CreateEnumStmt:
    5536         548 :             retval = _copyCreateEnumStmt(from);
    5537         548 :             break;
    5538         182 :         case T_CreateRangeStmt:
    5539         182 :             retval = _copyCreateRangeStmt(from);
    5540         182 :             break;
    5541         564 :         case T_AlterEnumStmt:
    5542         564 :             retval = _copyAlterEnumStmt(from);
    5543         564 :             break;
    5544      136402 :         case T_ViewStmt:
    5545      136402 :             retval = _copyViewStmt(from);
    5546      136402 :             break;
    5547          68 :         case T_LoadStmt:
    5548          68 :             retval = _copyLoadStmt(from);
    5549          68 :             break;
    5550        5728 :         case T_CreateDomainStmt:
    5551        5728 :             retval = _copyCreateDomainStmt(from);
    5552        5728 :             break;
    5553         654 :         case T_CreateOpClassStmt:
    5554         654 :             retval = _copyCreateOpClassStmt(from);
    5555         654 :             break;
    5556        7064 :         case T_CreateOpClassItem:
    5557        7064 :             retval = _copyCreateOpClassItem(from);
    5558        7064 :             break;
    5559         208 :         case T_CreateOpFamilyStmt:
    5560         208 :             retval = _copyCreateOpFamilyStmt(from);
    5561         208 :             break;
    5562         714 :         case T_AlterOpFamilyStmt:
    5563         714 :             retval = _copyAlterOpFamilyStmt(from);
    5564         714 :             break;
    5565        2524 :         case T_CreatedbStmt:
    5566        2524 :             retval = _copyCreatedbStmt(from);
    5567        2524 :             break;
    5568          12 :         case T_AlterDatabaseStmt:
    5569          12 :             retval = _copyAlterDatabaseStmt(from);
    5570          12 :             break;
    5571        1800 :         case T_AlterDatabaseSetStmt:
    5572        1800 :             retval = _copyAlterDatabaseSetStmt(from);
    5573        1800 :             break;
    5574          80 :         case T_DropdbStmt:
    5575          80 :             retval = _copyDropdbStmt(from);
    5576          80 :             break;
    5577       16384 :         case T_VacuumStmt:
    5578       16384 :             retval = _copyVacuumStmt(from);
    5579       16384 :             break;
    5580       14604 :         case T_VacuumRelation:
    5581       14604 :             retval = _copyVacuumRelation(from);
    5582       14604 :             break;
    5583       47320 :         case T_ExplainStmt:
    5584       47320 :             retval = _copyExplainStmt(from);
    5585       47320 :             break;
    5586        2432 :         case T_CreateTableAsStmt:
    5587        2432 :             retval = _copyCreateTableAsStmt(from);
    5588        2432 :             break;
    5589         266 :         case T_RefreshMatViewStmt:
    5590         266 :             retval = _copyRefreshMatViewStmt(from);
    5591         266 :             break;
    5592         318 :         case T_ReplicaIdentityStmt:
    5593         318 :             retval = _copyReplicaIdentityStmt(from);
    5594         318 :             break;
    5595         116 :         case T_AlterSystemStmt:
    5596         116 :             retval = _copyAlterSystemStmt(from);
    5597         116 :             break;
    5598         930 :         case T_CreateSeqStmt:
    5599         930 :             retval = _copyCreateSeqStmt(from);
    5600         930 :             break;
    5601         326 :         case T_AlterSeqStmt:
    5602         326 :             retval = _copyAlterSeqStmt(from);
    5603         326 :             break;
    5604       38352 :         case T_VariableSetStmt:
    5605       38352 :             retval = _copyVariableSetStmt(from);
    5606       38352 :             break;
    5607        1056 :         case T_VariableShowStmt:
    5608        1056 :             retval = _copyVariableShowStmt(from);
    5609        1056 :             break;
    5610          40 :         case T_DiscardStmt:
    5611          40 :             retval = _copyDiscardStmt(from);
    5612          40 :             break;
    5613          72 :         case T_CreateTableSpaceStmt:
    5614          72 :             retval = _copyCreateTableSpaceStmt(from);
    5615          72 :             break;
    5616          48 :         case T_DropTableSpaceStmt:
    5617          48 :             retval = _copyDropTableSpaceStmt(from);
    5618          48 :             break;
    5619          32 :         case T_AlterTableSpaceOptionsStmt:
    5620          32 :             retval = _copyAlterTableSpaceOptionsStmt(from);
    5621          32 :             break;
    5622          24 :         case T_AlterTableMoveAllStmt:
    5623          24 :             retval = _copyAlterTableMoveAllStmt(from);
    5624          24 :             break;
    5625        1426 :         case T_CreateExtensionStmt:
    5626        1426 :             retval = _copyCreateExtensionStmt(from);
    5627        1426 :             break;
    5628          30 :         case T_AlterExtensionStmt:
    5629          30 :             retval = _copyAlterExtensionStmt(from);
    5630          30 :             break;
    5631         294 :         case T_AlterExtensionContentsStmt:
    5632         294 :             retval = _copyAlterExtensionContentsStmt(from);
    5633         294 :             break;
    5634         248 :         case T_CreateFdwStmt:
    5635         248 :             retval = _copyCreateFdwStmt(from);
    5636         248 :             break;
    5637         168 :         case T_AlterFdwStmt:
    5638         168 :             retval = _copyAlterFdwStmt(from);
    5639         168 :             break;
    5640         380 :         case T_CreateForeignServerStmt:
    5641         380 :             retval = _copyCreateForeignServerStmt(from);
    5642         380 :             break;
    5643         252 :         case T_AlterForeignServerStmt:
    5644         252 :             retval = _copyAlterForeignServerStmt(from);
    5645         252 :             break;
    5646         368 :         case T_CreateUserMappingStmt:
    5647         368 :             retval = _copyCreateUserMappingStmt(from);
    5648         368 :             break;
    5649         176 :         case T_AlterUserMappingStmt:
    5650         176 :             retval = _copyAlterUserMappingStmt(from);
    5651         176 :             break;
    5652         200 :         case T_DropUserMappingStmt:
    5653         200 :             retval = _copyDropUserMappingStmt(from);
    5654         200 :             break;
    5655         660 :         case T_CreateForeignTableStmt:
    5656         660 :             retval = _copyCreateForeignTableStmt(from);
    5657         660 :             break;
    5658          72 :         case T_ImportForeignSchemaStmt:
    5659          72 :             retval = _copyImportForeignSchemaStmt(from);
    5660          72 :             break;
    5661          98 :         case T_CreateTransformStmt:
    5662          98 :             retval = _copyCreateTransformStmt(from);
    5663          98 :             break;
    5664          92 :         case T_CreateAmStmt:
    5665          92 :             retval = _copyCreateAmStmt(from);
    5666          92 :             break;
    5667        4590 :         case T_CreateTrigStmt:
    5668        4590 :             retval = _copyCreateTrigStmt(from);
    5669        4590 :             break;
    5670         228 :         case T_CreateEventTrigStmt:
    5671         228 :             retval = _copyCreateEventTrigStmt(from);
    5672         228 :             break;
    5673          44 :         case T_AlterEventTrigStmt:
    5674          44 :             retval = _copyAlterEventTrigStmt(from);
    5675          44 :             break;
    5676        1048 :         case T_CreatePLangStmt:
    5677        1048 :             retval = _copyCreatePLangStmt(from);
    5678        1048 :             break;
    5679        1648 :         case T_CreateRoleStmt:
    5680        1648 :             retval = _copyCreateRoleStmt(from);
    5681        1648 :             break;
    5682         468 :         case T_AlterRoleStmt:
    5683         468 :             retval = _copyAlterRoleStmt(from);
    5684         468 :             break;
    5685         128 :         case T_AlterRoleSetStmt:
    5686         128 :             retval = _copyAlterRoleSetStmt(from);
    5687         128 :             break;
    5688        1648 :         case T_DropRoleStmt:
    5689        1648 :             retval = _copyDropRoleStmt(from);
    5690        1648 :             break;
    5691       11268 :         case T_LockStmt:
    5692       11268 :             retval = _copyLockStmt(from);
    5693       11268 :             break;
    5694         148 :         case T_ConstraintsSetStmt:
    5695         148 :             retval = _copyConstraintsSetStmt(from);
    5696         148 :             break;
    5697        1196 :         case T_ReindexStmt:
    5698        1196 :             retval = _copyReindexStmt(from);
    5699        1196 :             break;
    5700         260 :         case T_CheckPointStmt:
    5701         260 :             retval = (void *) makeNode(CheckPointStmt);
    5702         260 :             break;
    5703        1916 :         case T_CreateSchemaStmt:
    5704        1916 :             retval = _copyCreateSchemaStmt(from);
    5705        1916 :             break;
    5706          90 :         case T_CreateConversionStmt:
    5707          90 :             retval = _copyCreateConversionStmt(from);
    5708          90 :             break;
    5709         420 :         case T_CreateCastStmt:
    5710         420 :             retval = _copyCreateCastStmt(from);
    5711         420 :             break;
    5712        2236 :         case T_PrepareStmt:
    5713        2236 :             retval = _copyPrepareStmt(from);
    5714        2236 :             break;
    5715       12120 :         case T_ExecuteStmt:
    5716       12120 :             retval = _copyExecuteStmt(from);
    5717       12120 :             break;
    5718        7736 :         case T_DeallocateStmt:
    5719        7736 :             retval = _copyDeallocateStmt(from);
    5720        7736 :             break;
    5721         180 :         case T_DropOwnedStmt:
    5722         180 :             retval = _copyDropOwnedStmt(from);
    5723         180 :             break;
    5724          32 :         case T_ReassignOwnedStmt:
    5725          32 :             retval = _copyReassignOwnedStmt(from);
    5726          32 :             break;
    5727          68 :         case T_AlterTSDictionaryStmt:
    5728          68 :             retval = _copyAlterTSDictionaryStmt(from);
    5729          68 :             break;
    5730       81338 :         case T_AlterTSConfigurationStmt:
    5731       81338 :             retval = _copyAlterTSConfigurationStmt(from);
    5732       81338 :             break;
    5733         812 :         case T_CreatePolicyStmt:
    5734         812 :             retval = _copyCreatePolicyStmt(from);
    5735         812 :             break;
    5736         116 :         case T_AlterPolicyStmt:
    5737         116 :             retval = _copyAlterPolicyStmt(from);
    5738         116 :             break;
    5739         580 :         case T_CreatePublicationStmt:
    5740         580 :             retval = _copyCreatePublicationStmt(from);
    5741         580 :             break;
    5742         432 :         case T_AlterPublicationStmt:
    5743         432 :             retval = _copyAlterPublicationStmt(from);
    5744         432 :             break;
    5745         372 :         case T_CreateSubscriptionStmt:
    5746         372 :             retval = _copyCreateSubscriptionStmt(from);
    5747         372 :             break;
    5748         384 :         case T_AlterSubscriptionStmt:
    5749         384 :             retval = _copyAlterSubscriptionStmt(from);
    5750         384 :             break;
    5751         164 :         case T_DropSubscriptionStmt:
    5752         164 :             retval = _copyDropSubscriptionStmt(from);
    5753         164 :             break;
    5754     1046334 :         case T_A_Expr:
    5755     1046334 :             retval = _copyA_Expr(from);
    5756     1046334 :             break;
    5757     3329062 :         case T_ColumnRef:
    5758     3329062 :             retval = _copyColumnRef(from);
    5759     3329062 :             break;
    5760      471508 :         case T_ParamRef:
    5761      471508 :             retval = _copyParamRef(from);
    5762      471508 :             break;
    5763     2024674 :         case T_A_Const:
    5764     2024674 :             retval = _copyA_Const(from);
    5765     2024674 :             break;
    5766      754608 :         case T_FuncCall:
    5767      754608 :             retval = _copyFuncCall(from);
    5768      754608 :             break;
    5769       72178 :         case T_A_Star:
    5770       72178 :             retval = _copyA_Star(from);
    5771       72178 :             break;
    5772       21892 :         case T_A_Indices:
    5773       21892 :             retval = _copyA_Indices(from);
    5774       21892 :             break;
    5775      131988 :         case T_A_Indirection:
    5776      131988 :             retval = _copyA_Indirection(from);
    5777      131988 :             break;
    5778        5166 :         case T_A_ArrayExpr:
    5779        5166 :             retval = _copyA_ArrayExpr(from);
    5780        5166 :             break;
    5781     2106814 :         case T_ResTarget:
    5782     2106814 :             retval = _copyResTarget(from);
    5783     2106814 :             break;
    5784         226 :         case T_MultiAssignRef:
    5785         226 :             retval = _copyMultiAssignRef(from);
    5786         226 :             break;
    5787      909098 :         case T_TypeCast:
    5788      909098 :             retval = _copyTypeCast(from);
    5789      909098 :             break;
    5790        5620 :         case T_CollateClause:
    5791        5620 :             retval = _copyCollateClause(from);
    5792        5620 :             break;
    5793       59494 :         case T_SortBy:
    5794       59494 :             retval = _copySortBy(from);
    5795       59494 :             break;
    5796        2908 :         case T_WindowDef:
    5797        2908 :             retval = _copyWindowDef(from);
    5798        2908 :             break;
    5799       37888 :         case T_RangeSubselect:
    5800       37888 :             retval = _copyRangeSubselect(from);
    5801       37888 :             break;
    5802       62562 :         case T_RangeFunction:
    5803       62562 :             retval = _copyRangeFunction(from);
    5804       62562 :             break;
    5805         192 :         case T_RangeTableSample:
    5806         192 :             retval = _copyRangeTableSample(from);
    5807         192 :             break;
    5808         160 :         case T_RangeTableFunc:
    5809         160 :             retval = _copyRangeTableFunc(from);
    5810         160 :             break;
    5811         612 :         case T_RangeTableFuncCol:
    5812         612 :             retval = _copyRangeTableFuncCol(from);
    5813         612 :             break;
    5814     1677948 :         case T_TypeName:
    5815     1677948 :             retval = _copyTypeName(from);
    5816     1677948 :             break;
    5817       12290 :         case T_IndexElem:
    5818       12290 :             retval = _copyIndexElem(from);
    5819       12290 :             break;
    5820        1772 :         case T_StatsElem:
    5821        1772 :             retval = _copyStatsElem(from);
    5822        1772 :             break;
    5823      110974 :         case T_ColumnDef:
    5824      110974 :             retval = _copyColumnDef(from);
    5825      110974 :             break;
    5826      191590 :         case T_Constraint:
    5827      191590 :             retval = _copyConstraint(from);
    5828      191590 :             break;
    5829      653768 :         case T_DefElem:
    5830      653768 :             retval = _copyDefElem(from);
    5831      653768 :             break;
    5832        4154 :         case T_LockingClause:
    5833        4154 :             retval = _copyLockingClause(from);
    5834        4154 :             break;
    5835     1708618 :         case T_RangeTblEntry:
    5836     1708618 :             retval = _copyRangeTblEntry(from);
    5837     1708618 :             break;
    5838       83952 :         case T_RangeTblFunction:
    5839       83952 :             retval = _copyRangeTblFunction(from);
    5840       83952 :             break;
    5841         438 :         case T_TableSampleClause:
    5842         438 :             retval = _copyTableSampleClause(from);
    5843         438 :             break;
    5844        2256 :         case T_WithCheckOption:
    5845        2256 :             retval = _copyWithCheckOption(from);
    5846        2256 :             break;
    5847      151154 :         case T_SortGroupClause:
    5848      151154 :             retval = _copySortGroupClause(from);
    5849      151154 :             break;
    5850        2612 :         case T_GroupingSet:
    5851        2612 :             retval = _copyGroupingSet(from);
    5852        2612 :             break;
    5853        2014 :         case T_WindowClause:
    5854        2014 :             retval = _copyWindowClause(from);
    5855        2014 :             break;
    5856       10170 :         case T_RowMarkClause:
    5857       10170 :             retval = _copyRowMarkClause(from);
    5858       10170 :             break;
    5859        2052 :         case T_WithClause:
    5860        2052 :             retval = _copyWithClause(from);
    5861        2052 :             break;
    5862         896 :         case T_InferClause:
    5863         896 :             retval = _copyInferClause(from);
    5864         896 :             break;
    5865        1042 :         case T_OnConflictClause:
    5866        1042 :             retval = _copyOnConflictClause(from);
    5867        1042 :             break;
    5868         152 :         case T_CTESearchClause:
    5869         152 :             retval = _copyCTESearchClause(from);
    5870         152 :             break;
    5871         176 :         case T_CTECycleClause:
    5872         176 :             retval = _copyCTECycleClause(from);
    5873         176 :             break;
    5874        5796 :         case T_CommonTableExpr:
    5875        5796 :             retval = _copyCommonTableExpr(from);
    5876        5796 :             break;
    5877       83278 :         case T_ObjectWithArgs:
    5878       83278 :             retval = _copyObjectWithArgs(from);
    5879       83278 :             break;
    5880      142956 :         case T_AccessPriv:
    5881      142956 :             retval = _copyAccessPriv(from);
    5882      142956 :             break;
    5883          36 :         case T_XmlSerialize:
    5884          36 :             retval = _copyXmlSerialize(from);
    5885          36 :             break;
    5886      166166 :         case T_RoleSpec:
    5887      166166 :             retval = _copyRoleSpec(from);
    5888      166166 :             break;
    5889         724 :         case T_TriggerTransition:
    5890         724 :             retval = _copyTriggerTransition(from);
    5891         724 :             break;
    5892        6490 :         case T_PartitionElem:
    5893        6490 :             retval = _copyPartitionElem(from);
    5894        6490 :             break;
    5895        5766 :         case T_PartitionSpec:
    5896        5766 :             retval = _copyPartitionSpec(from);
    5897        5766 :             break;
    5898       19810 :         case T_PartitionBoundSpec:
    5899       19810 :             retval = _copyPartitionBoundSpec(from);
    5900       19810 :             break;
    5901           0 :         case T_PartitionRangeDatum:
    5902           0 :             retval = _copyPartitionRangeDatum(from);
    5903           0 :             break;
    5904        6030 :         case T_PartitionCmd:
    5905        6030 :             retval = _copyPartitionCmd(from);
    5906        6030 :             break;
    5907         932 :         case T_PublicationObjSpec:
    5908         932 :             retval = _copyPublicationObject(from);
    5909         932 :             break;
    5910         516 :         case T_PublicationTable:
    5911         516 :             retval = _copyPublicationTable(from);
    5912         516 :             break;
    5913             : 
    5914             :             /*
    5915             :              * MISCELLANEOUS NODES
    5916             :              */
    5917        1934 :         case T_ForeignKeyCacheInfo:
    5918        1934 :             retval = _copyForeignKeyCacheInfo(from);
    5919        1934 :             break;
    5920             : 
    5921           0 :         default:
    5922           0 :             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
    5923             :             retval = 0;         /* keep compiler quiet */
    5924             :             break;
    5925             :     }
    5926             : 
    5927   113249738 :     return retval;
    5928             : }

Generated by: LCOV version 1.14