/*-------------------------------------------------------------------------
 *
 * copyfuncs.funcs.c
 *    Generated node infrastructure code
 *
 * Portions Copyright (c) 1996-2023, 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/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_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_BITMAPSET_FIELD(notnulls);
	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(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_SCALAR_FIELD(winref);
	COPY_SCALAR_FIELD(winstar);
	COPY_SCALAR_FIELD(winagg);
	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(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(rctype);
	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 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 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 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(isReturn);
	COPY_NODE_FIELD(cteList);
	COPY_NODE_FIELD(rtable);
	COPY_NODE_FIELD(rteperminfos);
	COPY_NODE_FIELD(jointree);
	COPY_NODE_FIELD(mergeActionList);
	COPY_SCALAR_FIELD(mergeUseOuterJoin);
	COPY_NODE_FIELD(targetList);
	COPY_SCALAR_FIELD(override);
	COPY_NODE_FIELD(onConflict);
	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_SCALAR_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(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(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_SCALAR_FIELD(rtekind);
	COPY_SCALAR_FIELD(relid);
	COPY_SCALAR_FIELD(relkind);
	COPY_SCALAR_FIELD(rellockmode);
	COPY_NODE_FIELD(tablesample);
	COPY_SCALAR_FIELD(perminfoindex);
	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(alias);
	COPY_NODE_FIELD(eref);
	COPY_SCALAR_FIELD(lateral);
	COPY_SCALAR_FIELD(inh);
	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(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_NODE_FIELD(runCondition);
	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(matched);
	COPY_SCALAR_FIELD(commandType);
	COPY_SCALAR_FIELD(override);
	COPY_NODE_FIELD(condition);
	COPY_NODE_FIELD(targetList);
	COPY_NODE_FIELD(values);

	return newnode;
}

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

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

	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 JsonKeyValue *
_copyJsonKeyValue(const JsonKeyValue *from)
{
	JsonKeyValue *newnode = makeNode(JsonKeyValue);

	COPY_NODE_FIELD(key);
	COPY_NODE_FIELD(value);

	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_SCALAR_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(returningList);
	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(returningList);
	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(returningList);
	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(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 ReplicaIdentityStmt *
_copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
{
	ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);

	COPY_SCALAR_FIELD(identity_type);
	COPY_STRING_FIELD(name);

	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 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(is_local);

	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(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_LOCATION_FIELD(location);
	COPY_SCALAR_FIELD(is_no_inherit);
	COPY_NODE_FIELD(raw_expr);
	COPY_STRING_FIELD(cooked_expr);
	COPY_SCALAR_FIELD(generated_when);
	COPY_SCALAR_FIELD(nulls_not_distinct);
	COPY_NODE_FIELD(keys);
	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_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_SCALAR_FIELD(skip_validation);
	COPY_SCALAR_FIELD(initially_valid);

	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.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(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_SCALAR_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);

	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);

	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);

	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_strategy);
	COPY_SCALAR_FIELD(pk_nulls_first);

	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(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(rtable);
	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_SCALAR_FIELD(stmt_len);

	return newnode;
}

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

	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.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.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_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);

	return newnode;
}

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

	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_NODE_FIELD(part_prune_info);

	return newnode;
}

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

	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_NODE_FIELD(part_prune_info);

	return newnode;
}

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

	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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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(mergeStrategies, list_length(from->mergeclauses) * sizeof(int));
	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.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.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.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.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.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.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.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.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(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.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.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.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.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.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(dupColIdx, from->numCols * sizeof(AttrNumber));
	COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
	COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
	COPY_SCALAR_FIELD(flagColIdx);
	COPY_SCALAR_FIELD(firstFlag);
	COPY_SCALAR_FIELD(numGroups);

	return newnode;
}

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

	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.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_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(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_ARRAY_FIELD(conkey);
	COPY_ARRAY_FIELD(confkey);
	COPY_ARRAY_FIELD(conpfeqop);

	return newnode;
}