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

Generated by: LCOV version 1.13