LCOV - code coverage report
Current view: top level - src/backend/nodes - copyfuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 3230 3343 96.6 %
Date: 2024-09-16 12:11:48 Functions: 311 319 97.5 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14