pg_query 5.0.0 → 6.0.0

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

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