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

Generated by: LCOV version 1.13