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

Generated by: LCOV version 1.13