/src/postgres/bld/src/backend/nodes/copyfuncs.funcs.c

Source (jump to first uncovered line)
/*-------------------------------------------------------------------------
 *
 * copyfuncs.funcs.c
 *    Generated node infrastructure code
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * NOTES
 *  ******************************
 *  *** DO NOT EDIT THIS FILE! ***
 *  ******************************
 *
 *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
 *
 *-------------------------------------------------------------------------
 */
#include "access/amapi.h"
#include "access/cmptype.h"
#include "access/sdir.h"
#include "access/tableam.h"
#include "access/tsmapi.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "executor/tuptable.h"
#include "foreign/fdwapi.h"
#include "nodes/bitmapset.h"
#include "nodes/execnodes.h"
#include "nodes/extensible.h"
#include "nodes/lockoptions.h"
#include "nodes/miscnodes.h"
#include "nodes/nodes.h"
#include "nodes/parsenodes.h"
#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"
#include "nodes/primnodes.h"
#include "nodes/replnodes.h"
#include "nodes/supportnodes.h"
#include "nodes/value.h"
#include "utils/rel.h"

static Alias *
_copyAlias(const Alias *from)
{
  Alias *newnode = makeNode(Alias);

  COPY_STRING_FIELD(aliasname);
  COPY_NODE_FIELD(colnames);

  return newnode;
}

static RangeVar *
_copyRangeVar(const RangeVar *from)
{
  RangeVar *newnode = makeNode(RangeVar);

  COPY_STRING_FIELD(catalogname);
  COPY_STRING_FIELD(schemaname);
  COPY_STRING_FIELD(relname);
  COPY_SCALAR_FIELD(inh);
  COPY_SCALAR_FIELD(relpersistence);
  COPY_NODE_FIELD(alias);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static TableFunc *
_copyTableFunc(const TableFunc *from)
{
  TableFunc *newnode = makeNode(TableFunc);

  COPY_SCALAR_FIELD(functype);
  COPY_NODE_FIELD(ns_uris);
  COPY_NODE_FIELD(ns_names);
  COPY_NODE_FIELD(docexpr);
  COPY_NODE_FIELD(rowexpr);
  COPY_NODE_FIELD(colnames);
  COPY_NODE_FIELD(coltypes);
  COPY_NODE_FIELD(coltypmods);
  COPY_NODE_FIELD(colcollations);
  COPY_NODE_FIELD(colexprs);
  COPY_NODE_FIELD(coldefexprs);
  COPY_NODE_FIELD(colvalexprs);
  COPY_NODE_FIELD(passingvalexprs);
  COPY_BITMAPSET_FIELD(notnulls);
  COPY_NODE_FIELD(plan);
  COPY_SCALAR_FIELD(ordinalitycol);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static IntoClause *
_copyIntoClause(const IntoClause *from)
{
  IntoClause *newnode = makeNode(IntoClause);

  COPY_NODE_FIELD(rel);
  COPY_NODE_FIELD(colNames);
  COPY_STRING_FIELD(accessMethod);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(onCommit);
  COPY_STRING_FIELD(tableSpaceName);
  COPY_NODE_FIELD(viewQuery);
  COPY_SCALAR_FIELD(skipData);

  return newnode;
}

static Var *
_copyVar(const Var *from)
{
  Var *newnode = makeNode(Var);

  COPY_SCALAR_FIELD(varno);
  COPY_SCALAR_FIELD(varattno);
  COPY_SCALAR_FIELD(vartype);
  COPY_SCALAR_FIELD(vartypmod);
  COPY_SCALAR_FIELD(varcollid);
  COPY_BITMAPSET_FIELD(varnullingrels);
  COPY_SCALAR_FIELD(varlevelsup);
  COPY_SCALAR_FIELD(varreturningtype);
  COPY_SCALAR_FIELD(varnosyn);
  COPY_SCALAR_FIELD(varattnosyn);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static Param *
_copyParam(const Param *from)
{
  Param *newnode = makeNode(Param);

  COPY_SCALAR_FIELD(paramkind);
  COPY_SCALAR_FIELD(paramid);
  COPY_SCALAR_FIELD(paramtype);
  COPY_SCALAR_FIELD(paramtypmod);
  COPY_SCALAR_FIELD(paramcollid);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static Aggref *
_copyAggref(const Aggref *from)
{
  Aggref *newnode = makeNode(Aggref);

  COPY_SCALAR_FIELD(aggfnoid);
  COPY_SCALAR_FIELD(aggtype);
  COPY_SCALAR_FIELD(aggcollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_SCALAR_FIELD(aggtranstype);
  COPY_NODE_FIELD(aggargtypes);
  COPY_NODE_FIELD(aggdirectargs);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(aggorder);
  COPY_NODE_FIELD(aggdistinct);
  COPY_NODE_FIELD(aggfilter);
  COPY_SCALAR_FIELD(aggstar);
  COPY_SCALAR_FIELD(aggvariadic);
  COPY_SCALAR_FIELD(aggkind);
  COPY_SCALAR_FIELD(aggpresorted);
  COPY_SCALAR_FIELD(agglevelsup);
  COPY_SCALAR_FIELD(aggsplit);
  COPY_SCALAR_FIELD(aggno);
  COPY_SCALAR_FIELD(aggtransno);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static GroupingFunc *
_copyGroupingFunc(const GroupingFunc *from)
{
  GroupingFunc *newnode = makeNode(GroupingFunc);

  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(refs);
  COPY_NODE_FIELD(cols);
  COPY_SCALAR_FIELD(agglevelsup);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static WindowFunc *
_copyWindowFunc(const WindowFunc *from)
{
  WindowFunc *newnode = makeNode(WindowFunc);

  COPY_SCALAR_FIELD(winfnoid);
  COPY_SCALAR_FIELD(wintype);
  COPY_SCALAR_FIELD(wincollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(aggfilter);
  COPY_NODE_FIELD(runCondition);
  COPY_SCALAR_FIELD(winref);
  COPY_SCALAR_FIELD(winstar);
  COPY_SCALAR_FIELD(winagg);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static WindowFuncRunCondition *
_copyWindowFuncRunCondition(const WindowFuncRunCondition *from)
{
  WindowFuncRunCondition *newnode = makeNode(WindowFuncRunCondition);

  COPY_SCALAR_FIELD(opno);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_SCALAR_FIELD(wfunc_left);
  COPY_NODE_FIELD(arg);

  return newnode;
}

static MergeSupportFunc *
_copyMergeSupportFunc(const MergeSupportFunc *from)
{
  MergeSupportFunc *newnode = makeNode(MergeSupportFunc);

  COPY_SCALAR_FIELD(msftype);
  COPY_SCALAR_FIELD(msfcollid);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static SubscriptingRef *
_copySubscriptingRef(const SubscriptingRef *from)
{
  SubscriptingRef *newnode = makeNode(SubscriptingRef);

  COPY_SCALAR_FIELD(refcontainertype);
  COPY_SCALAR_FIELD(refelemtype);
  COPY_SCALAR_FIELD(refrestype);
  COPY_SCALAR_FIELD(reftypmod);
  COPY_SCALAR_FIELD(refcollid);
  COPY_NODE_FIELD(refupperindexpr);
  COPY_NODE_FIELD(reflowerindexpr);
  COPY_NODE_FIELD(refexpr);
  COPY_NODE_FIELD(refassgnexpr);

  return newnode;
}

static FuncExpr *
_copyFuncExpr(const FuncExpr *from)
{
  FuncExpr *newnode = makeNode(FuncExpr);

  COPY_SCALAR_FIELD(funcid);
  COPY_SCALAR_FIELD(funcresulttype);
  COPY_SCALAR_FIELD(funcretset);
  COPY_SCALAR_FIELD(funcvariadic);
  COPY_SCALAR_FIELD(funcformat);
  COPY_SCALAR_FIELD(funccollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static NamedArgExpr *
_copyNamedArgExpr(const NamedArgExpr *from)
{
  NamedArgExpr *newnode = makeNode(NamedArgExpr);

  COPY_NODE_FIELD(arg);
  COPY_STRING_FIELD(name);
  COPY_SCALAR_FIELD(argnumber);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static OpExpr *
_copyOpExpr(const OpExpr *from)
{
  OpExpr *newnode = makeNode(OpExpr);

  COPY_SCALAR_FIELD(opno);
  COPY_SCALAR_FIELD(opfuncid);
  COPY_SCALAR_FIELD(opresulttype);
  COPY_SCALAR_FIELD(opretset);
  COPY_SCALAR_FIELD(opcollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static DistinctExpr *
_copyDistinctExpr(const DistinctExpr *from)
{
  DistinctExpr *newnode = makeNode(DistinctExpr);

  COPY_SCALAR_FIELD(opno);
  COPY_SCALAR_FIELD(opfuncid);
  COPY_SCALAR_FIELD(opresulttype);
  COPY_SCALAR_FIELD(opretset);
  COPY_SCALAR_FIELD(opcollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static NullIfExpr *
_copyNullIfExpr(const NullIfExpr *from)
{
  NullIfExpr *newnode = makeNode(NullIfExpr);

  COPY_SCALAR_FIELD(opno);
  COPY_SCALAR_FIELD(opfuncid);
  COPY_SCALAR_FIELD(opresulttype);
  COPY_SCALAR_FIELD(opretset);
  COPY_SCALAR_FIELD(opcollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ScalarArrayOpExpr *
_copyScalarArrayOpExpr(const ScalarArrayOpExpr *from)
{
  ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);

  COPY_SCALAR_FIELD(opno);
  COPY_SCALAR_FIELD(opfuncid);
  COPY_SCALAR_FIELD(hashfuncid);
  COPY_SCALAR_FIELD(negfuncid);
  COPY_SCALAR_FIELD(useOr);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static BoolExpr *
_copyBoolExpr(const BoolExpr *from)
{
  BoolExpr *newnode = makeNode(BoolExpr);

  COPY_SCALAR_FIELD(boolop);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static SubLink *
_copySubLink(const SubLink *from)
{
  SubLink *newnode = makeNode(SubLink);

  COPY_SCALAR_FIELD(subLinkType);
  COPY_SCALAR_FIELD(subLinkId);
  COPY_NODE_FIELD(testexpr);
  COPY_NODE_FIELD(operName);
  COPY_NODE_FIELD(subselect);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static SubPlan *
_copySubPlan(const SubPlan *from)
{
  SubPlan *newnode = makeNode(SubPlan);

  COPY_SCALAR_FIELD(subLinkType);
  COPY_NODE_FIELD(testexpr);
  COPY_NODE_FIELD(paramIds);
  COPY_SCALAR_FIELD(plan_id);
  COPY_STRING_FIELD(plan_name);
  COPY_SCALAR_FIELD(firstColType);
  COPY_SCALAR_FIELD(firstColTypmod);
  COPY_SCALAR_FIELD(firstColCollation);
  COPY_SCALAR_FIELD(useHashTable);
  COPY_SCALAR_FIELD(unknownEqFalse);
  COPY_SCALAR_FIELD(parallel_safe);
  COPY_NODE_FIELD(setParam);
  COPY_NODE_FIELD(parParam);
  COPY_NODE_FIELD(args);
  COPY_SCALAR_FIELD(startup_cost);
  COPY_SCALAR_FIELD(per_call_cost);

  return newnode;
}

static AlternativeSubPlan *
_copyAlternativeSubPlan(const AlternativeSubPlan *from)
{
  AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);

  COPY_NODE_FIELD(subplans);

  return newnode;
}

static FieldSelect *
_copyFieldSelect(const FieldSelect *from)
{
  FieldSelect *newnode = makeNode(FieldSelect);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(fieldnum);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(resulttypmod);
  COPY_SCALAR_FIELD(resultcollid);

  return newnode;
}

static FieldStore *
_copyFieldStore(const FieldStore *from)
{
  FieldStore *newnode = makeNode(FieldStore);

  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(newvals);
  COPY_NODE_FIELD(fieldnums);
  COPY_SCALAR_FIELD(resulttype);

  return newnode;
}

static RelabelType *
_copyRelabelType(const RelabelType *from)
{
  RelabelType *newnode = makeNode(RelabelType);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(resulttypmod);
  COPY_SCALAR_FIELD(resultcollid);
  COPY_SCALAR_FIELD(relabelformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CoerceViaIO *
_copyCoerceViaIO(const CoerceViaIO *from)
{
  CoerceViaIO *newnode = makeNode(CoerceViaIO);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(resultcollid);
  COPY_SCALAR_FIELD(coerceformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ArrayCoerceExpr *
_copyArrayCoerceExpr(const ArrayCoerceExpr *from)
{
  ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);

  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(elemexpr);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(resulttypmod);
  COPY_SCALAR_FIELD(resultcollid);
  COPY_SCALAR_FIELD(coerceformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ConvertRowtypeExpr *
_copyConvertRowtypeExpr(const ConvertRowtypeExpr *from)
{
  ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(convertformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CollateExpr *
_copyCollateExpr(const CollateExpr *from)
{
  CollateExpr *newnode = makeNode(CollateExpr);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(collOid);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CaseExpr *
_copyCaseExpr(const CaseExpr *from)
{
  CaseExpr *newnode = makeNode(CaseExpr);

  COPY_SCALAR_FIELD(casetype);
  COPY_SCALAR_FIELD(casecollid);
  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(defresult);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CaseWhen *
_copyCaseWhen(const CaseWhen *from)
{
  CaseWhen *newnode = makeNode(CaseWhen);

  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(result);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CaseTestExpr *
_copyCaseTestExpr(const CaseTestExpr *from)
{
  CaseTestExpr *newnode = makeNode(CaseTestExpr);

  COPY_SCALAR_FIELD(typeId);
  COPY_SCALAR_FIELD(typeMod);
  COPY_SCALAR_FIELD(collation);

  return newnode;
}

static ArrayExpr *
_copyArrayExpr(const ArrayExpr *from)
{
  ArrayExpr *newnode = makeNode(ArrayExpr);

  COPY_SCALAR_FIELD(array_typeid);
  COPY_SCALAR_FIELD(array_collid);
  COPY_SCALAR_FIELD(element_typeid);
  COPY_NODE_FIELD(elements);
  COPY_SCALAR_FIELD(multidims);
  COPY_LOCATION_FIELD(list_start);
  COPY_LOCATION_FIELD(list_end);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RowExpr *
_copyRowExpr(const RowExpr *from)
{
  RowExpr *newnode = makeNode(RowExpr);

  COPY_NODE_FIELD(args);
  COPY_SCALAR_FIELD(row_typeid);
  COPY_SCALAR_FIELD(row_format);
  COPY_NODE_FIELD(colnames);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RowCompareExpr *
_copyRowCompareExpr(const RowCompareExpr *from)
{
  RowCompareExpr *newnode = makeNode(RowCompareExpr);

  COPY_SCALAR_FIELD(cmptype);
  COPY_NODE_FIELD(opnos);
  COPY_NODE_FIELD(opfamilies);
  COPY_NODE_FIELD(inputcollids);
  COPY_NODE_FIELD(largs);
  COPY_NODE_FIELD(rargs);

  return newnode;
}

static CoalesceExpr *
_copyCoalesceExpr(const CoalesceExpr *from)
{
  CoalesceExpr *newnode = makeNode(CoalesceExpr);

  COPY_SCALAR_FIELD(coalescetype);
  COPY_SCALAR_FIELD(coalescecollid);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static MinMaxExpr *
_copyMinMaxExpr(const MinMaxExpr *from)
{
  MinMaxExpr *newnode = makeNode(MinMaxExpr);

  COPY_SCALAR_FIELD(minmaxtype);
  COPY_SCALAR_FIELD(minmaxcollid);
  COPY_SCALAR_FIELD(inputcollid);
  COPY_SCALAR_FIELD(op);
  COPY_NODE_FIELD(args);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static SQLValueFunction *
_copySQLValueFunction(const SQLValueFunction *from)
{
  SQLValueFunction *newnode = makeNode(SQLValueFunction);

  COPY_SCALAR_FIELD(op);
  COPY_SCALAR_FIELD(type);
  COPY_SCALAR_FIELD(typmod);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static XmlExpr *
_copyXmlExpr(const XmlExpr *from)
{
  XmlExpr *newnode = makeNode(XmlExpr);

  COPY_SCALAR_FIELD(op);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(named_args);
  COPY_NODE_FIELD(arg_names);
  COPY_NODE_FIELD(args);
  COPY_SCALAR_FIELD(xmloption);
  COPY_SCALAR_FIELD(indent);
  COPY_SCALAR_FIELD(type);
  COPY_SCALAR_FIELD(typmod);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonFormat *
_copyJsonFormat(const JsonFormat *from)
{
  JsonFormat *newnode = makeNode(JsonFormat);

  COPY_SCALAR_FIELD(format_type);
  COPY_SCALAR_FIELD(encoding);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonReturning *
_copyJsonReturning(const JsonReturning *from)
{
  JsonReturning *newnode = makeNode(JsonReturning);

  COPY_NODE_FIELD(format);
  COPY_SCALAR_FIELD(typid);
  COPY_SCALAR_FIELD(typmod);

  return newnode;
}

static JsonValueExpr *
_copyJsonValueExpr(const JsonValueExpr *from)
{
  JsonValueExpr *newnode = makeNode(JsonValueExpr);

  COPY_NODE_FIELD(raw_expr);
  COPY_NODE_FIELD(formatted_expr);
  COPY_NODE_FIELD(format);

  return newnode;
}

static JsonConstructorExpr *
_copyJsonConstructorExpr(const JsonConstructorExpr *from)
{
  JsonConstructorExpr *newnode = makeNode(JsonConstructorExpr);

  COPY_SCALAR_FIELD(type);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(func);
  COPY_NODE_FIELD(coercion);
  COPY_NODE_FIELD(returning);
  COPY_SCALAR_FIELD(absent_on_null);
  COPY_SCALAR_FIELD(unique);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonIsPredicate *
_copyJsonIsPredicate(const JsonIsPredicate *from)
{
  JsonIsPredicate *newnode = makeNode(JsonIsPredicate);

  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(format);
  COPY_SCALAR_FIELD(item_type);
  COPY_SCALAR_FIELD(unique_keys);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonBehavior *
_copyJsonBehavior(const JsonBehavior *from)
{
  JsonBehavior *newnode = makeNode(JsonBehavior);

  COPY_SCALAR_FIELD(btype);
  COPY_NODE_FIELD(expr);
  COPY_SCALAR_FIELD(coerce);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonExpr *
_copyJsonExpr(const JsonExpr *from)
{
  JsonExpr *newnode = makeNode(JsonExpr);

  COPY_SCALAR_FIELD(op);
  COPY_STRING_FIELD(column_name);
  COPY_NODE_FIELD(formatted_expr);
  COPY_NODE_FIELD(format);
  COPY_NODE_FIELD(path_spec);
  COPY_NODE_FIELD(returning);
  COPY_NODE_FIELD(passing_names);
  COPY_NODE_FIELD(passing_values);
  COPY_NODE_FIELD(on_empty);
  COPY_NODE_FIELD(on_error);
  COPY_SCALAR_FIELD(use_io_coercion);
  COPY_SCALAR_FIELD(use_json_coercion);
  COPY_SCALAR_FIELD(wrapper);
  COPY_SCALAR_FIELD(omit_quotes);
  COPY_SCALAR_FIELD(collation);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonTablePath *
_copyJsonTablePath(const JsonTablePath *from)
{
  JsonTablePath *newnode = makeNode(JsonTablePath);

  COPY_NODE_FIELD(value);
  COPY_STRING_FIELD(name);

  return newnode;
}

static JsonTablePathScan *
_copyJsonTablePathScan(const JsonTablePathScan *from)
{
  JsonTablePathScan *newnode = makeNode(JsonTablePathScan);

  COPY_NODE_FIELD(path);
  COPY_SCALAR_FIELD(errorOnError);
  COPY_NODE_FIELD(child);
  COPY_SCALAR_FIELD(colMin);
  COPY_SCALAR_FIELD(colMax);

  return newnode;
}

static JsonTableSiblingJoin *
_copyJsonTableSiblingJoin(const JsonTableSiblingJoin *from)
{
  JsonTableSiblingJoin *newnode = makeNode(JsonTableSiblingJoin);

  COPY_NODE_FIELD(lplan);
  COPY_NODE_FIELD(rplan);

  return newnode;
}

static NullTest *
_copyNullTest(const NullTest *from)
{
  NullTest *newnode = makeNode(NullTest);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(nulltesttype);
  COPY_SCALAR_FIELD(argisrow);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static BooleanTest *
_copyBooleanTest(const BooleanTest *from)
{
  BooleanTest *newnode = makeNode(BooleanTest);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(booltesttype);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static MergeAction *
_copyMergeAction(const MergeAction *from)
{
  MergeAction *newnode = makeNode(MergeAction);

  COPY_SCALAR_FIELD(matchKind);
  COPY_SCALAR_FIELD(commandType);
  COPY_SCALAR_FIELD(override);
  COPY_NODE_FIELD(qual);
  COPY_NODE_FIELD(targetList);
  COPY_NODE_FIELD(updateColnos);

  return newnode;
}

static CoerceToDomain *
_copyCoerceToDomain(const CoerceToDomain *from)
{
  CoerceToDomain *newnode = makeNode(CoerceToDomain);

  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(resulttype);
  COPY_SCALAR_FIELD(resulttypmod);
  COPY_SCALAR_FIELD(resultcollid);
  COPY_SCALAR_FIELD(coercionformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CoerceToDomainValue *
_copyCoerceToDomainValue(const CoerceToDomainValue *from)
{
  CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);

  COPY_SCALAR_FIELD(typeId);
  COPY_SCALAR_FIELD(typeMod);
  COPY_SCALAR_FIELD(collation);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static SetToDefault *
_copySetToDefault(const SetToDefault *from)
{
  SetToDefault *newnode = makeNode(SetToDefault);

  COPY_SCALAR_FIELD(typeId);
  COPY_SCALAR_FIELD(typeMod);
  COPY_SCALAR_FIELD(collation);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CurrentOfExpr *
_copyCurrentOfExpr(const CurrentOfExpr *from)
{
  CurrentOfExpr *newnode = makeNode(CurrentOfExpr);

  COPY_SCALAR_FIELD(cvarno);
  COPY_STRING_FIELD(cursor_name);
  COPY_SCALAR_FIELD(cursor_param);

  return newnode;
}

static NextValueExpr *
_copyNextValueExpr(const NextValueExpr *from)
{
  NextValueExpr *newnode = makeNode(NextValueExpr);

  COPY_SCALAR_FIELD(seqid);
  COPY_SCALAR_FIELD(typeId);

  return newnode;
}

static InferenceElem *
_copyInferenceElem(const InferenceElem *from)
{
  InferenceElem *newnode = makeNode(InferenceElem);

  COPY_NODE_FIELD(expr);
  COPY_SCALAR_FIELD(infercollid);
  COPY_SCALAR_FIELD(inferopclass);

  return newnode;
}

static ReturningExpr *
_copyReturningExpr(const ReturningExpr *from)
{
  ReturningExpr *newnode = makeNode(ReturningExpr);

  COPY_SCALAR_FIELD(retlevelsup);
  COPY_SCALAR_FIELD(retold);
  COPY_NODE_FIELD(retexpr);

  return newnode;
}

static TargetEntry *
_copyTargetEntry(const TargetEntry *from)
{
  TargetEntry *newnode = makeNode(TargetEntry);

  COPY_NODE_FIELD(expr);
  COPY_SCALAR_FIELD(resno);
  COPY_STRING_FIELD(resname);
  COPY_SCALAR_FIELD(ressortgroupref);
  COPY_SCALAR_FIELD(resorigtbl);
  COPY_SCALAR_FIELD(resorigcol);
  COPY_SCALAR_FIELD(resjunk);

  return newnode;
}

static RangeTblRef *
_copyRangeTblRef(const RangeTblRef *from)
{
  RangeTblRef *newnode = makeNode(RangeTblRef);

  COPY_SCALAR_FIELD(rtindex);

  return newnode;
}

static JoinExpr *
_copyJoinExpr(const JoinExpr *from)
{
  JoinExpr *newnode = makeNode(JoinExpr);

  COPY_SCALAR_FIELD(jointype);
  COPY_SCALAR_FIELD(isNatural);
  COPY_NODE_FIELD(larg);
  COPY_NODE_FIELD(rarg);
  COPY_NODE_FIELD(usingClause);
  COPY_NODE_FIELD(join_using_alias);
  COPY_NODE_FIELD(quals);
  COPY_NODE_FIELD(alias);
  COPY_SCALAR_FIELD(rtindex);

  return newnode;
}

static FromExpr *
_copyFromExpr(const FromExpr *from)
{
  FromExpr *newnode = makeNode(FromExpr);

  COPY_NODE_FIELD(fromlist);
  COPY_NODE_FIELD(quals);

  return newnode;
}

static OnConflictExpr *
_copyOnConflictExpr(const OnConflictExpr *from)
{
  OnConflictExpr *newnode = makeNode(OnConflictExpr);

  COPY_SCALAR_FIELD(action);
  COPY_NODE_FIELD(arbiterElems);
  COPY_NODE_FIELD(arbiterWhere);
  COPY_SCALAR_FIELD(constraint);
  COPY_NODE_FIELD(onConflictSet);
  COPY_NODE_FIELD(onConflictWhere);
  COPY_SCALAR_FIELD(exclRelIndex);
  COPY_NODE_FIELD(exclRelTlist);

  return newnode;
}

static Query *
_copyQuery(const Query *from)
{
  Query *newnode = makeNode(Query);

  COPY_SCALAR_FIELD(commandType);
  COPY_SCALAR_FIELD(querySource);
  COPY_SCALAR_FIELD(queryId);
  COPY_SCALAR_FIELD(canSetTag);
  COPY_NODE_FIELD(utilityStmt);
  COPY_SCALAR_FIELD(resultRelation);
  COPY_SCALAR_FIELD(hasAggs);
  COPY_SCALAR_FIELD(hasWindowFuncs);
  COPY_SCALAR_FIELD(hasTargetSRFs);
  COPY_SCALAR_FIELD(hasSubLinks);
  COPY_SCALAR_FIELD(hasDistinctOn);
  COPY_SCALAR_FIELD(hasRecursive);
  COPY_SCALAR_FIELD(hasModifyingCTE);
  COPY_SCALAR_FIELD(hasForUpdate);
  COPY_SCALAR_FIELD(hasRowSecurity);
  COPY_SCALAR_FIELD(hasGroupRTE);
  COPY_SCALAR_FIELD(isReturn);
  COPY_NODE_FIELD(cteList);
  COPY_NODE_FIELD(rtable);
  COPY_NODE_FIELD(rteperminfos);
  COPY_NODE_FIELD(jointree);
  COPY_NODE_FIELD(mergeActionList);
  COPY_SCALAR_FIELD(mergeTargetRelation);
  COPY_NODE_FIELD(mergeJoinCondition);
  COPY_NODE_FIELD(targetList);
  COPY_SCALAR_FIELD(override);
  COPY_NODE_FIELD(onConflict);
  COPY_STRING_FIELD(returningOldAlias);
  COPY_STRING_FIELD(returningNewAlias);
  COPY_NODE_FIELD(returningList);
  COPY_NODE_FIELD(groupClause);
  COPY_SCALAR_FIELD(groupDistinct);
  COPY_NODE_FIELD(groupingSets);
  COPY_NODE_FIELD(havingQual);
  COPY_NODE_FIELD(windowClause);
  COPY_NODE_FIELD(distinctClause);
  COPY_NODE_FIELD(sortClause);
  COPY_NODE_FIELD(limitOffset);
  COPY_NODE_FIELD(limitCount);
  COPY_SCALAR_FIELD(limitOption);
  COPY_NODE_FIELD(rowMarks);
  COPY_NODE_FIELD(setOperations);
  COPY_NODE_FIELD(constraintDeps);
  COPY_NODE_FIELD(withCheckOptions);
  COPY_LOCATION_FIELD(stmt_location);
  COPY_LOCATION_FIELD(stmt_len);

  return newnode;
}

static TypeName *
_copyTypeName(const TypeName *from)
{
  TypeName *newnode = makeNode(TypeName);

  COPY_NODE_FIELD(names);
  COPY_SCALAR_FIELD(typeOid);
  COPY_SCALAR_FIELD(setof);
  COPY_SCALAR_FIELD(pct_type);
  COPY_NODE_FIELD(typmods);
  COPY_SCALAR_FIELD(typemod);
  COPY_NODE_FIELD(arrayBounds);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ColumnRef *
_copyColumnRef(const ColumnRef *from)
{
  ColumnRef *newnode = makeNode(ColumnRef);

  COPY_NODE_FIELD(fields);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ParamRef *
_copyParamRef(const ParamRef *from)
{
  ParamRef *newnode = makeNode(ParamRef);

  COPY_SCALAR_FIELD(number);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static A_Expr *
_copyA_Expr(const A_Expr *from)
{
  A_Expr *newnode = makeNode(A_Expr);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(name);
  COPY_NODE_FIELD(lexpr);
  COPY_NODE_FIELD(rexpr);
  COPY_LOCATION_FIELD(rexpr_list_start);
  COPY_LOCATION_FIELD(rexpr_list_end);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static TypeCast *
_copyTypeCast(const TypeCast *from)
{
  TypeCast *newnode = makeNode(TypeCast);

  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(typeName);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CollateClause *
_copyCollateClause(const CollateClause *from)
{
  CollateClause *newnode = makeNode(CollateClause);

  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(collname);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RoleSpec *
_copyRoleSpec(const RoleSpec *from)
{
  RoleSpec *newnode = makeNode(RoleSpec);

  COPY_SCALAR_FIELD(roletype);
  COPY_STRING_FIELD(rolename);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static FuncCall *
_copyFuncCall(const FuncCall *from)
{
  FuncCall *newnode = makeNode(FuncCall);

  COPY_NODE_FIELD(funcname);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(agg_order);
  COPY_NODE_FIELD(agg_filter);
  COPY_NODE_FIELD(over);
  COPY_SCALAR_FIELD(agg_within_group);
  COPY_SCALAR_FIELD(agg_star);
  COPY_SCALAR_FIELD(agg_distinct);
  COPY_SCALAR_FIELD(func_variadic);
  COPY_SCALAR_FIELD(funcformat);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static A_Star *
_copyA_Star(const A_Star *from)
{
  A_Star *newnode = makeNode(A_Star);


  return newnode;
}

static A_Indices *
_copyA_Indices(const A_Indices *from)
{
  A_Indices *newnode = makeNode(A_Indices);

  COPY_SCALAR_FIELD(is_slice);
  COPY_NODE_FIELD(lidx);
  COPY_NODE_FIELD(uidx);

  return newnode;
}

static A_Indirection *
_copyA_Indirection(const A_Indirection *from)
{
  A_Indirection *newnode = makeNode(A_Indirection);

  COPY_NODE_FIELD(arg);
  COPY_NODE_FIELD(indirection);

  return newnode;
}

static A_ArrayExpr *
_copyA_ArrayExpr(const A_ArrayExpr *from)
{
  A_ArrayExpr *newnode = makeNode(A_ArrayExpr);

  COPY_NODE_FIELD(elements);
  COPY_LOCATION_FIELD(list_start);
  COPY_LOCATION_FIELD(list_end);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ResTarget *
_copyResTarget(const ResTarget *from)
{
  ResTarget *newnode = makeNode(ResTarget);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(indirection);
  COPY_NODE_FIELD(val);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static MultiAssignRef *
_copyMultiAssignRef(const MultiAssignRef *from)
{
  MultiAssignRef *newnode = makeNode(MultiAssignRef);

  COPY_NODE_FIELD(source);
  COPY_SCALAR_FIELD(colno);
  COPY_SCALAR_FIELD(ncolumns);

  return newnode;
}

static SortBy *
_copySortBy(const SortBy *from)
{
  SortBy *newnode = makeNode(SortBy);

  COPY_NODE_FIELD(node);
  COPY_SCALAR_FIELD(sortby_dir);
  COPY_SCALAR_FIELD(sortby_nulls);
  COPY_NODE_FIELD(useOp);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static WindowDef *
_copyWindowDef(const WindowDef *from)
{
  WindowDef *newnode = makeNode(WindowDef);

  COPY_STRING_FIELD(name);
  COPY_STRING_FIELD(refname);
  COPY_NODE_FIELD(partitionClause);
  COPY_NODE_FIELD(orderClause);
  COPY_SCALAR_FIELD(frameOptions);
  COPY_NODE_FIELD(startOffset);
  COPY_NODE_FIELD(endOffset);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RangeSubselect *
_copyRangeSubselect(const RangeSubselect *from)
{
  RangeSubselect *newnode = makeNode(RangeSubselect);

  COPY_SCALAR_FIELD(lateral);
  COPY_NODE_FIELD(subquery);
  COPY_NODE_FIELD(alias);

  return newnode;
}

static RangeFunction *
_copyRangeFunction(const RangeFunction *from)
{
  RangeFunction *newnode = makeNode(RangeFunction);

  COPY_SCALAR_FIELD(lateral);
  COPY_SCALAR_FIELD(ordinality);
  COPY_SCALAR_FIELD(is_rowsfrom);
  COPY_NODE_FIELD(functions);
  COPY_NODE_FIELD(alias);
  COPY_NODE_FIELD(coldeflist);

  return newnode;
}

static RangeTableFunc *
_copyRangeTableFunc(const RangeTableFunc *from)
{
  RangeTableFunc *newnode = makeNode(RangeTableFunc);

  COPY_SCALAR_FIELD(lateral);
  COPY_NODE_FIELD(docexpr);
  COPY_NODE_FIELD(rowexpr);
  COPY_NODE_FIELD(namespaces);
  COPY_NODE_FIELD(columns);
  COPY_NODE_FIELD(alias);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RangeTableFuncCol *
_copyRangeTableFuncCol(const RangeTableFuncCol *from)
{
  RangeTableFuncCol *newnode = makeNode(RangeTableFuncCol);

  COPY_STRING_FIELD(colname);
  COPY_NODE_FIELD(typeName);
  COPY_SCALAR_FIELD(for_ordinality);
  COPY_SCALAR_FIELD(is_not_null);
  COPY_NODE_FIELD(colexpr);
  COPY_NODE_FIELD(coldefexpr);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static RangeTableSample *
_copyRangeTableSample(const RangeTableSample *from)
{
  RangeTableSample *newnode = makeNode(RangeTableSample);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(method);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(repeatable);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ColumnDef *
_copyColumnDef(const ColumnDef *from)
{
  ColumnDef *newnode = makeNode(ColumnDef);

  COPY_STRING_FIELD(colname);
  COPY_NODE_FIELD(typeName);
  COPY_STRING_FIELD(compression);
  COPY_SCALAR_FIELD(inhcount);
  COPY_SCALAR_FIELD(is_local);
  COPY_SCALAR_FIELD(is_not_null);
  COPY_SCALAR_FIELD(is_from_type);
  COPY_SCALAR_FIELD(storage);
  COPY_STRING_FIELD(storage_name);
  COPY_NODE_FIELD(raw_default);
  COPY_NODE_FIELD(cooked_default);
  COPY_SCALAR_FIELD(identity);
  COPY_NODE_FIELD(identitySequence);
  COPY_SCALAR_FIELD(generated);
  COPY_NODE_FIELD(collClause);
  COPY_SCALAR_FIELD(collOid);
  COPY_NODE_FIELD(constraints);
  COPY_NODE_FIELD(fdwoptions);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static TableLikeClause *
_copyTableLikeClause(const TableLikeClause *from)
{
  TableLikeClause *newnode = makeNode(TableLikeClause);

  COPY_NODE_FIELD(relation);
  COPY_SCALAR_FIELD(options);
  COPY_SCALAR_FIELD(relationOid);

  return newnode;
}

static IndexElem *
_copyIndexElem(const IndexElem *from)
{
  IndexElem *newnode = makeNode(IndexElem);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(expr);
  COPY_STRING_FIELD(indexcolname);
  COPY_NODE_FIELD(collation);
  COPY_NODE_FIELD(opclass);
  COPY_NODE_FIELD(opclassopts);
  COPY_SCALAR_FIELD(ordering);
  COPY_SCALAR_FIELD(nulls_ordering);

  return newnode;
}

static DefElem *
_copyDefElem(const DefElem *from)
{
  DefElem *newnode = makeNode(DefElem);

  COPY_STRING_FIELD(defnamespace);
  COPY_STRING_FIELD(defname);
  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(defaction);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static LockingClause *
_copyLockingClause(const LockingClause *from)
{
  LockingClause *newnode = makeNode(LockingClause);

  COPY_NODE_FIELD(lockedRels);
  COPY_SCALAR_FIELD(strength);
  COPY_SCALAR_FIELD(waitPolicy);

  return newnode;
}

static XmlSerialize *
_copyXmlSerialize(const XmlSerialize *from)
{
  XmlSerialize *newnode = makeNode(XmlSerialize);

  COPY_SCALAR_FIELD(xmloption);
  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(typeName);
  COPY_SCALAR_FIELD(indent);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static PartitionElem *
_copyPartitionElem(const PartitionElem *from)
{
  PartitionElem *newnode = makeNode(PartitionElem);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(collation);
  COPY_NODE_FIELD(opclass);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static PartitionSpec *
_copyPartitionSpec(const PartitionSpec *from)
{
  PartitionSpec *newnode = makeNode(PartitionSpec);

  COPY_SCALAR_FIELD(strategy);
  COPY_NODE_FIELD(partParams);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static PartitionBoundSpec *
_copyPartitionBoundSpec(const PartitionBoundSpec *from)
{
  PartitionBoundSpec *newnode = makeNode(PartitionBoundSpec);

  COPY_SCALAR_FIELD(strategy);
  COPY_SCALAR_FIELD(is_default);
  COPY_SCALAR_FIELD(modulus);
  COPY_SCALAR_FIELD(remainder);
  COPY_NODE_FIELD(listdatums);
  COPY_NODE_FIELD(lowerdatums);
  COPY_NODE_FIELD(upperdatums);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static PartitionRangeDatum *
_copyPartitionRangeDatum(const PartitionRangeDatum *from)
{
  PartitionRangeDatum *newnode = makeNode(PartitionRangeDatum);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(value);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static PartitionCmd *
_copyPartitionCmd(const PartitionCmd *from)
{
  PartitionCmd *newnode = makeNode(PartitionCmd);

  COPY_NODE_FIELD(name);
  COPY_NODE_FIELD(bound);
  COPY_SCALAR_FIELD(concurrent);

  return newnode;
}

static RangeTblEntry *
_copyRangeTblEntry(const RangeTblEntry *from)
{
  RangeTblEntry *newnode = makeNode(RangeTblEntry);

  COPY_NODE_FIELD(alias);
  COPY_NODE_FIELD(eref);
  COPY_SCALAR_FIELD(rtekind);
  COPY_SCALAR_FIELD(relid);
  COPY_SCALAR_FIELD(inh);
  COPY_SCALAR_FIELD(relkind);
  COPY_SCALAR_FIELD(rellockmode);
  COPY_SCALAR_FIELD(perminfoindex);
  COPY_NODE_FIELD(tablesample);
  COPY_NODE_FIELD(subquery);
  COPY_SCALAR_FIELD(security_barrier);
  COPY_SCALAR_FIELD(jointype);
  COPY_SCALAR_FIELD(joinmergedcols);
  COPY_NODE_FIELD(joinaliasvars);
  COPY_NODE_FIELD(joinleftcols);
  COPY_NODE_FIELD(joinrightcols);
  COPY_NODE_FIELD(join_using_alias);
  COPY_NODE_FIELD(functions);
  COPY_SCALAR_FIELD(funcordinality);
  COPY_NODE_FIELD(tablefunc);
  COPY_NODE_FIELD(values_lists);
  COPY_STRING_FIELD(ctename);
  COPY_SCALAR_FIELD(ctelevelsup);
  COPY_SCALAR_FIELD(self_reference);
  COPY_NODE_FIELD(coltypes);
  COPY_NODE_FIELD(coltypmods);
  COPY_NODE_FIELD(colcollations);
  COPY_STRING_FIELD(enrname);
  COPY_SCALAR_FIELD(enrtuples);
  COPY_NODE_FIELD(groupexprs);
  COPY_SCALAR_FIELD(lateral);
  COPY_SCALAR_FIELD(inFromCl);
  COPY_NODE_FIELD(securityQuals);

  return newnode;
}

static RTEPermissionInfo *
_copyRTEPermissionInfo(const RTEPermissionInfo *from)
{
  RTEPermissionInfo *newnode = makeNode(RTEPermissionInfo);

  COPY_SCALAR_FIELD(relid);
  COPY_SCALAR_FIELD(inh);
  COPY_SCALAR_FIELD(requiredPerms);
  COPY_SCALAR_FIELD(checkAsUser);
  COPY_BITMAPSET_FIELD(selectedCols);
  COPY_BITMAPSET_FIELD(insertedCols);
  COPY_BITMAPSET_FIELD(updatedCols);

  return newnode;
}

static RangeTblFunction *
_copyRangeTblFunction(const RangeTblFunction *from)
{
  RangeTblFunction *newnode = makeNode(RangeTblFunction);

  COPY_NODE_FIELD(funcexpr);
  COPY_SCALAR_FIELD(funccolcount);
  COPY_NODE_FIELD(funccolnames);
  COPY_NODE_FIELD(funccoltypes);
  COPY_NODE_FIELD(funccoltypmods);
  COPY_NODE_FIELD(funccolcollations);
  COPY_BITMAPSET_FIELD(funcparams);

  return newnode;
}

static TableSampleClause *
_copyTableSampleClause(const TableSampleClause *from)
{
  TableSampleClause *newnode = makeNode(TableSampleClause);

  COPY_SCALAR_FIELD(tsmhandler);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(repeatable);

  return newnode;
}

static WithCheckOption *
_copyWithCheckOption(const WithCheckOption *from)
{
  WithCheckOption *newnode = makeNode(WithCheckOption);

  COPY_SCALAR_FIELD(kind);
  COPY_STRING_FIELD(relname);
  COPY_STRING_FIELD(polname);
  COPY_NODE_FIELD(qual);
  COPY_SCALAR_FIELD(cascaded);

  return newnode;
}

static SortGroupClause *
_copySortGroupClause(const SortGroupClause *from)
{
  SortGroupClause *newnode = makeNode(SortGroupClause);

  COPY_SCALAR_FIELD(tleSortGroupRef);
  COPY_SCALAR_FIELD(eqop);
  COPY_SCALAR_FIELD(sortop);
  COPY_SCALAR_FIELD(reverse_sort);
  COPY_SCALAR_FIELD(nulls_first);
  COPY_SCALAR_FIELD(hashable);

  return newnode;
}

static GroupingSet *
_copyGroupingSet(const GroupingSet *from)
{
  GroupingSet *newnode = makeNode(GroupingSet);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(content);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static WindowClause *
_copyWindowClause(const WindowClause *from)
{
  WindowClause *newnode = makeNode(WindowClause);

  COPY_STRING_FIELD(name);
  COPY_STRING_FIELD(refname);
  COPY_NODE_FIELD(partitionClause);
  COPY_NODE_FIELD(orderClause);
  COPY_SCALAR_FIELD(frameOptions);
  COPY_NODE_FIELD(startOffset);
  COPY_NODE_FIELD(endOffset);
  COPY_SCALAR_FIELD(startInRangeFunc);
  COPY_SCALAR_FIELD(endInRangeFunc);
  COPY_SCALAR_FIELD(inRangeColl);
  COPY_SCALAR_FIELD(inRangeAsc);
  COPY_SCALAR_FIELD(inRangeNullsFirst);
  COPY_SCALAR_FIELD(winref);
  COPY_SCALAR_FIELD(copiedOrder);

  return newnode;
}

static RowMarkClause *
_copyRowMarkClause(const RowMarkClause *from)
{
  RowMarkClause *newnode = makeNode(RowMarkClause);

  COPY_SCALAR_FIELD(rti);
  COPY_SCALAR_FIELD(strength);
  COPY_SCALAR_FIELD(waitPolicy);
  COPY_SCALAR_FIELD(pushedDown);

  return newnode;
}

static WithClause *
_copyWithClause(const WithClause *from)
{
  WithClause *newnode = makeNode(WithClause);

  COPY_NODE_FIELD(ctes);
  COPY_SCALAR_FIELD(recursive);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static InferClause *
_copyInferClause(const InferClause *from)
{
  InferClause *newnode = makeNode(InferClause);

  COPY_NODE_FIELD(indexElems);
  COPY_NODE_FIELD(whereClause);
  COPY_STRING_FIELD(conname);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static OnConflictClause *
_copyOnConflictClause(const OnConflictClause *from)
{
  OnConflictClause *newnode = makeNode(OnConflictClause);

  COPY_SCALAR_FIELD(action);
  COPY_NODE_FIELD(infer);
  COPY_NODE_FIELD(targetList);
  COPY_NODE_FIELD(whereClause);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CTESearchClause *
_copyCTESearchClause(const CTESearchClause *from)
{
  CTESearchClause *newnode = makeNode(CTESearchClause);

  COPY_NODE_FIELD(search_col_list);
  COPY_SCALAR_FIELD(search_breadth_first);
  COPY_STRING_FIELD(search_seq_column);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CTECycleClause *
_copyCTECycleClause(const CTECycleClause *from)
{
  CTECycleClause *newnode = makeNode(CTECycleClause);

  COPY_NODE_FIELD(cycle_col_list);
  COPY_STRING_FIELD(cycle_mark_column);
  COPY_NODE_FIELD(cycle_mark_value);
  COPY_NODE_FIELD(cycle_mark_default);
  COPY_STRING_FIELD(cycle_path_column);
  COPY_LOCATION_FIELD(location);
  COPY_SCALAR_FIELD(cycle_mark_type);
  COPY_SCALAR_FIELD(cycle_mark_typmod);
  COPY_SCALAR_FIELD(cycle_mark_collation);
  COPY_SCALAR_FIELD(cycle_mark_neop);

  return newnode;
}

static CommonTableExpr *
_copyCommonTableExpr(const CommonTableExpr *from)
{
  CommonTableExpr *newnode = makeNode(CommonTableExpr);

  COPY_STRING_FIELD(ctename);
  COPY_NODE_FIELD(aliascolnames);
  COPY_SCALAR_FIELD(ctematerialized);
  COPY_NODE_FIELD(ctequery);
  COPY_NODE_FIELD(search_clause);
  COPY_NODE_FIELD(cycle_clause);
  COPY_LOCATION_FIELD(location);
  COPY_SCALAR_FIELD(cterecursive);
  COPY_SCALAR_FIELD(cterefcount);
  COPY_NODE_FIELD(ctecolnames);
  COPY_NODE_FIELD(ctecoltypes);
  COPY_NODE_FIELD(ctecoltypmods);
  COPY_NODE_FIELD(ctecolcollations);

  return newnode;
}

static MergeWhenClause *
_copyMergeWhenClause(const MergeWhenClause *from)
{
  MergeWhenClause *newnode = makeNode(MergeWhenClause);

  COPY_SCALAR_FIELD(matchKind);
  COPY_SCALAR_FIELD(commandType);
  COPY_SCALAR_FIELD(override);
  COPY_NODE_FIELD(condition);
  COPY_NODE_FIELD(targetList);
  COPY_NODE_FIELD(values);

  return newnode;
}

static ReturningOption *
_copyReturningOption(const ReturningOption *from)
{
  ReturningOption *newnode = makeNode(ReturningOption);

  COPY_SCALAR_FIELD(option);
  COPY_STRING_FIELD(value);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static ReturningClause *
_copyReturningClause(const ReturningClause *from)
{
  ReturningClause *newnode = makeNode(ReturningClause);

  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(exprs);

  return newnode;
}

static TriggerTransition *
_copyTriggerTransition(const TriggerTransition *from)
{
  TriggerTransition *newnode = makeNode(TriggerTransition);

  COPY_STRING_FIELD(name);
  COPY_SCALAR_FIELD(isNew);
  COPY_SCALAR_FIELD(isTable);

  return newnode;
}

static JsonOutput *
_copyJsonOutput(const JsonOutput *from)
{
  JsonOutput *newnode = makeNode(JsonOutput);

  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(returning);

  return newnode;
}

static JsonArgument *
_copyJsonArgument(const JsonArgument *from)
{
  JsonArgument *newnode = makeNode(JsonArgument);

  COPY_NODE_FIELD(val);
  COPY_STRING_FIELD(name);

  return newnode;
}

static JsonFuncExpr *
_copyJsonFuncExpr(const JsonFuncExpr *from)
{
  JsonFuncExpr *newnode = makeNode(JsonFuncExpr);

  COPY_SCALAR_FIELD(op);
  COPY_STRING_FIELD(column_name);
  COPY_NODE_FIELD(context_item);
  COPY_NODE_FIELD(pathspec);
  COPY_NODE_FIELD(passing);
  COPY_NODE_FIELD(output);
  COPY_NODE_FIELD(on_empty);
  COPY_NODE_FIELD(on_error);
  COPY_SCALAR_FIELD(wrapper);
  COPY_SCALAR_FIELD(quotes);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonTablePathSpec *
_copyJsonTablePathSpec(const JsonTablePathSpec *from)
{
  JsonTablePathSpec *newnode = makeNode(JsonTablePathSpec);

  COPY_NODE_FIELD(string);
  COPY_STRING_FIELD(name);
  COPY_LOCATION_FIELD(name_location);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonTable *
_copyJsonTable(const JsonTable *from)
{
  JsonTable *newnode = makeNode(JsonTable);

  COPY_NODE_FIELD(context_item);
  COPY_NODE_FIELD(pathspec);
  COPY_NODE_FIELD(passing);
  COPY_NODE_FIELD(columns);
  COPY_NODE_FIELD(on_error);
  COPY_NODE_FIELD(alias);
  COPY_SCALAR_FIELD(lateral);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonTableColumn *
_copyJsonTableColumn(const JsonTableColumn *from)
{
  JsonTableColumn *newnode = makeNode(JsonTableColumn);

  COPY_SCALAR_FIELD(coltype);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(pathspec);
  COPY_NODE_FIELD(format);
  COPY_SCALAR_FIELD(wrapper);
  COPY_SCALAR_FIELD(quotes);
  COPY_NODE_FIELD(columns);
  COPY_NODE_FIELD(on_empty);
  COPY_NODE_FIELD(on_error);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonKeyValue *
_copyJsonKeyValue(const JsonKeyValue *from)
{
  JsonKeyValue *newnode = makeNode(JsonKeyValue);

  COPY_NODE_FIELD(key);
  COPY_NODE_FIELD(value);

  return newnode;
}

static JsonParseExpr *
_copyJsonParseExpr(const JsonParseExpr *from)
{
  JsonParseExpr *newnode = makeNode(JsonParseExpr);

  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(output);
  COPY_SCALAR_FIELD(unique_keys);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonScalarExpr *
_copyJsonScalarExpr(const JsonScalarExpr *from)
{
  JsonScalarExpr *newnode = makeNode(JsonScalarExpr);

  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(output);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonSerializeExpr *
_copyJsonSerializeExpr(const JsonSerializeExpr *from)
{
  JsonSerializeExpr *newnode = makeNode(JsonSerializeExpr);

  COPY_NODE_FIELD(expr);
  COPY_NODE_FIELD(output);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonObjectConstructor *
_copyJsonObjectConstructor(const JsonObjectConstructor *from)
{
  JsonObjectConstructor *newnode = makeNode(JsonObjectConstructor);

  COPY_NODE_FIELD(exprs);
  COPY_NODE_FIELD(output);
  COPY_SCALAR_FIELD(absent_on_null);
  COPY_SCALAR_FIELD(unique);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonArrayConstructor *
_copyJsonArrayConstructor(const JsonArrayConstructor *from)
{
  JsonArrayConstructor *newnode = makeNode(JsonArrayConstructor);

  COPY_NODE_FIELD(exprs);
  COPY_NODE_FIELD(output);
  COPY_SCALAR_FIELD(absent_on_null);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonArrayQueryConstructor *
_copyJsonArrayQueryConstructor(const JsonArrayQueryConstructor *from)
{
  JsonArrayQueryConstructor *newnode = makeNode(JsonArrayQueryConstructor);

  COPY_NODE_FIELD(query);
  COPY_NODE_FIELD(output);
  COPY_NODE_FIELD(format);
  COPY_SCALAR_FIELD(absent_on_null);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonAggConstructor *
_copyJsonAggConstructor(const JsonAggConstructor *from)
{
  JsonAggConstructor *newnode = makeNode(JsonAggConstructor);

  COPY_NODE_FIELD(output);
  COPY_NODE_FIELD(agg_filter);
  COPY_NODE_FIELD(agg_order);
  COPY_NODE_FIELD(over);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static JsonObjectAgg *
_copyJsonObjectAgg(const JsonObjectAgg *from)
{
  JsonObjectAgg *newnode = makeNode(JsonObjectAgg);

  COPY_NODE_FIELD(constructor);
  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(absent_on_null);
  COPY_SCALAR_FIELD(unique);

  return newnode;
}

static JsonArrayAgg *
_copyJsonArrayAgg(const JsonArrayAgg *from)
{
  JsonArrayAgg *newnode = makeNode(JsonArrayAgg);

  COPY_NODE_FIELD(constructor);
  COPY_NODE_FIELD(arg);
  COPY_SCALAR_FIELD(absent_on_null);

  return newnode;
}

static RawStmt *
_copyRawStmt(const RawStmt *from)
{
  RawStmt *newnode = makeNode(RawStmt);

  COPY_NODE_FIELD(stmt);
  COPY_LOCATION_FIELD(stmt_location);
  COPY_LOCATION_FIELD(stmt_len);

  return newnode;
}

static InsertStmt *
_copyInsertStmt(const InsertStmt *from)
{
  InsertStmt *newnode = makeNode(InsertStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(cols);
  COPY_NODE_FIELD(selectStmt);
  COPY_NODE_FIELD(onConflictClause);
  COPY_NODE_FIELD(returningClause);
  COPY_NODE_FIELD(withClause);
  COPY_SCALAR_FIELD(override);

  return newnode;
}

static DeleteStmt *
_copyDeleteStmt(const DeleteStmt *from)
{
  DeleteStmt *newnode = makeNode(DeleteStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(usingClause);
  COPY_NODE_FIELD(whereClause);
  COPY_NODE_FIELD(returningClause);
  COPY_NODE_FIELD(withClause);

  return newnode;
}

static UpdateStmt *
_copyUpdateStmt(const UpdateStmt *from)
{
  UpdateStmt *newnode = makeNode(UpdateStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(targetList);
  COPY_NODE_FIELD(whereClause);
  COPY_NODE_FIELD(fromClause);
  COPY_NODE_FIELD(returningClause);
  COPY_NODE_FIELD(withClause);

  return newnode;
}

static MergeStmt *
_copyMergeStmt(const MergeStmt *from)
{
  MergeStmt *newnode = makeNode(MergeStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(sourceRelation);
  COPY_NODE_FIELD(joinCondition);
  COPY_NODE_FIELD(mergeWhenClauses);
  COPY_NODE_FIELD(returningClause);
  COPY_NODE_FIELD(withClause);

  return newnode;
}

static SelectStmt *
_copySelectStmt(const SelectStmt *from)
{
  SelectStmt *newnode = makeNode(SelectStmt);

  COPY_NODE_FIELD(distinctClause);
  COPY_NODE_FIELD(intoClause);
  COPY_NODE_FIELD(targetList);
  COPY_NODE_FIELD(fromClause);
  COPY_NODE_FIELD(whereClause);
  COPY_NODE_FIELD(groupClause);
  COPY_SCALAR_FIELD(groupDistinct);
  COPY_NODE_FIELD(havingClause);
  COPY_NODE_FIELD(windowClause);
  COPY_NODE_FIELD(valuesLists);
  COPY_NODE_FIELD(sortClause);
  COPY_NODE_FIELD(limitOffset);
  COPY_NODE_FIELD(limitCount);
  COPY_SCALAR_FIELD(limitOption);
  COPY_NODE_FIELD(lockingClause);
  COPY_NODE_FIELD(withClause);
  COPY_SCALAR_FIELD(op);
  COPY_SCALAR_FIELD(all);
  COPY_NODE_FIELD(larg);
  COPY_NODE_FIELD(rarg);

  return newnode;
}

static SetOperationStmt *
_copySetOperationStmt(const SetOperationStmt *from)
{
  SetOperationStmt *newnode = makeNode(SetOperationStmt);

  COPY_SCALAR_FIELD(op);
  COPY_SCALAR_FIELD(all);
  COPY_NODE_FIELD(larg);
  COPY_NODE_FIELD(rarg);
  COPY_NODE_FIELD(colTypes);
  COPY_NODE_FIELD(colTypmods);
  COPY_NODE_FIELD(colCollations);
  COPY_NODE_FIELD(groupClauses);

  return newnode;
}

static ReturnStmt *
_copyReturnStmt(const ReturnStmt *from)
{
  ReturnStmt *newnode = makeNode(ReturnStmt);

  COPY_NODE_FIELD(returnval);

  return newnode;
}

static PLAssignStmt *
_copyPLAssignStmt(const PLAssignStmt *from)
{
  PLAssignStmt *newnode = makeNode(PLAssignStmt);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(indirection);
  COPY_SCALAR_FIELD(nnames);
  COPY_NODE_FIELD(val);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CreateSchemaStmt *
_copyCreateSchemaStmt(const CreateSchemaStmt *from)
{
  CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);

  COPY_STRING_FIELD(schemaname);
  COPY_NODE_FIELD(authrole);
  COPY_NODE_FIELD(schemaElts);
  COPY_SCALAR_FIELD(if_not_exists);

  return newnode;
}

static AlterTableStmt *
_copyAlterTableStmt(const AlterTableStmt *from)
{
  AlterTableStmt *newnode = makeNode(AlterTableStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(cmds);
  COPY_SCALAR_FIELD(objtype);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static AlterTableCmd *
_copyAlterTableCmd(const AlterTableCmd *from)
{
  AlterTableCmd *newnode = makeNode(AlterTableCmd);

  COPY_SCALAR_FIELD(subtype);
  COPY_STRING_FIELD(name);
  COPY_SCALAR_FIELD(num);
  COPY_NODE_FIELD(newowner);
  COPY_NODE_FIELD(def);
  COPY_SCALAR_FIELD(behavior);
  COPY_SCALAR_FIELD(missing_ok);
  COPY_SCALAR_FIELD(recurse);

  return newnode;
}

static ATAlterConstraint *
_copyATAlterConstraint(const ATAlterConstraint *from)
{
  ATAlterConstraint *newnode = makeNode(ATAlterConstraint);

  COPY_STRING_FIELD(conname);
  COPY_SCALAR_FIELD(alterEnforceability);
  COPY_SCALAR_FIELD(is_enforced);
  COPY_SCALAR_FIELD(alterDeferrability);
  COPY_SCALAR_FIELD(deferrable);
  COPY_SCALAR_FIELD(initdeferred);
  COPY_SCALAR_FIELD(alterInheritability);
  COPY_SCALAR_FIELD(noinherit);

  return newnode;
}

static ReplicaIdentityStmt *
_copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
{
  ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);

  COPY_SCALAR_FIELD(identity_type);
  COPY_STRING_FIELD(name);

  return newnode;
}

static AlterCollationStmt *
_copyAlterCollationStmt(const AlterCollationStmt *from)
{
  AlterCollationStmt *newnode = makeNode(AlterCollationStmt);

  COPY_NODE_FIELD(collname);

  return newnode;
}

static AlterDomainStmt *
_copyAlterDomainStmt(const AlterDomainStmt *from)
{
  AlterDomainStmt *newnode = makeNode(AlterDomainStmt);

  COPY_SCALAR_FIELD(subtype);
  COPY_NODE_FIELD(typeName);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(def);
  COPY_SCALAR_FIELD(behavior);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static GrantStmt *
_copyGrantStmt(const GrantStmt *from)
{
  GrantStmt *newnode = makeNode(GrantStmt);

  COPY_SCALAR_FIELD(is_grant);
  COPY_SCALAR_FIELD(targtype);
  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(objects);
  COPY_NODE_FIELD(privileges);
  COPY_NODE_FIELD(grantees);
  COPY_SCALAR_FIELD(grant_option);
  COPY_NODE_FIELD(grantor);
  COPY_SCALAR_FIELD(behavior);

  return newnode;
}

static ObjectWithArgs *
_copyObjectWithArgs(const ObjectWithArgs *from)
{
  ObjectWithArgs *newnode = makeNode(ObjectWithArgs);

  COPY_NODE_FIELD(objname);
  COPY_NODE_FIELD(objargs);
  COPY_NODE_FIELD(objfuncargs);
  COPY_SCALAR_FIELD(args_unspecified);

  return newnode;
}

static AccessPriv *
_copyAccessPriv(const AccessPriv *from)
{
  AccessPriv *newnode = makeNode(AccessPriv);

  COPY_STRING_FIELD(priv_name);
  COPY_NODE_FIELD(cols);

  return newnode;
}

static GrantRoleStmt *
_copyGrantRoleStmt(const GrantRoleStmt *from)
{
  GrantRoleStmt *newnode = makeNode(GrantRoleStmt);

  COPY_NODE_FIELD(granted_roles);
  COPY_NODE_FIELD(grantee_roles);
  COPY_SCALAR_FIELD(is_grant);
  COPY_NODE_FIELD(opt);
  COPY_NODE_FIELD(grantor);
  COPY_SCALAR_FIELD(behavior);

  return newnode;
}

static AlterDefaultPrivilegesStmt *
_copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from)
{
  AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);

  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(action);

  return newnode;
}

static CopyStmt *
_copyCopyStmt(const CopyStmt *from)
{
  CopyStmt *newnode = makeNode(CopyStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(query);
  COPY_NODE_FIELD(attlist);
  COPY_SCALAR_FIELD(is_from);
  COPY_SCALAR_FIELD(is_program);
  COPY_STRING_FIELD(filename);
  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(whereClause);

  return newnode;
}

static VariableSetStmt *
_copyVariableSetStmt(const VariableSetStmt *from)
{
  VariableSetStmt *newnode = makeNode(VariableSetStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(args);
  COPY_SCALAR_FIELD(jumble_args);
  COPY_SCALAR_FIELD(is_local);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static VariableShowStmt *
_copyVariableShowStmt(const VariableShowStmt *from)
{
  VariableShowStmt *newnode = makeNode(VariableShowStmt);

  COPY_STRING_FIELD(name);

  return newnode;
}

static CreateStmt *
_copyCreateStmt(const CreateStmt *from)
{
  CreateStmt *newnode = makeNode(CreateStmt);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(tableElts);
  COPY_NODE_FIELD(inhRelations);
  COPY_NODE_FIELD(partbound);
  COPY_NODE_FIELD(partspec);
  COPY_NODE_FIELD(ofTypename);
  COPY_NODE_FIELD(constraints);
  COPY_NODE_FIELD(nnconstraints);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(oncommit);
  COPY_STRING_FIELD(tablespacename);
  COPY_STRING_FIELD(accessMethod);
  COPY_SCALAR_FIELD(if_not_exists);

  return newnode;
}

static Constraint *
_copyConstraint(const Constraint *from)
{
  Constraint *newnode = makeNode(Constraint);

  COPY_SCALAR_FIELD(contype);
  COPY_STRING_FIELD(conname);
  COPY_SCALAR_FIELD(deferrable);
  COPY_SCALAR_FIELD(initdeferred);
  COPY_SCALAR_FIELD(is_enforced);
  COPY_SCALAR_FIELD(skip_validation);
  COPY_SCALAR_FIELD(initially_valid);
  COPY_SCALAR_FIELD(is_no_inherit);
  COPY_NODE_FIELD(raw_expr);
  COPY_STRING_FIELD(cooked_expr);
  COPY_SCALAR_FIELD(generated_when);
  COPY_SCALAR_FIELD(generated_kind);
  COPY_SCALAR_FIELD(nulls_not_distinct);
  COPY_NODE_FIELD(keys);
  COPY_SCALAR_FIELD(without_overlaps);
  COPY_NODE_FIELD(including);
  COPY_NODE_FIELD(exclusions);
  COPY_NODE_FIELD(options);
  COPY_STRING_FIELD(indexname);
  COPY_STRING_FIELD(indexspace);
  COPY_SCALAR_FIELD(reset_default_tblspc);
  COPY_STRING_FIELD(access_method);
  COPY_NODE_FIELD(where_clause);
  COPY_NODE_FIELD(pktable);
  COPY_NODE_FIELD(fk_attrs);
  COPY_NODE_FIELD(pk_attrs);
  COPY_SCALAR_FIELD(fk_with_period);
  COPY_SCALAR_FIELD(pk_with_period);
  COPY_SCALAR_FIELD(fk_matchtype);
  COPY_SCALAR_FIELD(fk_upd_action);
  COPY_SCALAR_FIELD(fk_del_action);
  COPY_NODE_FIELD(fk_del_set_cols);
  COPY_NODE_FIELD(old_conpfeqop);
  COPY_SCALAR_FIELD(old_pktable_oid);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CreateTableSpaceStmt *
_copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from)
{
  CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);

  COPY_STRING_FIELD(tablespacename);
  COPY_NODE_FIELD(owner);
  COPY_STRING_FIELD(location);
  COPY_NODE_FIELD(options);

  return newnode;
}

static DropTableSpaceStmt *
_copyDropTableSpaceStmt(const DropTableSpaceStmt *from)
{
  DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);

  COPY_STRING_FIELD(tablespacename);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static AlterTableSpaceOptionsStmt *
_copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from)
{
  AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);

  COPY_STRING_FIELD(tablespacename);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(isReset);

  return newnode;
}

static AlterTableMoveAllStmt *
_copyAlterTableMoveAllStmt(const AlterTableMoveAllStmt *from)
{
  AlterTableMoveAllStmt *newnode = makeNode(AlterTableMoveAllStmt);

  COPY_STRING_FIELD(orig_tablespacename);
  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(roles);
  COPY_STRING_FIELD(new_tablespacename);
  COPY_SCALAR_FIELD(nowait);

  return newnode;
}

static CreateExtensionStmt *
_copyCreateExtensionStmt(const CreateExtensionStmt *from)
{
  CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);

  COPY_STRING_FIELD(extname);
  COPY_SCALAR_FIELD(if_not_exists);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterExtensionStmt *
_copyAlterExtensionStmt(const AlterExtensionStmt *from)
{
  AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);

  COPY_STRING_FIELD(extname);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterExtensionContentsStmt *
_copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from)
{
  AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);

  COPY_STRING_FIELD(extname);
  COPY_SCALAR_FIELD(action);
  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(object);

  return newnode;
}

static CreateFdwStmt *
_copyCreateFdwStmt(const CreateFdwStmt *from)
{
  CreateFdwStmt *newnode = makeNode(CreateFdwStmt);

  COPY_STRING_FIELD(fdwname);
  COPY_NODE_FIELD(func_options);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterFdwStmt *
_copyAlterFdwStmt(const AlterFdwStmt *from)
{
  AlterFdwStmt *newnode = makeNode(AlterFdwStmt);

  COPY_STRING_FIELD(fdwname);
  COPY_NODE_FIELD(func_options);
  COPY_NODE_FIELD(options);

  return newnode;
}

static CreateForeignServerStmt *
_copyCreateForeignServerStmt(const CreateForeignServerStmt *from)
{
  CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);

  COPY_STRING_FIELD(servername);
  COPY_STRING_FIELD(servertype);
  COPY_STRING_FIELD(version);
  COPY_STRING_FIELD(fdwname);
  COPY_SCALAR_FIELD(if_not_exists);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterForeignServerStmt *
_copyAlterForeignServerStmt(const AlterForeignServerStmt *from)
{
  AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);

  COPY_STRING_FIELD(servername);
  COPY_STRING_FIELD(version);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(has_version);

  return newnode;
}

static CreateForeignTableStmt *
_copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
{
  CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);

  COPY_NODE_FIELD(base.relation);
  COPY_NODE_FIELD(base.tableElts);
  COPY_NODE_FIELD(base.inhRelations);
  COPY_NODE_FIELD(base.partbound);
  COPY_NODE_FIELD(base.partspec);
  COPY_NODE_FIELD(base.ofTypename);
  COPY_NODE_FIELD(base.constraints);
  COPY_NODE_FIELD(base.nnconstraints);
  COPY_NODE_FIELD(base.options);
  COPY_SCALAR_FIELD(base.oncommit);
  COPY_STRING_FIELD(base.tablespacename);
  COPY_STRING_FIELD(base.accessMethod);
  COPY_SCALAR_FIELD(base.if_not_exists);
  COPY_STRING_FIELD(servername);
  COPY_NODE_FIELD(options);

  return newnode;
}

static CreateUserMappingStmt *
_copyCreateUserMappingStmt(const CreateUserMappingStmt *from)
{
  CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);

  COPY_NODE_FIELD(user);
  COPY_STRING_FIELD(servername);
  COPY_SCALAR_FIELD(if_not_exists);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterUserMappingStmt *
_copyAlterUserMappingStmt(const AlterUserMappingStmt *from)
{
  AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);

  COPY_NODE_FIELD(user);
  COPY_STRING_FIELD(servername);
  COPY_NODE_FIELD(options);

  return newnode;
}

static DropUserMappingStmt *
_copyDropUserMappingStmt(const DropUserMappingStmt *from)
{
  DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);

  COPY_NODE_FIELD(user);
  COPY_STRING_FIELD(servername);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static ImportForeignSchemaStmt *
_copyImportForeignSchemaStmt(const ImportForeignSchemaStmt *from)
{
  ImportForeignSchemaStmt *newnode = makeNode(ImportForeignSchemaStmt);

  COPY_STRING_FIELD(server_name);
  COPY_STRING_FIELD(remote_schema);
  COPY_STRING_FIELD(local_schema);
  COPY_SCALAR_FIELD(list_type);
  COPY_NODE_FIELD(table_list);
  COPY_NODE_FIELD(options);

  return newnode;
}

static CreatePolicyStmt *
_copyCreatePolicyStmt(const CreatePolicyStmt *from)
{
  CreatePolicyStmt *newnode = makeNode(CreatePolicyStmt);

  COPY_STRING_FIELD(policy_name);
  COPY_NODE_FIELD(table);
  COPY_STRING_FIELD(cmd_name);
  COPY_SCALAR_FIELD(permissive);
  COPY_NODE_FIELD(roles);
  COPY_NODE_FIELD(qual);
  COPY_NODE_FIELD(with_check);

  return newnode;
}

static AlterPolicyStmt *
_copyAlterPolicyStmt(const AlterPolicyStmt *from)
{
  AlterPolicyStmt *newnode = makeNode(AlterPolicyStmt);

  COPY_STRING_FIELD(policy_name);
  COPY_NODE_FIELD(table);
  COPY_NODE_FIELD(roles);
  COPY_NODE_FIELD(qual);
  COPY_NODE_FIELD(with_check);

  return newnode;
}

static CreateAmStmt *
_copyCreateAmStmt(const CreateAmStmt *from)
{
  CreateAmStmt *newnode = makeNode(CreateAmStmt);

  COPY_STRING_FIELD(amname);
  COPY_NODE_FIELD(handler_name);
  COPY_SCALAR_FIELD(amtype);

  return newnode;
}

static CreateTrigStmt *
_copyCreateTrigStmt(const CreateTrigStmt *from)
{
  CreateTrigStmt *newnode = makeNode(CreateTrigStmt);

  COPY_SCALAR_FIELD(replace);
  COPY_SCALAR_FIELD(isconstraint);
  COPY_STRING_FIELD(trigname);
  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(funcname);
  COPY_NODE_FIELD(args);
  COPY_SCALAR_FIELD(row);
  COPY_SCALAR_FIELD(timing);
  COPY_SCALAR_FIELD(events);
  COPY_NODE_FIELD(columns);
  COPY_NODE_FIELD(whenClause);
  COPY_NODE_FIELD(transitionRels);
  COPY_SCALAR_FIELD(deferrable);
  COPY_SCALAR_FIELD(initdeferred);
  COPY_NODE_FIELD(constrrel);

  return newnode;
}

static CreateEventTrigStmt *
_copyCreateEventTrigStmt(const CreateEventTrigStmt *from)
{
  CreateEventTrigStmt *newnode = makeNode(CreateEventTrigStmt);

  COPY_STRING_FIELD(trigname);
  COPY_STRING_FIELD(eventname);
  COPY_NODE_FIELD(whenclause);
  COPY_NODE_FIELD(funcname);

  return newnode;
}

static AlterEventTrigStmt *
_copyAlterEventTrigStmt(const AlterEventTrigStmt *from)
{
  AlterEventTrigStmt *newnode = makeNode(AlterEventTrigStmt);

  COPY_STRING_FIELD(trigname);
  COPY_SCALAR_FIELD(tgenabled);

  return newnode;
}

static CreatePLangStmt *
_copyCreatePLangStmt(const CreatePLangStmt *from)
{
  CreatePLangStmt *newnode = makeNode(CreatePLangStmt);

  COPY_SCALAR_FIELD(replace);
  COPY_STRING_FIELD(plname);
  COPY_NODE_FIELD(plhandler);
  COPY_NODE_FIELD(plinline);
  COPY_NODE_FIELD(plvalidator);
  COPY_SCALAR_FIELD(pltrusted);

  return newnode;
}

static CreateRoleStmt *
_copyCreateRoleStmt(const CreateRoleStmt *from)
{
  CreateRoleStmt *newnode = makeNode(CreateRoleStmt);

  COPY_SCALAR_FIELD(stmt_type);
  COPY_STRING_FIELD(role);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterRoleStmt *
_copyAlterRoleStmt(const AlterRoleStmt *from)
{
  AlterRoleStmt *newnode = makeNode(AlterRoleStmt);

  COPY_NODE_FIELD(role);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(action);

  return newnode;
}

static AlterRoleSetStmt *
_copyAlterRoleSetStmt(const AlterRoleSetStmt *from)
{
  AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);

  COPY_NODE_FIELD(role);
  COPY_STRING_FIELD(database);
  COPY_NODE_FIELD(setstmt);

  return newnode;
}

static DropRoleStmt *
_copyDropRoleStmt(const DropRoleStmt *from)
{
  DropRoleStmt *newnode = makeNode(DropRoleStmt);

  COPY_NODE_FIELD(roles);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static CreateSeqStmt *
_copyCreateSeqStmt(const CreateSeqStmt *from)
{
  CreateSeqStmt *newnode = makeNode(CreateSeqStmt);

  COPY_NODE_FIELD(sequence);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(ownerId);
  COPY_SCALAR_FIELD(for_identity);
  COPY_SCALAR_FIELD(if_not_exists);

  return newnode;
}

static AlterSeqStmt *
_copyAlterSeqStmt(const AlterSeqStmt *from)
{
  AlterSeqStmt *newnode = makeNode(AlterSeqStmt);

  COPY_NODE_FIELD(sequence);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(for_identity);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static DefineStmt *
_copyDefineStmt(const DefineStmt *from)
{
  DefineStmt *newnode = makeNode(DefineStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_SCALAR_FIELD(oldstyle);
  COPY_NODE_FIELD(defnames);
  COPY_NODE_FIELD(args);
  COPY_NODE_FIELD(definition);
  COPY_SCALAR_FIELD(if_not_exists);
  COPY_SCALAR_FIELD(replace);

  return newnode;
}

static CreateDomainStmt *
_copyCreateDomainStmt(const CreateDomainStmt *from)
{
  CreateDomainStmt *newnode = makeNode(CreateDomainStmt);

  COPY_NODE_FIELD(domainname);
  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(collClause);
  COPY_NODE_FIELD(constraints);

  return newnode;
}

static CreateOpClassStmt *
_copyCreateOpClassStmt(const CreateOpClassStmt *from)
{
  CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);

  COPY_NODE_FIELD(opclassname);
  COPY_NODE_FIELD(opfamilyname);
  COPY_STRING_FIELD(amname);
  COPY_NODE_FIELD(datatype);
  COPY_NODE_FIELD(items);
  COPY_SCALAR_FIELD(isDefault);

  return newnode;
}

static CreateOpClassItem *
_copyCreateOpClassItem(const CreateOpClassItem *from)
{
  CreateOpClassItem *newnode = makeNode(CreateOpClassItem);

  COPY_SCALAR_FIELD(itemtype);
  COPY_NODE_FIELD(name);
  COPY_SCALAR_FIELD(number);
  COPY_NODE_FIELD(order_family);
  COPY_NODE_FIELD(class_args);
  COPY_NODE_FIELD(storedtype);

  return newnode;
}

static CreateOpFamilyStmt *
_copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from)
{
  CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);

  COPY_NODE_FIELD(opfamilyname);
  COPY_STRING_FIELD(amname);

  return newnode;
}

static AlterOpFamilyStmt *
_copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from)
{
  AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);

  COPY_NODE_FIELD(opfamilyname);
  COPY_STRING_FIELD(amname);
  COPY_SCALAR_FIELD(isDrop);
  COPY_NODE_FIELD(items);

  return newnode;
}

static DropStmt *
_copyDropStmt(const DropStmt *from)
{
  DropStmt *newnode = makeNode(DropStmt);

  COPY_NODE_FIELD(objects);
  COPY_SCALAR_FIELD(removeType);
  COPY_SCALAR_FIELD(behavior);
  COPY_SCALAR_FIELD(missing_ok);
  COPY_SCALAR_FIELD(concurrent);

  return newnode;
}

static TruncateStmt *
_copyTruncateStmt(const TruncateStmt *from)
{
  TruncateStmt *newnode = makeNode(TruncateStmt);

  COPY_NODE_FIELD(relations);
  COPY_SCALAR_FIELD(restart_seqs);
  COPY_SCALAR_FIELD(behavior);

  return newnode;
}

static CommentStmt *
_copyCommentStmt(const CommentStmt *from)
{
  CommentStmt *newnode = makeNode(CommentStmt);

  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(object);
  COPY_STRING_FIELD(comment);

  return newnode;
}

static SecLabelStmt *
_copySecLabelStmt(const SecLabelStmt *from)
{
  SecLabelStmt *newnode = makeNode(SecLabelStmt);

  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(object);
  COPY_STRING_FIELD(provider);
  COPY_STRING_FIELD(label);

  return newnode;
}

static DeclareCursorStmt *
_copyDeclareCursorStmt(const DeclareCursorStmt *from)
{
  DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);

  COPY_STRING_FIELD(portalname);
  COPY_SCALAR_FIELD(options);
  COPY_NODE_FIELD(query);

  return newnode;
}

static ClosePortalStmt *
_copyClosePortalStmt(const ClosePortalStmt *from)
{
  ClosePortalStmt *newnode = makeNode(ClosePortalStmt);

  COPY_STRING_FIELD(portalname);

  return newnode;
}

static FetchStmt *
_copyFetchStmt(const FetchStmt *from)
{
  FetchStmt *newnode = makeNode(FetchStmt);

  COPY_SCALAR_FIELD(direction);
  COPY_SCALAR_FIELD(howMany);
  COPY_STRING_FIELD(portalname);
  COPY_SCALAR_FIELD(ismove);

  return newnode;
}

static IndexStmt *
_copyIndexStmt(const IndexStmt *from)
{
  IndexStmt *newnode = makeNode(IndexStmt);

  COPY_STRING_FIELD(idxname);
  COPY_NODE_FIELD(relation);
  COPY_STRING_FIELD(accessMethod);
  COPY_STRING_FIELD(tableSpace);
  COPY_NODE_FIELD(indexParams);
  COPY_NODE_FIELD(indexIncludingParams);
  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(whereClause);
  COPY_NODE_FIELD(excludeOpNames);
  COPY_STRING_FIELD(idxcomment);
  COPY_SCALAR_FIELD(indexOid);
  COPY_SCALAR_FIELD(oldNumber);
  COPY_SCALAR_FIELD(oldCreateSubid);
  COPY_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
  COPY_SCALAR_FIELD(unique);
  COPY_SCALAR_FIELD(nulls_not_distinct);
  COPY_SCALAR_FIELD(primary);
  COPY_SCALAR_FIELD(isconstraint);
  COPY_SCALAR_FIELD(iswithoutoverlaps);
  COPY_SCALAR_FIELD(deferrable);
  COPY_SCALAR_FIELD(initdeferred);
  COPY_SCALAR_FIELD(transformed);
  COPY_SCALAR_FIELD(concurrent);
  COPY_SCALAR_FIELD(if_not_exists);
  COPY_SCALAR_FIELD(reset_default_tblspc);

  return newnode;
}

static CreateStatsStmt *
_copyCreateStatsStmt(const CreateStatsStmt *from)
{
  CreateStatsStmt *newnode = makeNode(CreateStatsStmt);

  COPY_NODE_FIELD(defnames);
  COPY_NODE_FIELD(stat_types);
  COPY_NODE_FIELD(exprs);
  COPY_NODE_FIELD(relations);
  COPY_STRING_FIELD(stxcomment);
  COPY_SCALAR_FIELD(transformed);
  COPY_SCALAR_FIELD(if_not_exists);

  return newnode;
}

static StatsElem *
_copyStatsElem(const StatsElem *from)
{
  StatsElem *newnode = makeNode(StatsElem);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(expr);

  return newnode;
}

static AlterStatsStmt *
_copyAlterStatsStmt(const AlterStatsStmt *from)
{
  AlterStatsStmt *newnode = makeNode(AlterStatsStmt);

  COPY_NODE_FIELD(defnames);
  COPY_NODE_FIELD(stxstattarget);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static CreateFunctionStmt *
_copyCreateFunctionStmt(const CreateFunctionStmt *from)
{
  CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);

  COPY_SCALAR_FIELD(is_procedure);
  COPY_SCALAR_FIELD(replace);
  COPY_NODE_FIELD(funcname);
  COPY_NODE_FIELD(parameters);
  COPY_NODE_FIELD(returnType);
  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(sql_body);

  return newnode;
}

static FunctionParameter *
_copyFunctionParameter(const FunctionParameter *from)
{
  FunctionParameter *newnode = makeNode(FunctionParameter);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(argType);
  COPY_SCALAR_FIELD(mode);
  COPY_NODE_FIELD(defexpr);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static AlterFunctionStmt *
_copyAlterFunctionStmt(const AlterFunctionStmt *from)
{
  AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);

  COPY_SCALAR_FIELD(objtype);
  COPY_NODE_FIELD(func);
  COPY_NODE_FIELD(actions);

  return newnode;
}

static DoStmt *
_copyDoStmt(const DoStmt *from)
{
  DoStmt *newnode = makeNode(DoStmt);

  COPY_NODE_FIELD(args);

  return newnode;
}

static CallStmt *
_copyCallStmt(const CallStmt *from)
{
  CallStmt *newnode = makeNode(CallStmt);

  COPY_NODE_FIELD(funccall);
  COPY_NODE_FIELD(funcexpr);
  COPY_NODE_FIELD(outargs);

  return newnode;
}

static RenameStmt *
_copyRenameStmt(const RenameStmt *from)
{
  RenameStmt *newnode = makeNode(RenameStmt);

  COPY_SCALAR_FIELD(renameType);
  COPY_SCALAR_FIELD(relationType);
  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(object);
  COPY_STRING_FIELD(subname);
  COPY_STRING_FIELD(newname);
  COPY_SCALAR_FIELD(behavior);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static AlterObjectDependsStmt *
_copyAlterObjectDependsStmt(const AlterObjectDependsStmt *from)
{
  AlterObjectDependsStmt *newnode = makeNode(AlterObjectDependsStmt);

  COPY_SCALAR_FIELD(objectType);
  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(object);
  COPY_NODE_FIELD(extname);
  COPY_SCALAR_FIELD(remove);

  return newnode;
}

static AlterObjectSchemaStmt *
_copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from)
{
  AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);

  COPY_SCALAR_FIELD(objectType);
  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(object);
  COPY_STRING_FIELD(newschema);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static AlterOwnerStmt *
_copyAlterOwnerStmt(const AlterOwnerStmt *from)
{
  AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);

  COPY_SCALAR_FIELD(objectType);
  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(object);
  COPY_NODE_FIELD(newowner);

  return newnode;
}

static AlterOperatorStmt *
_copyAlterOperatorStmt(const AlterOperatorStmt *from)
{
  AlterOperatorStmt *newnode = makeNode(AlterOperatorStmt);

  COPY_NODE_FIELD(opername);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterTypeStmt *
_copyAlterTypeStmt(const AlterTypeStmt *from)
{
  AlterTypeStmt *newnode = makeNode(AlterTypeStmt);

  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(options);

  return newnode;
}

static RuleStmt *
_copyRuleStmt(const RuleStmt *from)
{
  RuleStmt *newnode = makeNode(RuleStmt);

  COPY_NODE_FIELD(relation);
  COPY_STRING_FIELD(rulename);
  COPY_NODE_FIELD(whereClause);
  COPY_SCALAR_FIELD(event);
  COPY_SCALAR_FIELD(instead);
  COPY_NODE_FIELD(actions);
  COPY_SCALAR_FIELD(replace);

  return newnode;
}

static NotifyStmt *
_copyNotifyStmt(const NotifyStmt *from)
{
  NotifyStmt *newnode = makeNode(NotifyStmt);

  COPY_STRING_FIELD(conditionname);
  COPY_STRING_FIELD(payload);

  return newnode;
}

static ListenStmt *
_copyListenStmt(const ListenStmt *from)
{
  ListenStmt *newnode = makeNode(ListenStmt);

  COPY_STRING_FIELD(conditionname);

  return newnode;
}

static UnlistenStmt *
_copyUnlistenStmt(const UnlistenStmt *from)
{
  UnlistenStmt *newnode = makeNode(UnlistenStmt);

  COPY_STRING_FIELD(conditionname);

  return newnode;
}

static TransactionStmt *
_copyTransactionStmt(const TransactionStmt *from)
{
  TransactionStmt *newnode = makeNode(TransactionStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(options);
  COPY_STRING_FIELD(savepoint_name);
  COPY_STRING_FIELD(gid);
  COPY_SCALAR_FIELD(chain);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CompositeTypeStmt *
_copyCompositeTypeStmt(const CompositeTypeStmt *from)
{
  CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);

  COPY_NODE_FIELD(typevar);
  COPY_NODE_FIELD(coldeflist);

  return newnode;
}

static CreateEnumStmt *
_copyCreateEnumStmt(const CreateEnumStmt *from)
{
  CreateEnumStmt *newnode = makeNode(CreateEnumStmt);

  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(vals);

  return newnode;
}

static CreateRangeStmt *
_copyCreateRangeStmt(const CreateRangeStmt *from)
{
  CreateRangeStmt *newnode = makeNode(CreateRangeStmt);

  COPY_NODE_FIELD(typeName);
  COPY_NODE_FIELD(params);

  return newnode;
}

static AlterEnumStmt *
_copyAlterEnumStmt(const AlterEnumStmt *from)
{
  AlterEnumStmt *newnode = makeNode(AlterEnumStmt);

  COPY_NODE_FIELD(typeName);
  COPY_STRING_FIELD(oldVal);
  COPY_STRING_FIELD(newVal);
  COPY_STRING_FIELD(newValNeighbor);
  COPY_SCALAR_FIELD(newValIsAfter);
  COPY_SCALAR_FIELD(skipIfNewValExists);

  return newnode;
}

static ViewStmt *
_copyViewStmt(const ViewStmt *from)
{
  ViewStmt *newnode = makeNode(ViewStmt);

  COPY_NODE_FIELD(view);
  COPY_NODE_FIELD(aliases);
  COPY_NODE_FIELD(query);
  COPY_SCALAR_FIELD(replace);
  COPY_NODE_FIELD(options);
  COPY_SCALAR_FIELD(withCheckOption);

  return newnode;
}

static LoadStmt *
_copyLoadStmt(const LoadStmt *from)
{
  LoadStmt *newnode = makeNode(LoadStmt);

  COPY_STRING_FIELD(filename);

  return newnode;
}

static CreatedbStmt *
_copyCreatedbStmt(const CreatedbStmt *from)
{
  CreatedbStmt *newnode = makeNode(CreatedbStmt);

  COPY_STRING_FIELD(dbname);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterDatabaseStmt *
_copyAlterDatabaseStmt(const AlterDatabaseStmt *from)
{
  AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);

  COPY_STRING_FIELD(dbname);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterDatabaseRefreshCollStmt *
_copyAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *from)
{
  AlterDatabaseRefreshCollStmt *newnode = makeNode(AlterDatabaseRefreshCollStmt);

  COPY_STRING_FIELD(dbname);

  return newnode;
}

static AlterDatabaseSetStmt *
_copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from)
{
  AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);

  COPY_STRING_FIELD(dbname);
  COPY_NODE_FIELD(setstmt);

  return newnode;
}

static DropdbStmt *
_copyDropdbStmt(const DropdbStmt *from)
{
  DropdbStmt *newnode = makeNode(DropdbStmt);

  COPY_STRING_FIELD(dbname);
  COPY_SCALAR_FIELD(missing_ok);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterSystemStmt *
_copyAlterSystemStmt(const AlterSystemStmt *from)
{
  AlterSystemStmt *newnode = makeNode(AlterSystemStmt);

  COPY_NODE_FIELD(setstmt);

  return newnode;
}

static ClusterStmt *
_copyClusterStmt(const ClusterStmt *from)
{
  ClusterStmt *newnode = makeNode(ClusterStmt);

  COPY_NODE_FIELD(relation);
  COPY_STRING_FIELD(indexname);
  COPY_NODE_FIELD(params);

  return newnode;
}

static VacuumStmt *
_copyVacuumStmt(const VacuumStmt *from)
{
  VacuumStmt *newnode = makeNode(VacuumStmt);

  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(rels);
  COPY_SCALAR_FIELD(is_vacuumcmd);

  return newnode;
}

static VacuumRelation *
_copyVacuumRelation(const VacuumRelation *from)
{
  VacuumRelation *newnode = makeNode(VacuumRelation);

  COPY_NODE_FIELD(relation);
  COPY_SCALAR_FIELD(oid);
  COPY_NODE_FIELD(va_cols);

  return newnode;
}

static ExplainStmt *
_copyExplainStmt(const ExplainStmt *from)
{
  ExplainStmt *newnode = makeNode(ExplainStmt);

  COPY_NODE_FIELD(query);
  COPY_NODE_FIELD(options);

  return newnode;
}

static CreateTableAsStmt *
_copyCreateTableAsStmt(const CreateTableAsStmt *from)
{
  CreateTableAsStmt *newnode = makeNode(CreateTableAsStmt);

  COPY_NODE_FIELD(query);
  COPY_NODE_FIELD(into);
  COPY_SCALAR_FIELD(objtype);
  COPY_SCALAR_FIELD(is_select_into);
  COPY_SCALAR_FIELD(if_not_exists);

  return newnode;
}

static RefreshMatViewStmt *
_copyRefreshMatViewStmt(const RefreshMatViewStmt *from)
{
  RefreshMatViewStmt *newnode = makeNode(RefreshMatViewStmt);

  COPY_SCALAR_FIELD(concurrent);
  COPY_SCALAR_FIELD(skipData);
  COPY_NODE_FIELD(relation);

  return newnode;
}

static CheckPointStmt *
_copyCheckPointStmt(const CheckPointStmt *from)
{
  CheckPointStmt *newnode = makeNode(CheckPointStmt);


  return newnode;
}

static DiscardStmt *
_copyDiscardStmt(const DiscardStmt *from)
{
  DiscardStmt *newnode = makeNode(DiscardStmt);

  COPY_SCALAR_FIELD(target);

  return newnode;
}

static LockStmt *
_copyLockStmt(const LockStmt *from)
{
  LockStmt *newnode = makeNode(LockStmt);

  COPY_NODE_FIELD(relations);
  COPY_SCALAR_FIELD(mode);
  COPY_SCALAR_FIELD(nowait);

  return newnode;
}

static ConstraintsSetStmt *
_copyConstraintsSetStmt(const ConstraintsSetStmt *from)
{
  ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);

  COPY_NODE_FIELD(constraints);
  COPY_SCALAR_FIELD(deferred);

  return newnode;
}

static ReindexStmt *
_copyReindexStmt(const ReindexStmt *from)
{
  ReindexStmt *newnode = makeNode(ReindexStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(relation);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(params);

  return newnode;
}

static CreateConversionStmt *
_copyCreateConversionStmt(const CreateConversionStmt *from)
{
  CreateConversionStmt *newnode = makeNode(CreateConversionStmt);

  COPY_NODE_FIELD(conversion_name);
  COPY_STRING_FIELD(for_encoding_name);
  COPY_STRING_FIELD(to_encoding_name);
  COPY_NODE_FIELD(func_name);
  COPY_SCALAR_FIELD(def);

  return newnode;
}

static CreateCastStmt *
_copyCreateCastStmt(const CreateCastStmt *from)
{
  CreateCastStmt *newnode = makeNode(CreateCastStmt);

  COPY_NODE_FIELD(sourcetype);
  COPY_NODE_FIELD(targettype);
  COPY_NODE_FIELD(func);
  COPY_SCALAR_FIELD(context);
  COPY_SCALAR_FIELD(inout);

  return newnode;
}

static CreateTransformStmt *
_copyCreateTransformStmt(const CreateTransformStmt *from)
{
  CreateTransformStmt *newnode = makeNode(CreateTransformStmt);

  COPY_SCALAR_FIELD(replace);
  COPY_NODE_FIELD(type_name);
  COPY_STRING_FIELD(lang);
  COPY_NODE_FIELD(fromsql);
  COPY_NODE_FIELD(tosql);

  return newnode;
}

static PrepareStmt *
_copyPrepareStmt(const PrepareStmt *from)
{
  PrepareStmt *newnode = makeNode(PrepareStmt);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(argtypes);
  COPY_NODE_FIELD(query);

  return newnode;
}

static ExecuteStmt *
_copyExecuteStmt(const ExecuteStmt *from)
{
  ExecuteStmt *newnode = makeNode(ExecuteStmt);

  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(params);

  return newnode;
}

static DeallocateStmt *
_copyDeallocateStmt(const DeallocateStmt *from)
{
  DeallocateStmt *newnode = makeNode(DeallocateStmt);

  COPY_STRING_FIELD(name);
  COPY_SCALAR_FIELD(isall);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static DropOwnedStmt *
_copyDropOwnedStmt(const DropOwnedStmt *from)
{
  DropOwnedStmt *newnode = makeNode(DropOwnedStmt);

  COPY_NODE_FIELD(roles);
  COPY_SCALAR_FIELD(behavior);

  return newnode;
}

static ReassignOwnedStmt *
_copyReassignOwnedStmt(const ReassignOwnedStmt *from)
{
  ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);

  COPY_NODE_FIELD(roles);
  COPY_NODE_FIELD(newrole);

  return newnode;
}

static AlterTSDictionaryStmt *
_copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from)
{
  AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);

  COPY_NODE_FIELD(dictname);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterTSConfigurationStmt *
_copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from)
{
  AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_NODE_FIELD(cfgname);
  COPY_NODE_FIELD(tokentype);
  COPY_NODE_FIELD(dicts);
  COPY_SCALAR_FIELD(override);
  COPY_SCALAR_FIELD(replace);
  COPY_SCALAR_FIELD(missing_ok);

  return newnode;
}

static PublicationTable *
_copyPublicationTable(const PublicationTable *from)
{
  PublicationTable *newnode = makeNode(PublicationTable);

  COPY_NODE_FIELD(relation);
  COPY_NODE_FIELD(whereClause);
  COPY_NODE_FIELD(columns);

  return newnode;
}

static PublicationObjSpec *
_copyPublicationObjSpec(const PublicationObjSpec *from)
{
  PublicationObjSpec *newnode = makeNode(PublicationObjSpec);

  COPY_SCALAR_FIELD(pubobjtype);
  COPY_STRING_FIELD(name);
  COPY_NODE_FIELD(pubtable);
  COPY_LOCATION_FIELD(location);

  return newnode;
}

static CreatePublicationStmt *
_copyCreatePublicationStmt(const CreatePublicationStmt *from)
{
  CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);

  COPY_STRING_FIELD(pubname);
  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(pubobjects);
  COPY_SCALAR_FIELD(for_all_tables);

  return newnode;
}

static AlterPublicationStmt *
_copyAlterPublicationStmt(const AlterPublicationStmt *from)
{
  AlterPublicationStmt *newnode = makeNode(AlterPublicationStmt);

  COPY_STRING_FIELD(pubname);
  COPY_NODE_FIELD(options);
  COPY_NODE_FIELD(pubobjects);
  COPY_SCALAR_FIELD(for_all_tables);
  COPY_SCALAR_FIELD(action);

  return newnode;
}

static CreateSubscriptionStmt *
_copyCreateSubscriptionStmt(const CreateSubscriptionStmt *from)
{
  CreateSubscriptionStmt *newnode = makeNode(CreateSubscriptionStmt);

  COPY_STRING_FIELD(subname);
  COPY_STRING_FIELD(conninfo);
  COPY_NODE_FIELD(publication);
  COPY_NODE_FIELD(options);

  return newnode;
}

static AlterSubscriptionStmt *
_copyAlterSubscriptionStmt(const AlterSubscriptionStmt *from)
{
  AlterSubscriptionStmt *newnode = makeNode(AlterSubscriptionStmt);

  COPY_SCALAR_FIELD(kind);
  COPY_STRING_FIELD(subname);
  COPY_STRING_FIELD(conninfo);
  COPY_NODE_FIELD(publication);
  COPY_NODE_FIELD(options);

  return newnode;
}

static DropSubscriptionStmt *
_copyDropSubscriptionStmt(const DropSubscriptionStmt *from)
{
  DropSubscriptionStmt *newnode = makeNode(DropSubscriptionStmt);

  COPY_STRING_FIELD(subname);
  COPY_SCALAR_FIELD(missing_ok);
  COPY_SCALAR_FIELD(behavior);

  return newnode;
}

static PathKey *
_copyPathKey(const PathKey *from)
{
  PathKey *newnode = makeNode(PathKey);

  COPY_SCALAR_FIELD(pk_eclass);
  COPY_SCALAR_FIELD(pk_opfamily);
  COPY_SCALAR_FIELD(pk_cmptype);
  COPY_SCALAR_FIELD(pk_nulls_first);

  return newnode;
}

static GroupByOrdering *
_copyGroupByOrdering(const GroupByOrdering *from)
{
  GroupByOrdering *newnode = makeNode(GroupByOrdering);

  COPY_NODE_FIELD(pathkeys);
  COPY_NODE_FIELD(clauses);

  return newnode;
}

static RestrictInfo *
_copyRestrictInfo(const RestrictInfo *from)
{
  RestrictInfo *newnode = makeNode(RestrictInfo);

  COPY_NODE_FIELD(clause);
  COPY_SCALAR_FIELD(is_pushed_down);
  COPY_SCALAR_FIELD(can_join);
  COPY_SCALAR_FIELD(pseudoconstant);
  COPY_SCALAR_FIELD(has_clone);
  COPY_SCALAR_FIELD(is_clone);
  COPY_SCALAR_FIELD(leakproof);
  COPY_SCALAR_FIELD(has_volatile);
  COPY_SCALAR_FIELD(security_level);
  COPY_SCALAR_FIELD(num_base_rels);
  COPY_BITMAPSET_FIELD(clause_relids);
  COPY_BITMAPSET_FIELD(required_relids);
  COPY_BITMAPSET_FIELD(incompatible_relids);
  COPY_BITMAPSET_FIELD(outer_relids);
  COPY_BITMAPSET_FIELD(left_relids);
  COPY_BITMAPSET_FIELD(right_relids);
  COPY_NODE_FIELD(orclause);
  COPY_SCALAR_FIELD(rinfo_serial);
  COPY_SCALAR_FIELD(parent_ec);
  COPY_SCALAR_FIELD(eval_cost);
  COPY_SCALAR_FIELD(norm_selec);
  COPY_SCALAR_FIELD(outer_selec);
  COPY_NODE_FIELD(mergeopfamilies);
  COPY_SCALAR_FIELD(left_ec);
  COPY_SCALAR_FIELD(right_ec);
  COPY_SCALAR_FIELD(left_em);
  COPY_SCALAR_FIELD(right_em);
  newnode->scansel_cache = NIL;
  COPY_SCALAR_FIELD(outer_is_left);
  COPY_SCALAR_FIELD(hashjoinoperator);
  COPY_SCALAR_FIELD(left_bucketsize);
  COPY_SCALAR_FIELD(right_bucketsize);
  COPY_SCALAR_FIELD(left_mcvfreq);
  COPY_SCALAR_FIELD(right_mcvfreq);
  COPY_SCALAR_FIELD(left_hasheqoperator);
  COPY_SCALAR_FIELD(right_hasheqoperator);

  return newnode;
}

static PlaceHolderVar *
_copyPlaceHolderVar(const PlaceHolderVar *from)
{
  PlaceHolderVar *newnode = makeNode(PlaceHolderVar);

  COPY_NODE_FIELD(phexpr);
  COPY_BITMAPSET_FIELD(phrels);
  COPY_BITMAPSET_FIELD(phnullingrels);
  COPY_SCALAR_FIELD(phid);
  COPY_SCALAR_FIELD(phlevelsup);

  return newnode;
}

static SpecialJoinInfo *
_copySpecialJoinInfo(const SpecialJoinInfo *from)
{
  SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);

  COPY_BITMAPSET_FIELD(min_lefthand);
  COPY_BITMAPSET_FIELD(min_righthand);
  COPY_BITMAPSET_FIELD(syn_lefthand);
  COPY_BITMAPSET_FIELD(syn_righthand);
  COPY_SCALAR_FIELD(jointype);
  COPY_SCALAR_FIELD(ojrelid);
  COPY_BITMAPSET_FIELD(commute_above_l);
  COPY_BITMAPSET_FIELD(commute_above_r);
  COPY_BITMAPSET_FIELD(commute_below_l);
  COPY_BITMAPSET_FIELD(commute_below_r);
  COPY_SCALAR_FIELD(lhs_strict);
  COPY_SCALAR_FIELD(semi_can_btree);
  COPY_SCALAR_FIELD(semi_can_hash);
  COPY_NODE_FIELD(semi_operators);
  COPY_NODE_FIELD(semi_rhs_exprs);

  return newnode;
}

static AppendRelInfo *
_copyAppendRelInfo(const AppendRelInfo *from)
{
  AppendRelInfo *newnode = makeNode(AppendRelInfo);

  COPY_SCALAR_FIELD(parent_relid);
  COPY_SCALAR_FIELD(child_relid);
  COPY_SCALAR_FIELD(parent_reltype);
  COPY_SCALAR_FIELD(child_reltype);
  COPY_NODE_FIELD(translated_vars);
  COPY_SCALAR_FIELD(num_child_cols);
  COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber));
  COPY_SCALAR_FIELD(parent_reloid);

  return newnode;
}

static PlaceHolderInfo *
_copyPlaceHolderInfo(const PlaceHolderInfo *from)
{
  PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);

  COPY_SCALAR_FIELD(phid);
  COPY_NODE_FIELD(ph_var);
  COPY_BITMAPSET_FIELD(ph_eval_at);
  COPY_BITMAPSET_FIELD(ph_lateral);
  COPY_BITMAPSET_FIELD(ph_needed);
  COPY_SCALAR_FIELD(ph_width);

  return newnode;
}

static PlannedStmt *
_copyPlannedStmt(const PlannedStmt *from)
{
  PlannedStmt *newnode = makeNode(PlannedStmt);

  COPY_SCALAR_FIELD(commandType);
  COPY_SCALAR_FIELD(queryId);
  COPY_SCALAR_FIELD(planId);
  COPY_SCALAR_FIELD(hasReturning);
  COPY_SCALAR_FIELD(hasModifyingCTE);
  COPY_SCALAR_FIELD(canSetTag);
  COPY_SCALAR_FIELD(transientPlan);
  COPY_SCALAR_FIELD(dependsOnRole);
  COPY_SCALAR_FIELD(parallelModeNeeded);
  COPY_SCALAR_FIELD(jitFlags);
  COPY_NODE_FIELD(planTree);
  COPY_NODE_FIELD(partPruneInfos);
  COPY_NODE_FIELD(rtable);
  COPY_BITMAPSET_FIELD(unprunableRelids);
  COPY_NODE_FIELD(permInfos);
  COPY_NODE_FIELD(resultRelations);
  COPY_NODE_FIELD(appendRelations);
  COPY_NODE_FIELD(subplans);
  COPY_BITMAPSET_FIELD(rewindPlanIDs);
  COPY_NODE_FIELD(rowMarks);
  COPY_NODE_FIELD(relationOids);
  COPY_NODE_FIELD(invalItems);
  COPY_NODE_FIELD(paramExecTypes);
  COPY_NODE_FIELD(utilityStmt);
  COPY_LOCATION_FIELD(stmt_location);
  COPY_LOCATION_FIELD(stmt_len);

  return newnode;
}

static Result *
_copyResult(const Result *from)
{
  Result *newnode = makeNode(Result);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_NODE_FIELD(resconstantqual);

  return newnode;
}

static ProjectSet *
_copyProjectSet(const ProjectSet *from)
{
  ProjectSet *newnode = makeNode(ProjectSet);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);

  return newnode;
}

static ModifyTable *
_copyModifyTable(const ModifyTable *from)
{
  ModifyTable *newnode = makeNode(ModifyTable);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(operation);
  COPY_SCALAR_FIELD(canSetTag);
  COPY_SCALAR_FIELD(nominalRelation);
  COPY_SCALAR_FIELD(rootRelation);
  COPY_SCALAR_FIELD(partColsUpdated);
  COPY_NODE_FIELD(resultRelations);
  COPY_NODE_FIELD(updateColnosLists);
  COPY_NODE_FIELD(withCheckOptionLists);
  COPY_STRING_FIELD(returningOldAlias);
  COPY_STRING_FIELD(returningNewAlias);
  COPY_NODE_FIELD(returningLists);
  COPY_NODE_FIELD(fdwPrivLists);
  COPY_BITMAPSET_FIELD(fdwDirectModifyPlans);
  COPY_NODE_FIELD(rowMarks);
  COPY_SCALAR_FIELD(epqParam);
  COPY_SCALAR_FIELD(onConflictAction);
  COPY_NODE_FIELD(arbiterIndexes);
  COPY_NODE_FIELD(onConflictSet);
  COPY_NODE_FIELD(onConflictCols);
  COPY_NODE_FIELD(onConflictWhere);
  COPY_SCALAR_FIELD(exclRelRTI);
  COPY_NODE_FIELD(exclRelTlist);
  COPY_NODE_FIELD(mergeActionLists);
  COPY_NODE_FIELD(mergeJoinConditions);

  return newnode;
}

static Append *
_copyAppend(const Append *from)
{
  Append *newnode = makeNode(Append);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_BITMAPSET_FIELD(apprelids);
  COPY_NODE_FIELD(appendplans);
  COPY_SCALAR_FIELD(nasyncplans);
  COPY_SCALAR_FIELD(first_partial_plan);
  COPY_SCALAR_FIELD(part_prune_index);

  return newnode;
}

static MergeAppend *
_copyMergeAppend(const MergeAppend *from)
{
  MergeAppend *newnode = makeNode(MergeAppend);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_BITMAPSET_FIELD(apprelids);
  COPY_NODE_FIELD(mergeplans);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
  COPY_SCALAR_FIELD(part_prune_index);

  return newnode;
}

static RecursiveUnion *
_copyRecursiveUnion(const RecursiveUnion *from)
{
  RecursiveUnion *newnode = makeNode(RecursiveUnion);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(wtParam);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
  COPY_SCALAR_FIELD(numGroups);

  return newnode;
}

static BitmapAnd *
_copyBitmapAnd(const BitmapAnd *from)
{
  BitmapAnd *newnode = makeNode(BitmapAnd);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_NODE_FIELD(bitmapplans);

  return newnode;
}

static BitmapOr *
_copyBitmapOr(const BitmapOr *from)
{
  BitmapOr *newnode = makeNode(BitmapOr);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(isshared);
  COPY_NODE_FIELD(bitmapplans);

  return newnode;
}

static SeqScan *
_copySeqScan(const SeqScan *from)
{
  SeqScan *newnode = makeNode(SeqScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);

  return newnode;
}

static SampleScan *
_copySampleScan(const SampleScan *from)
{
  SampleScan *newnode = makeNode(SampleScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(tablesample);

  return newnode;
}

static IndexScan *
_copyIndexScan(const IndexScan *from)
{
  IndexScan *newnode = makeNode(IndexScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(indexid);
  COPY_NODE_FIELD(indexqual);
  COPY_NODE_FIELD(indexqualorig);
  COPY_NODE_FIELD(indexorderby);
  COPY_NODE_FIELD(indexorderbyorig);
  COPY_NODE_FIELD(indexorderbyops);
  COPY_SCALAR_FIELD(indexorderdir);

  return newnode;
}

static IndexOnlyScan *
_copyIndexOnlyScan(const IndexOnlyScan *from)
{
  IndexOnlyScan *newnode = makeNode(IndexOnlyScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(indexid);
  COPY_NODE_FIELD(indexqual);
  COPY_NODE_FIELD(recheckqual);
  COPY_NODE_FIELD(indexorderby);
  COPY_NODE_FIELD(indextlist);
  COPY_SCALAR_FIELD(indexorderdir);

  return newnode;
}

static BitmapIndexScan *
_copyBitmapIndexScan(const BitmapIndexScan *from)
{
  BitmapIndexScan *newnode = makeNode(BitmapIndexScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(indexid);
  COPY_SCALAR_FIELD(isshared);
  COPY_NODE_FIELD(indexqual);
  COPY_NODE_FIELD(indexqualorig);

  return newnode;
}

static BitmapHeapScan *
_copyBitmapHeapScan(const BitmapHeapScan *from)
{
  BitmapHeapScan *newnode = makeNode(BitmapHeapScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(bitmapqualorig);

  return newnode;
}

static TidScan *
_copyTidScan(const TidScan *from)
{
  TidScan *newnode = makeNode(TidScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(tidquals);

  return newnode;
}

static TidRangeScan *
_copyTidRangeScan(const TidRangeScan *from)
{
  TidRangeScan *newnode = makeNode(TidRangeScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(tidrangequals);

  return newnode;
}

static SubqueryScan *
_copySubqueryScan(const SubqueryScan *from)
{
  SubqueryScan *newnode = makeNode(SubqueryScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(subplan);
  COPY_SCALAR_FIELD(scanstatus);

  return newnode;
}

static FunctionScan *
_copyFunctionScan(const FunctionScan *from)
{
  FunctionScan *newnode = makeNode(FunctionScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(functions);
  COPY_SCALAR_FIELD(funcordinality);

  return newnode;
}

static ValuesScan *
_copyValuesScan(const ValuesScan *from)
{
  ValuesScan *newnode = makeNode(ValuesScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(values_lists);

  return newnode;
}

static TableFuncScan *
_copyTableFuncScan(const TableFuncScan *from)
{
  TableFuncScan *newnode = makeNode(TableFuncScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_NODE_FIELD(tablefunc);

  return newnode;
}

static CteScan *
_copyCteScan(const CteScan *from)
{
  CteScan *newnode = makeNode(CteScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(ctePlanId);
  COPY_SCALAR_FIELD(cteParam);

  return newnode;
}

static NamedTuplestoreScan *
_copyNamedTuplestoreScan(const NamedTuplestoreScan *from)
{
  NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_STRING_FIELD(enrname);

  return newnode;
}

static WorkTableScan *
_copyWorkTableScan(const WorkTableScan *from)
{
  WorkTableScan *newnode = makeNode(WorkTableScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(wtParam);

  return newnode;
}

static ForeignScan *
_copyForeignScan(const ForeignScan *from)
{
  ForeignScan *newnode = makeNode(ForeignScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(operation);
  COPY_SCALAR_FIELD(resultRelation);
  COPY_SCALAR_FIELD(checkAsUser);
  COPY_SCALAR_FIELD(fs_server);
  COPY_NODE_FIELD(fdw_exprs);
  COPY_NODE_FIELD(fdw_private);
  COPY_NODE_FIELD(fdw_scan_tlist);
  COPY_NODE_FIELD(fdw_recheck_quals);
  COPY_BITMAPSET_FIELD(fs_relids);
  COPY_BITMAPSET_FIELD(fs_base_relids);
  COPY_SCALAR_FIELD(fsSystemCol);

  return newnode;
}

static CustomScan *
_copyCustomScan(const CustomScan *from)
{
  CustomScan *newnode = makeNode(CustomScan);

  COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
  COPY_SCALAR_FIELD(scan.plan.startup_cost);
  COPY_SCALAR_FIELD(scan.plan.total_cost);
  COPY_SCALAR_FIELD(scan.plan.plan_rows);
  COPY_SCALAR_FIELD(scan.plan.plan_width);
  COPY_SCALAR_FIELD(scan.plan.parallel_aware);
  COPY_SCALAR_FIELD(scan.plan.parallel_safe);
  COPY_SCALAR_FIELD(scan.plan.async_capable);
  COPY_SCALAR_FIELD(scan.plan.plan_node_id);
  COPY_NODE_FIELD(scan.plan.targetlist);
  COPY_NODE_FIELD(scan.plan.qual);
  COPY_NODE_FIELD(scan.plan.lefttree);
  COPY_NODE_FIELD(scan.plan.righttree);
  COPY_NODE_FIELD(scan.plan.initPlan);
  COPY_BITMAPSET_FIELD(scan.plan.extParam);
  COPY_BITMAPSET_FIELD(scan.plan.allParam);
  COPY_SCALAR_FIELD(scan.scanrelid);
  COPY_SCALAR_FIELD(flags);
  COPY_NODE_FIELD(custom_plans);
  COPY_NODE_FIELD(custom_exprs);
  COPY_NODE_FIELD(custom_private);
  COPY_NODE_FIELD(custom_scan_tlist);
  COPY_BITMAPSET_FIELD(custom_relids);
  COPY_SCALAR_FIELD(methods);

  return newnode;
}

static NestLoop *
_copyNestLoop(const NestLoop *from)
{
  NestLoop *newnode = makeNode(NestLoop);

  COPY_SCALAR_FIELD(join.plan.disabled_nodes);
  COPY_SCALAR_FIELD(join.plan.startup_cost);
  COPY_SCALAR_FIELD(join.plan.total_cost);
  COPY_SCALAR_FIELD(join.plan.plan_rows);
  COPY_SCALAR_FIELD(join.plan.plan_width);
  COPY_SCALAR_FIELD(join.plan.parallel_aware);
  COPY_SCALAR_FIELD(join.plan.parallel_safe);
  COPY_SCALAR_FIELD(join.plan.async_capable);
  COPY_SCALAR_FIELD(join.plan.plan_node_id);
  COPY_NODE_FIELD(join.plan.targetlist);
  COPY_NODE_FIELD(join.plan.qual);
  COPY_NODE_FIELD(join.plan.lefttree);
  COPY_NODE_FIELD(join.plan.righttree);
  COPY_NODE_FIELD(join.plan.initPlan);
  COPY_BITMAPSET_FIELD(join.plan.extParam);
  COPY_BITMAPSET_FIELD(join.plan.allParam);
  COPY_SCALAR_FIELD(join.jointype);
  COPY_SCALAR_FIELD(join.inner_unique);
  COPY_NODE_FIELD(join.joinqual);
  COPY_NODE_FIELD(nestParams);

  return newnode;
}

static NestLoopParam *
_copyNestLoopParam(const NestLoopParam *from)
{
  NestLoopParam *newnode = makeNode(NestLoopParam);

  COPY_SCALAR_FIELD(paramno);
  COPY_NODE_FIELD(paramval);

  return newnode;
}

static MergeJoin *
_copyMergeJoin(const MergeJoin *from)
{
  MergeJoin *newnode = makeNode(MergeJoin);

  COPY_SCALAR_FIELD(join.plan.disabled_nodes);
  COPY_SCALAR_FIELD(join.plan.startup_cost);
  COPY_SCALAR_FIELD(join.plan.total_cost);
  COPY_SCALAR_FIELD(join.plan.plan_rows);
  COPY_SCALAR_FIELD(join.plan.plan_width);
  COPY_SCALAR_FIELD(join.plan.parallel_aware);
  COPY_SCALAR_FIELD(join.plan.parallel_safe);
  COPY_SCALAR_FIELD(join.plan.async_capable);
  COPY_SCALAR_FIELD(join.plan.plan_node_id);
  COPY_NODE_FIELD(join.plan.targetlist);
  COPY_NODE_FIELD(join.plan.qual);
  COPY_NODE_FIELD(join.plan.lefttree);
  COPY_NODE_FIELD(join.plan.righttree);
  COPY_NODE_FIELD(join.plan.initPlan);
  COPY_BITMAPSET_FIELD(join.plan.extParam);
  COPY_BITMAPSET_FIELD(join.plan.allParam);
  COPY_SCALAR_FIELD(join.jointype);
  COPY_SCALAR_FIELD(join.inner_unique);
  COPY_NODE_FIELD(join.joinqual);
  COPY_SCALAR_FIELD(skip_mark_restore);
  COPY_NODE_FIELD(mergeclauses);
  COPY_POINTER_FIELD(mergeFamilies, list_length(from->mergeclauses) * sizeof(Oid));
  COPY_POINTER_FIELD(mergeCollations, list_length(from->mergeclauses) * sizeof(Oid));
  COPY_POINTER_FIELD(mergeReversals, list_length(from->mergeclauses) * sizeof(bool));
  COPY_POINTER_FIELD(mergeNullsFirst, list_length(from->mergeclauses) * sizeof(bool));

  return newnode;
}

static HashJoin *
_copyHashJoin(const HashJoin *from)
{
  HashJoin *newnode = makeNode(HashJoin);

  COPY_SCALAR_FIELD(join.plan.disabled_nodes);
  COPY_SCALAR_FIELD(join.plan.startup_cost);
  COPY_SCALAR_FIELD(join.plan.total_cost);
  COPY_SCALAR_FIELD(join.plan.plan_rows);
  COPY_SCALAR_FIELD(join.plan.plan_width);
  COPY_SCALAR_FIELD(join.plan.parallel_aware);
  COPY_SCALAR_FIELD(join.plan.parallel_safe);
  COPY_SCALAR_FIELD(join.plan.async_capable);
  COPY_SCALAR_FIELD(join.plan.plan_node_id);
  COPY_NODE_FIELD(join.plan.targetlist);
  COPY_NODE_FIELD(join.plan.qual);
  COPY_NODE_FIELD(join.plan.lefttree);
  COPY_NODE_FIELD(join.plan.righttree);
  COPY_NODE_FIELD(join.plan.initPlan);
  COPY_BITMAPSET_FIELD(join.plan.extParam);
  COPY_BITMAPSET_FIELD(join.plan.allParam);
  COPY_SCALAR_FIELD(join.jointype);
  COPY_SCALAR_FIELD(join.inner_unique);
  COPY_NODE_FIELD(join.joinqual);
  COPY_NODE_FIELD(hashclauses);
  COPY_NODE_FIELD(hashoperators);
  COPY_NODE_FIELD(hashcollations);
  COPY_NODE_FIELD(hashkeys);

  return newnode;
}

static Material *
_copyMaterial(const Material *from)
{
  Material *newnode = makeNode(Material);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);

  return newnode;
}

static Memoize *
_copyMemoize(const Memoize *from)
{
  Memoize *newnode = makeNode(Memoize);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(numKeys);
  COPY_POINTER_FIELD(hashOperators, from->numKeys * sizeof(Oid));
  COPY_POINTER_FIELD(collations, from->numKeys * sizeof(Oid));
  COPY_NODE_FIELD(param_exprs);
  COPY_SCALAR_FIELD(singlerow);
  COPY_SCALAR_FIELD(binary_mode);
  COPY_SCALAR_FIELD(est_entries);
  COPY_BITMAPSET_FIELD(keyparamids);

  return newnode;
}

static Sort *
_copySort(const Sort *from)
{
  Sort *newnode = makeNode(Sort);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));

  return newnode;
}

static IncrementalSort *
_copyIncrementalSort(const IncrementalSort *from)
{
  IncrementalSort *newnode = makeNode(IncrementalSort);

  COPY_SCALAR_FIELD(sort.plan.disabled_nodes);
  COPY_SCALAR_FIELD(sort.plan.startup_cost);
  COPY_SCALAR_FIELD(sort.plan.total_cost);
  COPY_SCALAR_FIELD(sort.plan.plan_rows);
  COPY_SCALAR_FIELD(sort.plan.plan_width);
  COPY_SCALAR_FIELD(sort.plan.parallel_aware);
  COPY_SCALAR_FIELD(sort.plan.parallel_safe);
  COPY_SCALAR_FIELD(sort.plan.async_capable);
  COPY_SCALAR_FIELD(sort.plan.plan_node_id);
  COPY_NODE_FIELD(sort.plan.targetlist);
  COPY_NODE_FIELD(sort.plan.qual);
  COPY_NODE_FIELD(sort.plan.lefttree);
  COPY_NODE_FIELD(sort.plan.righttree);
  COPY_NODE_FIELD(sort.plan.initPlan);
  COPY_BITMAPSET_FIELD(sort.plan.extParam);
  COPY_BITMAPSET_FIELD(sort.plan.allParam);
  COPY_SCALAR_FIELD(sort.numCols);
  COPY_POINTER_FIELD(sort.sortColIdx, from->sort.numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(sort.sortOperators, from->sort.numCols * sizeof(Oid));
  COPY_POINTER_FIELD(sort.collations, from->sort.numCols * sizeof(Oid));
  COPY_POINTER_FIELD(sort.nullsFirst, from->sort.numCols * sizeof(bool));
  COPY_SCALAR_FIELD(nPresortedCols);

  return newnode;
}

static Group *
_copyGroup(const Group *from)
{
  Group *newnode = makeNode(Group);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));

  return newnode;
}

static Agg *
_copyAgg(const Agg *from)
{
  Agg *newnode = makeNode(Agg);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(aggstrategy);
  COPY_SCALAR_FIELD(aggsplit);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
  COPY_SCALAR_FIELD(numGroups);
  COPY_SCALAR_FIELD(transitionSpace);
  COPY_BITMAPSET_FIELD(aggParams);
  COPY_NODE_FIELD(groupingSets);
  COPY_NODE_FIELD(chain);

  return newnode;
}

static WindowAgg *
_copyWindowAgg(const WindowAgg *from)
{
  WindowAgg *newnode = makeNode(WindowAgg);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_STRING_FIELD(winname);
  COPY_SCALAR_FIELD(winref);
  COPY_SCALAR_FIELD(partNumCols);
  COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
  COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
  COPY_SCALAR_FIELD(ordNumCols);
  COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
  COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
  COPY_SCALAR_FIELD(frameOptions);
  COPY_NODE_FIELD(startOffset);
  COPY_NODE_FIELD(endOffset);
  COPY_NODE_FIELD(runCondition);
  COPY_NODE_FIELD(runConditionOrig);
  COPY_SCALAR_FIELD(startInRangeFunc);
  COPY_SCALAR_FIELD(endInRangeFunc);
  COPY_SCALAR_FIELD(inRangeColl);
  COPY_SCALAR_FIELD(inRangeAsc);
  COPY_SCALAR_FIELD(inRangeNullsFirst);
  COPY_SCALAR_FIELD(topWindow);

  return newnode;
}

static Unique *
_copyUnique(const Unique *from)
{
  Unique *newnode = makeNode(Unique);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(uniqCollations, from->numCols * sizeof(Oid));

  return newnode;
}

static Gather *
_copyGather(const Gather *from)
{
  Gather *newnode = makeNode(Gather);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(num_workers);
  COPY_SCALAR_FIELD(rescan_param);
  COPY_SCALAR_FIELD(single_copy);
  COPY_SCALAR_FIELD(invisible);
  COPY_BITMAPSET_FIELD(initParam);

  return newnode;
}

static GatherMerge *
_copyGatherMerge(const GatherMerge *from)
{
  GatherMerge *newnode = makeNode(GatherMerge);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(num_workers);
  COPY_SCALAR_FIELD(rescan_param);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
  COPY_BITMAPSET_FIELD(initParam);

  return newnode;
}

static Hash *
_copyHash(const Hash *from)
{
  Hash *newnode = makeNode(Hash);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_NODE_FIELD(hashkeys);
  COPY_SCALAR_FIELD(skewTable);
  COPY_SCALAR_FIELD(skewColumn);
  COPY_SCALAR_FIELD(skewInherit);
  COPY_SCALAR_FIELD(rows_total);

  return newnode;
}

static SetOp *
_copySetOp(const SetOp *from)
{
  SetOp *newnode = makeNode(SetOp);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_SCALAR_FIELD(cmd);
  COPY_SCALAR_FIELD(strategy);
  COPY_SCALAR_FIELD(numCols);
  COPY_POINTER_FIELD(cmpColIdx, from->numCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(cmpOperators, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(cmpCollations, from->numCols * sizeof(Oid));
  COPY_POINTER_FIELD(cmpNullsFirst, from->numCols * sizeof(bool));
  COPY_SCALAR_FIELD(numGroups);

  return newnode;
}

static LockRows *
_copyLockRows(const LockRows *from)
{
  LockRows *newnode = makeNode(LockRows);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_NODE_FIELD(rowMarks);
  COPY_SCALAR_FIELD(epqParam);

  return newnode;
}

static Limit *
_copyLimit(const Limit *from)
{
  Limit *newnode = makeNode(Limit);

  COPY_SCALAR_FIELD(plan.disabled_nodes);
  COPY_SCALAR_FIELD(plan.startup_cost);
  COPY_SCALAR_FIELD(plan.total_cost);
  COPY_SCALAR_FIELD(plan.plan_rows);
  COPY_SCALAR_FIELD(plan.plan_width);
  COPY_SCALAR_FIELD(plan.parallel_aware);
  COPY_SCALAR_FIELD(plan.parallel_safe);
  COPY_SCALAR_FIELD(plan.async_capable);
  COPY_SCALAR_FIELD(plan.plan_node_id);
  COPY_NODE_FIELD(plan.targetlist);
  COPY_NODE_FIELD(plan.qual);
  COPY_NODE_FIELD(plan.lefttree);
  COPY_NODE_FIELD(plan.righttree);
  COPY_NODE_FIELD(plan.initPlan);
  COPY_BITMAPSET_FIELD(plan.extParam);
  COPY_BITMAPSET_FIELD(plan.allParam);
  COPY_NODE_FIELD(limitOffset);
  COPY_NODE_FIELD(limitCount);
  COPY_SCALAR_FIELD(limitOption);
  COPY_SCALAR_FIELD(uniqNumCols);
  COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber));
  COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid));
  COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid));

  return newnode;
}

static PlanRowMark *
_copyPlanRowMark(const PlanRowMark *from)
{
  PlanRowMark *newnode = makeNode(PlanRowMark);

  COPY_SCALAR_FIELD(rti);
  COPY_SCALAR_FIELD(prti);
  COPY_SCALAR_FIELD(rowmarkId);
  COPY_SCALAR_FIELD(markType);
  COPY_SCALAR_FIELD(allMarkTypes);
  COPY_SCALAR_FIELD(strength);
  COPY_SCALAR_FIELD(waitPolicy);
  COPY_SCALAR_FIELD(isParent);

  return newnode;
}

static PartitionPruneInfo *
_copyPartitionPruneInfo(const PartitionPruneInfo *from)
{
  PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);

  COPY_BITMAPSET_FIELD(relids);
  COPY_NODE_FIELD(prune_infos);
  COPY_BITMAPSET_FIELD(other_subplans);

  return newnode;
}

static PartitionedRelPruneInfo *
_copyPartitionedRelPruneInfo(const PartitionedRelPruneInfo *from)
{
  PartitionedRelPruneInfo *newnode = makeNode(PartitionedRelPruneInfo);

  COPY_SCALAR_FIELD(rtindex);
  COPY_BITMAPSET_FIELD(present_parts);
  COPY_SCALAR_FIELD(nparts);
  COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int));
  COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
  COPY_POINTER_FIELD(leafpart_rti_map, from->nparts * sizeof(int));
  COPY_POINTER_FIELD(relid_map, from->nparts * sizeof(Oid));
  COPY_NODE_FIELD(initial_pruning_steps);
  COPY_NODE_FIELD(exec_pruning_steps);
  COPY_BITMAPSET_FIELD(execparamids);

  return newnode;
}

static PartitionPruneStepOp *
_copyPartitionPruneStepOp(const PartitionPruneStepOp *from)
{
  PartitionPruneStepOp *newnode = makeNode(PartitionPruneStepOp);

  COPY_SCALAR_FIELD(step.step_id);
  COPY_SCALAR_FIELD(opstrategy);
  COPY_NODE_FIELD(exprs);
  COPY_NODE_FIELD(cmpfns);
  COPY_BITMAPSET_FIELD(nullkeys);

  return newnode;
}

static PartitionPruneStepCombine *
_copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from)
{
  PartitionPruneStepCombine *newnode = makeNode(PartitionPruneStepCombine);

  COPY_SCALAR_FIELD(step.step_id);
  COPY_SCALAR_FIELD(combineOp);
  COPY_NODE_FIELD(source_stepids);

  return newnode;
}

static PlanInvalItem *
_copyPlanInvalItem(const PlanInvalItem *from)
{
  PlanInvalItem *newnode = makeNode(PlanInvalItem);

  COPY_SCALAR_FIELD(cacheId);
  COPY_SCALAR_FIELD(hashValue);

  return newnode;
}

static Integer *
_copyInteger(const Integer *from)
{
  Integer *newnode = makeNode(Integer);

  COPY_SCALAR_FIELD(ival);

  return newnode;
}

static Float *
_copyFloat(const Float *from)
{
  Float *newnode = makeNode(Float);

  COPY_STRING_FIELD(fval);

  return newnode;
}

static Boolean *
_copyBoolean(const Boolean *from)
{
  Boolean *newnode = makeNode(Boolean);

  COPY_SCALAR_FIELD(boolval);

  return newnode;
}

static String *
_copyString(const String *from)
{
  String *newnode = makeNode(String);

  COPY_STRING_FIELD(sval);

  return newnode;
}

static BitString *
_copyBitString(const BitString *from)
{
  BitString *newnode = makeNode(BitString);

  COPY_STRING_FIELD(bsval);

  return newnode;
}

static ForeignKeyCacheInfo *
_copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from)
{
  ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo);

  COPY_SCALAR_FIELD(conoid);
  COPY_SCALAR_FIELD(conrelid);
  COPY_SCALAR_FIELD(confrelid);
  COPY_SCALAR_FIELD(nkeys);
  COPY_SCALAR_FIELD(conenforced);
  COPY_ARRAY_FIELD(conkey);
  COPY_ARRAY_FIELD(confkey);
  COPY_ARRAY_FIELD(conpfeqop);

  return newnode;
}

Coverage Report

Created: 2025-06-13 06:06