pg_query 4.2.2 → 5.0.0

data/ext/pg_query/include/copyfuncs.funcs.c

@@ -0,0 +1,5013 @@
+/*-------------------------------------------------------------------------
+ *
+ * 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;
+}