Remove code sections obsoleted by node support automation

This removes the code sections that were ifdef'ed out by
964d01ae90c314eb31132c2e7712d5d9fc237331.

5 files changed, 9 insertions, 17737 deletions

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index b72c79f2df..b8e40a4195 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -3,13 +3,6 @@
  * copyfuncs.c
  *	  Copy functions for Postgres tree nodes.
  *
- * NOTE: we currently support copying all node types found in parse and
- * plan trees.  We do not support copying executor state trees; there
- * is no need for that, and no point in maintaining all the code that
- * would be needed.  We also do not support copying Path trees, mainly
- * because the circular linkages between RelOptInfo and Path nodes can't
- * be handled easily in a simple depth-first traversal.
- *
  *
  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
@@ -71,1370 +64,11 @@
 
 #include "copyfuncs.funcs.c"
 
-#ifdef OBSOLETE
-/* ****************************************************************
- *					 plannodes.h copy functions
- * ****************************************************************
- */
-
-/*
- * _copyPlannedStmt
- */
-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(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;
-}
-
-/*
- * CopyPlanFields
- *
- *		This function copies the fields of the Plan node.  It is used by
- *		all the copy functions for classes which inherit from Plan.
- */
-static void
-CopyPlanFields(const Plan *from, Plan *newnode)
-{
-	COPY_SCALAR_FIELD(startup_cost);
-	COPY_SCALAR_FIELD(total_cost);
-	COPY_SCALAR_FIELD(plan_rows);
-	COPY_SCALAR_FIELD(plan_width);
-	COPY_SCALAR_FIELD(parallel_aware);
-	COPY_SCALAR_FIELD(parallel_safe);
-	COPY_SCALAR_FIELD(async_capable);
-	COPY_SCALAR_FIELD(plan_node_id);
-	COPY_NODE_FIELD(targetlist);
-	COPY_NODE_FIELD(qual);
-	COPY_NODE_FIELD(lefttree);
-	COPY_NODE_FIELD(righttree);
-	COPY_NODE_FIELD(initPlan);
-	COPY_BITMAPSET_FIELD(extParam);
-	COPY_BITMAPSET_FIELD(allParam);
-}
-
-/*
- * _copyResult
- */
-static Result *
-_copyResult(const Result *from)
-{
-	Result	   *newnode = makeNode(Result);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(resconstantqual);
-
-	return newnode;
-}
-
-/*
- * _copyProjectSet
- */
-static ProjectSet *
-_copyProjectSet(const ProjectSet *from)
-{
-	ProjectSet *newnode = makeNode(ProjectSet);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	return newnode;
-}
-
-/*
- * _copyModifyTable
- */
-static ModifyTable *
-_copyModifyTable(const ModifyTable *from)
-{
-	ModifyTable *newnode = makeNode(ModifyTable);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyAppend
- */
-static Append *
-_copyAppend(const Append *from)
-{
-	Append	   *newnode = makeNode(Append);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyMergeAppend
- */
-static MergeAppend *
-_copyMergeAppend(const MergeAppend *from)
-{
-	MergeAppend *newnode = makeNode(MergeAppend);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyRecursiveUnion
- */
-static RecursiveUnion *
-_copyRecursiveUnion(const RecursiveUnion *from)
-{
-	RecursiveUnion *newnode = makeNode(RecursiveUnion);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyBitmapAnd
- */
-static BitmapAnd *
-_copyBitmapAnd(const BitmapAnd *from)
-{
-	BitmapAnd  *newnode = makeNode(BitmapAnd);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(bitmapplans);
-
-	return newnode;
-}
-
-/*
- * _copyBitmapOr
- */
-static BitmapOr *
-_copyBitmapOr(const BitmapOr *from)
-{
-	BitmapOr   *newnode = makeNode(BitmapOr);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(isshared);
-	COPY_NODE_FIELD(bitmapplans);
-
-	return newnode;
-}
-
-/*
- * _copyGather
- */
-static Gather *
-_copyGather(const Gather *from)
-{
-	Gather	   *newnode = makeNode(Gather);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyGatherMerge
- */
-static GatherMerge *
-_copyGatherMerge(const GatherMerge *from)
-{
-	GatherMerge *newnode = makeNode(GatherMerge);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * CopyScanFields
- *
- *		This function copies the fields of the Scan node.  It is used by
- *		all the copy functions for classes which inherit from Scan.
- */
-static void
-CopyScanFields(const Scan *from, Scan *newnode)
-{
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	COPY_SCALAR_FIELD(scanrelid);
-}
-
-/*
- * _copyScan
- */
-static Scan *
-_copyScan(const Scan *from)
-{
-	Scan	   *newnode = makeNode(Scan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	return newnode;
-}
-
-/*
- * _copySeqScan
- */
-static SeqScan *
-_copySeqScan(const SeqScan *from)
-{
-	SeqScan    *newnode = makeNode(SeqScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	return newnode;
-}
-
-/*
- * _copySampleScan
- */
-static SampleScan *
-_copySampleScan(const SampleScan *from)
-{
-	SampleScan *newnode = makeNode(SampleScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(tablesample);
-
-	return newnode;
-}
-
-/*
- * _copyIndexScan
- */
-static IndexScan *
-_copyIndexScan(const IndexScan *from)
-{
-	IndexScan  *newnode = makeNode(IndexScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyIndexOnlyScan
- */
-static IndexOnlyScan *
-_copyIndexOnlyScan(const IndexOnlyScan *from)
-{
-	IndexOnlyScan *newnode = makeNode(IndexOnlyScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyBitmapIndexScan
- */
-static BitmapIndexScan *
-_copyBitmapIndexScan(const BitmapIndexScan *from)
-{
-	BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(indexid);
-	COPY_SCALAR_FIELD(isshared);
-	COPY_NODE_FIELD(indexqual);
-	COPY_NODE_FIELD(indexqualorig);
-
-	return newnode;
-}
-
-/*
- * _copyBitmapHeapScan
- */
-static BitmapHeapScan *
-_copyBitmapHeapScan(const BitmapHeapScan *from)
-{
-	BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(bitmapqualorig);
-
-	return newnode;
-}
-
-/*
- * _copyTidScan
- */
-static TidScan *
-_copyTidScan(const TidScan *from)
-{
-	TidScan    *newnode = makeNode(TidScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(tidquals);
-
-	return newnode;
-}
-
-/*
- * _copyTidRangeScan
- */
-static TidRangeScan *
-_copyTidRangeScan(const TidRangeScan *from)
-{
-	TidRangeScan *newnode = makeNode(TidRangeScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(tidrangequals);
-
-	return newnode;
-}
-
-/*
- * _copySubqueryScan
- */
-static SubqueryScan *
-_copySubqueryScan(const SubqueryScan *from)
-{
-	SubqueryScan *newnode = makeNode(SubqueryScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(subplan);
-	COPY_SCALAR_FIELD(scanstatus);
-
-	return newnode;
-}
-
-/*
- * _copyFunctionScan
- */
-static FunctionScan *
-_copyFunctionScan(const FunctionScan *from)
-{
-	FunctionScan *newnode = makeNode(FunctionScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(functions);
-	COPY_SCALAR_FIELD(funcordinality);
-
-	return newnode;
-}
-
-/*
- * _copyTableFuncScan
- */
-static TableFuncScan *
-_copyTableFuncScan(const TableFuncScan *from)
-{
-	TableFuncScan *newnode = makeNode(TableFuncScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(tablefunc);
-
-	return newnode;
-}
-
-/*
- * _copyValuesScan
- */
-static ValuesScan *
-_copyValuesScan(const ValuesScan *from)
-{
-	ValuesScan *newnode = makeNode(ValuesScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(values_lists);
-
-	return newnode;
-}
-
-/*
- * _copyCteScan
- */
-static CteScan *
-_copyCteScan(const CteScan *from)
-{
-	CteScan    *newnode = makeNode(CteScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(ctePlanId);
-	COPY_SCALAR_FIELD(cteParam);
-
-	return newnode;
-}
-
-/*
- * _copyNamedTuplestoreScan
- */
-static NamedTuplestoreScan *
-_copyNamedTuplestoreScan(const NamedTuplestoreScan *from)
-{
-	NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_STRING_FIELD(enrname);
-
-	return newnode;
-}
-
-/*
- * _copyWorkTableScan
- */
-static WorkTableScan *
-_copyWorkTableScan(const WorkTableScan *from)
-{
-	WorkTableScan *newnode = makeNode(WorkTableScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(wtParam);
-
-	return newnode;
-}
-
-/*
- * _copyForeignScan
- */
-static ForeignScan *
-_copyForeignScan(const ForeignScan *from)
-{
-	ForeignScan *newnode = makeNode(ForeignScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(operation);
-	COPY_SCALAR_FIELD(resultRelation);
-	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_SCALAR_FIELD(fsSystemCol);
-
-	return newnode;
-}
-
-/*
- * _copyCustomScan
- */
-static CustomScan *
-_copyCustomScan(const CustomScan *from)
-{
-	CustomScan *newnode = makeNode(CustomScan);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyScanFields((const Scan *) from, (Scan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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);
-
-	/*
-	 * NOTE: The method field of CustomScan is required to be a pointer to a
-	 * static table of callback functions.  So we don't copy the table itself,
-	 * just reference the original one.
-	 */
-	COPY_SCALAR_FIELD(methods);
-
-	return newnode;
-}
-
-/*
- * CopyJoinFields
- *
- *		This function copies the fields of the Join node.  It is used by
- *		all the copy functions for classes which inherit from Join.
- */
-static void
-CopyJoinFields(const Join *from, Join *newnode)
-{
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	COPY_SCALAR_FIELD(jointype);
-	COPY_SCALAR_FIELD(inner_unique);
-	COPY_NODE_FIELD(joinqual);
-}
-
-
-/*
- * _copyNestLoop
- */
-static NestLoop *
-_copyNestLoop(const NestLoop *from)
-{
-	NestLoop   *newnode = makeNode(NestLoop);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyJoinFields((const Join *) from, (Join *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(nestParams);
-
-	return newnode;
-}
-
-
-/*
- * _copyMergeJoin
- */
-static MergeJoin *
-_copyMergeJoin(const MergeJoin *from)
-{
-	MergeJoin  *newnode = makeNode(MergeJoin);
-	int			numCols;
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyJoinFields((const Join *) from, (Join *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(skip_mark_restore);
-	COPY_NODE_FIELD(mergeclauses);
-	numCols = list_length(from->mergeclauses);
-	COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
-	COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
-	COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
-	COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
-
-	return newnode;
-}
-
-/*
- * _copyHashJoin
- */
-static HashJoin *
-_copyHashJoin(const HashJoin *from)
-{
-	HashJoin   *newnode = makeNode(HashJoin);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyJoinFields((const Join *) from, (Join *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(hashclauses);
-	COPY_NODE_FIELD(hashoperators);
-	COPY_NODE_FIELD(hashcollations);
-	COPY_NODE_FIELD(hashkeys);
-
-	return newnode;
-}
-
-
-/*
- * _copyMaterial
- */
-static Material *
-_copyMaterial(const Material *from)
-{
-	Material   *newnode = makeNode(Material);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	return newnode;
-}
-
 
 /*
- * _copyMemoize
+ * Support functions for nodes with custom_copy_equal attribute
  */
-static Memoize *
-_copyMemoize(const Memoize *from)
-{
-	Memoize    *newnode = makeNode(Memoize);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(numKeys);
-	COPY_POINTER_FIELD(hashOperators, sizeof(Oid) * from->numKeys);
-	COPY_POINTER_FIELD(collations, sizeof(Oid) * from->numKeys);
-	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;
-}
-
 
-/*
- * CopySortFields
- *
- *		This function copies the fields of the Sort node.  It is used by
- *		all the copy functions for classes which inherit from Sort.
- */
-static void
-CopySortFields(const Sort *from, Sort *newnode)
-{
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	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));
-}
-
-/*
- * _copySort
- */
-static Sort *
-_copySort(const Sort *from)
-{
-	Sort	   *newnode = makeNode(Sort);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopySortFields(from, newnode);
-
-	return newnode;
-}
-
-
-/*
- * _copyIncrementalSort
- */
-static IncrementalSort *
-_copyIncrementalSort(const IncrementalSort *from)
-{
-	IncrementalSort *newnode = makeNode(IncrementalSort);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopySortFields((const Sort *) from, (Sort *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_SCALAR_FIELD(nPresortedCols);
-
-	return newnode;
-}
-
-
-/*
- * _copyGroup
- */
-static Group *
-_copyGroup(const Group *from)
-{
-	Group	   *newnode = makeNode(Group);
-
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	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;
-}
-
-/*
- * _copyAgg
- */
-static Agg *
-_copyAgg(const Agg *from)
-{
-	Agg		   *newnode = makeNode(Agg);
-
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	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;
-}
-
-/*
- * _copyWindowAgg
- */
-static WindowAgg *
-_copyWindowAgg(const WindowAgg *from)
-{
-	WindowAgg  *newnode = makeNode(WindowAgg);
-
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	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;
-}
-
-/*
- * _copyUnique
- */
-static Unique *
-_copyUnique(const Unique *from)
-{
-	Unique	   *newnode = makeNode(Unique);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyHash
- */
-static Hash *
-_copyHash(const Hash *from)
-{
-	Hash	   *newnode = makeNode(Hash);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(hashkeys);
-	COPY_SCALAR_FIELD(skewTable);
-	COPY_SCALAR_FIELD(skewColumn);
-	COPY_SCALAR_FIELD(skewInherit);
-	COPY_SCALAR_FIELD(rows_total);
-
-	return newnode;
-}
-
-/*
- * _copySetOp
- */
-static SetOp *
-_copySetOp(const SetOp *from)
-{
-	SetOp	   *newnode = makeNode(SetOp);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyLockRows
- */
-static LockRows *
-_copyLockRows(const LockRows *from)
-{
-	LockRows   *newnode = makeNode(LockRows);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	COPY_NODE_FIELD(rowMarks);
-	COPY_SCALAR_FIELD(epqParam);
-
-	return newnode;
-}
-
-/*
- * _copyLimit
- */
-static Limit *
-_copyLimit(const Limit *from)
-{
-	Limit	   *newnode = makeNode(Limit);
-
-	/*
-	 * copy node superclass fields
-	 */
-	CopyPlanFields((const Plan *) from, (Plan *) newnode);
-
-	/*
-	 * copy remainder of node
-	 */
-	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;
-}
-
-/*
- * _copyNestLoopParam
- */
-static NestLoopParam *
-_copyNestLoopParam(const NestLoopParam *from)
-{
-	NestLoopParam *newnode = makeNode(NestLoopParam);
-
-	COPY_SCALAR_FIELD(paramno);
-	COPY_NODE_FIELD(paramval);
-
-	return newnode;
-}
-
-/*
- * _copyPlanRowMark
- */
-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;
-}
-
-/*
- * _copyPartitionPruneStepOp
- */
-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;
-}
-
-/*
- * _copyPartitionPruneStepCombine
- */
-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;
-}
-
-/*
- * _copyPlanInvalItem
- */
-static PlanInvalItem *
-_copyPlanInvalItem(const PlanInvalItem *from)
-{
-	PlanInvalItem *newnode = makeNode(PlanInvalItem);
-
-	COPY_SCALAR_FIELD(cacheId);
-	COPY_SCALAR_FIELD(hashValue);
-
-	return newnode;
-}
-
-/* ****************************************************************
- *					   primnodes.h copy functions
- * ****************************************************************
- */
-
-/*
- * _copyAlias
- */
-static Alias *
-_copyAlias(const Alias *from)
-{
-	Alias	   *newnode = makeNode(Alias);
-
-	COPY_STRING_FIELD(aliasname);
-	COPY_NODE_FIELD(colnames);
-
-	return newnode;
-}
-
-/*
- * _copyRangeVar
- */
-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;
-}
-
-/*
- * _copyTableFunc
- */
-static TableFunc *
-_copyTableFunc(const TableFunc *from)
-{
-	TableFunc  *newnode = makeNode(TableFunc);
-
-	COPY_SCALAR_FIELD(functype);
-	COPY_NODE_FIELD(ns_uris);
-	COPY_NODE_FIELD(ns_names);
-	COPY_NODE_FIELD(docexpr);
-	COPY_NODE_FIELD(rowexpr);
-	COPY_NODE_FIELD(colnames);
-	COPY_NODE_FIELD(coltypes);
-	COPY_NODE_FIELD(coltypmods);
-	COPY_NODE_FIELD(colcollations);
-	COPY_NODE_FIELD(colexprs);
-	COPY_NODE_FIELD(coldefexprs);
-	COPY_NODE_FIELD(colvalexprs);
-	COPY_BITMAPSET_FIELD(notnulls);
-	COPY_NODE_FIELD(plan);
-	COPY_SCALAR_FIELD(ordinalitycol);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyIntoClause
- */
-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;
-}
-
-/*
- * We don't need a _copyExpr because Expr is an abstract supertype which
- * should never actually get instantiated.  Also, since it has no common
- * fields except NodeTag, there's no need for a helper routine to factor
- * out copying the common fields...
- */
-
-/*
- * _copyVar
- */
-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_SCALAR_FIELD(varlevelsup);
-	COPY_SCALAR_FIELD(varnosyn);
-	COPY_SCALAR_FIELD(varattnosyn);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-#endif							/* OBSOLETE */
-
-/*
- * _copyConst
- */
 static Const *
 _copyConst(const Const *from)
 {
@@ -1470,1753 +104,6 @@ _copyConst(const Const *from)
 	return newnode;
 }
 
-#ifdef OBSOLETE
-/*
- * _copyParam
- */
-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;
-}
-
-/*
- * _copyAggref
- */
-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(agglevelsup);
-	COPY_SCALAR_FIELD(aggsplit);
-	COPY_SCALAR_FIELD(aggno);
-	COPY_SCALAR_FIELD(aggtransno);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyGroupingFunc
- */
-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;
-}
-
-/*
- * _copyWindowFunc
- */
-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;
-}
-
-/*
- * _copySubscriptingRef
- */
-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;
-}
-
-/*
- * _copyFuncExpr
- */
-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;
-}
-
-/*
- * _copyNamedArgExpr *
- */
-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;
-}
-
-/*
- * _copyOpExpr
- */
-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;
-}
-
-/*
- * _copyDistinctExpr (same as OpExpr)
- */
-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;
-}
-
-/*
- * _copyNullIfExpr (same as OpExpr)
- */
-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;
-}
-
-/*
- * _copyScalarArrayOpExpr
- */
-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;
-}
-
-/*
- * _copyBoolExpr
- */
-static BoolExpr *
-_copyBoolExpr(const BoolExpr *from)
-{
-	BoolExpr   *newnode = makeNode(BoolExpr);
-
-	COPY_SCALAR_FIELD(boolop);
-	COPY_NODE_FIELD(args);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copySubLink
- */
-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;
-}
-
-/*
- * _copySubPlan
- */
-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;
-}
-
-/*
- * _copyAlternativeSubPlan
- */
-static AlternativeSubPlan *
-_copyAlternativeSubPlan(const AlternativeSubPlan *from)
-{
-	AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
-
-	COPY_NODE_FIELD(subplans);
-
-	return newnode;
-}
-
-/*
- * _copyFieldSelect
- */
-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;
-}
-
-/*
- * _copyFieldStore
- */
-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;
-}
-
-/*
- * _copyRelabelType
- */
-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;
-}
-
-/*
- * _copyCoerceViaIO
- */
-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;
-}
-
-/*
- * _copyArrayCoerceExpr
- */
-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;
-}
-
-/*
- * _copyConvertRowtypeExpr
- */
-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;
-}
-
-/*
- * _copyCollateExpr
- */
-static CollateExpr *
-_copyCollateExpr(const CollateExpr *from)
-{
-	CollateExpr *newnode = makeNode(CollateExpr);
-
-	COPY_NODE_FIELD(arg);
-	COPY_SCALAR_FIELD(collOid);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyCaseExpr
- */
-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;
-}
-
-/*
- * _copyCaseWhen
- */
-static CaseWhen *
-_copyCaseWhen(const CaseWhen *from)
-{
-	CaseWhen   *newnode = makeNode(CaseWhen);
-
-	COPY_NODE_FIELD(expr);
-	COPY_NODE_FIELD(result);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyCaseTestExpr
- */
-static CaseTestExpr *
-_copyCaseTestExpr(const CaseTestExpr *from)
-{
-	CaseTestExpr *newnode = makeNode(CaseTestExpr);
-
-	COPY_SCALAR_FIELD(typeId);
-	COPY_SCALAR_FIELD(typeMod);
-	COPY_SCALAR_FIELD(collation);
-
-	return newnode;
-}
-
-/*
- * _copyArrayExpr
- */
-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;
-}
-
-/*
- * _copyRowExpr
- */
-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;
-}
-
-/*
- * _copyRowCompareExpr
- */
-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;
-}
-
-/*
- * _copyCoalesceExpr
- */
-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;
-}
-
-/*
- * _copyMinMaxExpr
- */
-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;
-}
-
-/*
- * _copySQLValueFunction
- */
-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;
-}
-
-/*
- * _copyXmlExpr
- */
-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(type);
-	COPY_SCALAR_FIELD(typmod);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyNullTest
- */
-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;
-}
-
-/*
- * _copyBooleanTest
- */
-static BooleanTest *
-_copyBooleanTest(const BooleanTest *from)
-{
-	BooleanTest *newnode = makeNode(BooleanTest);
-
-	COPY_NODE_FIELD(arg);
-	COPY_SCALAR_FIELD(booltesttype);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyCoerceToDomain
- */
-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;
-}
-
-/*
- * _copyCoerceToDomainValue
- */
-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;
-}
-
-/*
- * _copySetToDefault
- */
-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;
-}
-
-/*
- * _copyCurrentOfExpr
- */
-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;
-}
-
- /*
-  * _copyNextValueExpr
-  */
-static NextValueExpr *
-_copyNextValueExpr(const NextValueExpr *from)
-{
-	NextValueExpr *newnode = makeNode(NextValueExpr);
-
-	COPY_SCALAR_FIELD(seqid);
-	COPY_SCALAR_FIELD(typeId);
-
-	return newnode;
-}
-
-/*
- * _copyInferenceElem
- */
-static InferenceElem *
-_copyInferenceElem(const InferenceElem *from)
-{
-	InferenceElem *newnode = makeNode(InferenceElem);
-
-	COPY_NODE_FIELD(expr);
-	COPY_SCALAR_FIELD(infercollid);
-	COPY_SCALAR_FIELD(inferopclass);
-
-	return newnode;
-}
-
-/*
- * _copyTargetEntry
- */
-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;
-}
-
-/*
- * _copyRangeTblRef
- */
-static RangeTblRef *
-_copyRangeTblRef(const RangeTblRef *from)
-{
-	RangeTblRef *newnode = makeNode(RangeTblRef);
-
-	COPY_SCALAR_FIELD(rtindex);
-
-	return newnode;
-}
-
-/*
- * _copyJoinExpr
- */
-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;
-}
-
-/*
- * _copyFromExpr
- */
-static FromExpr *
-_copyFromExpr(const FromExpr *from)
-{
-	FromExpr   *newnode = makeNode(FromExpr);
-
-	COPY_NODE_FIELD(fromlist);
-	COPY_NODE_FIELD(quals);
-
-	return newnode;
-}
-
-/*
- * _copyOnConflictExpr
- */
-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;
-}
-
-
-/*
- * _copyJsonFormat
- */
-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;
-}
-
-/*
- * _copyJsonReturning
- */
-static JsonReturning *
-_copyJsonReturning(const JsonReturning *from)
-{
-	JsonReturning *newnode = makeNode(JsonReturning);
-
-	COPY_NODE_FIELD(format);
-	COPY_SCALAR_FIELD(typid);
-	COPY_SCALAR_FIELD(typmod);
-
-	return newnode;
-}
-
-/*
- * _copyJsonValueExpr
- */
-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;
-}
-
-/*
- * _copyJsonParseExpr
- */
-static JsonParseExpr *
-_copyJsonParseExpr(const JsonParseExpr *from)
-{
-	JsonParseExpr *newnode = makeNode(JsonParseExpr);
-
-	COPY_NODE_FIELD(expr);
-	COPY_NODE_FIELD(output);
-	COPY_SCALAR_FIELD(unique_keys);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonScalarExpr
- */
-static JsonScalarExpr *
-_copyJsonScalarExpr(const JsonScalarExpr *from)
-{
-	JsonScalarExpr *newnode = makeNode(JsonScalarExpr);
-
-	COPY_NODE_FIELD(expr);
-	COPY_NODE_FIELD(output);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonSerializeExpr
- */
-static JsonSerializeExpr *
-_copyJsonSerializeExpr(const JsonSerializeExpr *from)
-{
-	JsonSerializeExpr *newnode = makeNode(JsonSerializeExpr);
-
-	COPY_NODE_FIELD(expr);
-	COPY_NODE_FIELD(output);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonConstructorExpr
- */
-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;
-}
-
-/*
- * _copyJsonKeyValue
- */
-static JsonKeyValue *
-_copyJsonKeyValue(const JsonKeyValue *from)
-{
-	JsonKeyValue *newnode = makeNode(JsonKeyValue);
-
-	COPY_NODE_FIELD(key);
-	COPY_NODE_FIELD(value);
-
-	return newnode;
-}
-
-/*
- * _copyJsonObjectConstructor
- */
-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;
-}
-
-/*
- * _copyJsonAggConstructor
- */
-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;
-}
-
-/*
- * _copyJsonObjectAgg
- */
-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;
-}
-
-/*
- * _copyJsonOutput
- */
-static JsonOutput *
-_copyJsonOutput(const JsonOutput *from)
-{
-	JsonOutput *newnode = makeNode(JsonOutput);
-
-	COPY_NODE_FIELD(typeName);
-	COPY_NODE_FIELD(returning);
-
-	return newnode;
-}
-
-/*
- * _copyJsonArrayConstructor
- */
-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;
-}
-
-/*
- * _copyJsonArrayAgg
- */
-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;
-}
-
-/*
- * _copyJsonArrayQueryConstructor
- */
-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;
-}
-
-/*
- * _copyJsonExpr
- */
-static JsonExpr *
-_copyJsonExpr(const JsonExpr *from)
-{
-	JsonExpr   *newnode = makeNode(JsonExpr);
-
-	COPY_SCALAR_FIELD(op);
-	COPY_NODE_FIELD(formatted_expr);
-	COPY_NODE_FIELD(result_coercion);
-	COPY_NODE_FIELD(format);
-	COPY_NODE_FIELD(path_spec);
-	COPY_NODE_FIELD(passing_names);
-	COPY_NODE_FIELD(passing_values);
-	COPY_NODE_FIELD(returning);
-	COPY_NODE_FIELD(on_empty);
-	COPY_NODE_FIELD(on_error);
-	COPY_NODE_FIELD(coercions);
-	COPY_SCALAR_FIELD(wrapper);
-	COPY_SCALAR_FIELD(omit_quotes);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonCoercion
- */
-static JsonCoercion *
-_copyJsonCoercion(const JsonCoercion *from)
-{
-	JsonCoercion *newnode = makeNode(JsonCoercion);
-
-	COPY_NODE_FIELD(expr);
-	COPY_SCALAR_FIELD(via_populate);
-	COPY_SCALAR_FIELD(via_io);
-	COPY_SCALAR_FIELD(collation);
-
-	return newnode;
-}
-
-/*
- * _copyJsonItemCoercions
- */
-static JsonItemCoercions *
-_copyJsonItemCoercions(const JsonItemCoercions *from)
-{
-	JsonItemCoercions *newnode = makeNode(JsonItemCoercions);
-
-	COPY_NODE_FIELD(null);
-	COPY_NODE_FIELD(string);
-	COPY_NODE_FIELD(numeric);
-	COPY_NODE_FIELD(boolean);
-	COPY_NODE_FIELD(date);
-	COPY_NODE_FIELD(time);
-	COPY_NODE_FIELD(timetz);
-	COPY_NODE_FIELD(timestamp);
-	COPY_NODE_FIELD(timestamptz);
-	COPY_NODE_FIELD(composite);
-
-	return newnode;
-}
-
-/*
- * _copyJsonFuncExpr
- */
-static JsonFuncExpr *
-_copyJsonFuncExpr(const JsonFuncExpr *from)
-{
-	JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
-
-	COPY_SCALAR_FIELD(op);
-	COPY_NODE_FIELD(common);
-	COPY_NODE_FIELD(output);
-	COPY_NODE_FIELD(on_empty);
-	COPY_NODE_FIELD(on_error);
-	COPY_SCALAR_FIELD(wrapper);
-	COPY_SCALAR_FIELD(omit_quotes);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonIsPredicate
- */
-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;
-}
-
-/*
- * _copyJsonBehavior
- */
-static JsonBehavior *
-_copyJsonBehavior(const JsonBehavior *from)
-{
-	JsonBehavior *newnode = makeNode(JsonBehavior);
-
-	COPY_SCALAR_FIELD(btype);
-	COPY_NODE_FIELD(default_expr);
-
-	return newnode;
-}
-
-/*
- * _copyJsonCommon
- */
-static JsonCommon *
-_copyJsonCommon(const JsonCommon *from)
-{
-	JsonCommon *newnode = makeNode(JsonCommon);
-
-	COPY_NODE_FIELD(expr);
-	COPY_NODE_FIELD(pathspec);
-	COPY_STRING_FIELD(pathname);
-	COPY_NODE_FIELD(passing);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonArgument
- */
-static JsonArgument *
-_copyJsonArgument(const JsonArgument *from)
-{
-	JsonArgument *newnode = makeNode(JsonArgument);
-
-	COPY_NODE_FIELD(val);
-	COPY_STRING_FIELD(name);
-
-	return newnode;
-}
-
-/*
- * _copyJsonTable
- */
-static JsonTable *
-_copyJsonTable(const JsonTable *from)
-{
-	JsonTable  *newnode = makeNode(JsonTable);
-
-	COPY_NODE_FIELD(common);
-	COPY_NODE_FIELD(columns);
-	COPY_NODE_FIELD(plan);
-	COPY_NODE_FIELD(on_error);
-	COPY_NODE_FIELD(alias);
-	COPY_SCALAR_FIELD(lateral);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonTableColumn
- */
-static JsonTableColumn *
-_copyJsonTableColumn(const JsonTableColumn *from)
-{
-	JsonTableColumn *newnode = makeNode(JsonTableColumn);
-
-	COPY_SCALAR_FIELD(coltype);
-	COPY_STRING_FIELD(name);
-	COPY_NODE_FIELD(typeName);
-	COPY_STRING_FIELD(pathspec);
-	COPY_STRING_FIELD(pathname);
-	COPY_NODE_FIELD(format);
-	COPY_SCALAR_FIELD(wrapper);
-	COPY_SCALAR_FIELD(omit_quotes);
-	COPY_NODE_FIELD(columns);
-	COPY_NODE_FIELD(on_empty);
-	COPY_NODE_FIELD(on_error);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonTablePlan
- */
-static JsonTablePlan *
-_copyJsonTablePlan(const JsonTablePlan *from)
-{
-	JsonTablePlan *newnode = makeNode(JsonTablePlan);
-
-	COPY_SCALAR_FIELD(plan_type);
-	COPY_SCALAR_FIELD(join_type);
-	COPY_NODE_FIELD(plan1);
-	COPY_NODE_FIELD(plan2);
-	COPY_STRING_FIELD(pathname);
-	COPY_LOCATION_FIELD(location);
-
-	return newnode;
-}
-
-/*
- * _copyJsonTableParent
- */
-static JsonTableParent *
-_copyJsonTableParent(const JsonTableParent *from)
-{
-	JsonTableParent *newnode = makeNode(JsonTableParent);
-
-	COPY_NODE_FIELD(path);
-	COPY_STRING_FIELD(name);
-	COPY_NODE_FIELD(child);
-	COPY_SCALAR_FIELD(outerJoin);
-	COPY_SCALAR_FIELD(colMin);
-	COPY_SCALAR_FIELD(colMax);
-	COPY_SCALAR_FIELD(errorOnError);
-
-	return newnode;
-}
-
-/*
- * _copyJsonTableSibling
- */
-static JsonTableSibling *
-_copyJsonTableSibling(const JsonTableSibling *from)
-{
-	JsonTableSibling *newnode = makeNode(JsonTableSibling);
-
-	COPY_NODE_FIELD(larg);
-	COPY_NODE_FIELD(rarg);
-	COPY_SCALAR_FIELD(cross);
-
-	return newnode;
-}
-
-/* ****************************************************************
- *						pathnodes.h copy functions
- *
- * We don't support copying RelOptInfo, IndexOptInfo, or Path nodes.
- * There are some subsidiary structs that are useful to copy, though.
- * ****************************************************************
- */
-
-/*
- * _copyPathKey
- */
-static PathKey *
-_copyPathKey(const PathKey *from)
-{
-	PathKey    *newnode = makeNode(PathKey);
-
-	/* EquivalenceClasses are never moved, so just shallow-copy the pointer */
-	COPY_SCALAR_FIELD(pk_eclass);
-	COPY_SCALAR_FIELD(pk_opfamily);
-	COPY_SCALAR_FIELD(pk_strategy);
-	COPY_SCALAR_FIELD(pk_nulls_first);
-
-	return newnode;
-}
-
-/*
- * _copyRestrictInfo
- */
-static RestrictInfo *
-_copyRestrictInfo(const RestrictInfo *from)
-{
-	RestrictInfo *newnode = makeNode(RestrictInfo);
-
-	COPY_NODE_FIELD(clause);
-	COPY_SCALAR_FIELD(is_pushed_down);
-	COPY_SCALAR_FIELD(outerjoin_delayed);
-	COPY_SCALAR_FIELD(can_join);
-	COPY_SCALAR_FIELD(pseudoconstant);
-	COPY_SCALAR_FIELD(leakproof);
-	COPY_SCALAR_FIELD(has_volatile);
-	COPY_SCALAR_FIELD(security_level);
-	COPY_BITMAPSET_FIELD(clause_relids);
-	COPY_BITMAPSET_FIELD(required_relids);
-	COPY_BITMAPSET_FIELD(outer_relids);
-	COPY_BITMAPSET_FIELD(nullable_relids);
-	COPY_BITMAPSET_FIELD(left_relids);
-	COPY_BITMAPSET_FIELD(right_relids);
-	COPY_NODE_FIELD(orclause);
-	/* EquivalenceClasses are never copied, so shallow-copy the pointers */
-	COPY_SCALAR_FIELD(parent_ec);
-	COPY_SCALAR_FIELD(eval_cost);
-	COPY_SCALAR_FIELD(norm_selec);
-	COPY_SCALAR_FIELD(outer_selec);
-	COPY_NODE_FIELD(mergeopfamilies);
-	/* EquivalenceClasses are never copied, so shallow-copy the pointers */
-	COPY_SCALAR_FIELD(left_ec);
-	COPY_SCALAR_FIELD(right_ec);
-	COPY_SCALAR_FIELD(left_em);
-	COPY_SCALAR_FIELD(right_em);
-	/* MergeScanSelCache isn't a Node, so hard to copy; just reset cache */
-	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;
-}
-
-/*
- * _copyPlaceHolderVar
- */
-static PlaceHolderVar *
-_copyPlaceHolderVar(const PlaceHolderVar *from)
-{
-	PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
-
-	COPY_NODE_FIELD(phexpr);
-	COPY_BITMAPSET_FIELD(phrels);
-	COPY_SCALAR_FIELD(phid);
-	COPY_SCALAR_FIELD(phlevelsup);
-
-	return newnode;
-}
-
-/*
- * _copySpecialJoinInfo
- */
-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(lhs_strict);
-	COPY_SCALAR_FIELD(delay_upper_joins);
-	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;
-}
-
-/*
- * _copyAppendRelInfo
- */
-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;
-}
-
-/*
- * _copyPlaceHolderInfo
- */
-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;
-}
-
-/* ****************************************************************
- *					parsenodes.h copy functions
- * ****************************************************************
- */
-
-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_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_SCALAR_FIELD(requiredPerms);
-	COPY_SCALAR_FIELD(checkAsUser);
-	COPY_BITMAPSET_FIELD(selectedCols);
-	COPY_BITMAPSET_FIELD(insertedCols);
-	COPY_BITMAPSET_FIELD(updatedCols);
-	COPY_BITMAPSET_FIELD(extraUpdatedCols);
-	COPY_NODE_FIELD(securityQuals);
-
-	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 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 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;
-}
-#endif							/* OBSOLETE */
-
 static A_Const *
 _copyA_Const(const A_Const *from)
 {
@@ -3256,2178 +143,6 @@ _copyA_Const(const A_Const *from)
 	return newnode;
 }
 
-#ifdef OBSOLETE
-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 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 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 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 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 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 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 StatsElem *
-_copyStatsElem(const StatsElem *from)
-{
-	StatsElem  *newnode = makeNode(StatsElem);
-
-	COPY_STRING_FIELD(name);
-	COPY_NODE_FIELD(expr);
-
-	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_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 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 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_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 TriggerTransition *
-_copyTriggerTransition(const TriggerTransition *from)
-{
-	TriggerTransition *newnode = makeNode(TriggerTransition);
-
-	COPY_STRING_FIELD(name);
-	COPY_SCALAR_FIELD(isNew);
-	COPY_SCALAR_FIELD(isTable);
-
-	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(jointree);
-	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_NODE_FIELD(mergeActionList);
-	COPY_SCALAR_FIELD(mergeUseOuterJoin);
-	COPY_LOCATION_FIELD(stmt_location);
-	COPY_SCALAR_FIELD(stmt_len);
-
-	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 AlterTableStmt *
-_copyAlterTableStmt(const AlterTableStmt *from)
-{
-	AlterTableStmt *newnode = makeNode(AlterTableStmt);
-
-	COPY_NODE_FIELD(relation);
-	COPY_NODE_FIELD(cmds);
-	COPY_SCALAR_FIELD(objtype);
-	COPY_SCALAR_FIELD(missing_ok);
-
-	return newnode;
-}
-
-static AlterTableCmd *
-_copyAlterTableCmd(const AlterTableCmd *from)
-{
-	AlterTableCmd *newnode = makeNode(AlterTableCmd);
-
-	COPY_SCALAR_FIELD(subtype);
-	COPY_STRING_FIELD(name);
-	COPY_SCALAR_FIELD(num);
-	COPY_NODE_FIELD(newowner);
-	COPY_NODE_FIELD(def);
-	COPY_SCALAR_FIELD(behavior);
-	COPY_SCALAR_FIELD(missing_ok);
-
-	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_SCALAR_FIELD(admin_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 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 CallStmt *
-_copyCallStmt(const CallStmt *from)
-{
-	CallStmt   *newnode = makeNode(CallStmt);
-
-	COPY_NODE_FIELD(funccall);
-	COPY_NODE_FIELD(funcexpr);
-	COPY_NODE_FIELD(outargs);
-
-	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 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;
-}
-
-/*
- * CopyCreateStmtFields
- *
- *		This function copies the fields of the CreateStmt node.  It is used by
- *		copy functions for classes which inherit from CreateStmt.
- */
-static void
-CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode)
-{
-	COPY_NODE_FIELD(relation);
-	COPY_NODE_FIELD(tableElts);
-	COPY_NODE_FIELD(inhRelations);
-	COPY_NODE_FIELD(partspec);
-	COPY_NODE_FIELD(partbound);
-	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);
-}
-
-static CreateStmt *
-_copyCreateStmt(const CreateStmt *from)
-{
-	CreateStmt *newnode = makeNode(CreateStmt);
-
-	CopyCreateStmtFields(from, newnode);
-
-	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 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 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 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 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 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 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 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 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 ReplicaIdentityStmt *
-_copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
-{
-	ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);
-
-	COPY_SCALAR_FIELD(identity_type);
-	COPY_STRING_FIELD(name);
-
-	return newnode;
-}
-
-static AlterSystemStmt *
-_copyAlterSystemStmt(const AlterSystemStmt *from)
-{
-	AlterSystemStmt *newnode = makeNode(AlterSystemStmt);
-
-	COPY_NODE_FIELD(setstmt);
-
-	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 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 DiscardStmt *
-_copyDiscardStmt(const DiscardStmt *from)
-{
-	DiscardStmt *newnode = makeNode(DiscardStmt);
-
-	COPY_SCALAR_FIELD(target);
-
-	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 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 CreateForeignTableStmt *
-_copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
-{
-	CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
-
-	CopyCreateStmtFields((const CreateStmt *) from, (CreateStmt *) newnode);
-
-	COPY_STRING_FIELD(servername);
-	COPY_NODE_FIELD(options);
-
-	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 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 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 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 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 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 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 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 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_STRING_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 PublicationObjSpec *
-_copyPublicationObject(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 PublicationTable *
-_copyPublicationTable(const PublicationTable *from)
-{
-	PublicationTable *newnode = makeNode(PublicationTable);
-
-	COPY_NODE_FIELD(relation);
-	COPY_NODE_FIELD(whereClause);
-	COPY_NODE_FIELD(columns);
-
-	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;
-}
-#endif							/* OBSOLETE */
-
-/* ****************************************************************
- *					extensible.h copy functions
- * ****************************************************************
- */
 static ExtensibleNode *
 _copyExtensibleNode(const ExtensibleNode *from)
 {
@@ -5445,78 +160,6 @@ _copyExtensibleNode(const ExtensibleNode *from)
 	return newnode;
 }
 
-#ifdef OBSOLETE
-/* ****************************************************************
- *					value.h copy functions
- * ****************************************************************
- */
-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;
-}
-#endif							/* OBSOLETE */
 
 /*
  * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
@@ -5538,450 +181,7 @@ copyObjectImpl(const void *from)
 	switch (nodeTag(from))
 	{
 #include "copyfuncs.switch.c"
-#ifdef OBSOLETE
-			/*
-			 * PLAN NODES
-			 */
-		case T_PlannedStmt:
-			retval = _copyPlannedStmt(from);
-			break;
-		case T_Result:
-			retval = _copyResult(from);
-			break;
-		case T_ProjectSet:
-			retval = _copyProjectSet(from);
-			break;
-		case T_ModifyTable:
-			retval = _copyModifyTable(from);
-			break;
-		case T_Append:
-			retval = _copyAppend(from);
-			break;
-		case T_MergeAppend:
-			retval = _copyMergeAppend(from);
-			break;
-		case T_RecursiveUnion:
-			retval = _copyRecursiveUnion(from);
-			break;
-		case T_BitmapAnd:
-			retval = _copyBitmapAnd(from);
-			break;
-		case T_BitmapOr:
-			retval = _copyBitmapOr(from);
-			break;
-		case T_Scan:
-			retval = _copyScan(from);
-			break;
-		case T_Gather:
-			retval = _copyGather(from);
-			break;
-		case T_GatherMerge:
-			retval = _copyGatherMerge(from);
-			break;
-		case T_SeqScan:
-			retval = _copySeqScan(from);
-			break;
-		case T_SampleScan:
-			retval = _copySampleScan(from);
-			break;
-		case T_IndexScan:
-			retval = _copyIndexScan(from);
-			break;
-		case T_IndexOnlyScan:
-			retval = _copyIndexOnlyScan(from);
-			break;
-		case T_BitmapIndexScan:
-			retval = _copyBitmapIndexScan(from);
-			break;
-		case T_BitmapHeapScan:
-			retval = _copyBitmapHeapScan(from);
-			break;
-		case T_TidScan:
-			retval = _copyTidScan(from);
-			break;
-		case T_TidRangeScan:
-			retval = _copyTidRangeScan(from);
-			break;
-		case T_SubqueryScan:
-			retval = _copySubqueryScan(from);
-			break;
-		case T_FunctionScan:
-			retval = _copyFunctionScan(from);
-			break;
-		case T_TableFuncScan:
-			retval = _copyTableFuncScan(from);
-			break;
-		case T_ValuesScan:
-			retval = _copyValuesScan(from);
-			break;
-		case T_CteScan:
-			retval = _copyCteScan(from);
-			break;
-		case T_NamedTuplestoreScan:
-			retval = _copyNamedTuplestoreScan(from);
-			break;
-		case T_WorkTableScan:
-			retval = _copyWorkTableScan(from);
-			break;
-		case T_ForeignScan:
-			retval = _copyForeignScan(from);
-			break;
-		case T_CustomScan:
-			retval = _copyCustomScan(from);
-			break;
-		case T_NestLoop:
-			retval = _copyNestLoop(from);
-			break;
-		case T_MergeJoin:
-			retval = _copyMergeJoin(from);
-			break;
-		case T_HashJoin:
-			retval = _copyHashJoin(from);
-			break;
-		case T_Material:
-			retval = _copyMaterial(from);
-			break;
-		case T_Memoize:
-			retval = _copyMemoize(from);
-			break;
-		case T_Sort:
-			retval = _copySort(from);
-			break;
-		case T_IncrementalSort:
-			retval = _copyIncrementalSort(from);
-			break;
-		case T_Group:
-			retval = _copyGroup(from);
-			break;
-		case T_Agg:
-			retval = _copyAgg(from);
-			break;
-		case T_WindowAgg:
-			retval = _copyWindowAgg(from);
-			break;
-		case T_Unique:
-			retval = _copyUnique(from);
-			break;
-		case T_Hash:
-			retval = _copyHash(from);
-			break;
-		case T_SetOp:
-			retval = _copySetOp(from);
-			break;
-		case T_LockRows:
-			retval = _copyLockRows(from);
-			break;
-		case T_Limit:
-			retval = _copyLimit(from);
-			break;
-		case T_NestLoopParam:
-			retval = _copyNestLoopParam(from);
-			break;
-		case T_PlanRowMark:
-			retval = _copyPlanRowMark(from);
-			break;
-		case T_PartitionPruneInfo:
-			retval = _copyPartitionPruneInfo(from);
-			break;
-		case T_PartitionedRelPruneInfo:
-			retval = _copyPartitionedRelPruneInfo(from);
-			break;
-		case T_PartitionPruneStepOp:
-			retval = _copyPartitionPruneStepOp(from);
-			break;
-		case T_PartitionPruneStepCombine:
-			retval = _copyPartitionPruneStepCombine(from);
-			break;
-		case T_PlanInvalItem:
-			retval = _copyPlanInvalItem(from);
-			break;
-
-			/*
-			 * PRIMITIVE NODES
-			 */
-		case T_Alias:
-			retval = _copyAlias(from);
-			break;
-		case T_RangeVar:
-			retval = _copyRangeVar(from);
-			break;
-		case T_TableFunc:
-			retval = _copyTableFunc(from);
-			break;
-		case T_IntoClause:
-			retval = _copyIntoClause(from);
-			break;
-		case T_Var:
-			retval = _copyVar(from);
-			break;
-		case T_Const:
-			retval = _copyConst(from);
-			break;
-		case T_Param:
-			retval = _copyParam(from);
-			break;
-		case T_Aggref:
-			retval = _copyAggref(from);
-			break;
-		case T_GroupingFunc:
-			retval = _copyGroupingFunc(from);
-			break;
-		case T_WindowFunc:
-			retval = _copyWindowFunc(from);
-			break;
-		case T_SubscriptingRef:
-			retval = _copySubscriptingRef(from);
-			break;
-		case T_FuncExpr:
-			retval = _copyFuncExpr(from);
-			break;
-		case T_NamedArgExpr:
-			retval = _copyNamedArgExpr(from);
-			break;
-		case T_OpExpr:
-			retval = _copyOpExpr(from);
-			break;
-		case T_DistinctExpr:
-			retval = _copyDistinctExpr(from);
-			break;
-		case T_NullIfExpr:
-			retval = _copyNullIfExpr(from);
-			break;
-		case T_ScalarArrayOpExpr:
-			retval = _copyScalarArrayOpExpr(from);
-			break;
-		case T_BoolExpr:
-			retval = _copyBoolExpr(from);
-			break;
-		case T_SubLink:
-			retval = _copySubLink(from);
-			break;
-		case T_SubPlan:
-			retval = _copySubPlan(from);
-			break;
-		case T_AlternativeSubPlan:
-			retval = _copyAlternativeSubPlan(from);
-			break;
-		case T_FieldSelect:
-			retval = _copyFieldSelect(from);
-			break;
-		case T_FieldStore:
-			retval = _copyFieldStore(from);
-			break;
-		case T_RelabelType:
-			retval = _copyRelabelType(from);
-			break;
-		case T_CoerceViaIO:
-			retval = _copyCoerceViaIO(from);
-			break;
-		case T_ArrayCoerceExpr:
-			retval = _copyArrayCoerceExpr(from);
-			break;
-		case T_ConvertRowtypeExpr:
-			retval = _copyConvertRowtypeExpr(from);
-			break;
-		case T_CollateExpr:
-			retval = _copyCollateExpr(from);
-			break;
-		case T_CaseExpr:
-			retval = _copyCaseExpr(from);
-			break;
-		case T_CaseWhen:
-			retval = _copyCaseWhen(from);
-			break;
-		case T_CaseTestExpr:
-			retval = _copyCaseTestExpr(from);
-			break;
-		case T_ArrayExpr:
-			retval = _copyArrayExpr(from);
-			break;
-		case T_RowExpr:
-			retval = _copyRowExpr(from);
-			break;
-		case T_RowCompareExpr:
-			retval = _copyRowCompareExpr(from);
-			break;
-		case T_CoalesceExpr:
-			retval = _copyCoalesceExpr(from);
-			break;
-		case T_MinMaxExpr:
-			retval = _copyMinMaxExpr(from);
-			break;
-		case T_SQLValueFunction:
-			retval = _copySQLValueFunction(from);
-			break;
-		case T_XmlExpr:
-			retval = _copyXmlExpr(from);
-			break;
-		case T_NullTest:
-			retval = _copyNullTest(from);
-			break;
-		case T_BooleanTest:
-			retval = _copyBooleanTest(from);
-			break;
-		case T_CoerceToDomain:
-			retval = _copyCoerceToDomain(from);
-			break;
-		case T_CoerceToDomainValue:
-			retval = _copyCoerceToDomainValue(from);
-			break;
-		case T_SetToDefault:
-			retval = _copySetToDefault(from);
-			break;
-		case T_CurrentOfExpr:
-			retval = _copyCurrentOfExpr(from);
-			break;
-		case T_NextValueExpr:
-			retval = _copyNextValueExpr(from);
-			break;
-		case T_InferenceElem:
-			retval = _copyInferenceElem(from);
-			break;
-		case T_TargetEntry:
-			retval = _copyTargetEntry(from);
-			break;
-		case T_RangeTblRef:
-			retval = _copyRangeTblRef(from);
-			break;
-		case T_JoinExpr:
-			retval = _copyJoinExpr(from);
-			break;
-		case T_FromExpr:
-			retval = _copyFromExpr(from);
-			break;
-		case T_OnConflictExpr:
-			retval = _copyOnConflictExpr(from);
-			break;
-		case T_JsonFormat:
-			retval = _copyJsonFormat(from);
-			break;
-		case T_JsonReturning:
-			retval = _copyJsonReturning(from);
-			break;
-		case T_JsonValueExpr:
-			retval = _copyJsonValueExpr(from);
-			break;
-		case T_JsonParseExpr:
-			retval = _copyJsonParseExpr(from);
-			break;
-		case T_JsonScalarExpr:
-			retval = _copyJsonScalarExpr(from);
-			break;
-		case T_JsonSerializeExpr:
-			retval = _copyJsonSerializeExpr(from);
-			break;
-		case T_JsonKeyValue:
-			retval = _copyJsonKeyValue(from);
-			break;
-		case T_JsonConstructorExpr:
-			retval = _copyJsonConstructorExpr(from);
-			break;
-		case T_JsonObjectConstructor:
-			retval = _copyJsonObjectConstructor(from);
-			break;
-		case T_JsonAggConstructor:
-			retval = _copyJsonAggConstructor(from);
-			break;
-		case T_JsonObjectAgg:
-			retval = _copyJsonObjectAgg(from);
-			break;
-		case T_JsonOutput:
-			retval = _copyJsonOutput(from);
-			break;
-		case T_JsonArrayConstructor:
-			retval = _copyJsonArrayConstructor(from);
-			break;
-		case T_JsonArrayQueryConstructor:
-			retval = _copyJsonArrayQueryConstructor(from);
-			break;
-		case T_JsonArrayAgg:
-			retval = _copyJsonArrayAgg(from);
-			break;
-		case T_JsonIsPredicate:
-			retval = _copyJsonIsPredicate(from);
-			break;
-		case T_JsonFuncExpr:
-			retval = _copyJsonFuncExpr(from);
-			break;
-		case T_JsonExpr:
-			retval = _copyJsonExpr(from);
-			break;
-		case T_JsonCommon:
-			retval = _copyJsonCommon(from);
-			break;
-		case T_JsonBehavior:
-			retval = _copyJsonBehavior(from);
-			break;
-		case T_JsonArgument:
-			retval = _copyJsonArgument(from);
-			break;
-		case T_JsonCoercion:
-			retval = _copyJsonCoercion(from);
-			break;
-		case T_JsonItemCoercions:
-			retval = _copyJsonItemCoercions(from);
-			break;
-		case T_JsonTable:
-			retval = _copyJsonTable(from);
-			break;
-		case T_JsonTableColumn:
-			retval = _copyJsonTableColumn(from);
-			break;
-		case T_JsonTablePlan:
-			retval = _copyJsonTablePlan(from);
-			break;
-		case T_JsonTableParent:
-			retval = _copyJsonTableParent(from);
-			break;
-		case T_JsonTableSibling:
-			retval = _copyJsonTableSibling(from);
-			break;
 
-			/*
-			 * RELATION NODES
-			 */
-		case T_PathKey:
-			retval = _copyPathKey(from);
-			break;
-		case T_RestrictInfo:
-			retval = _copyRestrictInfo(from);
-			break;
-		case T_PlaceHolderVar:
-			retval = _copyPlaceHolderVar(from);
-			break;
-		case T_SpecialJoinInfo:
-			retval = _copySpecialJoinInfo(from);
-			break;
-		case T_AppendRelInfo:
-			retval = _copyAppendRelInfo(from);
-			break;
-		case T_PlaceHolderInfo:
-			retval = _copyPlaceHolderInfo(from);
-			break;
-
-			/*
-			 * VALUE NODES
-			 */
-		case T_Integer:
-			retval = _copyInteger(from);
-			break;
-		case T_Float:
-			retval = _copyFloat(from);
-			break;
-		case T_Boolean:
-			retval = _copyBoolean(from);
-			break;
-		case T_String:
-			retval = _copyString(from);
-			break;
-		case T_BitString:
-			retval = _copyBitString(from);
-			break;
-#endif							/* OBSOLETE */
-
-			/*
-			 * LIST NODES
-			 */
 		case T_List:
 			retval = list_copy_deep(from);
 			break;
@@ -5995,561 +195,6 @@ copyObjectImpl(const void *from)
 			retval = list_copy(from);
 			break;
 
-#ifdef OBSOLETE
-
-			/*
-			 * EXTENSIBLE NODES
-			 */
-		case T_ExtensibleNode:
-			retval = _copyExtensibleNode(from);
-			break;
-
-			/*
-			 * PARSE NODES
-			 */
-		case T_Query:
-			retval = _copyQuery(from);
-			break;
-		case T_RawStmt:
-			retval = _copyRawStmt(from);
-			break;
-		case T_InsertStmt:
-			retval = _copyInsertStmt(from);
-			break;
-		case T_DeleteStmt:
-			retval = _copyDeleteStmt(from);
-			break;
-		case T_UpdateStmt:
-			retval = _copyUpdateStmt(from);
-			break;
-		case T_MergeStmt:
-			retval = _copyMergeStmt(from);
-			break;
-		case T_SelectStmt:
-			retval = _copySelectStmt(from);
-			break;
-		case T_SetOperationStmt:
-			retval = _copySetOperationStmt(from);
-			break;
-		case T_ReturnStmt:
-			retval = _copyReturnStmt(from);
-			break;
-		case T_PLAssignStmt:
-			retval = _copyPLAssignStmt(from);
-			break;
-		case T_AlterTableStmt:
-			retval = _copyAlterTableStmt(from);
-			break;
-		case T_AlterTableCmd:
-			retval = _copyAlterTableCmd(from);
-			break;
-		case T_AlterCollationStmt:
-			retval = _copyAlterCollationStmt(from);
-			break;
-		case T_AlterDomainStmt:
-			retval = _copyAlterDomainStmt(from);
-			break;
-		case T_GrantStmt:
-			retval = _copyGrantStmt(from);
-			break;
-		case T_GrantRoleStmt:
-			retval = _copyGrantRoleStmt(from);
-			break;
-		case T_AlterDefaultPrivilegesStmt:
-			retval = _copyAlterDefaultPrivilegesStmt(from);
-			break;
-		case T_DeclareCursorStmt:
-			retval = _copyDeclareCursorStmt(from);
-			break;
-		case T_ClosePortalStmt:
-			retval = _copyClosePortalStmt(from);
-			break;
-		case T_CallStmt:
-			retval = _copyCallStmt(from);
-			break;
-		case T_ClusterStmt:
-			retval = _copyClusterStmt(from);
-			break;
-		case T_CopyStmt:
-			retval = _copyCopyStmt(from);
-			break;
-		case T_CreateStmt:
-			retval = _copyCreateStmt(from);
-			break;
-		case T_TableLikeClause:
-			retval = _copyTableLikeClause(from);
-			break;
-		case T_DefineStmt:
-			retval = _copyDefineStmt(from);
-			break;
-		case T_DropStmt:
-			retval = _copyDropStmt(from);
-			break;
-		case T_TruncateStmt:
-			retval = _copyTruncateStmt(from);
-			break;
-		case T_CommentStmt:
-			retval = _copyCommentStmt(from);
-			break;
-		case T_SecLabelStmt:
-			retval = _copySecLabelStmt(from);
-			break;
-		case T_FetchStmt:
-			retval = _copyFetchStmt(from);
-			break;
-		case T_IndexStmt:
-			retval = _copyIndexStmt(from);
-			break;
-		case T_CreateStatsStmt:
-			retval = _copyCreateStatsStmt(from);
-			break;
-		case T_AlterStatsStmt:
-			retval = _copyAlterStatsStmt(from);
-			break;
-		case T_CreateFunctionStmt:
-			retval = _copyCreateFunctionStmt(from);
-			break;
-		case T_FunctionParameter:
-			retval = _copyFunctionParameter(from);
-			break;
-		case T_AlterFunctionStmt:
-			retval = _copyAlterFunctionStmt(from);
-			break;
-		case T_DoStmt:
-			retval = _copyDoStmt(from);
-			break;
-		case T_RenameStmt:
-			retval = _copyRenameStmt(from);
-			break;
-		case T_AlterObjectDependsStmt:
-			retval = _copyAlterObjectDependsStmt(from);
-			break;
-		case T_AlterObjectSchemaStmt:
-			retval = _copyAlterObjectSchemaStmt(from);
-			break;
-		case T_AlterOwnerStmt:
-			retval = _copyAlterOwnerStmt(from);
-			break;
-		case T_AlterOperatorStmt:
-			retval = _copyAlterOperatorStmt(from);
-			break;
-		case T_AlterTypeStmt:
-			retval = _copyAlterTypeStmt(from);
-			break;
-		case T_RuleStmt:
-			retval = _copyRuleStmt(from);
-			break;
-		case T_NotifyStmt:
-			retval = _copyNotifyStmt(from);
-			break;
-		case T_ListenStmt:
-			retval = _copyListenStmt(from);
-			break;
-		case T_UnlistenStmt:
-			retval = _copyUnlistenStmt(from);
-			break;
-		case T_TransactionStmt:
-			retval = _copyTransactionStmt(from);
-			break;
-		case T_CompositeTypeStmt:
-			retval = _copyCompositeTypeStmt(from);
-			break;
-		case T_CreateEnumStmt:
-			retval = _copyCreateEnumStmt(from);
-			break;
-		case T_CreateRangeStmt:
-			retval = _copyCreateRangeStmt(from);
-			break;
-		case T_AlterEnumStmt:
-			retval = _copyAlterEnumStmt(from);
-			break;
-		case T_ViewStmt:
-			retval = _copyViewStmt(from);
-			break;
-		case T_LoadStmt:
-			retval = _copyLoadStmt(from);
-			break;
-		case T_CreateDomainStmt:
-			retval = _copyCreateDomainStmt(from);
-			break;
-		case T_CreateOpClassStmt:
-			retval = _copyCreateOpClassStmt(from);
-			break;
-		case T_CreateOpClassItem:
-			retval = _copyCreateOpClassItem(from);
-			break;
-		case T_CreateOpFamilyStmt:
-			retval = _copyCreateOpFamilyStmt(from);
-			break;
-		case T_AlterOpFamilyStmt:
-			retval = _copyAlterOpFamilyStmt(from);
-			break;
-		case T_CreatedbStmt:
-			retval = _copyCreatedbStmt(from);
-			break;
-		case T_AlterDatabaseStmt:
-			retval = _copyAlterDatabaseStmt(from);
-			break;
-		case T_AlterDatabaseRefreshCollStmt:
-			retval = _copyAlterDatabaseRefreshCollStmt(from);
-			break;
-		case T_AlterDatabaseSetStmt:
-			retval = _copyAlterDatabaseSetStmt(from);
-			break;
-		case T_DropdbStmt:
-			retval = _copyDropdbStmt(from);
-			break;
-		case T_VacuumStmt:
-			retval = _copyVacuumStmt(from);
-			break;
-		case T_VacuumRelation:
-			retval = _copyVacuumRelation(from);
-			break;
-		case T_ExplainStmt:
-			retval = _copyExplainStmt(from);
-			break;
-		case T_CreateTableAsStmt:
-			retval = _copyCreateTableAsStmt(from);
-			break;
-		case T_RefreshMatViewStmt:
-			retval = _copyRefreshMatViewStmt(from);
-			break;
-		case T_ReplicaIdentityStmt:
-			retval = _copyReplicaIdentityStmt(from);
-			break;
-		case T_AlterSystemStmt:
-			retval = _copyAlterSystemStmt(from);
-			break;
-		case T_CreateSeqStmt:
-			retval = _copyCreateSeqStmt(from);
-			break;
-		case T_AlterSeqStmt:
-			retval = _copyAlterSeqStmt(from);
-			break;
-		case T_VariableSetStmt:
-			retval = _copyVariableSetStmt(from);
-			break;
-		case T_VariableShowStmt:
-			retval = _copyVariableShowStmt(from);
-			break;
-		case T_DiscardStmt:
-			retval = _copyDiscardStmt(from);
-			break;
-		case T_CreateTableSpaceStmt:
-			retval = _copyCreateTableSpaceStmt(from);
-			break;
-		case T_DropTableSpaceStmt:
-			retval = _copyDropTableSpaceStmt(from);
-			break;
-		case T_AlterTableSpaceOptionsStmt:
-			retval = _copyAlterTableSpaceOptionsStmt(from);
-			break;
-		case T_AlterTableMoveAllStmt:
-			retval = _copyAlterTableMoveAllStmt(from);
-			break;
-		case T_CreateExtensionStmt:
-			retval = _copyCreateExtensionStmt(from);
-			break;
-		case T_AlterExtensionStmt:
-			retval = _copyAlterExtensionStmt(from);
-			break;
-		case T_AlterExtensionContentsStmt:
-			retval = _copyAlterExtensionContentsStmt(from);
-			break;
-		case T_CreateFdwStmt:
-			retval = _copyCreateFdwStmt(from);
-			break;
-		case T_AlterFdwStmt:
-			retval = _copyAlterFdwStmt(from);
-			break;
-		case T_CreateForeignServerStmt:
-			retval = _copyCreateForeignServerStmt(from);
-			break;
-		case T_AlterForeignServerStmt:
-			retval = _copyAlterForeignServerStmt(from);
-			break;
-		case T_CreateUserMappingStmt:
-			retval = _copyCreateUserMappingStmt(from);
-			break;
-		case T_AlterUserMappingStmt:
-			retval = _copyAlterUserMappingStmt(from);
-			break;
-		case T_DropUserMappingStmt:
-			retval = _copyDropUserMappingStmt(from);
-			break;
-		case T_CreateForeignTableStmt:
-			retval = _copyCreateForeignTableStmt(from);
-			break;
-		case T_ImportForeignSchemaStmt:
-			retval = _copyImportForeignSchemaStmt(from);
-			break;
-		case T_CreateTransformStmt:
-			retval = _copyCreateTransformStmt(from);
-			break;
-		case T_CreateAmStmt:
-			retval = _copyCreateAmStmt(from);
-			break;
-		case T_CreateTrigStmt:
-			retval = _copyCreateTrigStmt(from);
-			break;
-		case T_CreateEventTrigStmt:
-			retval = _copyCreateEventTrigStmt(from);
-			break;
-		case T_AlterEventTrigStmt:
-			retval = _copyAlterEventTrigStmt(from);
-			break;
-		case T_CreatePLangStmt:
-			retval = _copyCreatePLangStmt(from);
-			break;
-		case T_CreateRoleStmt:
-			retval = _copyCreateRoleStmt(from);
-			break;
-		case T_AlterRoleStmt:
-			retval = _copyAlterRoleStmt(from);
-			break;
-		case T_AlterRoleSetStmt:
-			retval = _copyAlterRoleSetStmt(from);
-			break;
-		case T_DropRoleStmt:
-			retval = _copyDropRoleStmt(from);
-			break;
-		case T_LockStmt:
-			retval = _copyLockStmt(from);
-			break;
-		case T_ConstraintsSetStmt:
-			retval = _copyConstraintsSetStmt(from);
-			break;
-		case T_ReindexStmt:
-			retval = _copyReindexStmt(from);
-			break;
-		case T_CheckPointStmt:
-			retval = (void *) makeNode(CheckPointStmt);
-			break;
-		case T_CreateSchemaStmt:
-			retval = _copyCreateSchemaStmt(from);
-			break;
-		case T_CreateConversionStmt:
-			retval = _copyCreateConversionStmt(from);
-			break;
-		case T_CreateCastStmt:
-			retval = _copyCreateCastStmt(from);
-			break;
-		case T_PrepareStmt:
-			retval = _copyPrepareStmt(from);
-			break;
-		case T_ExecuteStmt:
-			retval = _copyExecuteStmt(from);
-			break;
-		case T_DeallocateStmt:
-			retval = _copyDeallocateStmt(from);
-			break;
-		case T_DropOwnedStmt:
-			retval = _copyDropOwnedStmt(from);
-			break;
-		case T_ReassignOwnedStmt:
-			retval = _copyReassignOwnedStmt(from);
-			break;
-		case T_AlterTSDictionaryStmt:
-			retval = _copyAlterTSDictionaryStmt(from);
-			break;
-		case T_AlterTSConfigurationStmt:
-			retval = _copyAlterTSConfigurationStmt(from);
-			break;
-		case T_CreatePolicyStmt:
-			retval = _copyCreatePolicyStmt(from);
-			break;
-		case T_AlterPolicyStmt:
-			retval = _copyAlterPolicyStmt(from);
-			break;
-		case T_CreatePublicationStmt:
-			retval = _copyCreatePublicationStmt(from);
-			break;
-		case T_AlterPublicationStmt:
-			retval = _copyAlterPublicationStmt(from);
-			break;
-		case T_CreateSubscriptionStmt:
-			retval = _copyCreateSubscriptionStmt(from);
-			break;
-		case T_AlterSubscriptionStmt:
-			retval = _copyAlterSubscriptionStmt(from);
-			break;
-		case T_DropSubscriptionStmt:
-			retval = _copyDropSubscriptionStmt(from);
-			break;
-		case T_A_Expr:
-			retval = _copyA_Expr(from);
-			break;
-		case T_ColumnRef:
-			retval = _copyColumnRef(from);
-			break;
-		case T_ParamRef:
-			retval = _copyParamRef(from);
-			break;
-		case T_A_Const:
-			retval = _copyA_Const(from);
-			break;
-		case T_FuncCall:
-			retval = _copyFuncCall(from);
-			break;
-		case T_A_Star:
-			retval = _copyA_Star(from);
-			break;
-		case T_A_Indices:
-			retval = _copyA_Indices(from);
-			break;
-		case T_A_Indirection:
-			retval = _copyA_Indirection(from);
-			break;
-		case T_A_ArrayExpr:
-			retval = _copyA_ArrayExpr(from);
-			break;
-		case T_ResTarget:
-			retval = _copyResTarget(from);
-			break;
-		case T_MultiAssignRef:
-			retval = _copyMultiAssignRef(from);
-			break;
-		case T_TypeCast:
-			retval = _copyTypeCast(from);
-			break;
-		case T_CollateClause:
-			retval = _copyCollateClause(from);
-			break;
-		case T_SortBy:
-			retval = _copySortBy(from);
-			break;
-		case T_WindowDef:
-			retval = _copyWindowDef(from);
-			break;
-		case T_RangeSubselect:
-			retval = _copyRangeSubselect(from);
-			break;
-		case T_RangeFunction:
-			retval = _copyRangeFunction(from);
-			break;
-		case T_RangeTableSample:
-			retval = _copyRangeTableSample(from);
-			break;
-		case T_RangeTableFunc:
-			retval = _copyRangeTableFunc(from);
-			break;
-		case T_RangeTableFuncCol:
-			retval = _copyRangeTableFuncCol(from);
-			break;
-		case T_TypeName:
-			retval = _copyTypeName(from);
-			break;
-		case T_IndexElem:
-			retval = _copyIndexElem(from);
-			break;
-		case T_StatsElem:
-			retval = _copyStatsElem(from);
-			break;
-		case T_ColumnDef:
-			retval = _copyColumnDef(from);
-			break;
-		case T_Constraint:
-			retval = _copyConstraint(from);
-			break;
-		case T_DefElem:
-			retval = _copyDefElem(from);
-			break;
-		case T_LockingClause:
-			retval = _copyLockingClause(from);
-			break;
-		case T_RangeTblEntry:
-			retval = _copyRangeTblEntry(from);
-			break;
-		case T_RangeTblFunction:
-			retval = _copyRangeTblFunction(from);
-			break;
-		case T_TableSampleClause:
-			retval = _copyTableSampleClause(from);
-			break;
-		case T_WithCheckOption:
-			retval = _copyWithCheckOption(from);
-			break;
-		case T_SortGroupClause:
-			retval = _copySortGroupClause(from);
-			break;
-		case T_GroupingSet:
-			retval = _copyGroupingSet(from);
-			break;
-		case T_WindowClause:
-			retval = _copyWindowClause(from);
-			break;
-		case T_RowMarkClause:
-			retval = _copyRowMarkClause(from);
-			break;
-		case T_WithClause:
-			retval = _copyWithClause(from);
-			break;
-		case T_InferClause:
-			retval = _copyInferClause(from);
-			break;
-		case T_OnConflictClause:
-			retval = _copyOnConflictClause(from);
-			break;
-		case T_CTESearchClause:
-			retval = _copyCTESearchClause(from);
-			break;
-		case T_CTECycleClause:
-			retval = _copyCTECycleClause(from);
-			break;
-		case T_CommonTableExpr:
-			retval = _copyCommonTableExpr(from);
-			break;
-		case T_MergeWhenClause:
-			retval = _copyMergeWhenClause(from);
-			break;
-		case T_MergeAction:
-			retval = _copyMergeAction(from);
-			break;
-		case T_ObjectWithArgs:
-			retval = _copyObjectWithArgs(from);
-			break;
-		case T_AccessPriv:
-			retval = _copyAccessPriv(from);
-			break;
-		case T_XmlSerialize:
-			retval = _copyXmlSerialize(from);
-			break;
-		case T_RoleSpec:
-			retval = _copyRoleSpec(from);
-			break;
-		case T_TriggerTransition:
-			retval = _copyTriggerTransition(from);
-			break;
-		case T_PartitionElem:
-			retval = _copyPartitionElem(from);
-			break;
-		case T_PartitionSpec:
-			retval = _copyPartitionSpec(from);
-			break;
-		case T_PartitionBoundSpec:
-			retval = _copyPartitionBoundSpec(from);
-			break;
-		case T_PartitionRangeDatum:
-			retval = _copyPartitionRangeDatum(from);
-			break;
-		case T_PartitionCmd:
-			retval = _copyPartitionCmd(from);
-			break;
-		case T_PublicationObjSpec:
-			retval = _copyPublicationObject(from);
-			break;
-		case T_PublicationTable:
-			retval = _copyPublicationTable(from);
-			break;
-
-			/*
-			 * MISCELLANEOUS NODES
-			 */
-		case T_ForeignKeyCacheInfo:
-			retval = _copyForeignKeyCacheInfo(from);
-			break;
-#endif							/* OBSOLETE */
-
 		default:
 			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
 			retval = 0;			/* keep compiler quiet */
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index 8d18548ade..8d54e1a486 100644
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -3,13 +3,6 @@
  * equalfuncs.c
  *	  Equality functions to compare node trees.
  *
- * NOTE: we currently support comparing all node types found in parse
- * trees.  We do not support comparing executor state trees; there
- * is no need for that, and no point in maintaining all the code that
- * would be needed.  We also do not support comparing Path trees, mainly
- * because the circular linkages between RelOptInfo and Path nodes can't
- * be handled easily in a simple depth-first traversal.
- *
  * NOTE: it is intentional that parse location fields (in nodes that have
  * one) are not compared.  This is because we want, for example, a variable
  * "x" to be considered equal() to another reference to "x" in the query.
@@ -94,171 +87,12 @@
 
 #include "equalfuncs.funcs.c"
 
-#ifdef OBSOLETE
-/*
- *	Stuff from primnodes.h
- */
-
-static bool
-_equalAlias(const Alias *a, const Alias *b)
-{
-	COMPARE_STRING_FIELD(aliasname);
-	COMPARE_NODE_FIELD(colnames);
-
-	return true;
-}
-
-static bool
-_equalRangeVar(const RangeVar *a, const RangeVar *b)
-{
-	COMPARE_STRING_FIELD(catalogname);
-	COMPARE_STRING_FIELD(schemaname);
-	COMPARE_STRING_FIELD(relname);
-	COMPARE_SCALAR_FIELD(inh);
-	COMPARE_SCALAR_FIELD(relpersistence);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalTableFunc(const TableFunc *a, const TableFunc *b)
-{
-	COMPARE_SCALAR_FIELD(functype);
-	COMPARE_NODE_FIELD(ns_uris);
-	COMPARE_NODE_FIELD(ns_names);
-	COMPARE_NODE_FIELD(docexpr);
-	COMPARE_NODE_FIELD(rowexpr);
-	COMPARE_NODE_FIELD(colnames);
-	COMPARE_NODE_FIELD(coltypes);
-	COMPARE_NODE_FIELD(coltypmods);
-	COMPARE_NODE_FIELD(colcollations);
-	COMPARE_NODE_FIELD(colexprs);
-	COMPARE_NODE_FIELD(coldefexprs);
-	COMPARE_NODE_FIELD(colvalexprs);
-	COMPARE_BITMAPSET_FIELD(notnulls);
-	COMPARE_NODE_FIELD(plan);
-	COMPARE_SCALAR_FIELD(ordinalitycol);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonTablePlan(const JsonTablePlan *a, const JsonTablePlan *b)
-{
-	COMPARE_SCALAR_FIELD(plan_type);
-	COMPARE_SCALAR_FIELD(join_type);
-	COMPARE_NODE_FIELD(plan1);
-	COMPARE_NODE_FIELD(plan2);
-	COMPARE_STRING_FIELD(pathname);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonTable(const JsonTable *a, const JsonTable *b)
-{
-	COMPARE_NODE_FIELD(common);
-	COMPARE_NODE_FIELD(columns);
-	COMPARE_NODE_FIELD(plan);
-	COMPARE_NODE_FIELD(on_error);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonTableColumn(const JsonTableColumn *a, const JsonTableColumn *b)
-{
-	COMPARE_SCALAR_FIELD(coltype);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_STRING_FIELD(pathspec);
-	COMPARE_STRING_FIELD(pathname);
-	COMPARE_NODE_FIELD(format);
-	COMPARE_SCALAR_FIELD(wrapper);
-	COMPARE_SCALAR_FIELD(omit_quotes);
-	COMPARE_NODE_FIELD(columns);
-	COMPARE_NODE_FIELD(on_empty);
-	COMPARE_NODE_FIELD(on_error);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonTableParent(const JsonTableParent *a, const JsonTableParent *b)
-{
-	COMPARE_NODE_FIELD(path);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(child);
-	COMPARE_SCALAR_FIELD(outerJoin);
-	COMPARE_SCALAR_FIELD(colMin);
-	COMPARE_SCALAR_FIELD(colMax);
-	COMPARE_SCALAR_FIELD(errorOnError);
-
-	return true;
-}
-
-static bool
-_equalJsonTableSibling(const JsonTableSibling *a, const JsonTableSibling *b)
-{
-	COMPARE_NODE_FIELD(larg);
-	COMPARE_NODE_FIELD(rarg);
-	COMPARE_SCALAR_FIELD(cross);
-
-	return true;
-}
-
-static bool
-_equalIntoClause(const IntoClause *a, const IntoClause *b)
-{
-	COMPARE_NODE_FIELD(rel);
-	COMPARE_NODE_FIELD(colNames);
-	COMPARE_STRING_FIELD(accessMethod);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(onCommit);
-	COMPARE_STRING_FIELD(tableSpaceName);
-	COMPARE_NODE_FIELD(viewQuery);
-	COMPARE_SCALAR_FIELD(skipData);
-
-	return true;
-}
 
 /*
- * We don't need an _equalExpr because Expr is an abstract supertype which
- * should never actually get instantiated.  Also, since it has no common
- * fields except NodeTag, there's no need for a helper routine to factor
- * out comparing the common fields...
+ * Support functions for nodes with custom_copy_equal attribute
  */
 
 static bool
-_equalVar(const Var *a, const Var *b)
-{
-	COMPARE_SCALAR_FIELD(varno);
-	COMPARE_SCALAR_FIELD(varattno);
-	COMPARE_SCALAR_FIELD(vartype);
-	COMPARE_SCALAR_FIELD(vartypmod);
-	COMPARE_SCALAR_FIELD(varcollid);
-	COMPARE_SCALAR_FIELD(varlevelsup);
-
-	/*
-	 * varnosyn/varattnosyn are intentionally ignored here, because Vars with
-	 * different syntactic identifiers are semantically the same as long as
-	 * their varno/varattno match.
-	 */
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-#endif							/* OBSOLETE */
-
-static bool
 _equalConst(const Const *a, const Const *b)
 {
 	COMPARE_SCALAR_FIELD(consttype);
@@ -279,1036 +113,6 @@ _equalConst(const Const *a, const Const *b)
 						a->constbyval, a->constlen);
 }
 
-#ifdef OBSOLETE
-static bool
-_equalParam(const Param *a, const Param *b)
-{
-	COMPARE_SCALAR_FIELD(paramkind);
-	COMPARE_SCALAR_FIELD(paramid);
-	COMPARE_SCALAR_FIELD(paramtype);
-	COMPARE_SCALAR_FIELD(paramtypmod);
-	COMPARE_SCALAR_FIELD(paramcollid);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalAggref(const Aggref *a, const Aggref *b)
-{
-	COMPARE_SCALAR_FIELD(aggfnoid);
-	COMPARE_SCALAR_FIELD(aggtype);
-	COMPARE_SCALAR_FIELD(aggcollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	/* ignore aggtranstype since it might not be set yet */
-	COMPARE_NODE_FIELD(aggargtypes);
-	COMPARE_NODE_FIELD(aggdirectargs);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(aggorder);
-	COMPARE_NODE_FIELD(aggdistinct);
-	COMPARE_NODE_FIELD(aggfilter);
-	COMPARE_SCALAR_FIELD(aggstar);
-	COMPARE_SCALAR_FIELD(aggvariadic);
-	COMPARE_SCALAR_FIELD(aggkind);
-	COMPARE_SCALAR_FIELD(agglevelsup);
-	COMPARE_SCALAR_FIELD(aggsplit);
-	COMPARE_SCALAR_FIELD(aggno);
-	COMPARE_SCALAR_FIELD(aggtransno);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b)
-{
-	COMPARE_NODE_FIELD(args);
-
-	/*
-	 * We must not compare the refs or cols field
-	 */
-
-	COMPARE_SCALAR_FIELD(agglevelsup);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
-{
-	COMPARE_SCALAR_FIELD(winfnoid);
-	COMPARE_SCALAR_FIELD(wintype);
-	COMPARE_SCALAR_FIELD(wincollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(aggfilter);
-	COMPARE_SCALAR_FIELD(winref);
-	COMPARE_SCALAR_FIELD(winstar);
-	COMPARE_SCALAR_FIELD(winagg);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
-{
-	COMPARE_SCALAR_FIELD(refcontainertype);
-	COMPARE_SCALAR_FIELD(refelemtype);
-	COMPARE_SCALAR_FIELD(refrestype);
-	COMPARE_SCALAR_FIELD(reftypmod);
-	COMPARE_SCALAR_FIELD(refcollid);
-	COMPARE_NODE_FIELD(refupperindexpr);
-	COMPARE_NODE_FIELD(reflowerindexpr);
-	COMPARE_NODE_FIELD(refexpr);
-	COMPARE_NODE_FIELD(refassgnexpr);
-
-	return true;
-}
-
-static bool
-_equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
-{
-	COMPARE_SCALAR_FIELD(funcid);
-	COMPARE_SCALAR_FIELD(funcresulttype);
-	COMPARE_SCALAR_FIELD(funcretset);
-	COMPARE_SCALAR_FIELD(funcvariadic);
-	COMPARE_COERCIONFORM_FIELD(funcformat);
-	COMPARE_SCALAR_FIELD(funccollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_SCALAR_FIELD(argnumber);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalOpExpr(const OpExpr *a, const OpExpr *b)
-{
-	COMPARE_SCALAR_FIELD(opno);
-
-	/*
-	 * Special-case opfuncid: it is allowable for it to differ if one node
-	 * contains zero and the other doesn't.  This just means that the one node
-	 * isn't as far along in the parse/plan pipeline and hasn't had the
-	 * opfuncid cache filled yet.
-	 */
-	if (a->opfuncid != b->opfuncid &&
-		a->opfuncid != 0 &&
-		b->opfuncid != 0)
-		return false;
-
-	COMPARE_SCALAR_FIELD(opresulttype);
-	COMPARE_SCALAR_FIELD(opretset);
-	COMPARE_SCALAR_FIELD(opcollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
-{
-	COMPARE_SCALAR_FIELD(opno);
-
-	/*
-	 * Special-case opfuncid: it is allowable for it to differ if one node
-	 * contains zero and the other doesn't.  This just means that the one node
-	 * isn't as far along in the parse/plan pipeline and hasn't had the
-	 * opfuncid cache filled yet.
-	 */
-	if (a->opfuncid != b->opfuncid &&
-		a->opfuncid != 0 &&
-		b->opfuncid != 0)
-		return false;
-
-	COMPARE_SCALAR_FIELD(opresulttype);
-	COMPARE_SCALAR_FIELD(opretset);
-	COMPARE_SCALAR_FIELD(opcollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
-{
-	COMPARE_SCALAR_FIELD(opno);
-
-	/*
-	 * Special-case opfuncid: it is allowable for it to differ if one node
-	 * contains zero and the other doesn't.  This just means that the one node
-	 * isn't as far along in the parse/plan pipeline and hasn't had the
-	 * opfuncid cache filled yet.
-	 */
-	if (a->opfuncid != b->opfuncid &&
-		a->opfuncid != 0 &&
-		b->opfuncid != 0)
-		return false;
-
-	COMPARE_SCALAR_FIELD(opresulttype);
-	COMPARE_SCALAR_FIELD(opretset);
-	COMPARE_SCALAR_FIELD(opcollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
-{
-	COMPARE_SCALAR_FIELD(opno);
-
-	/*
-	 * Special-case opfuncid: it is allowable for it to differ if one node
-	 * contains zero and the other doesn't.  This just means that the one node
-	 * isn't as far along in the parse/plan pipeline and hasn't had the
-	 * opfuncid cache filled yet.
-	 */
-	if (a->opfuncid != b->opfuncid &&
-		a->opfuncid != 0 &&
-		b->opfuncid != 0)
-		return false;
-
-	/* As above, hashfuncid may differ too */
-	if (a->hashfuncid != b->hashfuncid &&
-		a->hashfuncid != 0 &&
-		b->hashfuncid != 0)
-		return false;
-
-	/* Likewise for the negfuncid */
-	if (a->negfuncid != b->negfuncid &&
-		a->negfuncid != 0 &&
-		b->negfuncid != 0)
-		return false;
-
-	COMPARE_SCALAR_FIELD(useOr);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
-{
-	COMPARE_SCALAR_FIELD(boolop);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSubLink(const SubLink *a, const SubLink *b)
-{
-	COMPARE_SCALAR_FIELD(subLinkType);
-	COMPARE_SCALAR_FIELD(subLinkId);
-	COMPARE_NODE_FIELD(testexpr);
-	COMPARE_NODE_FIELD(operName);
-	COMPARE_NODE_FIELD(subselect);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSubPlan(const SubPlan *a, const SubPlan *b)
-{
-	COMPARE_SCALAR_FIELD(subLinkType);
-	COMPARE_NODE_FIELD(testexpr);
-	COMPARE_NODE_FIELD(paramIds);
-	COMPARE_SCALAR_FIELD(plan_id);
-	COMPARE_STRING_FIELD(plan_name);
-	COMPARE_SCALAR_FIELD(firstColType);
-	COMPARE_SCALAR_FIELD(firstColTypmod);
-	COMPARE_SCALAR_FIELD(firstColCollation);
-	COMPARE_SCALAR_FIELD(useHashTable);
-	COMPARE_SCALAR_FIELD(unknownEqFalse);
-	COMPARE_SCALAR_FIELD(parallel_safe);
-	COMPARE_NODE_FIELD(setParam);
-	COMPARE_NODE_FIELD(parParam);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_SCALAR_FIELD(startup_cost);
-	COMPARE_SCALAR_FIELD(per_call_cost);
-
-	return true;
-}
-
-static bool
-_equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
-{
-	COMPARE_NODE_FIELD(subplans);
-
-	return true;
-}
-
-static bool
-_equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(fieldnum);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_SCALAR_FIELD(resulttypmod);
-	COMPARE_SCALAR_FIELD(resultcollid);
-
-	return true;
-}
-
-static bool
-_equalFieldStore(const FieldStore *a, const FieldStore *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(newvals);
-	COMPARE_NODE_FIELD(fieldnums);
-	COMPARE_SCALAR_FIELD(resulttype);
-
-	return true;
-}
-
-static bool
-_equalRelabelType(const RelabelType *a, const RelabelType *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_SCALAR_FIELD(resulttypmod);
-	COMPARE_SCALAR_FIELD(resultcollid);
-	COMPARE_COERCIONFORM_FIELD(relabelformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_SCALAR_FIELD(resultcollid);
-	COMPARE_COERCIONFORM_FIELD(coerceformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(elemexpr);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_SCALAR_FIELD(resulttypmod);
-	COMPARE_SCALAR_FIELD(resultcollid);
-	COMPARE_COERCIONFORM_FIELD(coerceformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_COERCIONFORM_FIELD(convertformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(collOid);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
-{
-	COMPARE_SCALAR_FIELD(casetype);
-	COMPARE_SCALAR_FIELD(casecollid);
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(defresult);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(result);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
-{
-	COMPARE_SCALAR_FIELD(typeId);
-	COMPARE_SCALAR_FIELD(typeMod);
-	COMPARE_SCALAR_FIELD(collation);
-
-	return true;
-}
-
-static bool
-_equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
-{
-	COMPARE_SCALAR_FIELD(array_typeid);
-	COMPARE_SCALAR_FIELD(array_collid);
-	COMPARE_SCALAR_FIELD(element_typeid);
-	COMPARE_NODE_FIELD(elements);
-	COMPARE_SCALAR_FIELD(multidims);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRowExpr(const RowExpr *a, const RowExpr *b)
-{
-	COMPARE_NODE_FIELD(args);
-	COMPARE_SCALAR_FIELD(row_typeid);
-	COMPARE_COERCIONFORM_FIELD(row_format);
-	COMPARE_NODE_FIELD(colnames);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
-{
-	COMPARE_SCALAR_FIELD(rctype);
-	COMPARE_NODE_FIELD(opnos);
-	COMPARE_NODE_FIELD(opfamilies);
-	COMPARE_NODE_FIELD(inputcollids);
-	COMPARE_NODE_FIELD(largs);
-	COMPARE_NODE_FIELD(rargs);
-
-	return true;
-}
-
-static bool
-_equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
-{
-	COMPARE_SCALAR_FIELD(coalescetype);
-	COMPARE_SCALAR_FIELD(coalescecollid);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
-{
-	COMPARE_SCALAR_FIELD(minmaxtype);
-	COMPARE_SCALAR_FIELD(minmaxcollid);
-	COMPARE_SCALAR_FIELD(inputcollid);
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b)
-{
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_SCALAR_FIELD(type);
-	COMPARE_SCALAR_FIELD(typmod);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
-{
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(named_args);
-	COMPARE_NODE_FIELD(arg_names);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_SCALAR_FIELD(xmloption);
-	COMPARE_SCALAR_FIELD(type);
-	COMPARE_SCALAR_FIELD(typmod);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalNullTest(const NullTest *a, const NullTest *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(nulltesttype);
-	COMPARE_SCALAR_FIELD(argisrow);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(booltesttype);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(resulttype);
-	COMPARE_SCALAR_FIELD(resulttypmod);
-	COMPARE_SCALAR_FIELD(resultcollid);
-	COMPARE_COERCIONFORM_FIELD(coercionformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
-{
-	COMPARE_SCALAR_FIELD(typeId);
-	COMPARE_SCALAR_FIELD(typeMod);
-	COMPARE_SCALAR_FIELD(collation);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
-{
-	COMPARE_SCALAR_FIELD(typeId);
-	COMPARE_SCALAR_FIELD(typeMod);
-	COMPARE_SCALAR_FIELD(collation);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
-{
-	COMPARE_SCALAR_FIELD(cvarno);
-	COMPARE_STRING_FIELD(cursor_name);
-	COMPARE_SCALAR_FIELD(cursor_param);
-
-	return true;
-}
-
-static bool
-_equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b)
-{
-	COMPARE_SCALAR_FIELD(seqid);
-	COMPARE_SCALAR_FIELD(typeId);
-
-	return true;
-}
-
-static bool
-_equalInferenceElem(const InferenceElem *a, const InferenceElem *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_SCALAR_FIELD(infercollid);
-	COMPARE_SCALAR_FIELD(inferopclass);
-
-	return true;
-}
-
-static bool
-_equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_SCALAR_FIELD(resno);
-	COMPARE_STRING_FIELD(resname);
-	COMPARE_SCALAR_FIELD(ressortgroupref);
-	COMPARE_SCALAR_FIELD(resorigtbl);
-	COMPARE_SCALAR_FIELD(resorigcol);
-	COMPARE_SCALAR_FIELD(resjunk);
-
-	return true;
-}
-
-static bool
-_equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
-{
-	COMPARE_SCALAR_FIELD(rtindex);
-
-	return true;
-}
-
-static bool
-_equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
-{
-	COMPARE_SCALAR_FIELD(jointype);
-	COMPARE_SCALAR_FIELD(isNatural);
-	COMPARE_NODE_FIELD(larg);
-	COMPARE_NODE_FIELD(rarg);
-	COMPARE_NODE_FIELD(usingClause);
-	COMPARE_NODE_FIELD(join_using_alias);
-	COMPARE_NODE_FIELD(quals);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_SCALAR_FIELD(rtindex);
-
-	return true;
-}
-
-static bool
-_equalFromExpr(const FromExpr *a, const FromExpr *b)
-{
-	COMPARE_NODE_FIELD(fromlist);
-	COMPARE_NODE_FIELD(quals);
-
-	return true;
-}
-
-static bool
-_equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b)
-{
-	COMPARE_SCALAR_FIELD(action);
-	COMPARE_NODE_FIELD(arbiterElems);
-	COMPARE_NODE_FIELD(arbiterWhere);
-	COMPARE_SCALAR_FIELD(constraint);
-	COMPARE_NODE_FIELD(onConflictSet);
-	COMPARE_NODE_FIELD(onConflictWhere);
-	COMPARE_SCALAR_FIELD(exclRelIndex);
-	COMPARE_NODE_FIELD(exclRelTlist);
-
-	return true;
-}
-
-static bool
-_equalJsonFormat(const JsonFormat *a, const JsonFormat *b)
-{
-	COMPARE_SCALAR_FIELD(format_type);
-	COMPARE_SCALAR_FIELD(encoding);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonReturning(const JsonReturning *a, const JsonReturning *b)
-{
-	COMPARE_NODE_FIELD(format);
-	COMPARE_SCALAR_FIELD(typid);
-	COMPARE_SCALAR_FIELD(typmod);
-
-	return true;
-}
-
-static bool
-_equalJsonValueExpr(const JsonValueExpr *a, const JsonValueExpr *b)
-{
-	COMPARE_NODE_FIELD(raw_expr);
-	COMPARE_NODE_FIELD(formatted_expr);
-	COMPARE_NODE_FIELD(format);
-
-	return true;
-}
-
-static bool
-_equalJsonParseExpr(const JsonParseExpr *a, const JsonParseExpr *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_SCALAR_FIELD(unique_keys);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonScalarExpr(const JsonScalarExpr *a, const JsonScalarExpr *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonSerializeExpr(const JsonSerializeExpr *a, const JsonSerializeExpr *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonConstructorExpr(const JsonConstructorExpr *a, const JsonConstructorExpr *b)
-{
-	COMPARE_SCALAR_FIELD(type);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(func);
-	COMPARE_NODE_FIELD(coercion);
-	COMPARE_NODE_FIELD(returning);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-	COMPARE_SCALAR_FIELD(unique);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonKeyValue(const JsonKeyValue *a, const JsonKeyValue *b)
-{
-	COMPARE_NODE_FIELD(key);
-	COMPARE_NODE_FIELD(value);
-
-	return true;
-}
-
-static bool
-_equalJsonObjectConstructor(const JsonObjectConstructor *a,
-							const JsonObjectConstructor *b)
-{
-	COMPARE_NODE_FIELD(exprs);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-	COMPARE_SCALAR_FIELD(unique);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonAggConstructor(const JsonAggConstructor *a,
-						 const JsonAggConstructor *b)
-{
-	COMPARE_NODE_FIELD(output);
-	COMPARE_NODE_FIELD(agg_filter);
-	COMPARE_NODE_FIELD(agg_order);
-	COMPARE_NODE_FIELD(over);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonObjectAgg(const JsonObjectAgg *a, const JsonObjectAgg *b)
-{
-	COMPARE_NODE_FIELD(constructor);
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-	COMPARE_SCALAR_FIELD(unique);
-
-	return true;
-}
-
-static bool
-_equalJsonOutput(const JsonOutput *a, const JsonOutput *b)
-{
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(returning);
-
-	return true;
-}
-
-static bool
-_equalJsonArrayConstructor(const JsonArrayConstructor *a,
-						   const JsonArrayConstructor *b)
-{
-	COMPARE_NODE_FIELD(exprs);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonArrayAgg(const JsonArrayAgg *a, const JsonArrayAgg *b)
-{
-	COMPARE_NODE_FIELD(constructor);
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-
-	return true;
-}
-
-static bool
-_equalJsonArrayQueryConstructor(const JsonArrayQueryConstructor *a,
-								const JsonArrayQueryConstructor *b)
-{
-	COMPARE_NODE_FIELD(query);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_NODE_FIELD(format);
-	COMPARE_SCALAR_FIELD(absent_on_null);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonFuncExpr(const JsonFuncExpr *a, const JsonFuncExpr *b)
-{
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_NODE_FIELD(common);
-	COMPARE_NODE_FIELD(output);
-	COMPARE_NODE_FIELD(on_empty);
-	COMPARE_NODE_FIELD(on_error);
-	COMPARE_SCALAR_FIELD(wrapper);
-	COMPARE_SCALAR_FIELD(omit_quotes);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonCommon(const JsonCommon *a, const JsonCommon *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(pathspec);
-	COMPARE_STRING_FIELD(pathname);
-	COMPARE_NODE_FIELD(passing);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalJsonArgument(const JsonArgument *a, const JsonArgument *b)
-{
-	COMPARE_NODE_FIELD(val);
-	COMPARE_STRING_FIELD(name);
-
-	return true;
-}
-
-static bool
-_equalJsonIsPredicate(const JsonIsPredicate *a,
-					  const JsonIsPredicate *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(format);
-	COMPARE_SCALAR_FIELD(item_type);
-	COMPARE_SCALAR_FIELD(unique_keys);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-/*
- * _equalJsonBehavior
- */
-static bool
-_equalJsonBehavior(const JsonBehavior *a, const JsonBehavior *b)
-{
-	COMPARE_SCALAR_FIELD(btype);
-	COMPARE_NODE_FIELD(default_expr);
-
-	return true;
-}
-
-/*
- * _equalJsonExpr
- */
-static bool
-_equalJsonExpr(const JsonExpr *a, const JsonExpr *b)
-{
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_NODE_FIELD(formatted_expr);
-	COMPARE_NODE_FIELD(result_coercion);
-	COMPARE_NODE_FIELD(format);
-	COMPARE_NODE_FIELD(path_spec);
-	COMPARE_NODE_FIELD(passing_names);
-	COMPARE_NODE_FIELD(passing_values);
-	COMPARE_NODE_FIELD(returning);
-	COMPARE_NODE_FIELD(on_empty);
-	COMPARE_NODE_FIELD(on_error);
-	COMPARE_NODE_FIELD(coercions);
-	COMPARE_SCALAR_FIELD(wrapper);
-	COMPARE_SCALAR_FIELD(omit_quotes);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-/*
- * _equalJsonCoercion
- */
-static bool
-_equalJsonCoercion(const JsonCoercion *a, const JsonCoercion *b)
-{
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_SCALAR_FIELD(via_populate);
-	COMPARE_SCALAR_FIELD(via_io);
-	COMPARE_SCALAR_FIELD(collation);
-
-	return true;
-}
-
-/*
- * _equalJsonItemCoercions
- */
-static bool
-_equalJsonItemCoercions(const JsonItemCoercions *a, const JsonItemCoercions *b)
-{
-	COMPARE_NODE_FIELD(null);
-	COMPARE_NODE_FIELD(string);
-	COMPARE_NODE_FIELD(numeric);
-	COMPARE_NODE_FIELD(boolean);
-	COMPARE_NODE_FIELD(date);
-	COMPARE_NODE_FIELD(time);
-	COMPARE_NODE_FIELD(timetz);
-	COMPARE_NODE_FIELD(timestamp);
-	COMPARE_NODE_FIELD(timestamptz);
-	COMPARE_NODE_FIELD(composite);
-
-	return true;
-}
-
-/*
- * Stuff from pathnodes.h
- */
-
-static bool
-_equalPathKey(const PathKey *a, const PathKey *b)
-{
-	/* We assume pointer equality is sufficient to compare the eclasses */
-	COMPARE_SCALAR_FIELD(pk_eclass);
-	COMPARE_SCALAR_FIELD(pk_opfamily);
-	COMPARE_SCALAR_FIELD(pk_strategy);
-	COMPARE_SCALAR_FIELD(pk_nulls_first);
-
-	return true;
-}
-
-static bool
-_equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
-{
-	COMPARE_NODE_FIELD(clause);
-	COMPARE_SCALAR_FIELD(is_pushed_down);
-	COMPARE_SCALAR_FIELD(outerjoin_delayed);
-	COMPARE_SCALAR_FIELD(security_level);
-	COMPARE_BITMAPSET_FIELD(required_relids);
-	COMPARE_BITMAPSET_FIELD(outer_relids);
-	COMPARE_BITMAPSET_FIELD(nullable_relids);
-
-	/*
-	 * We ignore all the remaining fields, since they may not be set yet, and
-	 * should be derivable from the clause anyway.
-	 */
-
-	return true;
-}
-
-static bool
-_equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
-{
-	/*
-	 * We intentionally do not compare phexpr.  Two PlaceHolderVars with the
-	 * same ID and levelsup should be considered equal even if the contained
-	 * expressions have managed to mutate to different states.  This will
-	 * happen during final plan construction when there are nested PHVs, since
-	 * the inner PHV will get replaced by a Param in some copies of the outer
-	 * PHV.  Another way in which it can happen is that initplan sublinks
-	 * could get replaced by differently-numbered Params when sublink folding
-	 * is done.  (The end result of such a situation would be some
-	 * unreferenced initplans, which is annoying but not really a problem.) On
-	 * the same reasoning, there is no need to examine phrels.
-	 *
-	 * COMPARE_NODE_FIELD(phexpr);
-	 *
-	 * COMPARE_BITMAPSET_FIELD(phrels);
-	 */
-	COMPARE_SCALAR_FIELD(phid);
-	COMPARE_SCALAR_FIELD(phlevelsup);
-
-	return true;
-}
-
-static bool
-_equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
-{
-	COMPARE_BITMAPSET_FIELD(min_lefthand);
-	COMPARE_BITMAPSET_FIELD(min_righthand);
-	COMPARE_BITMAPSET_FIELD(syn_lefthand);
-	COMPARE_BITMAPSET_FIELD(syn_righthand);
-	COMPARE_SCALAR_FIELD(jointype);
-	COMPARE_SCALAR_FIELD(lhs_strict);
-	COMPARE_SCALAR_FIELD(delay_upper_joins);
-	COMPARE_SCALAR_FIELD(semi_can_btree);
-	COMPARE_SCALAR_FIELD(semi_can_hash);
-	COMPARE_NODE_FIELD(semi_operators);
-	COMPARE_NODE_FIELD(semi_rhs_exprs);
-
-	return true;
-}
-
-static bool
-_equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
-{
-	COMPARE_SCALAR_FIELD(parent_relid);
-	COMPARE_SCALAR_FIELD(child_relid);
-	COMPARE_SCALAR_FIELD(parent_reltype);
-	COMPARE_SCALAR_FIELD(child_reltype);
-	COMPARE_NODE_FIELD(translated_vars);
-	COMPARE_SCALAR_FIELD(num_child_cols);
-	COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber));
-	COMPARE_SCALAR_FIELD(parent_reloid);
-
-	return true;
-}
-
-static bool
-_equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
-{
-	COMPARE_SCALAR_FIELD(phid);
-	COMPARE_NODE_FIELD(ph_var); /* should be redundant */
-	COMPARE_BITMAPSET_FIELD(ph_eval_at);
-	COMPARE_BITMAPSET_FIELD(ph_lateral);
-	COMPARE_BITMAPSET_FIELD(ph_needed);
-	COMPARE_SCALAR_FIELD(ph_width);
-
-	return true;
-}
-#endif							/* OBSOLETE */
-
-/*
- * Stuff from extensible.h
- */
 static bool
 _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b)
 {
@@ -1326,1499 +130,6 @@ _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b)
 	return true;
 }
 
-#ifdef OBSOLETE
-/*
- * Stuff from parsenodes.h
- */
-
-static bool
-_equalQuery(const Query *a, const Query *b)
-{
-	COMPARE_SCALAR_FIELD(commandType);
-	COMPARE_SCALAR_FIELD(querySource);
-	/* we intentionally ignore queryId, since it might not be set */
-	COMPARE_SCALAR_FIELD(canSetTag);
-	COMPARE_NODE_FIELD(utilityStmt);
-	COMPARE_SCALAR_FIELD(resultRelation);
-	COMPARE_SCALAR_FIELD(hasAggs);
-	COMPARE_SCALAR_FIELD(hasWindowFuncs);
-	COMPARE_SCALAR_FIELD(hasTargetSRFs);
-	COMPARE_SCALAR_FIELD(hasSubLinks);
-	COMPARE_SCALAR_FIELD(hasDistinctOn);
-	COMPARE_SCALAR_FIELD(hasRecursive);
-	COMPARE_SCALAR_FIELD(hasModifyingCTE);
-	COMPARE_SCALAR_FIELD(hasForUpdate);
-	COMPARE_SCALAR_FIELD(hasRowSecurity);
-	COMPARE_SCALAR_FIELD(isReturn);
-	COMPARE_NODE_FIELD(cteList);
-	COMPARE_NODE_FIELD(rtable);
-	COMPARE_NODE_FIELD(jointree);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_SCALAR_FIELD(override);
-	COMPARE_NODE_FIELD(onConflict);
-	COMPARE_NODE_FIELD(returningList);
-	COMPARE_NODE_FIELD(groupClause);
-	COMPARE_SCALAR_FIELD(groupDistinct);
-	COMPARE_NODE_FIELD(groupingSets);
-	COMPARE_NODE_FIELD(havingQual);
-	COMPARE_NODE_FIELD(windowClause);
-	COMPARE_NODE_FIELD(distinctClause);
-	COMPARE_NODE_FIELD(sortClause);
-	COMPARE_NODE_FIELD(limitOffset);
-	COMPARE_NODE_FIELD(limitCount);
-	COMPARE_SCALAR_FIELD(limitOption);
-	COMPARE_NODE_FIELD(rowMarks);
-	COMPARE_NODE_FIELD(setOperations);
-	COMPARE_NODE_FIELD(constraintDeps);
-	COMPARE_NODE_FIELD(withCheckOptions);
-	COMPARE_NODE_FIELD(mergeActionList);
-	COMPARE_SCALAR_FIELD(mergeUseOuterJoin);
-	COMPARE_LOCATION_FIELD(stmt_location);
-	COMPARE_SCALAR_FIELD(stmt_len);
-
-	return true;
-}
-
-static bool
-_equalRawStmt(const RawStmt *a, const RawStmt *b)
-{
-	COMPARE_NODE_FIELD(stmt);
-	COMPARE_LOCATION_FIELD(stmt_location);
-	COMPARE_SCALAR_FIELD(stmt_len);
-
-	return true;
-}
-
-static bool
-_equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(cols);
-	COMPARE_NODE_FIELD(selectStmt);
-	COMPARE_NODE_FIELD(onConflictClause);
-	COMPARE_NODE_FIELD(returningList);
-	COMPARE_NODE_FIELD(withClause);
-	COMPARE_SCALAR_FIELD(override);
-
-	return true;
-}
-
-static bool
-_equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(usingClause);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_NODE_FIELD(returningList);
-	COMPARE_NODE_FIELD(withClause);
-
-	return true;
-}
-
-static bool
-_equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_NODE_FIELD(fromClause);
-	COMPARE_NODE_FIELD(returningList);
-	COMPARE_NODE_FIELD(withClause);
-
-	return true;
-}
-
-static bool
-_equalMergeStmt(const MergeStmt *a, const MergeStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(sourceRelation);
-	COMPARE_NODE_FIELD(joinCondition);
-	COMPARE_NODE_FIELD(mergeWhenClauses);
-	COMPARE_NODE_FIELD(withClause);
-
-	return true;
-}
-
-static bool
-_equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
-{
-	COMPARE_NODE_FIELD(distinctClause);
-	COMPARE_NODE_FIELD(intoClause);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(fromClause);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_NODE_FIELD(groupClause);
-	COMPARE_SCALAR_FIELD(groupDistinct);
-	COMPARE_NODE_FIELD(havingClause);
-	COMPARE_NODE_FIELD(windowClause);
-	COMPARE_NODE_FIELD(valuesLists);
-	COMPARE_NODE_FIELD(sortClause);
-	COMPARE_NODE_FIELD(limitOffset);
-	COMPARE_NODE_FIELD(limitCount);
-	COMPARE_SCALAR_FIELD(limitOption);
-	COMPARE_NODE_FIELD(lockingClause);
-	COMPARE_NODE_FIELD(withClause);
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_SCALAR_FIELD(all);
-	COMPARE_NODE_FIELD(larg);
-	COMPARE_NODE_FIELD(rarg);
-
-	return true;
-}
-
-static bool
-_equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
-{
-	COMPARE_SCALAR_FIELD(op);
-	COMPARE_SCALAR_FIELD(all);
-	COMPARE_NODE_FIELD(larg);
-	COMPARE_NODE_FIELD(rarg);
-	COMPARE_NODE_FIELD(colTypes);
-	COMPARE_NODE_FIELD(colTypmods);
-	COMPARE_NODE_FIELD(colCollations);
-	COMPARE_NODE_FIELD(groupClauses);
-
-	return true;
-}
-
-static bool
-_equalReturnStmt(const ReturnStmt *a, const ReturnStmt *b)
-{
-	COMPARE_NODE_FIELD(returnval);
-
-	return true;
-}
-
-static bool
-_equalPLAssignStmt(const PLAssignStmt *a, const PLAssignStmt *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(indirection);
-	COMPARE_SCALAR_FIELD(nnames);
-	COMPARE_NODE_FIELD(val);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(cmds);
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
-{
-	COMPARE_SCALAR_FIELD(subtype);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_SCALAR_FIELD(num);
-	COMPARE_NODE_FIELD(newowner);
-	COMPARE_NODE_FIELD(def);
-	COMPARE_SCALAR_FIELD(behavior);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b)
-{
-	COMPARE_NODE_FIELD(collname);
-
-	return true;
-}
-
-static bool
-_equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
-{
-	COMPARE_SCALAR_FIELD(subtype);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(def);
-	COMPARE_SCALAR_FIELD(behavior);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
-{
-	COMPARE_SCALAR_FIELD(is_grant);
-	COMPARE_SCALAR_FIELD(targtype);
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(objects);
-	COMPARE_NODE_FIELD(privileges);
-	COMPARE_NODE_FIELD(grantees);
-	COMPARE_SCALAR_FIELD(grant_option);
-	COMPARE_NODE_FIELD(grantor);
-	COMPARE_SCALAR_FIELD(behavior);
-
-	return true;
-}
-
-static bool
-_equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b)
-{
-	COMPARE_NODE_FIELD(objname);
-	COMPARE_NODE_FIELD(objargs);
-	COMPARE_NODE_FIELD(objfuncargs);
-	COMPARE_SCALAR_FIELD(args_unspecified);
-
-	return true;
-}
-
-static bool
-_equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
-{
-	COMPARE_STRING_FIELD(priv_name);
-	COMPARE_NODE_FIELD(cols);
-
-	return true;
-}
-
-static bool
-_equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
-{
-	COMPARE_NODE_FIELD(granted_roles);
-	COMPARE_NODE_FIELD(grantee_roles);
-	COMPARE_SCALAR_FIELD(is_grant);
-	COMPARE_SCALAR_FIELD(admin_opt);
-	COMPARE_NODE_FIELD(grantor);
-	COMPARE_SCALAR_FIELD(behavior);
-
-	return true;
-}
-
-static bool
-_equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
-{
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(action);
-
-	return true;
-}
-
-static bool
-_equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
-{
-	COMPARE_STRING_FIELD(portalname);
-	COMPARE_SCALAR_FIELD(options);
-	COMPARE_NODE_FIELD(query);
-
-	return true;
-}
-
-static bool
-_equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
-{
-	COMPARE_STRING_FIELD(portalname);
-
-	return true;
-}
-
-static bool
-_equalCallStmt(const CallStmt *a, const CallStmt *b)
-{
-	COMPARE_NODE_FIELD(funccall);
-	COMPARE_NODE_FIELD(funcexpr);
-	COMPARE_NODE_FIELD(outargs);
-
-	return true;
-}
-
-static bool
-_equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_STRING_FIELD(indexname);
-	COMPARE_NODE_FIELD(params);
-
-	return true;
-}
-
-static bool
-_equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(query);
-	COMPARE_NODE_FIELD(attlist);
-	COMPARE_SCALAR_FIELD(is_from);
-	COMPARE_SCALAR_FIELD(is_program);
-	COMPARE_STRING_FIELD(filename);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(whereClause);
-
-	return true;
-}
-
-static bool
-_equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(tableElts);
-	COMPARE_NODE_FIELD(inhRelations);
-	COMPARE_NODE_FIELD(partbound);
-	COMPARE_NODE_FIELD(partspec);
-	COMPARE_NODE_FIELD(ofTypename);
-	COMPARE_NODE_FIELD(constraints);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(oncommit);
-	COMPARE_STRING_FIELD(tablespacename);
-	COMPARE_STRING_FIELD(accessMethod);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-
-	return true;
-}
-
-static bool
-_equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_SCALAR_FIELD(options);
-	COMPARE_SCALAR_FIELD(relationOid);
-
-	return true;
-}
-
-static bool
-_equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_SCALAR_FIELD(oldstyle);
-	COMPARE_NODE_FIELD(defnames);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(definition);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-	COMPARE_SCALAR_FIELD(replace);
-
-	return true;
-}
-
-static bool
-_equalDropStmt(const DropStmt *a, const DropStmt *b)
-{
-	COMPARE_NODE_FIELD(objects);
-	COMPARE_SCALAR_FIELD(removeType);
-	COMPARE_SCALAR_FIELD(behavior);
-	COMPARE_SCALAR_FIELD(missing_ok);
-	COMPARE_SCALAR_FIELD(concurrent);
-
-	return true;
-}
-
-static bool
-_equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
-{
-	COMPARE_NODE_FIELD(relations);
-	COMPARE_SCALAR_FIELD(restart_seqs);
-	COMPARE_SCALAR_FIELD(behavior);
-
-	return true;
-}
-
-static bool
-_equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_STRING_FIELD(comment);
-
-	return true;
-}
-
-static bool
-_equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_STRING_FIELD(provider);
-	COMPARE_STRING_FIELD(label);
-
-	return true;
-}
-
-static bool
-_equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
-{
-	COMPARE_SCALAR_FIELD(direction);
-	COMPARE_SCALAR_FIELD(howMany);
-	COMPARE_STRING_FIELD(portalname);
-	COMPARE_SCALAR_FIELD(ismove);
-
-	return true;
-}
-
-static bool
-_equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
-{
-	COMPARE_STRING_FIELD(idxname);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_STRING_FIELD(accessMethod);
-	COMPARE_STRING_FIELD(tableSpace);
-	COMPARE_NODE_FIELD(indexParams);
-	COMPARE_NODE_FIELD(indexIncludingParams);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_NODE_FIELD(excludeOpNames);
-	COMPARE_STRING_FIELD(idxcomment);
-	COMPARE_SCALAR_FIELD(indexOid);
-	COMPARE_SCALAR_FIELD(oldNumber);
-	COMPARE_SCALAR_FIELD(oldCreateSubid);
-	COMPARE_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
-	COMPARE_SCALAR_FIELD(unique);
-	COMPARE_SCALAR_FIELD(nulls_not_distinct);
-	COMPARE_SCALAR_FIELD(primary);
-	COMPARE_SCALAR_FIELD(isconstraint);
-	COMPARE_SCALAR_FIELD(deferrable);
-	COMPARE_SCALAR_FIELD(initdeferred);
-	COMPARE_SCALAR_FIELD(transformed);
-	COMPARE_SCALAR_FIELD(concurrent);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-	COMPARE_SCALAR_FIELD(reset_default_tblspc);
-
-	return true;
-}
-
-static bool
-_equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b)
-{
-	COMPARE_NODE_FIELD(defnames);
-	COMPARE_NODE_FIELD(stat_types);
-	COMPARE_NODE_FIELD(exprs);
-	COMPARE_NODE_FIELD(relations);
-	COMPARE_STRING_FIELD(stxcomment);
-	COMPARE_SCALAR_FIELD(transformed);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-
-	return true;
-}
-
-static bool
-_equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b)
-{
-	COMPARE_NODE_FIELD(defnames);
-	COMPARE_SCALAR_FIELD(stxstattarget);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
-{
-	COMPARE_SCALAR_FIELD(is_procedure);
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_NODE_FIELD(funcname);
-	COMPARE_NODE_FIELD(parameters);
-	COMPARE_NODE_FIELD(returnType);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(sql_body);
-
-	return true;
-}
-
-static bool
-_equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(argType);
-	COMPARE_SCALAR_FIELD(mode);
-	COMPARE_NODE_FIELD(defexpr);
-
-	return true;
-}
-
-static bool
-_equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(func);
-	COMPARE_NODE_FIELD(actions);
-
-	return true;
-}
-
-static bool
-_equalDoStmt(const DoStmt *a, const DoStmt *b)
-{
-	COMPARE_NODE_FIELD(args);
-
-	return true;
-}
-
-static bool
-_equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
-{
-	COMPARE_SCALAR_FIELD(renameType);
-	COMPARE_SCALAR_FIELD(relationType);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_STRING_FIELD(subname);
-	COMPARE_STRING_FIELD(newname);
-	COMPARE_SCALAR_FIELD(behavior);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objectType);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_NODE_FIELD(extname);
-	COMPARE_SCALAR_FIELD(remove);
-
-	return true;
-}
-
-static bool
-_equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objectType);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_STRING_FIELD(newschema);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
-{
-	COMPARE_SCALAR_FIELD(objectType);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(object);
-	COMPARE_NODE_FIELD(newowner);
-
-	return true;
-}
-
-static bool
-_equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b)
-{
-	COMPARE_NODE_FIELD(opername);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b)
-{
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_STRING_FIELD(rulename);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_SCALAR_FIELD(event);
-	COMPARE_SCALAR_FIELD(instead);
-	COMPARE_NODE_FIELD(actions);
-	COMPARE_SCALAR_FIELD(replace);
-
-	return true;
-}
-
-static bool
-_equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
-{
-	COMPARE_STRING_FIELD(conditionname);
-	COMPARE_STRING_FIELD(payload);
-
-	return true;
-}
-
-static bool
-_equalListenStmt(const ListenStmt *a, const ListenStmt *b)
-{
-	COMPARE_STRING_FIELD(conditionname);
-
-	return true;
-}
-
-static bool
-_equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
-{
-	COMPARE_STRING_FIELD(conditionname);
-
-	return true;
-}
-
-static bool
-_equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_STRING_FIELD(savepoint_name);
-	COMPARE_STRING_FIELD(gid);
-	COMPARE_SCALAR_FIELD(chain);
-
-	return true;
-}
-
-static bool
-_equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
-{
-	COMPARE_NODE_FIELD(typevar);
-	COMPARE_NODE_FIELD(coldeflist);
-
-	return true;
-}
-
-static bool
-_equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
-{
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(vals);
-
-	return true;
-}
-
-static bool
-_equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
-{
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(params);
-
-	return true;
-}
-
-static bool
-_equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
-{
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_STRING_FIELD(oldVal);
-	COMPARE_STRING_FIELD(newVal);
-	COMPARE_STRING_FIELD(newValNeighbor);
-	COMPARE_SCALAR_FIELD(newValIsAfter);
-	COMPARE_SCALAR_FIELD(skipIfNewValExists);
-
-	return true;
-}
-
-static bool
-_equalViewStmt(const ViewStmt *a, const ViewStmt *b)
-{
-	COMPARE_NODE_FIELD(view);
-	COMPARE_NODE_FIELD(aliases);
-	COMPARE_NODE_FIELD(query);
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(withCheckOption);
-
-	return true;
-}
-
-static bool
-_equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
-{
-	COMPARE_STRING_FIELD(filename);
-
-	return true;
-}
-
-static bool
-_equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
-{
-	COMPARE_NODE_FIELD(domainname);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(collClause);
-	COMPARE_NODE_FIELD(constraints);
-
-	return true;
-}
-
-static bool
-_equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
-{
-	COMPARE_NODE_FIELD(opclassname);
-	COMPARE_NODE_FIELD(opfamilyname);
-	COMPARE_STRING_FIELD(amname);
-	COMPARE_NODE_FIELD(datatype);
-	COMPARE_NODE_FIELD(items);
-	COMPARE_SCALAR_FIELD(isDefault);
-
-	return true;
-}
-
-static bool
-_equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
-{
-	COMPARE_SCALAR_FIELD(itemtype);
-	COMPARE_NODE_FIELD(name);
-	COMPARE_SCALAR_FIELD(number);
-	COMPARE_NODE_FIELD(order_family);
-	COMPARE_NODE_FIELD(class_args);
-	COMPARE_NODE_FIELD(storedtype);
-
-	return true;
-}
-
-static bool
-_equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
-{
-	COMPARE_NODE_FIELD(opfamilyname);
-	COMPARE_STRING_FIELD(amname);
-
-	return true;
-}
-
-static bool
-_equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
-{
-	COMPARE_NODE_FIELD(opfamilyname);
-	COMPARE_STRING_FIELD(amname);
-	COMPARE_SCALAR_FIELD(isDrop);
-	COMPARE_NODE_FIELD(items);
-
-	return true;
-}
-
-static bool
-_equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
-{
-	COMPARE_STRING_FIELD(dbname);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
-{
-	COMPARE_STRING_FIELD(dbname);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *a, const AlterDatabaseRefreshCollStmt *b)
-{
-	COMPARE_STRING_FIELD(dbname);
-
-	return true;
-}
-
-static bool
-_equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
-{
-	COMPARE_STRING_FIELD(dbname);
-	COMPARE_NODE_FIELD(setstmt);
-
-	return true;
-}
-
-static bool
-_equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
-{
-	COMPARE_STRING_FIELD(dbname);
-	COMPARE_SCALAR_FIELD(missing_ok);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
-{
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(rels);
-	COMPARE_SCALAR_FIELD(is_vacuumcmd);
-
-	return true;
-}
-
-static bool
-_equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_SCALAR_FIELD(oid);
-	COMPARE_NODE_FIELD(va_cols);
-
-	return true;
-}
-
-static bool
-_equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
-{
-	COMPARE_NODE_FIELD(query);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
-{
-	COMPARE_NODE_FIELD(query);
-	COMPARE_NODE_FIELD(into);
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_SCALAR_FIELD(is_select_into);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-
-	return true;
-}
-
-static bool
-_equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
-{
-	COMPARE_SCALAR_FIELD(concurrent);
-	COMPARE_SCALAR_FIELD(skipData);
-	COMPARE_NODE_FIELD(relation);
-
-	return true;
-}
-
-static bool
-_equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
-{
-	COMPARE_SCALAR_FIELD(identity_type);
-	COMPARE_STRING_FIELD(name);
-
-	return true;
-}
-
-static bool
-_equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b)
-{
-	COMPARE_NODE_FIELD(setstmt);
-
-	return true;
-}
-
-
-static bool
-_equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
-{
-	COMPARE_NODE_FIELD(sequence);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(ownerId);
-	COMPARE_SCALAR_FIELD(for_identity);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-
-	return true;
-}
-
-static bool
-_equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
-{
-	COMPARE_NODE_FIELD(sequence);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(for_identity);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_SCALAR_FIELD(is_local);
-
-	return true;
-}
-
-static bool
-_equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
-{
-	COMPARE_STRING_FIELD(name);
-
-	return true;
-}
-
-static bool
-_equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
-{
-	COMPARE_SCALAR_FIELD(target);
-
-	return true;
-}
-
-static bool
-_equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
-{
-	COMPARE_STRING_FIELD(tablespacename);
-	COMPARE_NODE_FIELD(owner);
-	COMPARE_STRING_FIELD(location);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
-{
-	COMPARE_STRING_FIELD(tablespacename);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a,
-								 const AlterTableSpaceOptionsStmt *b)
-{
-	COMPARE_STRING_FIELD(tablespacename);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(isReset);
-
-	return true;
-}
-
-static bool
-_equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a,
-							const AlterTableMoveAllStmt *b)
-{
-	COMPARE_STRING_FIELD(orig_tablespacename);
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_STRING_FIELD(new_tablespacename);
-	COMPARE_SCALAR_FIELD(nowait);
-
-	return true;
-}
-
-static bool
-_equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
-{
-	COMPARE_STRING_FIELD(extname);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
-{
-	COMPARE_STRING_FIELD(extname);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
-{
-	COMPARE_STRING_FIELD(extname);
-	COMPARE_SCALAR_FIELD(action);
-	COMPARE_SCALAR_FIELD(objtype);
-	COMPARE_NODE_FIELD(object);
-
-	return true;
-}
-
-static bool
-_equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
-{
-	COMPARE_STRING_FIELD(fdwname);
-	COMPARE_NODE_FIELD(func_options);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
-{
-	COMPARE_STRING_FIELD(fdwname);
-	COMPARE_NODE_FIELD(func_options);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
-{
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_STRING_FIELD(servertype);
-	COMPARE_STRING_FIELD(version);
-	COMPARE_STRING_FIELD(fdwname);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
-{
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_STRING_FIELD(version);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(has_version);
-
-	return true;
-}
-
-static bool
-_equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
-{
-	COMPARE_NODE_FIELD(user);
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
-{
-	COMPARE_NODE_FIELD(user);
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
-{
-	COMPARE_NODE_FIELD(user);
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
-{
-	if (!_equalCreateStmt(&a->base, &b->base))
-		return false;
-
-	COMPARE_STRING_FIELD(servername);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b)
-{
-	COMPARE_STRING_FIELD(server_name);
-	COMPARE_STRING_FIELD(remote_schema);
-	COMPARE_STRING_FIELD(local_schema);
-	COMPARE_SCALAR_FIELD(list_type);
-	COMPARE_NODE_FIELD(table_list);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b)
-{
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_NODE_FIELD(type_name);
-	COMPARE_STRING_FIELD(lang);
-	COMPARE_NODE_FIELD(fromsql);
-	COMPARE_NODE_FIELD(tosql);
-
-	return true;
-}
-
-static bool
-_equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b)
-{
-	COMPARE_STRING_FIELD(amname);
-	COMPARE_NODE_FIELD(handler_name);
-	COMPARE_SCALAR_FIELD(amtype);
-
-	return true;
-}
-
-static bool
-_equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
-{
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_SCALAR_FIELD(isconstraint);
-	COMPARE_STRING_FIELD(trigname);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(funcname);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_SCALAR_FIELD(row);
-	COMPARE_SCALAR_FIELD(timing);
-	COMPARE_SCALAR_FIELD(events);
-	COMPARE_NODE_FIELD(columns);
-	COMPARE_NODE_FIELD(whenClause);
-	COMPARE_NODE_FIELD(transitionRels);
-	COMPARE_SCALAR_FIELD(deferrable);
-	COMPARE_SCALAR_FIELD(initdeferred);
-	COMPARE_NODE_FIELD(constrrel);
-
-	return true;
-}
-
-static bool
-_equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b)
-{
-	COMPARE_STRING_FIELD(trigname);
-	COMPARE_STRING_FIELD(eventname);
-	COMPARE_NODE_FIELD(whenclause);
-	COMPARE_NODE_FIELD(funcname);
-
-	return true;
-}
-
-static bool
-_equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b)
-{
-	COMPARE_STRING_FIELD(trigname);
-	COMPARE_SCALAR_FIELD(tgenabled);
-
-	return true;
-}
-
-static bool
-_equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
-{
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_STRING_FIELD(plname);
-	COMPARE_NODE_FIELD(plhandler);
-	COMPARE_NODE_FIELD(plinline);
-	COMPARE_NODE_FIELD(plvalidator);
-	COMPARE_SCALAR_FIELD(pltrusted);
-
-	return true;
-}
-
-static bool
-_equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
-{
-	COMPARE_SCALAR_FIELD(stmt_type);
-	COMPARE_STRING_FIELD(role);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
-{
-	COMPARE_NODE_FIELD(role);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_SCALAR_FIELD(action);
-
-	return true;
-}
-
-static bool
-_equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
-{
-	COMPARE_NODE_FIELD(role);
-	COMPARE_STRING_FIELD(database);
-	COMPARE_NODE_FIELD(setstmt);
-
-	return true;
-}
-
-static bool
-_equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
-{
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalLockStmt(const LockStmt *a, const LockStmt *b)
-{
-	COMPARE_NODE_FIELD(relations);
-	COMPARE_SCALAR_FIELD(mode);
-	COMPARE_SCALAR_FIELD(nowait);
-
-	return true;
-}
-
-static bool
-_equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
-{
-	COMPARE_NODE_FIELD(constraints);
-	COMPARE_SCALAR_FIELD(deferred);
-
-	return true;
-}
-
-static bool
-_equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(params);
-
-	return true;
-}
-
-static bool
-_equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
-{
-	COMPARE_STRING_FIELD(schemaname);
-	COMPARE_NODE_FIELD(authrole);
-	COMPARE_NODE_FIELD(schemaElts);
-	COMPARE_SCALAR_FIELD(if_not_exists);
-
-	return true;
-}
-
-static bool
-_equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
-{
-	COMPARE_NODE_FIELD(conversion_name);
-	COMPARE_STRING_FIELD(for_encoding_name);
-	COMPARE_STRING_FIELD(to_encoding_name);
-	COMPARE_NODE_FIELD(func_name);
-	COMPARE_SCALAR_FIELD(def);
-
-	return true;
-}
-
-static bool
-_equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
-{
-	COMPARE_NODE_FIELD(sourcetype);
-	COMPARE_NODE_FIELD(targettype);
-	COMPARE_NODE_FIELD(func);
-	COMPARE_SCALAR_FIELD(context);
-	COMPARE_SCALAR_FIELD(inout);
-
-	return true;
-}
-
-static bool
-_equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(argtypes);
-	COMPARE_NODE_FIELD(query);
-
-	return true;
-}
-
-static bool
-_equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(params);
-
-	return true;
-}
-
-static bool
-_equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
-{
-	COMPARE_STRING_FIELD(name);
-
-	return true;
-}
-
-static bool
-_equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
-{
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_SCALAR_FIELD(behavior);
-
-	return true;
-}
-
-static bool
-_equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
-{
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_NODE_FIELD(newrole);
-
-	return true;
-}
-
-static bool
-_equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
-{
-	COMPARE_NODE_FIELD(dictname);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a,
-							   const AlterTSConfigurationStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(cfgname);
-	COMPARE_NODE_FIELD(tokentype);
-	COMPARE_NODE_FIELD(dicts);
-	COMPARE_SCALAR_FIELD(override);
-	COMPARE_SCALAR_FIELD(replace);
-	COMPARE_SCALAR_FIELD(missing_ok);
-
-	return true;
-}
-
-static bool
-_equalPublicationObject(const PublicationObjSpec *a,
-						const PublicationObjSpec *b)
-{
-	COMPARE_SCALAR_FIELD(pubobjtype);
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(pubtable);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalPublicationTable(const PublicationTable *a, const PublicationTable *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_NODE_FIELD(columns);
-
-	return true;
-}
-
-static bool
-_equalCreatePublicationStmt(const CreatePublicationStmt *a,
-							const CreatePublicationStmt *b)
-{
-	COMPARE_STRING_FIELD(pubname);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(pubobjects);
-	COMPARE_SCALAR_FIELD(for_all_tables);
-
-	return true;
-}
-
-static bool
-_equalAlterPublicationStmt(const AlterPublicationStmt *a,
-						   const AlterPublicationStmt *b)
-{
-	COMPARE_STRING_FIELD(pubname);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_NODE_FIELD(pubobjects);
-	COMPARE_SCALAR_FIELD(for_all_tables);
-	COMPARE_SCALAR_FIELD(action);
-
-	return true;
-}
-
-static bool
-_equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a,
-							 const CreateSubscriptionStmt *b)
-{
-	COMPARE_STRING_FIELD(subname);
-	COMPARE_STRING_FIELD(conninfo);
-	COMPARE_NODE_FIELD(publication);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a,
-							const AlterSubscriptionStmt *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_STRING_FIELD(subname);
-	COMPARE_STRING_FIELD(conninfo);
-	COMPARE_NODE_FIELD(publication);
-	COMPARE_NODE_FIELD(options);
-
-	return true;
-}
-
-static bool
-_equalDropSubscriptionStmt(const DropSubscriptionStmt *a,
-						   const DropSubscriptionStmt *b)
-{
-	COMPARE_STRING_FIELD(subname);
-	COMPARE_SCALAR_FIELD(missing_ok);
-	COMPARE_SCALAR_FIELD(behavior);
-
-	return true;
-}
-
-static bool
-_equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b)
-{
-	COMPARE_STRING_FIELD(policy_name);
-	COMPARE_NODE_FIELD(table);
-	COMPARE_STRING_FIELD(cmd_name);
-	COMPARE_SCALAR_FIELD(permissive);
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_NODE_FIELD(qual);
-	COMPARE_NODE_FIELD(with_check);
-
-	return true;
-}
-
-static bool
-_equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b)
-{
-	COMPARE_STRING_FIELD(policy_name);
-	COMPARE_NODE_FIELD(table);
-	COMPARE_NODE_FIELD(roles);
-	COMPARE_NODE_FIELD(qual);
-	COMPARE_NODE_FIELD(with_check);
-
-	return true;
-}
-
-static bool
-_equalA_Expr(const A_Expr *a, const A_Expr *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(name);
-	COMPARE_NODE_FIELD(lexpr);
-	COMPARE_NODE_FIELD(rexpr);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalColumnRef(const ColumnRef *a, const ColumnRef *b)
-{
-	COMPARE_NODE_FIELD(fields);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalParamRef(const ParamRef *a, const ParamRef *b)
-{
-	COMPARE_SCALAR_FIELD(number);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-#endif							/* OBSOLETE */
-
 static bool
 _equalA_Const(const A_Const *a, const A_Const *b)
 {
@@ -2834,650 +145,9 @@ _equalA_Const(const A_Const *a, const A_Const *b)
 	return true;
 }
 
-#ifdef OBSOLETE
-static bool
-_equalFuncCall(const FuncCall *a, const FuncCall *b)
-{
-	COMPARE_NODE_FIELD(funcname);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(agg_order);
-	COMPARE_NODE_FIELD(agg_filter);
-	COMPARE_NODE_FIELD(over);
-	COMPARE_SCALAR_FIELD(agg_within_group);
-	COMPARE_SCALAR_FIELD(agg_star);
-	COMPARE_SCALAR_FIELD(agg_distinct);
-	COMPARE_SCALAR_FIELD(func_variadic);
-	COMPARE_COERCIONFORM_FIELD(funcformat);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalA_Star(const A_Star *a, const A_Star *b)
-{
-	return true;
-}
-
-static bool
-_equalA_Indices(const A_Indices *a, const A_Indices *b)
-{
-	COMPARE_SCALAR_FIELD(is_slice);
-	COMPARE_NODE_FIELD(lidx);
-	COMPARE_NODE_FIELD(uidx);
-
-	return true;
-}
-
-static bool
-_equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(indirection);
-
-	return true;
-}
-
-static bool
-_equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
-{
-	COMPARE_NODE_FIELD(elements);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalResTarget(const ResTarget *a, const ResTarget *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(indirection);
-	COMPARE_NODE_FIELD(val);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b)
-{
-	COMPARE_NODE_FIELD(source);
-	COMPARE_SCALAR_FIELD(colno);
-	COMPARE_SCALAR_FIELD(ncolumns);
-
-	return true;
-}
-
-static bool
-_equalTypeName(const TypeName *a, const TypeName *b)
-{
-	COMPARE_NODE_FIELD(names);
-	COMPARE_SCALAR_FIELD(typeOid);
-	COMPARE_SCALAR_FIELD(setof);
-	COMPARE_SCALAR_FIELD(pct_type);
-	COMPARE_NODE_FIELD(typmods);
-	COMPARE_SCALAR_FIELD(typemod);
-	COMPARE_NODE_FIELD(arrayBounds);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalTypeCast(const TypeCast *a, const TypeCast *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCollateClause(const CollateClause *a, const CollateClause *b)
-{
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_NODE_FIELD(collname);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalSortBy(const SortBy *a, const SortBy *b)
-{
-	COMPARE_NODE_FIELD(node);
-	COMPARE_SCALAR_FIELD(sortby_dir);
-	COMPARE_SCALAR_FIELD(sortby_nulls);
-	COMPARE_NODE_FIELD(useOp);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalWindowDef(const WindowDef *a, const WindowDef *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_STRING_FIELD(refname);
-	COMPARE_NODE_FIELD(partitionClause);
-	COMPARE_NODE_FIELD(orderClause);
-	COMPARE_SCALAR_FIELD(frameOptions);
-	COMPARE_NODE_FIELD(startOffset);
-	COMPARE_NODE_FIELD(endOffset);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
-{
-	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_NODE_FIELD(subquery);
-	COMPARE_NODE_FIELD(alias);
-
-	return true;
-}
-
-static bool
-_equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
-{
-	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_SCALAR_FIELD(ordinality);
-	COMPARE_SCALAR_FIELD(is_rowsfrom);
-	COMPARE_NODE_FIELD(functions);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_NODE_FIELD(coldeflist);
-
-	return true;
-}
-
-static bool
-_equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
-{
-	COMPARE_NODE_FIELD(relation);
-	COMPARE_NODE_FIELD(method);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(repeatable);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b)
-{
-	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_NODE_FIELD(docexpr);
-	COMPARE_NODE_FIELD(rowexpr);
-	COMPARE_NODE_FIELD(namespaces);
-	COMPARE_NODE_FIELD(columns);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b)
-{
-	COMPARE_STRING_FIELD(colname);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_SCALAR_FIELD(for_ordinality);
-	COMPARE_SCALAR_FIELD(is_not_null);
-	COMPARE_NODE_FIELD(colexpr);
-	COMPARE_NODE_FIELD(coldefexpr);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-
-static bool
-_equalIndexElem(const IndexElem *a, const IndexElem *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_STRING_FIELD(indexcolname);
-	COMPARE_NODE_FIELD(collation);
-	COMPARE_NODE_FIELD(opclass);
-	COMPARE_NODE_FIELD(opclassopts);
-	COMPARE_SCALAR_FIELD(ordering);
-	COMPARE_SCALAR_FIELD(nulls_ordering);
-
-	return true;
-}
-
-
-static bool
-_equalStatsElem(const StatsElem *a, const StatsElem *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(expr);
-
-	return true;
-}
-
-static bool
-_equalColumnDef(const ColumnDef *a, const ColumnDef *b)
-{
-	COMPARE_STRING_FIELD(colname);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_STRING_FIELD(compression);
-	COMPARE_SCALAR_FIELD(inhcount);
-	COMPARE_SCALAR_FIELD(is_local);
-	COMPARE_SCALAR_FIELD(is_not_null);
-	COMPARE_SCALAR_FIELD(is_from_type);
-	COMPARE_SCALAR_FIELD(storage);
-	COMPARE_NODE_FIELD(raw_default);
-	COMPARE_NODE_FIELD(cooked_default);
-	COMPARE_SCALAR_FIELD(identity);
-	COMPARE_NODE_FIELD(identitySequence);
-	COMPARE_SCALAR_FIELD(generated);
-	COMPARE_NODE_FIELD(collClause);
-	COMPARE_SCALAR_FIELD(collOid);
-	COMPARE_NODE_FIELD(constraints);
-	COMPARE_NODE_FIELD(fdwoptions);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalConstraint(const Constraint *a, const Constraint *b)
-{
-	COMPARE_SCALAR_FIELD(contype);
-	COMPARE_STRING_FIELD(conname);
-	COMPARE_SCALAR_FIELD(deferrable);
-	COMPARE_SCALAR_FIELD(initdeferred);
-	COMPARE_LOCATION_FIELD(location);
-	COMPARE_SCALAR_FIELD(is_no_inherit);
-	COMPARE_NODE_FIELD(raw_expr);
-	COMPARE_STRING_FIELD(cooked_expr);
-	COMPARE_SCALAR_FIELD(generated_when);
-	COMPARE_SCALAR_FIELD(nulls_not_distinct);
-	COMPARE_NODE_FIELD(keys);
-	COMPARE_NODE_FIELD(including);
-	COMPARE_NODE_FIELD(exclusions);
-	COMPARE_NODE_FIELD(options);
-	COMPARE_STRING_FIELD(indexname);
-	COMPARE_STRING_FIELD(indexspace);
-	COMPARE_SCALAR_FIELD(reset_default_tblspc);
-	COMPARE_STRING_FIELD(access_method);
-	COMPARE_NODE_FIELD(where_clause);
-	COMPARE_NODE_FIELD(pktable);
-	COMPARE_NODE_FIELD(fk_attrs);
-	COMPARE_NODE_FIELD(pk_attrs);
-	COMPARE_SCALAR_FIELD(fk_matchtype);
-	COMPARE_SCALAR_FIELD(fk_upd_action);
-	COMPARE_SCALAR_FIELD(fk_del_action);
-	COMPARE_NODE_FIELD(fk_del_set_cols);
-	COMPARE_NODE_FIELD(old_conpfeqop);
-	COMPARE_SCALAR_FIELD(old_pktable_oid);
-	COMPARE_SCALAR_FIELD(skip_validation);
-	COMPARE_SCALAR_FIELD(initially_valid);
-
-	return true;
-}
-
-static bool
-_equalDefElem(const DefElem *a, const DefElem *b)
-{
-	COMPARE_STRING_FIELD(defnamespace);
-	COMPARE_STRING_FIELD(defname);
-	COMPARE_NODE_FIELD(arg);
-	COMPARE_SCALAR_FIELD(defaction);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalLockingClause(const LockingClause *a, const LockingClause *b)
-{
-	COMPARE_NODE_FIELD(lockedRels);
-	COMPARE_SCALAR_FIELD(strength);
-	COMPARE_SCALAR_FIELD(waitPolicy);
-
-	return true;
-}
-
-static bool
-_equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
-{
-	COMPARE_SCALAR_FIELD(rtekind);
-	COMPARE_SCALAR_FIELD(relid);
-	COMPARE_SCALAR_FIELD(relkind);
-	COMPARE_SCALAR_FIELD(rellockmode);
-	COMPARE_NODE_FIELD(tablesample);
-	COMPARE_NODE_FIELD(subquery);
-	COMPARE_SCALAR_FIELD(security_barrier);
-	COMPARE_SCALAR_FIELD(jointype);
-	COMPARE_SCALAR_FIELD(joinmergedcols);
-	COMPARE_NODE_FIELD(joinaliasvars);
-	COMPARE_NODE_FIELD(joinleftcols);
-	COMPARE_NODE_FIELD(joinrightcols);
-	COMPARE_NODE_FIELD(join_using_alias);
-	COMPARE_NODE_FIELD(functions);
-	COMPARE_SCALAR_FIELD(funcordinality);
-	COMPARE_NODE_FIELD(tablefunc);
-	COMPARE_NODE_FIELD(values_lists);
-	COMPARE_STRING_FIELD(ctename);
-	COMPARE_SCALAR_FIELD(ctelevelsup);
-	COMPARE_SCALAR_FIELD(self_reference);
-	COMPARE_NODE_FIELD(coltypes);
-	COMPARE_NODE_FIELD(coltypmods);
-	COMPARE_NODE_FIELD(colcollations);
-	COMPARE_STRING_FIELD(enrname);
-	COMPARE_SCALAR_FIELD(enrtuples);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_NODE_FIELD(eref);
-	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_SCALAR_FIELD(inh);
-	COMPARE_SCALAR_FIELD(inFromCl);
-	COMPARE_SCALAR_FIELD(requiredPerms);
-	COMPARE_SCALAR_FIELD(checkAsUser);
-	COMPARE_BITMAPSET_FIELD(selectedCols);
-	COMPARE_BITMAPSET_FIELD(insertedCols);
-	COMPARE_BITMAPSET_FIELD(updatedCols);
-	COMPARE_BITMAPSET_FIELD(extraUpdatedCols);
-	COMPARE_NODE_FIELD(securityQuals);
-
-	return true;
-}
-
-static bool
-_equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
-{
-	COMPARE_NODE_FIELD(funcexpr);
-	COMPARE_SCALAR_FIELD(funccolcount);
-	COMPARE_NODE_FIELD(funccolnames);
-	COMPARE_NODE_FIELD(funccoltypes);
-	COMPARE_NODE_FIELD(funccoltypmods);
-	COMPARE_NODE_FIELD(funccolcollations);
-	COMPARE_BITMAPSET_FIELD(funcparams);
-
-	return true;
-}
-
-static bool
-_equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b)
-{
-	COMPARE_SCALAR_FIELD(tsmhandler);
-	COMPARE_NODE_FIELD(args);
-	COMPARE_NODE_FIELD(repeatable);
-
-	return true;
-}
-
-static bool
-_equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_STRING_FIELD(relname);
-	COMPARE_STRING_FIELD(polname);
-	COMPARE_NODE_FIELD(qual);
-	COMPARE_SCALAR_FIELD(cascaded);
-
-	return true;
-}
-
-static bool
-_equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
-{
-	COMPARE_SCALAR_FIELD(tleSortGroupRef);
-	COMPARE_SCALAR_FIELD(eqop);
-	COMPARE_SCALAR_FIELD(sortop);
-	COMPARE_SCALAR_FIELD(nulls_first);
-	COMPARE_SCALAR_FIELD(hashable);
-
-	return true;
-}
-
-static bool
-_equalGroupingSet(const GroupingSet *a, const GroupingSet *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(content);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalWindowClause(const WindowClause *a, const WindowClause *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_STRING_FIELD(refname);
-	COMPARE_NODE_FIELD(partitionClause);
-	COMPARE_NODE_FIELD(orderClause);
-	COMPARE_SCALAR_FIELD(frameOptions);
-	COMPARE_NODE_FIELD(startOffset);
-	COMPARE_NODE_FIELD(endOffset);
-	COMPARE_NODE_FIELD(runCondition);
-	COMPARE_SCALAR_FIELD(startInRangeFunc);
-	COMPARE_SCALAR_FIELD(endInRangeFunc);
-	COMPARE_SCALAR_FIELD(inRangeColl);
-	COMPARE_SCALAR_FIELD(inRangeAsc);
-	COMPARE_SCALAR_FIELD(inRangeNullsFirst);
-	COMPARE_SCALAR_FIELD(winref);
-	COMPARE_SCALAR_FIELD(copiedOrder);
-
-	return true;
-}
-
-static bool
-_equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
-{
-	COMPARE_SCALAR_FIELD(rti);
-	COMPARE_SCALAR_FIELD(strength);
-	COMPARE_SCALAR_FIELD(waitPolicy);
-	COMPARE_SCALAR_FIELD(pushedDown);
-
-	return true;
-}
-
-static bool
-_equalWithClause(const WithClause *a, const WithClause *b)
-{
-	COMPARE_NODE_FIELD(ctes);
-	COMPARE_SCALAR_FIELD(recursive);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalInferClause(const InferClause *a, const InferClause *b)
-{
-	COMPARE_NODE_FIELD(indexElems);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_STRING_FIELD(conname);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b)
-{
-	COMPARE_SCALAR_FIELD(action);
-	COMPARE_NODE_FIELD(infer);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(whereClause);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCTESearchClause(const CTESearchClause *a, const CTESearchClause *b)
-{
-	COMPARE_NODE_FIELD(search_col_list);
-	COMPARE_SCALAR_FIELD(search_breadth_first);
-	COMPARE_STRING_FIELD(search_seq_column);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalCTECycleClause(const CTECycleClause *a, const CTECycleClause *b)
-{
-	COMPARE_NODE_FIELD(cycle_col_list);
-	COMPARE_STRING_FIELD(cycle_mark_column);
-	COMPARE_NODE_FIELD(cycle_mark_value);
-	COMPARE_NODE_FIELD(cycle_mark_default);
-	COMPARE_STRING_FIELD(cycle_path_column);
-	COMPARE_LOCATION_FIELD(location);
-	COMPARE_SCALAR_FIELD(cycle_mark_type);
-	COMPARE_SCALAR_FIELD(cycle_mark_typmod);
-	COMPARE_SCALAR_FIELD(cycle_mark_collation);
-	COMPARE_SCALAR_FIELD(cycle_mark_neop);
-
-	return true;
-}
-
-static bool
-_equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
-{
-	COMPARE_STRING_FIELD(ctename);
-	COMPARE_NODE_FIELD(aliascolnames);
-	COMPARE_SCALAR_FIELD(ctematerialized);
-	COMPARE_NODE_FIELD(ctequery);
-	COMPARE_NODE_FIELD(search_clause);
-	COMPARE_NODE_FIELD(cycle_clause);
-	COMPARE_LOCATION_FIELD(location);
-	COMPARE_SCALAR_FIELD(cterecursive);
-	COMPARE_SCALAR_FIELD(cterefcount);
-	COMPARE_NODE_FIELD(ctecolnames);
-	COMPARE_NODE_FIELD(ctecoltypes);
-	COMPARE_NODE_FIELD(ctecoltypmods);
-	COMPARE_NODE_FIELD(ctecolcollations);
-
-	return true;
-}
-
-static bool
-_equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b)
-{
-	COMPARE_SCALAR_FIELD(matched);
-	COMPARE_SCALAR_FIELD(commandType);
-	COMPARE_SCALAR_FIELD(override);
-	COMPARE_NODE_FIELD(condition);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(values);
-
-	return true;
-}
-
-static bool
-_equalMergeAction(const MergeAction *a, const MergeAction *b)
-{
-	COMPARE_SCALAR_FIELD(matched);
-	COMPARE_SCALAR_FIELD(commandType);
-	COMPARE_SCALAR_FIELD(override);
-	COMPARE_NODE_FIELD(qual);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(updateColnos);
-
-	return true;
-}
-
-static bool
-_equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
-{
-	COMPARE_SCALAR_FIELD(xmloption);
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(typeName);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
-{
-	COMPARE_SCALAR_FIELD(roletype);
-	COMPARE_STRING_FIELD(rolename);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_SCALAR_FIELD(isNew);
-	COMPARE_SCALAR_FIELD(isTable);
-
-	return true;
-}
-
-static bool
-_equalPartitionElem(const PartitionElem *a, const PartitionElem *b)
-{
-	COMPARE_STRING_FIELD(name);
-	COMPARE_NODE_FIELD(expr);
-	COMPARE_NODE_FIELD(collation);
-	COMPARE_NODE_FIELD(opclass);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b)
-{
-	COMPARE_STRING_FIELD(strategy);
-	COMPARE_NODE_FIELD(partParams);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b)
-{
-	COMPARE_SCALAR_FIELD(strategy);
-	COMPARE_SCALAR_FIELD(is_default);
-	COMPARE_SCALAR_FIELD(modulus);
-	COMPARE_SCALAR_FIELD(remainder);
-	COMPARE_NODE_FIELD(listdatums);
-	COMPARE_NODE_FIELD(lowerdatums);
-	COMPARE_NODE_FIELD(upperdatums);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b)
-{
-	COMPARE_SCALAR_FIELD(kind);
-	COMPARE_NODE_FIELD(value);
-	COMPARE_LOCATION_FIELD(location);
-
-	return true;
-}
-
-static bool
-_equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
-{
-	COMPARE_NODE_FIELD(name);
-	COMPARE_NODE_FIELD(bound);
-	COMPARE_SCALAR_FIELD(concurrent);
-
-	return true;
-}
-#endif							/* OBSOLETE */
-
 /*
- * Stuff from pg_list.h
+ * Lists are handled specially
  */
-
 static bool
 _equalList(const List *a, const List *b)
 {
@@ -3533,51 +203,6 @@ _equalList(const List *a, const List *b)
 	return true;
 }
 
-#ifdef OBSOLETE
-/*
- * Stuff from value.h
- */
-
-static bool
-_equalInteger(const Integer *a, const Integer *b)
-{
-	COMPARE_SCALAR_FIELD(ival);
-
-	return true;
-}
-
-static bool
-_equalFloat(const Float *a, const Float *b)
-{
-	COMPARE_STRING_FIELD(fval);
-
-	return true;
-}
-
-static bool
-_equalBoolean(const Boolean *a, const Boolean *b)
-{
-	COMPARE_SCALAR_FIELD(boolval);
-
-	return true;
-}
-
-static bool
-_equalString(const String *a, const String *b)
-{
-	COMPARE_STRING_FIELD(sval);
-
-	return true;
-}
-
-static bool
-_equalBitString(const BitString *a, const BitString *b)
-{
-	COMPARE_STRING_FIELD(bsval);
-
-	return true;
-}
-#endif							/* OBSOLETE */
 
 /*
  * equal
@@ -3609,228 +234,6 @@ equal(const void *a, const void *b)
 	switch (nodeTag(a))
 	{
 #include "equalfuncs.switch.c"
-#ifdef OBSOLETE
-			/*
-			 * PRIMITIVE NODES
-			 */
-		case T_Alias:
-			retval = _equalAlias(a, b);
-			break;
-		case T_RangeVar:
-			retval = _equalRangeVar(a, b);
-			break;
-		case T_TableFunc:
-			retval = _equalTableFunc(a, b);
-			break;
-		case T_IntoClause:
-			retval = _equalIntoClause(a, b);
-			break;
-		case T_Var:
-			retval = _equalVar(a, b);
-			break;
-		case T_Const:
-			retval = _equalConst(a, b);
-			break;
-		case T_Param:
-			retval = _equalParam(a, b);
-			break;
-		case T_Aggref:
-			retval = _equalAggref(a, b);
-			break;
-		case T_GroupingFunc:
-			retval = _equalGroupingFunc(a, b);
-			break;
-		case T_WindowFunc:
-			retval = _equalWindowFunc(a, b);
-			break;
-		case T_SubscriptingRef:
-			retval = _equalSubscriptingRef(a, b);
-			break;
-		case T_FuncExpr:
-			retval = _equalFuncExpr(a, b);
-			break;
-		case T_NamedArgExpr:
-			retval = _equalNamedArgExpr(a, b);
-			break;
-		case T_OpExpr:
-			retval = _equalOpExpr(a, b);
-			break;
-		case T_DistinctExpr:
-			retval = _equalDistinctExpr(a, b);
-			break;
-		case T_NullIfExpr:
-			retval = _equalNullIfExpr(a, b);
-			break;
-		case T_ScalarArrayOpExpr:
-			retval = _equalScalarArrayOpExpr(a, b);
-			break;
-		case T_BoolExpr:
-			retval = _equalBoolExpr(a, b);
-			break;
-		case T_SubLink:
-			retval = _equalSubLink(a, b);
-			break;
-		case T_SubPlan:
-			retval = _equalSubPlan(a, b);
-			break;
-		case T_AlternativeSubPlan:
-			retval = _equalAlternativeSubPlan(a, b);
-			break;
-		case T_FieldSelect:
-			retval = _equalFieldSelect(a, b);
-			break;
-		case T_FieldStore:
-			retval = _equalFieldStore(a, b);
-			break;
-		case T_RelabelType:
-			retval = _equalRelabelType(a, b);
-			break;
-		case T_CoerceViaIO:
-			retval = _equalCoerceViaIO(a, b);
-			break;
-		case T_ArrayCoerceExpr:
-			retval = _equalArrayCoerceExpr(a, b);
-			break;
-		case T_ConvertRowtypeExpr:
-			retval = _equalConvertRowtypeExpr(a, b);
-			break;
-		case T_CollateExpr:
-			retval = _equalCollateExpr(a, b);
-			break;
-		case T_CaseExpr:
-			retval = _equalCaseExpr(a, b);
-			break;
-		case T_CaseWhen:
-			retval = _equalCaseWhen(a, b);
-			break;
-		case T_CaseTestExpr:
-			retval = _equalCaseTestExpr(a, b);
-			break;
-		case T_ArrayExpr:
-			retval = _equalArrayExpr(a, b);
-			break;
-		case T_RowExpr:
-			retval = _equalRowExpr(a, b);
-			break;
-		case T_RowCompareExpr:
-			retval = _equalRowCompareExpr(a, b);
-			break;
-		case T_CoalesceExpr:
-			retval = _equalCoalesceExpr(a, b);
-			break;
-		case T_MinMaxExpr:
-			retval = _equalMinMaxExpr(a, b);
-			break;
-		case T_SQLValueFunction:
-			retval = _equalSQLValueFunction(a, b);
-			break;
-		case T_XmlExpr:
-			retval = _equalXmlExpr(a, b);
-			break;
-		case T_NullTest:
-			retval = _equalNullTest(a, b);
-			break;
-		case T_BooleanTest:
-			retval = _equalBooleanTest(a, b);
-			break;
-		case T_CoerceToDomain:
-			retval = _equalCoerceToDomain(a, b);
-			break;
-		case T_CoerceToDomainValue:
-			retval = _equalCoerceToDomainValue(a, b);
-			break;
-		case T_SetToDefault:
-			retval = _equalSetToDefault(a, b);
-			break;
-		case T_CurrentOfExpr:
-			retval = _equalCurrentOfExpr(a, b);
-			break;
-		case T_NextValueExpr:
-			retval = _equalNextValueExpr(a, b);
-			break;
-		case T_InferenceElem:
-			retval = _equalInferenceElem(a, b);
-			break;
-		case T_TargetEntry:
-			retval = _equalTargetEntry(a, b);
-			break;
-		case T_RangeTblRef:
-			retval = _equalRangeTblRef(a, b);
-			break;
-		case T_FromExpr:
-			retval = _equalFromExpr(a, b);
-			break;
-		case T_OnConflictExpr:
-			retval = _equalOnConflictExpr(a, b);
-			break;
-		case T_JoinExpr:
-			retval = _equalJoinExpr(a, b);
-			break;
-		case T_JsonFormat:
-			retval = _equalJsonFormat(a, b);
-			break;
-		case T_JsonReturning:
-			retval = _equalJsonReturning(a, b);
-			break;
-		case T_JsonValueExpr:
-			retval = _equalJsonValueExpr(a, b);
-			break;
-		case T_JsonParseExpr:
-			retval = _equalJsonParseExpr(a, b);
-			break;
-		case T_JsonScalarExpr:
-			retval = _equalJsonScalarExpr(a, b);
-			break;
-		case T_JsonSerializeExpr:
-			retval = _equalJsonSerializeExpr(a, b);
-			break;
-		case T_JsonConstructorExpr:
-			retval = _equalJsonConstructorExpr(a, b);
-			break;
-		case T_JsonIsPredicate:
-			retval = _equalJsonIsPredicate(a, b);
-			break;
-		case T_JsonBehavior:
-			retval = _equalJsonBehavior(a, b);
-			break;
-		case T_JsonExpr:
-			retval = _equalJsonExpr(a, b);
-			break;
-		case T_JsonCoercion:
-			retval = _equalJsonCoercion(a, b);
-			break;
-		case T_JsonItemCoercions:
-			retval = _equalJsonItemCoercions(a, b);
-			break;
-		case T_JsonTableParent:
-			retval = _equalJsonTableParent(a, b);
-			break;
-		case T_JsonTableSibling:
-			retval = _equalJsonTableSibling(a, b);
-			break;
-
-			/*
-			 * RELATION NODES
-			 */
-		case T_PathKey:
-			retval = _equalPathKey(a, b);
-			break;
-		case T_RestrictInfo:
-			retval = _equalRestrictInfo(a, b);
-			break;
-		case T_PlaceHolderVar:
-			retval = _equalPlaceHolderVar(a, b);
-			break;
-		case T_SpecialJoinInfo:
-			retval = _equalSpecialJoinInfo(a, b);
-			break;
-		case T_AppendRelInfo:
-			retval = _equalAppendRelInfo(a, b);
-			break;
-		case T_PlaceHolderInfo:
-			retval = _equalPlaceHolderInfo(a, b);
-			break;
-#endif							/* OBSOLETE */
 
 		case T_List:
 		case T_IntList:
@@ -3838,611 +241,6 @@ equal(const void *a, const void *b)
 			retval = _equalList(a, b);
 			break;
 
-#ifdef OBSOLETE
-		case T_Integer:
-			retval = _equalInteger(a, b);
-			break;
-		case T_Float:
-			retval = _equalFloat(a, b);
-			break;
-		case T_Boolean:
-			retval = _equalBoolean(a, b);
-			break;
-		case T_String:
-			retval = _equalString(a, b);
-			break;
-		case T_BitString:
-			retval = _equalBitString(a, b);
-			break;
-
-			/*
-			 * EXTENSIBLE NODES
-			 */
-		case T_ExtensibleNode:
-			retval = _equalExtensibleNode(a, b);
-			break;
-
-			/*
-			 * PARSE NODES
-			 */
-		case T_Query:
-			retval = _equalQuery(a, b);
-			break;
-		case T_RawStmt:
-			retval = _equalRawStmt(a, b);
-			break;
-		case T_InsertStmt:
-			retval = _equalInsertStmt(a, b);
-			break;
-		case T_DeleteStmt:
-			retval = _equalDeleteStmt(a, b);
-			break;
-		case T_UpdateStmt:
-			retval = _equalUpdateStmt(a, b);
-			break;
-		case T_MergeStmt:
-			retval = _equalMergeStmt(a, b);
-			break;
-		case T_SelectStmt:
-			retval = _equalSelectStmt(a, b);
-			break;
-		case T_SetOperationStmt:
-			retval = _equalSetOperationStmt(a, b);
-			break;
-		case T_ReturnStmt:
-			retval = _equalReturnStmt(a, b);
-			break;
-		case T_PLAssignStmt:
-			retval = _equalPLAssignStmt(a, b);
-			break;
-		case T_AlterTableStmt:
-			retval = _equalAlterTableStmt(a, b);
-			break;
-		case T_AlterTableCmd:
-			retval = _equalAlterTableCmd(a, b);
-			break;
-		case T_AlterCollationStmt:
-			retval = _equalAlterCollationStmt(a, b);
-			break;
-		case T_AlterDomainStmt:
-			retval = _equalAlterDomainStmt(a, b);
-			break;
-		case T_GrantStmt:
-			retval = _equalGrantStmt(a, b);
-			break;
-		case T_GrantRoleStmt:
-			retval = _equalGrantRoleStmt(a, b);
-			break;
-		case T_AlterDefaultPrivilegesStmt:
-			retval = _equalAlterDefaultPrivilegesStmt(a, b);
-			break;
-		case T_DeclareCursorStmt:
-			retval = _equalDeclareCursorStmt(a, b);
-			break;
-		case T_ClosePortalStmt:
-			retval = _equalClosePortalStmt(a, b);
-			break;
-		case T_CallStmt:
-			retval = _equalCallStmt(a, b);
-			break;
-		case T_ClusterStmt:
-			retval = _equalClusterStmt(a, b);
-			break;
-		case T_CopyStmt:
-			retval = _equalCopyStmt(a, b);
-			break;
-		case T_CreateStmt:
-			retval = _equalCreateStmt(a, b);
-			break;
-		case T_TableLikeClause:
-			retval = _equalTableLikeClause(a, b);
-			break;
-		case T_DefineStmt:
-			retval = _equalDefineStmt(a, b);
-			break;
-		case T_DropStmt:
-			retval = _equalDropStmt(a, b);
-			break;
-		case T_TruncateStmt:
-			retval = _equalTruncateStmt(a, b);
-			break;
-		case T_CommentStmt:
-			retval = _equalCommentStmt(a, b);
-			break;
-		case T_SecLabelStmt:
-			retval = _equalSecLabelStmt(a, b);
-			break;
-		case T_FetchStmt:
-			retval = _equalFetchStmt(a, b);
-			break;
-		case T_IndexStmt:
-			retval = _equalIndexStmt(a, b);
-			break;
-		case T_CreateStatsStmt:
-			retval = _equalCreateStatsStmt(a, b);
-			break;
-		case T_AlterStatsStmt:
-			retval = _equalAlterStatsStmt(a, b);
-			break;
-		case T_CreateFunctionStmt:
-			retval = _equalCreateFunctionStmt(a, b);
-			break;
-		case T_FunctionParameter:
-			retval = _equalFunctionParameter(a, b);
-			break;
-		case T_AlterFunctionStmt:
-			retval = _equalAlterFunctionStmt(a, b);
-			break;
-		case T_DoStmt:
-			retval = _equalDoStmt(a, b);
-			break;
-		case T_RenameStmt:
-			retval = _equalRenameStmt(a, b);
-			break;
-		case T_AlterObjectDependsStmt:
-			retval = _equalAlterObjectDependsStmt(a, b);
-			break;
-		case T_AlterObjectSchemaStmt:
-			retval = _equalAlterObjectSchemaStmt(a, b);
-			break;
-		case T_AlterOwnerStmt:
-			retval = _equalAlterOwnerStmt(a, b);
-			break;
-		case T_AlterOperatorStmt:
-			retval = _equalAlterOperatorStmt(a, b);
-			break;
-		case T_AlterTypeStmt:
-			retval = _equalAlterTypeStmt(a, b);
-			break;
-		case T_RuleStmt:
-			retval = _equalRuleStmt(a, b);
-			break;
-		case T_NotifyStmt:
-			retval = _equalNotifyStmt(a, b);
-			break;
-		case T_ListenStmt:
-			retval = _equalListenStmt(a, b);
-			break;
-		case T_UnlistenStmt:
-			retval = _equalUnlistenStmt(a, b);
-			break;
-		case T_TransactionStmt:
-			retval = _equalTransactionStmt(a, b);
-			break;
-		case T_CompositeTypeStmt:
-			retval = _equalCompositeTypeStmt(a, b);
-			break;
-		case T_CreateEnumStmt:
-			retval = _equalCreateEnumStmt(a, b);
-			break;
-		case T_CreateRangeStmt:
-			retval = _equalCreateRangeStmt(a, b);
-			break;
-		case T_AlterEnumStmt:
-			retval = _equalAlterEnumStmt(a, b);
-			break;
-		case T_ViewStmt:
-			retval = _equalViewStmt(a, b);
-			break;
-		case T_LoadStmt:
-			retval = _equalLoadStmt(a, b);
-			break;
-		case T_CreateDomainStmt:
-			retval = _equalCreateDomainStmt(a, b);
-			break;
-		case T_CreateOpClassStmt:
-			retval = _equalCreateOpClassStmt(a, b);
-			break;
-		case T_CreateOpClassItem:
-			retval = _equalCreateOpClassItem(a, b);
-			break;
-		case T_CreateOpFamilyStmt:
-			retval = _equalCreateOpFamilyStmt(a, b);
-			break;
-		case T_AlterOpFamilyStmt:
-			retval = _equalAlterOpFamilyStmt(a, b);
-			break;
-		case T_CreatedbStmt:
-			retval = _equalCreatedbStmt(a, b);
-			break;
-		case T_AlterDatabaseStmt:
-			retval = _equalAlterDatabaseStmt(a, b);
-			break;
-		case T_AlterDatabaseRefreshCollStmt:
-			retval = _equalAlterDatabaseRefreshCollStmt(a, b);
-			break;
-		case T_AlterDatabaseSetStmt:
-			retval = _equalAlterDatabaseSetStmt(a, b);
-			break;
-		case T_DropdbStmt:
-			retval = _equalDropdbStmt(a, b);
-			break;
-		case T_VacuumStmt:
-			retval = _equalVacuumStmt(a, b);
-			break;
-		case T_VacuumRelation:
-			retval = _equalVacuumRelation(a, b);
-			break;
-		case T_ExplainStmt:
-			retval = _equalExplainStmt(a, b);
-			break;
-		case T_CreateTableAsStmt:
-			retval = _equalCreateTableAsStmt(a, b);
-			break;
-		case T_RefreshMatViewStmt:
-			retval = _equalRefreshMatViewStmt(a, b);
-			break;
-		case T_ReplicaIdentityStmt:
-			retval = _equalReplicaIdentityStmt(a, b);
-			break;
-		case T_AlterSystemStmt:
-			retval = _equalAlterSystemStmt(a, b);
-			break;
-		case T_CreateSeqStmt:
-			retval = _equalCreateSeqStmt(a, b);
-			break;
-		case T_AlterSeqStmt:
-			retval = _equalAlterSeqStmt(a, b);
-			break;
-		case T_VariableSetStmt:
-			retval = _equalVariableSetStmt(a, b);
-			break;
-		case T_VariableShowStmt:
-			retval = _equalVariableShowStmt(a, b);
-			break;
-		case T_DiscardStmt:
-			retval = _equalDiscardStmt(a, b);
-			break;
-		case T_CreateTableSpaceStmt:
-			retval = _equalCreateTableSpaceStmt(a, b);
-			break;
-		case T_DropTableSpaceStmt:
-			retval = _equalDropTableSpaceStmt(a, b);
-			break;
-		case T_AlterTableSpaceOptionsStmt:
-			retval = _equalAlterTableSpaceOptionsStmt(a, b);
-			break;
-		case T_AlterTableMoveAllStmt:
-			retval = _equalAlterTableMoveAllStmt(a, b);
-			break;
-		case T_CreateExtensionStmt:
-			retval = _equalCreateExtensionStmt(a, b);
-			break;
-		case T_AlterExtensionStmt:
-			retval = _equalAlterExtensionStmt(a, b);
-			break;
-		case T_AlterExtensionContentsStmt:
-			retval = _equalAlterExtensionContentsStmt(a, b);
-			break;
-		case T_CreateFdwStmt:
-			retval = _equalCreateFdwStmt(a, b);
-			break;
-		case T_AlterFdwStmt:
-			retval = _equalAlterFdwStmt(a, b);
-			break;
-		case T_CreateForeignServerStmt:
-			retval = _equalCreateForeignServerStmt(a, b);
-			break;
-		case T_AlterForeignServerStmt:
-			retval = _equalAlterForeignServerStmt(a, b);
-			break;
-		case T_CreateUserMappingStmt:
-			retval = _equalCreateUserMappingStmt(a, b);
-			break;
-		case T_AlterUserMappingStmt:
-			retval = _equalAlterUserMappingStmt(a, b);
-			break;
-		case T_DropUserMappingStmt:
-			retval = _equalDropUserMappingStmt(a, b);
-			break;
-		case T_CreateForeignTableStmt:
-			retval = _equalCreateForeignTableStmt(a, b);
-			break;
-		case T_ImportForeignSchemaStmt:
-			retval = _equalImportForeignSchemaStmt(a, b);
-			break;
-		case T_CreateTransformStmt:
-			retval = _equalCreateTransformStmt(a, b);
-			break;
-		case T_CreateAmStmt:
-			retval = _equalCreateAmStmt(a, b);
-			break;
-		case T_CreateTrigStmt:
-			retval = _equalCreateTrigStmt(a, b);
-			break;
-		case T_CreateEventTrigStmt:
-			retval = _equalCreateEventTrigStmt(a, b);
-			break;
-		case T_AlterEventTrigStmt:
-			retval = _equalAlterEventTrigStmt(a, b);
-			break;
-		case T_CreatePLangStmt:
-			retval = _equalCreatePLangStmt(a, b);
-			break;
-		case T_CreateRoleStmt:
-			retval = _equalCreateRoleStmt(a, b);
-			break;
-		case T_AlterRoleStmt:
-			retval = _equalAlterRoleStmt(a, b);
-			break;
-		case T_AlterRoleSetStmt:
-			retval = _equalAlterRoleSetStmt(a, b);
-			break;
-		case T_DropRoleStmt:
-			retval = _equalDropRoleStmt(a, b);
-			break;
-		case T_LockStmt:
-			retval = _equalLockStmt(a, b);
-			break;
-		case T_ConstraintsSetStmt:
-			retval = _equalConstraintsSetStmt(a, b);
-			break;
-		case T_ReindexStmt:
-			retval = _equalReindexStmt(a, b);
-			break;
-		case T_CheckPointStmt:
-			retval = true;
-			break;
-		case T_CreateSchemaStmt:
-			retval = _equalCreateSchemaStmt(a, b);
-			break;
-		case T_CreateConversionStmt:
-			retval = _equalCreateConversionStmt(a, b);
-			break;
-		case T_CreateCastStmt:
-			retval = _equalCreateCastStmt(a, b);
-			break;
-		case T_PrepareStmt:
-			retval = _equalPrepareStmt(a, b);
-			break;
-		case T_ExecuteStmt:
-			retval = _equalExecuteStmt(a, b);
-			break;
-		case T_DeallocateStmt:
-			retval = _equalDeallocateStmt(a, b);
-			break;
-		case T_DropOwnedStmt:
-			retval = _equalDropOwnedStmt(a, b);
-			break;
-		case T_ReassignOwnedStmt:
-			retval = _equalReassignOwnedStmt(a, b);
-			break;
-		case T_AlterTSDictionaryStmt:
-			retval = _equalAlterTSDictionaryStmt(a, b);
-			break;
-		case T_AlterTSConfigurationStmt:
-			retval = _equalAlterTSConfigurationStmt(a, b);
-			break;
-		case T_CreatePolicyStmt:
-			retval = _equalCreatePolicyStmt(a, b);
-			break;
-		case T_AlterPolicyStmt:
-			retval = _equalAlterPolicyStmt(a, b);
-			break;
-		case T_CreatePublicationStmt:
-			retval = _equalCreatePublicationStmt(a, b);
-			break;
-		case T_AlterPublicationStmt:
-			retval = _equalAlterPublicationStmt(a, b);
-			break;
-		case T_CreateSubscriptionStmt:
-			retval = _equalCreateSubscriptionStmt(a, b);
-			break;
-		case T_AlterSubscriptionStmt:
-			retval = _equalAlterSubscriptionStmt(a, b);
-			break;
-		case T_DropSubscriptionStmt:
-			retval = _equalDropSubscriptionStmt(a, b);
-			break;
-		case T_A_Expr:
-			retval = _equalA_Expr(a, b);
-			break;
-		case T_ColumnRef:
-			retval = _equalColumnRef(a, b);
-			break;
-		case T_ParamRef:
-			retval = _equalParamRef(a, b);
-			break;
-		case T_A_Const:
-			retval = _equalA_Const(a, b);
-			break;
-		case T_FuncCall:
-			retval = _equalFuncCall(a, b);
-			break;
-		case T_A_Star:
-			retval = _equalA_Star(a, b);
-			break;
-		case T_A_Indices:
-			retval = _equalA_Indices(a, b);
-			break;
-		case T_A_Indirection:
-			retval = _equalA_Indirection(a, b);
-			break;
-		case T_A_ArrayExpr:
-			retval = _equalA_ArrayExpr(a, b);
-			break;
-		case T_ResTarget:
-			retval = _equalResTarget(a, b);
-			break;
-		case T_MultiAssignRef:
-			retval = _equalMultiAssignRef(a, b);
-			break;
-		case T_TypeCast:
-			retval = _equalTypeCast(a, b);
-			break;
-		case T_CollateClause:
-			retval = _equalCollateClause(a, b);
-			break;
-		case T_SortBy:
-			retval = _equalSortBy(a, b);
-			break;
-		case T_WindowDef:
-			retval = _equalWindowDef(a, b);
-			break;
-		case T_RangeSubselect:
-			retval = _equalRangeSubselect(a, b);
-			break;
-		case T_RangeFunction:
-			retval = _equalRangeFunction(a, b);
-			break;
-		case T_RangeTableSample:
-			retval = _equalRangeTableSample(a, b);
-			break;
-		case T_RangeTableFunc:
-			retval = _equalRangeTableFunc(a, b);
-			break;
-		case T_RangeTableFuncCol:
-			retval = _equalRangeTableFuncCol(a, b);
-			break;
-		case T_TypeName:
-			retval = _equalTypeName(a, b);
-			break;
-		case T_IndexElem:
-			retval = _equalIndexElem(a, b);
-			break;
-		case T_StatsElem:
-			retval = _equalStatsElem(a, b);
-			break;
-		case T_ColumnDef:
-			retval = _equalColumnDef(a, b);
-			break;
-		case T_Constraint:
-			retval = _equalConstraint(a, b);
-			break;
-		case T_DefElem:
-			retval = _equalDefElem(a, b);
-			break;
-		case T_LockingClause:
-			retval = _equalLockingClause(a, b);
-			break;
-		case T_RangeTblEntry:
-			retval = _equalRangeTblEntry(a, b);
-			break;
-		case T_RangeTblFunction:
-			retval = _equalRangeTblFunction(a, b);
-			break;
-		case T_TableSampleClause:
-			retval = _equalTableSampleClause(a, b);
-			break;
-		case T_WithCheckOption:
-			retval = _equalWithCheckOption(a, b);
-			break;
-		case T_SortGroupClause:
-			retval = _equalSortGroupClause(a, b);
-			break;
-		case T_GroupingSet:
-			retval = _equalGroupingSet(a, b);
-			break;
-		case T_WindowClause:
-			retval = _equalWindowClause(a, b);
-			break;
-		case T_RowMarkClause:
-			retval = _equalRowMarkClause(a, b);
-			break;
-		case T_WithClause:
-			retval = _equalWithClause(a, b);
-			break;
-		case T_InferClause:
-			retval = _equalInferClause(a, b);
-			break;
-		case T_OnConflictClause:
-			retval = _equalOnConflictClause(a, b);
-			break;
-		case T_CTESearchClause:
-			retval = _equalCTESearchClause(a, b);
-			break;
-		case T_CTECycleClause:
-			retval = _equalCTECycleClause(a, b);
-			break;
-		case T_CommonTableExpr:
-			retval = _equalCommonTableExpr(a, b);
-			break;
-		case T_MergeWhenClause:
-			retval = _equalMergeWhenClause(a, b);
-			break;
-		case T_MergeAction:
-			retval = _equalMergeAction(a, b);
-			break;
-		case T_ObjectWithArgs:
-			retval = _equalObjectWithArgs(a, b);
-			break;
-		case T_AccessPriv:
-			retval = _equalAccessPriv(a, b);
-			break;
-		case T_XmlSerialize:
-			retval = _equalXmlSerialize(a, b);
-			break;
-		case T_RoleSpec:
-			retval = _equalRoleSpec(a, b);
-			break;
-		case T_TriggerTransition:
-			retval = _equalTriggerTransition(a, b);
-			break;
-		case T_PartitionElem:
-			retval = _equalPartitionElem(a, b);
-			break;
-		case T_PartitionSpec:
-			retval = _equalPartitionSpec(a, b);
-			break;
-		case T_PartitionBoundSpec:
-			retval = _equalPartitionBoundSpec(a, b);
-			break;
-		case T_PartitionRangeDatum:
-			retval = _equalPartitionRangeDatum(a, b);
-			break;
-		case T_PartitionCmd:
-			retval = _equalPartitionCmd(a, b);
-			break;
-		case T_PublicationObjSpec:
-			retval = _equalPublicationObject(a, b);
-			break;
-		case T_PublicationTable:
-			retval = _equalPublicationTable(a, b);
-			break;
-		case T_JsonKeyValue:
-			retval = _equalJsonKeyValue(a, b);
-			break;
-		case T_JsonObjectConstructor:
-			retval = _equalJsonObjectConstructor(a, b);
-			break;
-		case T_JsonAggConstructor:
-			retval = _equalJsonAggConstructor(a, b);
-			break;
-		case T_JsonObjectAgg:
-			retval = _equalJsonObjectAgg(a, b);
-			break;
-		case T_JsonOutput:
-			retval = _equalJsonOutput(a, b);
-			break;
-		case T_JsonArrayConstructor:
-			retval = _equalJsonArrayConstructor(a, b);
-			break;
-		case T_JsonArrayQueryConstructor:
-			retval = _equalJsonArrayQueryConstructor(a, b);
-			break;
-		case T_JsonArrayAgg:
-			retval = _equalJsonArrayAgg(a, b);
-			break;
-		case T_JsonFuncExpr:
-			retval = _equalJsonFuncExpr(a, b);
-			break;
-		case T_JsonCommon:
-			retval = _equalJsonCommon(a, b);
-			break;
-		case T_JsonArgument:
-			retval = _equalJsonArgument(a, b);
-			break;
-		case T_JsonTablePlan:
-			retval = _equalJsonTablePlan(a, b);
-			break;
-		case T_JsonTable:
-			retval = _equalJsonTable(a, b);
-			break;
-		case T_JsonTableColumn:
-			retval = _equalJsonTableColumn(a, b);
-			break;
-#endif							/* OBSOLETE */
-
 		default:
 			elog(ERROR, "unrecognized node type: %d",
 				 (int) nodeTag(a));
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f26c129d59..9e70bbb4d6 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -307,840 +307,11 @@ outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
 
 #include "outfuncs.funcs.c"
 
-#ifdef OBSOLETE
-/*
- *	Stuff from plannodes.h
- */
-
-static void
-_outPlannedStmt(StringInfo str, const PlannedStmt *node)
-{
-	WRITE_NODE_TYPE("PLANNEDSTMT");
-
-	WRITE_ENUM_FIELD(commandType, CmdType);
-	WRITE_UINT64_FIELD(queryId);
-	WRITE_BOOL_FIELD(hasReturning);
-	WRITE_BOOL_FIELD(hasModifyingCTE);
-	WRITE_BOOL_FIELD(canSetTag);
-	WRITE_BOOL_FIELD(transientPlan);
-	WRITE_BOOL_FIELD(dependsOnRole);
-	WRITE_BOOL_FIELD(parallelModeNeeded);
-	WRITE_INT_FIELD(jitFlags);
-	WRITE_NODE_FIELD(planTree);
-	WRITE_NODE_FIELD(rtable);
-	WRITE_NODE_FIELD(resultRelations);
-	WRITE_NODE_FIELD(appendRelations);
-	WRITE_NODE_FIELD(subplans);
-	WRITE_BITMAPSET_FIELD(rewindPlanIDs);
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_NODE_FIELD(relationOids);
-	WRITE_NODE_FIELD(invalItems);
-	WRITE_NODE_FIELD(paramExecTypes);
-	WRITE_NODE_FIELD(utilityStmt);
-	WRITE_LOCATION_FIELD(stmt_location);
-	WRITE_INT_FIELD(stmt_len);
-}
-
-/*
- * print the basic stuff of all nodes that inherit from Plan
- */
-static void
-_outPlanInfo(StringInfo str, const Plan *node)
-{
-	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
-	WRITE_FLOAT_FIELD(total_cost, "%.2f");
-	WRITE_FLOAT_FIELD(plan_rows, "%.0f");
-	WRITE_INT_FIELD(plan_width);
-	WRITE_BOOL_FIELD(parallel_aware);
-	WRITE_BOOL_FIELD(parallel_safe);
-	WRITE_BOOL_FIELD(async_capable);
-	WRITE_INT_FIELD(plan_node_id);
-	WRITE_NODE_FIELD(targetlist);
-	WRITE_NODE_FIELD(qual);
-	WRITE_NODE_FIELD(lefttree);
-	WRITE_NODE_FIELD(righttree);
-	WRITE_NODE_FIELD(initPlan);
-	WRITE_BITMAPSET_FIELD(extParam);
-	WRITE_BITMAPSET_FIELD(allParam);
-}
-
-/*
- * print the basic stuff of all nodes that inherit from Scan
- */
-static void
-_outScanInfo(StringInfo str, const Scan *node)
-{
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_UINT_FIELD(scanrelid);
-}
 
 /*
- * print the basic stuff of all nodes that inherit from Join
+ * Support functions for nodes with custom_read_write attribute or
+ * special_read_write attribute
  */
-static void
-_outJoinPlanInfo(StringInfo str, const Join *node)
-{
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_ENUM_FIELD(jointype, JoinType);
-	WRITE_BOOL_FIELD(inner_unique);
-	WRITE_NODE_FIELD(joinqual);
-}
-
-static void
-_outResult(StringInfo str, const Result *node)
-{
-	WRITE_NODE_TYPE("RESULT");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_NODE_FIELD(resconstantqual);
-}
-
-static void
-_outProjectSet(StringInfo str, const ProjectSet *node)
-{
-	WRITE_NODE_TYPE("PROJECTSET");
-
-	_outPlanInfo(str, (const Plan *) node);
-}
-
-static void
-_outModifyTable(StringInfo str, const ModifyTable *node)
-{
-	WRITE_NODE_TYPE("MODIFYTABLE");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_ENUM_FIELD(operation, CmdType);
-	WRITE_BOOL_FIELD(canSetTag);
-	WRITE_UINT_FIELD(nominalRelation);
-	WRITE_UINT_FIELD(rootRelation);
-	WRITE_BOOL_FIELD(partColsUpdated);
-	WRITE_NODE_FIELD(resultRelations);
-	WRITE_NODE_FIELD(updateColnosLists);
-	WRITE_NODE_FIELD(withCheckOptionLists);
-	WRITE_NODE_FIELD(returningLists);
-	WRITE_NODE_FIELD(fdwPrivLists);
-	WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans);
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_INT_FIELD(epqParam);
-	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
-	WRITE_NODE_FIELD(arbiterIndexes);
-	WRITE_NODE_FIELD(onConflictSet);
-	WRITE_NODE_FIELD(onConflictCols);
-	WRITE_NODE_FIELD(onConflictWhere);
-	WRITE_UINT_FIELD(exclRelRTI);
-	WRITE_NODE_FIELD(exclRelTlist);
-	WRITE_NODE_FIELD(mergeActionLists);
-}
-
-static void
-_outAppend(StringInfo str, const Append *node)
-{
-	WRITE_NODE_TYPE("APPEND");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_BITMAPSET_FIELD(apprelids);
-	WRITE_NODE_FIELD(appendplans);
-	WRITE_INT_FIELD(nasyncplans);
-	WRITE_INT_FIELD(first_partial_plan);
-	WRITE_NODE_FIELD(part_prune_info);
-}
-
-static void
-_outMergeAppend(StringInfo str, const MergeAppend *node)
-{
-	WRITE_NODE_TYPE("MERGEAPPEND");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_BITMAPSET_FIELD(apprelids);
-	WRITE_NODE_FIELD(mergeplans);
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
-	WRITE_OID_ARRAY(sortOperators, node->numCols);
-	WRITE_OID_ARRAY(collations, node->numCols);
-	WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
-	WRITE_NODE_FIELD(part_prune_info);
-}
-
-static void
-_outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
-{
-	WRITE_NODE_TYPE("RECURSIVEUNION");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(wtParam);
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols);
-	WRITE_OID_ARRAY(dupOperators, node->numCols);
-	WRITE_OID_ARRAY(dupCollations, node->numCols);
-	WRITE_LONG_FIELD(numGroups);
-}
-
-static void
-_outBitmapAnd(StringInfo str, const BitmapAnd *node)
-{
-	WRITE_NODE_TYPE("BITMAPAND");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_NODE_FIELD(bitmapplans);
-}
-
-static void
-_outBitmapOr(StringInfo str, const BitmapOr *node)
-{
-	WRITE_NODE_TYPE("BITMAPOR");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_BOOL_FIELD(isshared);
-	WRITE_NODE_FIELD(bitmapplans);
-}
-
-static void
-_outGather(StringInfo str, const Gather *node)
-{
-	WRITE_NODE_TYPE("GATHER");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(num_workers);
-	WRITE_INT_FIELD(rescan_param);
-	WRITE_BOOL_FIELD(single_copy);
-	WRITE_BOOL_FIELD(invisible);
-	WRITE_BITMAPSET_FIELD(initParam);
-}
-
-static void
-_outGatherMerge(StringInfo str, const GatherMerge *node)
-{
-	WRITE_NODE_TYPE("GATHERMERGE");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(num_workers);
-	WRITE_INT_FIELD(rescan_param);
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
-	WRITE_OID_ARRAY(sortOperators, node->numCols);
-	WRITE_OID_ARRAY(collations, node->numCols);
-	WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
-	WRITE_BITMAPSET_FIELD(initParam);
-}
-
-static void
-_outScan(StringInfo str, const Scan *node)
-{
-	WRITE_NODE_TYPE("SCAN");
-
-	_outScanInfo(str, node);
-}
-
-static void
-_outSeqScan(StringInfo str, const SeqScan *node)
-{
-	WRITE_NODE_TYPE("SEQSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-}
-
-static void
-_outSampleScan(StringInfo str, const SampleScan *node)
-{
-	WRITE_NODE_TYPE("SAMPLESCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(tablesample);
-}
-
-static void
-_outIndexScan(StringInfo str, const IndexScan *node)
-{
-	WRITE_NODE_TYPE("INDEXSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_OID_FIELD(indexid);
-	WRITE_NODE_FIELD(indexqual);
-	WRITE_NODE_FIELD(indexqualorig);
-	WRITE_NODE_FIELD(indexorderby);
-	WRITE_NODE_FIELD(indexorderbyorig);
-	WRITE_NODE_FIELD(indexorderbyops);
-	WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
-}
-
-static void
-_outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
-{
-	WRITE_NODE_TYPE("INDEXONLYSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_OID_FIELD(indexid);
-	WRITE_NODE_FIELD(indexqual);
-	WRITE_NODE_FIELD(recheckqual);
-	WRITE_NODE_FIELD(indexorderby);
-	WRITE_NODE_FIELD(indextlist);
-	WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
-}
-
-static void
-_outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
-{
-	WRITE_NODE_TYPE("BITMAPINDEXSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_OID_FIELD(indexid);
-	WRITE_BOOL_FIELD(isshared);
-	WRITE_NODE_FIELD(indexqual);
-	WRITE_NODE_FIELD(indexqualorig);
-}
-
-static void
-_outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
-{
-	WRITE_NODE_TYPE("BITMAPHEAPSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(bitmapqualorig);
-}
-
-static void
-_outTidScan(StringInfo str, const TidScan *node)
-{
-	WRITE_NODE_TYPE("TIDSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(tidquals);
-}
-
-static void
-_outTidRangeScan(StringInfo str, const TidRangeScan *node)
-{
-	WRITE_NODE_TYPE("TIDRANGESCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(tidrangequals);
-}
-
-static void
-_outSubqueryScan(StringInfo str, const SubqueryScan *node)
-{
-	WRITE_NODE_TYPE("SUBQUERYSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(subplan);
-	WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus);
-}
-
-static void
-_outFunctionScan(StringInfo str, const FunctionScan *node)
-{
-	WRITE_NODE_TYPE("FUNCTIONSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(functions);
-	WRITE_BOOL_FIELD(funcordinality);
-}
-
-static void
-_outTableFuncScan(StringInfo str, const TableFuncScan *node)
-{
-	WRITE_NODE_TYPE("TABLEFUNCSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(tablefunc);
-}
-
-static void
-_outValuesScan(StringInfo str, const ValuesScan *node)
-{
-	WRITE_NODE_TYPE("VALUESSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_NODE_FIELD(values_lists);
-}
-
-static void
-_outCteScan(StringInfo str, const CteScan *node)
-{
-	WRITE_NODE_TYPE("CTESCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_INT_FIELD(ctePlanId);
-	WRITE_INT_FIELD(cteParam);
-}
-
-static void
-_outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node)
-{
-	WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_STRING_FIELD(enrname);
-}
-
-static void
-_outWorkTableScan(StringInfo str, const WorkTableScan *node)
-{
-	WRITE_NODE_TYPE("WORKTABLESCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_INT_FIELD(wtParam);
-}
-
-static void
-_outForeignScan(StringInfo str, const ForeignScan *node)
-{
-	WRITE_NODE_TYPE("FOREIGNSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_ENUM_FIELD(operation, CmdType);
-	WRITE_UINT_FIELD(resultRelation);
-	WRITE_OID_FIELD(fs_server);
-	WRITE_NODE_FIELD(fdw_exprs);
-	WRITE_NODE_FIELD(fdw_private);
-	WRITE_NODE_FIELD(fdw_scan_tlist);
-	WRITE_NODE_FIELD(fdw_recheck_quals);
-	WRITE_BITMAPSET_FIELD(fs_relids);
-	WRITE_BOOL_FIELD(fsSystemCol);
-}
-
-static void
-_outCustomScan(StringInfo str, const CustomScan *node)
-{
-	WRITE_NODE_TYPE("CUSTOMSCAN");
-
-	_outScanInfo(str, (const Scan *) node);
-
-	WRITE_UINT_FIELD(flags);
-	WRITE_NODE_FIELD(custom_plans);
-	WRITE_NODE_FIELD(custom_exprs);
-	WRITE_NODE_FIELD(custom_private);
-	WRITE_NODE_FIELD(custom_scan_tlist);
-	WRITE_BITMAPSET_FIELD(custom_relids);
-	/* CustomName is a key to lookup CustomScanMethods */
-	appendStringInfoString(str, " :methods ");
-	outToken(str, node->methods->CustomName);
-}
-
-static void
-_outNestLoop(StringInfo str, const NestLoop *node)
-{
-	WRITE_NODE_TYPE("NESTLOOP");
-
-	_outJoinPlanInfo(str, (const Join *) node);
-
-	WRITE_NODE_FIELD(nestParams);
-}
-
-static void
-_outMergeJoin(StringInfo str, const MergeJoin *node)
-{
-	int			numCols;
-
-	WRITE_NODE_TYPE("MERGEJOIN");
-
-	_outJoinPlanInfo(str, (const Join *) node);
-
-	WRITE_BOOL_FIELD(skip_mark_restore);
-	WRITE_NODE_FIELD(mergeclauses);
-
-	numCols = list_length(node->mergeclauses);
-
-	WRITE_OID_ARRAY(mergeFamilies, numCols);
-	WRITE_OID_ARRAY(mergeCollations, numCols);
-	WRITE_INT_ARRAY(mergeStrategies, numCols);
-	WRITE_BOOL_ARRAY(mergeNullsFirst, numCols);
-}
-
-static void
-_outHashJoin(StringInfo str, const HashJoin *node)
-{
-	WRITE_NODE_TYPE("HASHJOIN");
-
-	_outJoinPlanInfo(str, (const Join *) node);
-
-	WRITE_NODE_FIELD(hashclauses);
-	WRITE_NODE_FIELD(hashoperators);
-	WRITE_NODE_FIELD(hashcollations);
-	WRITE_NODE_FIELD(hashkeys);
-}
-
-static void
-_outAgg(StringInfo str, const Agg *node)
-{
-	WRITE_NODE_TYPE("AGG");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
-	WRITE_ENUM_FIELD(aggsplit, AggSplit);
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
-	WRITE_OID_ARRAY(grpOperators, node->numCols);
-	WRITE_OID_ARRAY(grpCollations, node->numCols);
-	WRITE_LONG_FIELD(numGroups);
-	WRITE_UINT64_FIELD(transitionSpace);
-	WRITE_BITMAPSET_FIELD(aggParams);
-	WRITE_NODE_FIELD(groupingSets);
-	WRITE_NODE_FIELD(chain);
-}
-
-static void
-_outWindowAgg(StringInfo str, const WindowAgg *node)
-{
-	WRITE_NODE_TYPE("WINDOWAGG");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_UINT_FIELD(winref);
-	WRITE_INT_FIELD(partNumCols);
-	WRITE_ATTRNUMBER_ARRAY(partColIdx, node->partNumCols);
-	WRITE_OID_ARRAY(partOperators, node->partNumCols);
-	WRITE_OID_ARRAY(partCollations, node->partNumCols);
-	WRITE_INT_FIELD(ordNumCols);
-	WRITE_ATTRNUMBER_ARRAY(ordColIdx, node->ordNumCols);
-	WRITE_OID_ARRAY(ordOperators, node->ordNumCols);
-	WRITE_OID_ARRAY(ordCollations, node->ordNumCols);
-	WRITE_INT_FIELD(frameOptions);
-	WRITE_NODE_FIELD(startOffset);
-	WRITE_NODE_FIELD(endOffset);
-	WRITE_NODE_FIELD(runCondition);
-	WRITE_NODE_FIELD(runConditionOrig);
-	WRITE_OID_FIELD(startInRangeFunc);
-	WRITE_OID_FIELD(endInRangeFunc);
-	WRITE_OID_FIELD(inRangeColl);
-	WRITE_BOOL_FIELD(inRangeAsc);
-	WRITE_BOOL_FIELD(inRangeNullsFirst);
-	WRITE_BOOL_FIELD(topWindow);
-}
-
-static void
-_outGroup(StringInfo str, const Group *node)
-{
-	WRITE_NODE_TYPE("GROUP");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
-	WRITE_OID_ARRAY(grpOperators, node->numCols);
-	WRITE_OID_ARRAY(grpCollations, node->numCols);
-}
-
-static void
-_outMaterial(StringInfo str, const Material *node)
-{
-	WRITE_NODE_TYPE("MATERIAL");
-
-	_outPlanInfo(str, (const Plan *) node);
-}
-
-static void
-_outMemoize(StringInfo str, const Memoize *node)
-{
-	WRITE_NODE_TYPE("MEMOIZE");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(numKeys);
-	WRITE_OID_ARRAY(hashOperators, node->numKeys);
-	WRITE_OID_ARRAY(collations, node->numKeys);
-	WRITE_NODE_FIELD(param_exprs);
-	WRITE_BOOL_FIELD(singlerow);
-	WRITE_BOOL_FIELD(binary_mode);
-	WRITE_UINT_FIELD(est_entries);
-	WRITE_BITMAPSET_FIELD(keyparamids);
-}
-
-static void
-_outSortInfo(StringInfo str, const Sort *node)
-{
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
-	WRITE_OID_ARRAY(sortOperators, node->numCols);
-	WRITE_OID_ARRAY(collations, node->numCols);
-	WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
-}
-
-static void
-_outSort(StringInfo str, const Sort *node)
-{
-	WRITE_NODE_TYPE("SORT");
-
-	_outSortInfo(str, node);
-}
-
-static void
-_outIncrementalSort(StringInfo str, const IncrementalSort *node)
-{
-	WRITE_NODE_TYPE("INCREMENTALSORT");
-
-	_outSortInfo(str, (const Sort *) node);
-
-	WRITE_INT_FIELD(nPresortedCols);
-}
-
-static void
-_outUnique(StringInfo str, const Unique *node)
-{
-	WRITE_NODE_TYPE("UNIQUE");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->numCols);
-	WRITE_OID_ARRAY(uniqOperators, node->numCols);
-	WRITE_OID_ARRAY(uniqCollations, node->numCols);
-}
-
-static void
-_outHash(StringInfo str, const Hash *node)
-{
-	WRITE_NODE_TYPE("HASH");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_NODE_FIELD(hashkeys);
-	WRITE_OID_FIELD(skewTable);
-	WRITE_INT_FIELD(skewColumn);
-	WRITE_BOOL_FIELD(skewInherit);
-	WRITE_FLOAT_FIELD(rows_total, "%.0f");
-}
-
-static void
-_outSetOp(StringInfo str, const SetOp *node)
-{
-	WRITE_NODE_TYPE("SETOP");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_ENUM_FIELD(cmd, SetOpCmd);
-	WRITE_ENUM_FIELD(strategy, SetOpStrategy);
-	WRITE_INT_FIELD(numCols);
-	WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols);
-	WRITE_OID_ARRAY(dupOperators, node->numCols);
-	WRITE_OID_ARRAY(dupCollations, node->numCols);
-	WRITE_INT_FIELD(flagColIdx);
-	WRITE_INT_FIELD(firstFlag);
-	WRITE_LONG_FIELD(numGroups);
-}
-
-static void
-_outLockRows(StringInfo str, const LockRows *node)
-{
-	WRITE_NODE_TYPE("LOCKROWS");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_INT_FIELD(epqParam);
-}
-
-static void
-_outLimit(StringInfo str, const Limit *node)
-{
-	WRITE_NODE_TYPE("LIMIT");
-
-	_outPlanInfo(str, (const Plan *) node);
-
-	WRITE_NODE_FIELD(limitOffset);
-	WRITE_NODE_FIELD(limitCount);
-	WRITE_ENUM_FIELD(limitOption, LimitOption);
-	WRITE_INT_FIELD(uniqNumCols);
-	WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->uniqNumCols);
-	WRITE_OID_ARRAY(uniqOperators, node->uniqNumCols);
-	WRITE_OID_ARRAY(uniqCollations, node->uniqNumCols);
-}
-
-static void
-_outNestLoopParam(StringInfo str, const NestLoopParam *node)
-{
-	WRITE_NODE_TYPE("NESTLOOPPARAM");
-
-	WRITE_INT_FIELD(paramno);
-	WRITE_NODE_FIELD(paramval);
-}
-
-static void
-_outPlanRowMark(StringInfo str, const PlanRowMark *node)
-{
-	WRITE_NODE_TYPE("PLANROWMARK");
-
-	WRITE_UINT_FIELD(rti);
-	WRITE_UINT_FIELD(prti);
-	WRITE_UINT_FIELD(rowmarkId);
-	WRITE_ENUM_FIELD(markType, RowMarkType);
-	WRITE_INT_FIELD(allMarkTypes);
-	WRITE_ENUM_FIELD(strength, LockClauseStrength);
-	WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
-	WRITE_BOOL_FIELD(isParent);
-}
-
-static void
-_outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
-{
-	WRITE_NODE_TYPE("PARTITIONPRUNEINFO");
-
-	WRITE_NODE_FIELD(prune_infos);
-	WRITE_BITMAPSET_FIELD(other_subplans);
-}
-
-static void
-_outPartitionedRelPruneInfo(StringInfo str, const PartitionedRelPruneInfo *node)
-{
-	WRITE_NODE_TYPE("PARTITIONEDRELPRUNEINFO");
-
-	WRITE_UINT_FIELD(rtindex);
-	WRITE_BITMAPSET_FIELD(present_parts);
-	WRITE_INT_FIELD(nparts);
-	WRITE_INT_ARRAY(subplan_map, node->nparts);
-	WRITE_INT_ARRAY(subpart_map, node->nparts);
-	WRITE_OID_ARRAY(relid_map, node->nparts);
-	WRITE_NODE_FIELD(initial_pruning_steps);
-	WRITE_NODE_FIELD(exec_pruning_steps);
-	WRITE_BITMAPSET_FIELD(execparamids);
-}
-
-static void
-_outPartitionPruneStepOp(StringInfo str, const PartitionPruneStepOp *node)
-{
-	WRITE_NODE_TYPE("PARTITIONPRUNESTEPOP");
-
-	WRITE_INT_FIELD(step.step_id);
-	WRITE_INT_FIELD(opstrategy);
-	WRITE_NODE_FIELD(exprs);
-	WRITE_NODE_FIELD(cmpfns);
-	WRITE_BITMAPSET_FIELD(nullkeys);
-}
-
-static void
-_outPartitionPruneStepCombine(StringInfo str, const PartitionPruneStepCombine *node)
-{
-	WRITE_NODE_TYPE("PARTITIONPRUNESTEPCOMBINE");
-
-	WRITE_INT_FIELD(step.step_id);
-	WRITE_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
-	WRITE_NODE_FIELD(source_stepids);
-}
-
-static void
-_outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
-{
-	WRITE_NODE_TYPE("PLANINVALITEM");
-
-	WRITE_INT_FIELD(cacheId);
-	WRITE_UINT_FIELD(hashValue);
-}
-
-/*****************************************************************************
- *
- *	Stuff from primnodes.h.
- *
- *****************************************************************************/
-
-static void
-_outAlias(StringInfo str, const Alias *node)
-{
-	WRITE_NODE_TYPE("ALIAS");
-
-	WRITE_STRING_FIELD(aliasname);
-	WRITE_NODE_FIELD(colnames);
-}
-
-static void
-_outRangeVar(StringInfo str, const RangeVar *node)
-{
-	WRITE_NODE_TYPE("RANGEVAR");
-
-	/*
-	 * we deliberately ignore catalogname here, since it is presently not
-	 * semantically meaningful
-	 */
-	WRITE_STRING_FIELD(schemaname);
-	WRITE_STRING_FIELD(relname);
-	WRITE_BOOL_FIELD(inh);
-	WRITE_CHAR_FIELD(relpersistence);
-	WRITE_NODE_FIELD(alias);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outTableFunc(StringInfo str, const TableFunc *node)
-{
-	WRITE_NODE_TYPE("TABLEFUNC");
-
-	WRITE_ENUM_FIELD(functype, TableFuncType);
-	WRITE_NODE_FIELD(ns_uris);
-	WRITE_NODE_FIELD(ns_names);
-	WRITE_NODE_FIELD(docexpr);
-	WRITE_NODE_FIELD(rowexpr);
-	WRITE_NODE_FIELD(colnames);
-	WRITE_NODE_FIELD(coltypes);
-	WRITE_NODE_FIELD(coltypmods);
-	WRITE_NODE_FIELD(colcollations);
-	WRITE_NODE_FIELD(colexprs);
-	WRITE_NODE_FIELD(coldefexprs);
-	WRITE_NODE_FIELD(colvalexprs);
-	WRITE_BITMAPSET_FIELD(notnulls);
-	WRITE_NODE_FIELD(plan);
-	WRITE_INT_FIELD(ordinalitycol);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outIntoClause(StringInfo str, const IntoClause *node)
-{
-	WRITE_NODE_TYPE("INTOCLAUSE");
-
-	WRITE_NODE_FIELD(rel);
-	WRITE_NODE_FIELD(colNames);
-	WRITE_STRING_FIELD(accessMethod);
-	WRITE_NODE_FIELD(options);
-	WRITE_ENUM_FIELD(onCommit, OnCommitAction);
-	WRITE_STRING_FIELD(tableSpaceName);
-	WRITE_NODE_FIELD(viewQuery);
-	WRITE_BOOL_FIELD(skipData);
-}
-
-static void
-_outVar(StringInfo str, const Var *node)
-{
-	WRITE_NODE_TYPE("VAR");
-
-	WRITE_INT_FIELD(varno);
-	WRITE_INT_FIELD(varattno);
-	WRITE_OID_FIELD(vartype);
-	WRITE_INT_FIELD(vartypmod);
-	WRITE_OID_FIELD(varcollid);
-	WRITE_UINT_FIELD(varlevelsup);
-	WRITE_UINT_FIELD(varnosyn);
-	WRITE_INT_FIELD(varattnosyn);
-	WRITE_LOCATION_FIELD(location);
-}
-#endif							/* OBSOLETE */
 
 static void
 _outConst(StringInfo str, const Const *node)
@@ -1162,179 +333,6 @@ _outConst(StringInfo str, const Const *node)
 		outDatum(str, node->constvalue, node->constlen, node->constbyval);
 }
 
-#ifdef OBSOLETE
-static void
-_outParam(StringInfo str, const Param *node)
-{
-	WRITE_NODE_TYPE("PARAM");
-
-	WRITE_ENUM_FIELD(paramkind, ParamKind);
-	WRITE_INT_FIELD(paramid);
-	WRITE_OID_FIELD(paramtype);
-	WRITE_INT_FIELD(paramtypmod);
-	WRITE_OID_FIELD(paramcollid);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outAggref(StringInfo str, const Aggref *node)
-{
-	WRITE_NODE_TYPE("AGGREF");
-
-	WRITE_OID_FIELD(aggfnoid);
-	WRITE_OID_FIELD(aggtype);
-	WRITE_OID_FIELD(aggcollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_OID_FIELD(aggtranstype);
-	WRITE_NODE_FIELD(aggargtypes);
-	WRITE_NODE_FIELD(aggdirectargs);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(aggorder);
-	WRITE_NODE_FIELD(aggdistinct);
-	WRITE_NODE_FIELD(aggfilter);
-	WRITE_BOOL_FIELD(aggstar);
-	WRITE_BOOL_FIELD(aggvariadic);
-	WRITE_CHAR_FIELD(aggkind);
-	WRITE_UINT_FIELD(agglevelsup);
-	WRITE_ENUM_FIELD(aggsplit, AggSplit);
-	WRITE_INT_FIELD(aggno);
-	WRITE_INT_FIELD(aggtransno);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outGroupingFunc(StringInfo str, const GroupingFunc *node)
-{
-	WRITE_NODE_TYPE("GROUPINGFUNC");
-
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(refs);
-	WRITE_NODE_FIELD(cols);
-	WRITE_UINT_FIELD(agglevelsup);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outWindowFunc(StringInfo str, const WindowFunc *node)
-{
-	WRITE_NODE_TYPE("WINDOWFUNC");
-
-	WRITE_OID_FIELD(winfnoid);
-	WRITE_OID_FIELD(wintype);
-	WRITE_OID_FIELD(wincollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(aggfilter);
-	WRITE_UINT_FIELD(winref);
-	WRITE_BOOL_FIELD(winstar);
-	WRITE_BOOL_FIELD(winagg);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outSubscriptingRef(StringInfo str, const SubscriptingRef *node)
-{
-	WRITE_NODE_TYPE("SUBSCRIPTINGREF");
-
-	WRITE_OID_FIELD(refcontainertype);
-	WRITE_OID_FIELD(refelemtype);
-	WRITE_OID_FIELD(refrestype);
-	WRITE_INT_FIELD(reftypmod);
-	WRITE_OID_FIELD(refcollid);
-	WRITE_NODE_FIELD(refupperindexpr);
-	WRITE_NODE_FIELD(reflowerindexpr);
-	WRITE_NODE_FIELD(refexpr);
-	WRITE_NODE_FIELD(refassgnexpr);
-}
-
-static void
-_outFuncExpr(StringInfo str, const FuncExpr *node)
-{
-	WRITE_NODE_TYPE("FUNCEXPR");
-
-	WRITE_OID_FIELD(funcid);
-	WRITE_OID_FIELD(funcresulttype);
-	WRITE_BOOL_FIELD(funcretset);
-	WRITE_BOOL_FIELD(funcvariadic);
-	WRITE_ENUM_FIELD(funcformat, CoercionForm);
-	WRITE_OID_FIELD(funccollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
-{
-	WRITE_NODE_TYPE("NAMEDARGEXPR");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_STRING_FIELD(name);
-	WRITE_INT_FIELD(argnumber);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outOpExpr(StringInfo str, const OpExpr *node)
-{
-	WRITE_NODE_TYPE("OPEXPR");
-
-	WRITE_OID_FIELD(opno);
-	WRITE_OID_FIELD(opfuncid);
-	WRITE_OID_FIELD(opresulttype);
-	WRITE_BOOL_FIELD(opretset);
-	WRITE_OID_FIELD(opcollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outDistinctExpr(StringInfo str, const DistinctExpr *node)
-{
-	WRITE_NODE_TYPE("DISTINCTEXPR");
-
-	WRITE_OID_FIELD(opno);
-	WRITE_OID_FIELD(opfuncid);
-	WRITE_OID_FIELD(opresulttype);
-	WRITE_BOOL_FIELD(opretset);
-	WRITE_OID_FIELD(opcollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outNullIfExpr(StringInfo str, const NullIfExpr *node)
-{
-	WRITE_NODE_TYPE("NULLIFEXPR");
-
-	WRITE_OID_FIELD(opno);
-	WRITE_OID_FIELD(opfuncid);
-	WRITE_OID_FIELD(opresulttype);
-	WRITE_BOOL_FIELD(opretset);
-	WRITE_OID_FIELD(opcollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
-{
-	WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
-
-	WRITE_OID_FIELD(opno);
-	WRITE_OID_FIELD(opfuncid);
-	WRITE_OID_FIELD(hashfuncid);
-	WRITE_OID_FIELD(negfuncid);
-	WRITE_BOOL_FIELD(useOr);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outBoolExpr(StringInfo str, const BoolExpr *node)
 {
@@ -1362,1221 +360,6 @@ _outBoolExpr(StringInfo str, const BoolExpr *node)
 	WRITE_LOCATION_FIELD(location);
 }
 
-#ifdef OBSOLETE
-static void
-_outSubLink(StringInfo str, const SubLink *node)
-{
-	WRITE_NODE_TYPE("SUBLINK");
-
-	WRITE_ENUM_FIELD(subLinkType, SubLinkType);
-	WRITE_INT_FIELD(subLinkId);
-	WRITE_NODE_FIELD(testexpr);
-	WRITE_NODE_FIELD(operName);
-	WRITE_NODE_FIELD(subselect);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outSubPlan(StringInfo str, const SubPlan *node)
-{
-	WRITE_NODE_TYPE("SUBPLAN");
-
-	WRITE_ENUM_FIELD(subLinkType, SubLinkType);
-	WRITE_NODE_FIELD(testexpr);
-	WRITE_NODE_FIELD(paramIds);
-	WRITE_INT_FIELD(plan_id);
-	WRITE_STRING_FIELD(plan_name);
-	WRITE_OID_FIELD(firstColType);
-	WRITE_INT_FIELD(firstColTypmod);
-	WRITE_OID_FIELD(firstColCollation);
-	WRITE_BOOL_FIELD(useHashTable);
-	WRITE_BOOL_FIELD(unknownEqFalse);
-	WRITE_BOOL_FIELD(parallel_safe);
-	WRITE_NODE_FIELD(setParam);
-	WRITE_NODE_FIELD(parParam);
-	WRITE_NODE_FIELD(args);
-	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
-	WRITE_FLOAT_FIELD(per_call_cost, "%.2f");
-}
-
-static void
-_outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
-{
-	WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
-
-	WRITE_NODE_FIELD(subplans);
-}
-
-static void
-_outFieldSelect(StringInfo str, const FieldSelect *node)
-{
-	WRITE_NODE_TYPE("FIELDSELECT");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_INT_FIELD(fieldnum);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_INT_FIELD(resulttypmod);
-	WRITE_OID_FIELD(resultcollid);
-}
-
-static void
-_outFieldStore(StringInfo str, const FieldStore *node)
-{
-	WRITE_NODE_TYPE("FIELDSTORE");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(newvals);
-	WRITE_NODE_FIELD(fieldnums);
-	WRITE_OID_FIELD(resulttype);
-}
-
-static void
-_outRelabelType(StringInfo str, const RelabelType *node)
-{
-	WRITE_NODE_TYPE("RELABELTYPE");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_INT_FIELD(resulttypmod);
-	WRITE_OID_FIELD(resultcollid);
-	WRITE_ENUM_FIELD(relabelformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
-{
-	WRITE_NODE_TYPE("COERCEVIAIO");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_OID_FIELD(resultcollid);
-	WRITE_ENUM_FIELD(coerceformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
-{
-	WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(elemexpr);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_INT_FIELD(resulttypmod);
-	WRITE_OID_FIELD(resultcollid);
-	WRITE_ENUM_FIELD(coerceformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
-{
-	WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_ENUM_FIELD(convertformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCollateExpr(StringInfo str, const CollateExpr *node)
-{
-	WRITE_NODE_TYPE("COLLATEEXPR");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_OID_FIELD(collOid);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCaseExpr(StringInfo str, const CaseExpr *node)
-{
-	WRITE_NODE_TYPE("CASEEXPR");
-
-	WRITE_OID_FIELD(casetype);
-	WRITE_OID_FIELD(casecollid);
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(defresult);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCaseWhen(StringInfo str, const CaseWhen *node)
-{
-	WRITE_NODE_TYPE("CASEWHEN");
-
-	WRITE_NODE_FIELD(expr);
-	WRITE_NODE_FIELD(result);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
-{
-	WRITE_NODE_TYPE("CASETESTEXPR");
-
-	WRITE_OID_FIELD(typeId);
-	WRITE_INT_FIELD(typeMod);
-	WRITE_OID_FIELD(collation);
-}
-
-static void
-_outArrayExpr(StringInfo str, const ArrayExpr *node)
-{
-	WRITE_NODE_TYPE("ARRAYEXPR");
-
-	WRITE_OID_FIELD(array_typeid);
-	WRITE_OID_FIELD(array_collid);
-	WRITE_OID_FIELD(element_typeid);
-	WRITE_NODE_FIELD(elements);
-	WRITE_BOOL_FIELD(multidims);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outRowExpr(StringInfo str, const RowExpr *node)
-{
-	WRITE_NODE_TYPE("ROWEXPR");
-
-	WRITE_NODE_FIELD(args);
-	WRITE_OID_FIELD(row_typeid);
-	WRITE_ENUM_FIELD(row_format, CoercionForm);
-	WRITE_NODE_FIELD(colnames);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
-{
-	WRITE_NODE_TYPE("ROWCOMPAREEXPR");
-
-	WRITE_ENUM_FIELD(rctype, RowCompareType);
-	WRITE_NODE_FIELD(opnos);
-	WRITE_NODE_FIELD(opfamilies);
-	WRITE_NODE_FIELD(inputcollids);
-	WRITE_NODE_FIELD(largs);
-	WRITE_NODE_FIELD(rargs);
-}
-
-static void
-_outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
-{
-	WRITE_NODE_TYPE("COALESCEEXPR");
-
-	WRITE_OID_FIELD(coalescetype);
-	WRITE_OID_FIELD(coalescecollid);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
-{
-	WRITE_NODE_TYPE("MINMAXEXPR");
-
-	WRITE_OID_FIELD(minmaxtype);
-	WRITE_OID_FIELD(minmaxcollid);
-	WRITE_OID_FIELD(inputcollid);
-	WRITE_ENUM_FIELD(op, MinMaxOp);
-	WRITE_NODE_FIELD(args);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outSQLValueFunction(StringInfo str, const SQLValueFunction *node)
-{
-	WRITE_NODE_TYPE("SQLVALUEFUNCTION");
-
-	WRITE_ENUM_FIELD(op, SQLValueFunctionOp);
-	WRITE_OID_FIELD(type);
-	WRITE_INT_FIELD(typmod);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outXmlExpr(StringInfo str, const XmlExpr *node)
-{
-	WRITE_NODE_TYPE("XMLEXPR");
-
-	WRITE_ENUM_FIELD(op, XmlExprOp);
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(named_args);
-	WRITE_NODE_FIELD(arg_names);
-	WRITE_NODE_FIELD(args);
-	WRITE_ENUM_FIELD(xmloption, XmlOptionType);
-	WRITE_OID_FIELD(type);
-	WRITE_INT_FIELD(typmod);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outNullTest(StringInfo str, const NullTest *node)
-{
-	WRITE_NODE_TYPE("NULLTEST");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_ENUM_FIELD(nulltesttype, NullTestType);
-	WRITE_BOOL_FIELD(argisrow);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outBooleanTest(StringInfo str, const BooleanTest *node)
-{
-	WRITE_NODE_TYPE("BOOLEANTEST");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_ENUM_FIELD(booltesttype, BoolTestType);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
-{
-	WRITE_NODE_TYPE("COERCETODOMAIN");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_OID_FIELD(resulttype);
-	WRITE_INT_FIELD(resulttypmod);
-	WRITE_OID_FIELD(resultcollid);
-	WRITE_ENUM_FIELD(coercionformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
-{
-	WRITE_NODE_TYPE("COERCETODOMAINVALUE");
-
-	WRITE_OID_FIELD(typeId);
-	WRITE_INT_FIELD(typeMod);
-	WRITE_OID_FIELD(collation);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outSetToDefault(StringInfo str, const SetToDefault *node)
-{
-	WRITE_NODE_TYPE("SETTODEFAULT");
-
-	WRITE_OID_FIELD(typeId);
-	WRITE_INT_FIELD(typeMod);
-	WRITE_OID_FIELD(collation);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
-{
-	WRITE_NODE_TYPE("CURRENTOFEXPR");
-
-	WRITE_UINT_FIELD(cvarno);
-	WRITE_STRING_FIELD(cursor_name);
-	WRITE_INT_FIELD(cursor_param);
-}
-
-static void
-_outNextValueExpr(StringInfo str, const NextValueExpr *node)
-{
-	WRITE_NODE_TYPE("NEXTVALUEEXPR");
-
-	WRITE_OID_FIELD(seqid);
-	WRITE_OID_FIELD(typeId);
-}
-
-static void
-_outInferenceElem(StringInfo str, const InferenceElem *node)
-{
-	WRITE_NODE_TYPE("INFERENCEELEM");
-
-	WRITE_NODE_FIELD(expr);
-	WRITE_OID_FIELD(infercollid);
-	WRITE_OID_FIELD(inferopclass);
-}
-
-static void
-_outTargetEntry(StringInfo str, const TargetEntry *node)
-{
-	WRITE_NODE_TYPE("TARGETENTRY");
-
-	WRITE_NODE_FIELD(expr);
-	WRITE_INT_FIELD(resno);
-	WRITE_STRING_FIELD(resname);
-	WRITE_UINT_FIELD(ressortgroupref);
-	WRITE_OID_FIELD(resorigtbl);
-	WRITE_INT_FIELD(resorigcol);
-	WRITE_BOOL_FIELD(resjunk);
-}
-
-static void
-_outRangeTblRef(StringInfo str, const RangeTblRef *node)
-{
-	WRITE_NODE_TYPE("RANGETBLREF");
-
-	WRITE_INT_FIELD(rtindex);
-}
-
-static void
-_outJoinExpr(StringInfo str, const JoinExpr *node)
-{
-	WRITE_NODE_TYPE("JOINEXPR");
-
-	WRITE_ENUM_FIELD(jointype, JoinType);
-	WRITE_BOOL_FIELD(isNatural);
-	WRITE_NODE_FIELD(larg);
-	WRITE_NODE_FIELD(rarg);
-	WRITE_NODE_FIELD(usingClause);
-	WRITE_NODE_FIELD(join_using_alias);
-	WRITE_NODE_FIELD(quals);
-	WRITE_NODE_FIELD(alias);
-	WRITE_INT_FIELD(rtindex);
-}
-
-static void
-_outFromExpr(StringInfo str, const FromExpr *node)
-{
-	WRITE_NODE_TYPE("FROMEXPR");
-
-	WRITE_NODE_FIELD(fromlist);
-	WRITE_NODE_FIELD(quals);
-}
-
-static void
-_outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
-{
-	WRITE_NODE_TYPE("ONCONFLICTEXPR");
-
-	WRITE_ENUM_FIELD(action, OnConflictAction);
-	WRITE_NODE_FIELD(arbiterElems);
-	WRITE_NODE_FIELD(arbiterWhere);
-	WRITE_OID_FIELD(constraint);
-	WRITE_NODE_FIELD(onConflictSet);
-	WRITE_NODE_FIELD(onConflictWhere);
-	WRITE_INT_FIELD(exclRelIndex);
-	WRITE_NODE_FIELD(exclRelTlist);
-}
-
-static void
-_outJsonFormat(StringInfo str, const JsonFormat *node)
-{
-	WRITE_NODE_TYPE("JSONFORMAT");
-
-	WRITE_ENUM_FIELD(format_type, JsonFormatType);
-	WRITE_ENUM_FIELD(encoding, JsonEncoding);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outJsonReturning(StringInfo str, const JsonReturning *node)
-{
-	WRITE_NODE_TYPE("JSONRETURNING");
-
-	WRITE_NODE_FIELD(format);
-	WRITE_OID_FIELD(typid);
-	WRITE_INT_FIELD(typmod);
-}
-
-static void
-_outJsonValueExpr(StringInfo str, const JsonValueExpr *node)
-{
-	WRITE_NODE_TYPE("JSONVALUEEXPR");
-
-	WRITE_NODE_FIELD(raw_expr);
-	WRITE_NODE_FIELD(formatted_expr);
-	WRITE_NODE_FIELD(format);
-}
-
-static void
-_outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node)
-{
-	WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR");
-
-	WRITE_ENUM_FIELD(type, JsonConstructorType);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(func);
-	WRITE_NODE_FIELD(coercion);
-	WRITE_NODE_FIELD(returning);
-	WRITE_BOOL_FIELD(absent_on_null);
-	WRITE_BOOL_FIELD(unique);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node)
-{
-	WRITE_NODE_TYPE("JSONISPREDICATE");
-
-	WRITE_NODE_FIELD(expr);
-	WRITE_NODE_FIELD(format);
-	WRITE_ENUM_FIELD(item_type, JsonValueType);
-	WRITE_BOOL_FIELD(unique_keys);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outJsonBehavior(StringInfo str, const JsonBehavior *node)
-{
-	WRITE_NODE_TYPE("JSONBEHAVIOR");
-
-	WRITE_ENUM_FIELD(btype, JsonBehaviorType);
-	WRITE_NODE_FIELD(default_expr);
-}
-
-static void
-_outJsonExpr(StringInfo str, const JsonExpr *node)
-{
-	WRITE_NODE_TYPE("JSONEXPR");
-
-	WRITE_ENUM_FIELD(op, JsonExprOp);
-	WRITE_NODE_FIELD(formatted_expr);
-	WRITE_NODE_FIELD(result_coercion);
-	WRITE_NODE_FIELD(format);
-	WRITE_NODE_FIELD(path_spec);
-	WRITE_NODE_FIELD(passing_names);
-	WRITE_NODE_FIELD(passing_values);
-	WRITE_NODE_FIELD(returning);
-	WRITE_NODE_FIELD(on_empty);
-	WRITE_NODE_FIELD(on_error);
-	WRITE_NODE_FIELD(coercions);
-	WRITE_ENUM_FIELD(wrapper, JsonWrapper);
-	WRITE_BOOL_FIELD(omit_quotes);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outJsonCoercion(StringInfo str, const JsonCoercion *node)
-{
-	WRITE_NODE_TYPE("JSONCOERCION");
-
-	WRITE_NODE_FIELD(expr);
-	WRITE_BOOL_FIELD(via_populate);
-	WRITE_BOOL_FIELD(via_io);
-	WRITE_OID_FIELD(collation);
-}
-
-static void
-_outJsonItemCoercions(StringInfo str, const JsonItemCoercions *node)
-{
-	WRITE_NODE_TYPE("JSONITEMCOERCIONS");
-
-	WRITE_NODE_FIELD(null);
-	WRITE_NODE_FIELD(string);
-	WRITE_NODE_FIELD(numeric);
-	WRITE_NODE_FIELD(boolean);
-	WRITE_NODE_FIELD(date);
-	WRITE_NODE_FIELD(time);
-	WRITE_NODE_FIELD(timetz);
-	WRITE_NODE_FIELD(timestamp);
-	WRITE_NODE_FIELD(timestamptz);
-	WRITE_NODE_FIELD(composite);
-}
-
-static void
-_outJsonTableParent(StringInfo str, const JsonTableParent *node)
-{
-	WRITE_NODE_TYPE("JSONTABLEPARENT");
-
-	WRITE_NODE_FIELD(path);
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(child);
-	WRITE_BOOL_FIELD(outerJoin);
-	WRITE_INT_FIELD(colMin);
-	WRITE_INT_FIELD(colMax);
-	WRITE_BOOL_FIELD(errorOnError);
-}
-
-static void
-_outJsonTableSibling(StringInfo str, const JsonTableSibling *node)
-{
-	WRITE_NODE_TYPE("JSONTABLESIBLING");
-
-	WRITE_NODE_FIELD(larg);
-	WRITE_NODE_FIELD(rarg);
-	WRITE_BOOL_FIELD(cross);
-}
-
-/*****************************************************************************
- *
- *	Stuff from pathnodes.h.
- *
- *****************************************************************************/
-
-/*
- * print the basic stuff of all nodes that inherit from Path
- *
- * Note we do NOT print the parent, else we'd be in infinite recursion.
- * We can print the parent's relids for identification purposes, though.
- * We print the pathtarget only if it's not the default one for the rel.
- * We also do not print the whole of param_info, since it's printed by
- * _outRelOptInfo; it's sufficient and less cluttering to print just the
- * required outer relids.
- */
-static void
-_outPathInfo(StringInfo str, const Path *node)
-{
-	WRITE_ENUM_FIELD(pathtype, NodeTag);
-	appendStringInfoString(str, " :parent_relids ");
-	outBitmapset(str, node->parent->relids);
-	if (node->pathtarget != node->parent->reltarget)
-		WRITE_NODE_FIELD(pathtarget);
-	appendStringInfoString(str, " :required_outer ");
-	if (node->param_info)
-		outBitmapset(str, node->param_info->ppi_req_outer);
-	else
-		outBitmapset(str, NULL);
-	WRITE_BOOL_FIELD(parallel_aware);
-	WRITE_BOOL_FIELD(parallel_safe);
-	WRITE_INT_FIELD(parallel_workers);
-	WRITE_FLOAT_FIELD(rows, "%.0f");
-	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
-	WRITE_FLOAT_FIELD(total_cost, "%.2f");
-	WRITE_NODE_FIELD(pathkeys);
-}
-
-/*
- * print the basic stuff of all nodes that inherit from JoinPath
- */
-static void
-_outJoinPathInfo(StringInfo str, const JoinPath *node)
-{
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_ENUM_FIELD(jointype, JoinType);
-	WRITE_BOOL_FIELD(inner_unique);
-	WRITE_NODE_FIELD(outerjoinpath);
-	WRITE_NODE_FIELD(innerjoinpath);
-	WRITE_NODE_FIELD(joinrestrictinfo);
-}
-
-static void
-_outPath(StringInfo str, const Path *node)
-{
-	WRITE_NODE_TYPE("PATH");
-
-	_outPathInfo(str, (const Path *) node);
-}
-
-static void
-_outIndexPath(StringInfo str, const IndexPath *node)
-{
-	WRITE_NODE_TYPE("INDEXPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(indexinfo);
-	WRITE_NODE_FIELD(indexclauses);
-	WRITE_NODE_FIELD(indexorderbys);
-	WRITE_NODE_FIELD(indexorderbycols);
-	WRITE_ENUM_FIELD(indexscandir, ScanDirection);
-	WRITE_FLOAT_FIELD(indextotalcost, "%.2f");
-	WRITE_FLOAT_FIELD(indexselectivity, "%.4f");
-}
-
-static void
-_outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
-{
-	WRITE_NODE_TYPE("BITMAPHEAPPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(bitmapqual);
-}
-
-static void
-_outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
-{
-	WRITE_NODE_TYPE("BITMAPANDPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(bitmapquals);
-	WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
-}
-
-static void
-_outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
-{
-	WRITE_NODE_TYPE("BITMAPORPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(bitmapquals);
-	WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
-}
-
-static void
-_outTidPath(StringInfo str, const TidPath *node)
-{
-	WRITE_NODE_TYPE("TIDPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(tidquals);
-}
-
-static void
-_outTidRangePath(StringInfo str, const TidRangePath *node)
-{
-	WRITE_NODE_TYPE("TIDRANGEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(tidrangequals);
-}
-
-static void
-_outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node)
-{
-	WRITE_NODE_TYPE("SUBQUERYSCANPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-}
-
-static void
-_outForeignPath(StringInfo str, const ForeignPath *node)
-{
-	WRITE_NODE_TYPE("FOREIGNPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(fdw_outerpath);
-	WRITE_NODE_FIELD(fdw_private);
-}
-
-static void
-_outCustomPath(StringInfo str, const CustomPath *node)
-{
-	WRITE_NODE_TYPE("CUSTOMPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_UINT_FIELD(flags);
-	WRITE_NODE_FIELD(custom_paths);
-	WRITE_NODE_FIELD(custom_private);
-	appendStringInfoString(str, " :methods ");
-	outToken(str, node->methods->CustomName);
-}
-
-static void
-_outAppendPath(StringInfo str, const AppendPath *node)
-{
-	WRITE_NODE_TYPE("APPENDPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpaths);
-	WRITE_INT_FIELD(first_partial_path);
-	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
-}
-
-static void
-_outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
-{
-	WRITE_NODE_TYPE("MERGEAPPENDPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpaths);
-	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
-}
-
-static void
-_outGroupResultPath(StringInfo str, const GroupResultPath *node)
-{
-	WRITE_NODE_TYPE("GROUPRESULTPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(quals);
-}
-
-static void
-_outMaterialPath(StringInfo str, const MaterialPath *node)
-{
-	WRITE_NODE_TYPE("MATERIALPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-}
-
-static void
-_outMemoizePath(StringInfo str, const MemoizePath *node)
-{
-	WRITE_NODE_TYPE("MEMOIZEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_NODE_FIELD(hash_operators);
-	WRITE_NODE_FIELD(param_exprs);
-	WRITE_BOOL_FIELD(singlerow);
-	WRITE_BOOL_FIELD(binary_mode);
-	WRITE_FLOAT_FIELD(calls, "%.0f");
-	WRITE_UINT_FIELD(est_entries);
-}
-
-static void
-_outUniquePath(StringInfo str, const UniquePath *node)
-{
-	WRITE_NODE_TYPE("UNIQUEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_ENUM_FIELD(umethod, UniquePathMethod);
-	WRITE_NODE_FIELD(in_operators);
-	WRITE_NODE_FIELD(uniq_exprs);
-}
-
-static void
-_outGatherPath(StringInfo str, const GatherPath *node)
-{
-	WRITE_NODE_TYPE("GATHERPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_BOOL_FIELD(single_copy);
-	WRITE_INT_FIELD(num_workers);
-}
-
-static void
-_outProjectionPath(StringInfo str, const ProjectionPath *node)
-{
-	WRITE_NODE_TYPE("PROJECTIONPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_BOOL_FIELD(dummypp);
-}
-
-static void
-_outProjectSetPath(StringInfo str, const ProjectSetPath *node)
-{
-	WRITE_NODE_TYPE("PROJECTSETPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-}
-
-static void
-_outSortPathInfo(StringInfo str, const SortPath *node)
-{
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-}
-
-static void
-_outSortPath(StringInfo str, const SortPath *node)
-{
-	WRITE_NODE_TYPE("SORTPATH");
-
-	_outSortPathInfo(str, node);
-}
-
-static void
-_outIncrementalSortPath(StringInfo str, const IncrementalSortPath *node)
-{
-	WRITE_NODE_TYPE("INCREMENTALSORTPATH");
-
-	_outSortPathInfo(str, (const SortPath *) node);
-
-	WRITE_INT_FIELD(nPresortedCols);
-}
-
-static void
-_outGroupPath(StringInfo str, const GroupPath *node)
-{
-	WRITE_NODE_TYPE("GROUPPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_NODE_FIELD(groupClause);
-	WRITE_NODE_FIELD(qual);
-}
-
-static void
-_outUpperUniquePath(StringInfo str, const UpperUniquePath *node)
-{
-	WRITE_NODE_TYPE("UPPERUNIQUEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_INT_FIELD(numkeys);
-}
-
-static void
-_outAggPath(StringInfo str, const AggPath *node)
-{
-	WRITE_NODE_TYPE("AGGPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
-	WRITE_ENUM_FIELD(aggsplit, AggSplit);
-	WRITE_FLOAT_FIELD(numGroups, "%.0f");
-	WRITE_UINT64_FIELD(transitionSpace);
-	WRITE_NODE_FIELD(groupClause);
-	WRITE_NODE_FIELD(qual);
-}
-
-static void
-_outRollupData(StringInfo str, const RollupData *node)
-{
-	WRITE_NODE_TYPE("ROLLUP");
-
-	WRITE_NODE_FIELD(groupClause);
-	WRITE_NODE_FIELD(gsets);
-	WRITE_NODE_FIELD(gsets_data);
-	WRITE_FLOAT_FIELD(numGroups, "%.0f");
-	WRITE_BOOL_FIELD(hashable);
-	WRITE_BOOL_FIELD(is_hashed);
-}
-
-static void
-_outGroupingSetData(StringInfo str, const GroupingSetData *node)
-{
-	WRITE_NODE_TYPE("GSDATA");
-
-	WRITE_NODE_FIELD(set);
-	WRITE_FLOAT_FIELD(numGroups, "%.0f");
-}
-
-static void
-_outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node)
-{
-	WRITE_NODE_TYPE("GROUPINGSETSPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
-	WRITE_NODE_FIELD(rollups);
-	WRITE_NODE_FIELD(qual);
-	WRITE_UINT64_FIELD(transitionSpace);
-}
-
-static void
-_outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node)
-{
-	WRITE_NODE_TYPE("MINMAXAGGPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(mmaggregates);
-	WRITE_NODE_FIELD(quals);
-}
-
-static void
-_outWindowAggPath(StringInfo str, const WindowAggPath *node)
-{
-	WRITE_NODE_TYPE("WINDOWAGGPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_NODE_FIELD(winclause);
-	WRITE_NODE_FIELD(qual);
-	WRITE_BOOL_FIELD(topwindow);
-}
-
-static void
-_outSetOpPath(StringInfo str, const SetOpPath *node)
-{
-	WRITE_NODE_TYPE("SETOPPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_ENUM_FIELD(cmd, SetOpCmd);
-	WRITE_ENUM_FIELD(strategy, SetOpStrategy);
-	WRITE_NODE_FIELD(distinctList);
-	WRITE_INT_FIELD(flagColIdx);
-	WRITE_INT_FIELD(firstFlag);
-	WRITE_FLOAT_FIELD(numGroups, "%.0f");
-}
-
-static void
-_outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node)
-{
-	WRITE_NODE_TYPE("RECURSIVEUNIONPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(leftpath);
-	WRITE_NODE_FIELD(rightpath);
-	WRITE_NODE_FIELD(distinctList);
-	WRITE_INT_FIELD(wtParam);
-	WRITE_FLOAT_FIELD(numGroups, "%.0f");
-}
-
-static void
-_outLockRowsPath(StringInfo str, const LockRowsPath *node)
-{
-	WRITE_NODE_TYPE("LOCKROWSPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_INT_FIELD(epqParam);
-}
-
-static void
-_outModifyTablePath(StringInfo str, const ModifyTablePath *node)
-{
-	WRITE_NODE_TYPE("MODIFYTABLEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_ENUM_FIELD(operation, CmdType);
-	WRITE_BOOL_FIELD(canSetTag);
-	WRITE_UINT_FIELD(nominalRelation);
-	WRITE_UINT_FIELD(rootRelation);
-	WRITE_BOOL_FIELD(partColsUpdated);
-	WRITE_NODE_FIELD(resultRelations);
-	WRITE_NODE_FIELD(updateColnosLists);
-	WRITE_NODE_FIELD(withCheckOptionLists);
-	WRITE_NODE_FIELD(returningLists);
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_NODE_FIELD(onconflict);
-	WRITE_INT_FIELD(epqParam);
-	WRITE_NODE_FIELD(mergeActionLists);
-}
-
-static void
-_outLimitPath(StringInfo str, const LimitPath *node)
-{
-	WRITE_NODE_TYPE("LIMITPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_NODE_FIELD(limitOffset);
-	WRITE_NODE_FIELD(limitCount);
-	WRITE_ENUM_FIELD(limitOption, LimitOption);
-}
-
-static void
-_outGatherMergePath(StringInfo str, const GatherMergePath *node)
-{
-	WRITE_NODE_TYPE("GATHERMERGEPATH");
-
-	_outPathInfo(str, (const Path *) node);
-
-	WRITE_NODE_FIELD(subpath);
-	WRITE_INT_FIELD(num_workers);
-}
-
-static void
-_outNestPath(StringInfo str, const NestPath *node)
-{
-	WRITE_NODE_TYPE("NESTPATH");
-
-	_outJoinPathInfo(str, (const JoinPath *) node);
-}
-
-static void
-_outMergePath(StringInfo str, const MergePath *node)
-{
-	WRITE_NODE_TYPE("MERGEPATH");
-
-	_outJoinPathInfo(str, (const JoinPath *) node);
-
-	WRITE_NODE_FIELD(path_mergeclauses);
-	WRITE_NODE_FIELD(outersortkeys);
-	WRITE_NODE_FIELD(innersortkeys);
-	WRITE_BOOL_FIELD(skip_mark_restore);
-	WRITE_BOOL_FIELD(materialize_inner);
-}
-
-static void
-_outHashPath(StringInfo str, const HashPath *node)
-{
-	WRITE_NODE_TYPE("HASHPATH");
-
-	_outJoinPathInfo(str, (const JoinPath *) node);
-
-	WRITE_NODE_FIELD(path_hashclauses);
-	WRITE_INT_FIELD(num_batches);
-	WRITE_FLOAT_FIELD(inner_rows_total, "%.0f");
-}
-
-static void
-_outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
-{
-	WRITE_NODE_TYPE("PLANNERGLOBAL");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_NODE_FIELD(subplans);
-	WRITE_BITMAPSET_FIELD(rewindPlanIDs);
-	WRITE_NODE_FIELD(finalrtable);
-	WRITE_NODE_FIELD(finalrowmarks);
-	WRITE_NODE_FIELD(resultRelations);
-	WRITE_NODE_FIELD(appendRelations);
-	WRITE_NODE_FIELD(relationOids);
-	WRITE_NODE_FIELD(invalItems);
-	WRITE_NODE_FIELD(paramExecTypes);
-	WRITE_UINT_FIELD(lastPHId);
-	WRITE_UINT_FIELD(lastRowMarkId);
-	WRITE_INT_FIELD(lastPlanNodeId);
-	WRITE_BOOL_FIELD(transientPlan);
-	WRITE_BOOL_FIELD(dependsOnRole);
-	WRITE_BOOL_FIELD(parallelModeOK);
-	WRITE_BOOL_FIELD(parallelModeNeeded);
-	WRITE_CHAR_FIELD(maxParallelHazard);
-}
-
-static void
-_outPlannerInfo(StringInfo str, const PlannerInfo *node)
-{
-	WRITE_NODE_TYPE("PLANNERINFO");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_NODE_FIELD(parse);
-	WRITE_NODE_FIELD(glob);
-	WRITE_UINT_FIELD(query_level);
-	WRITE_NODE_FIELD(plan_params);
-	WRITE_BITMAPSET_FIELD(outer_params);
-	WRITE_BITMAPSET_FIELD(all_baserels);
-	WRITE_BITMAPSET_FIELD(nullable_baserels);
-	WRITE_NODE_FIELD(join_rel_list);
-	WRITE_INT_FIELD(join_cur_level);
-	WRITE_NODE_FIELD(init_plans);
-	WRITE_NODE_FIELD(cte_plan_ids);
-	WRITE_NODE_FIELD(multiexpr_params);
-	WRITE_NODE_FIELD(eq_classes);
-	WRITE_BOOL_FIELD(ec_merging_done);
-	WRITE_NODE_FIELD(canon_pathkeys);
-	WRITE_NODE_FIELD(left_join_clauses);
-	WRITE_NODE_FIELD(right_join_clauses);
-	WRITE_NODE_FIELD(full_join_clauses);
-	WRITE_NODE_FIELD(join_info_list);
-	WRITE_BITMAPSET_FIELD(all_result_relids);
-	WRITE_BITMAPSET_FIELD(leaf_result_relids);
-	WRITE_NODE_FIELD(append_rel_list);
-	WRITE_NODE_FIELD(row_identity_vars);
-	WRITE_NODE_FIELD(rowMarks);
-	WRITE_NODE_FIELD(placeholder_list);
-	WRITE_NODE_FIELD(fkey_list);
-	WRITE_NODE_FIELD(query_pathkeys);
-	WRITE_NODE_FIELD(group_pathkeys);
-	WRITE_NODE_FIELD(window_pathkeys);
-	WRITE_NODE_FIELD(distinct_pathkeys);
-	WRITE_NODE_FIELD(sort_pathkeys);
-	WRITE_NODE_FIELD(processed_tlist);
-	WRITE_NODE_FIELD(update_colnos);
-	WRITE_NODE_FIELD(minmax_aggs);
-	WRITE_FLOAT_FIELD(total_table_pages, "%.0f");
-	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
-	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
-	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_BOOL_FIELD(hasJoinRTEs);
-	WRITE_BOOL_FIELD(hasLateralRTEs);
-	WRITE_BOOL_FIELD(hasHavingQual);
-	WRITE_BOOL_FIELD(hasPseudoConstantQuals);
-	WRITE_BOOL_FIELD(hasAlternativeSubPlans);
-	WRITE_BOOL_FIELD(hasRecursion);
-	WRITE_INT_FIELD(wt_param_id);
-	WRITE_BITMAPSET_FIELD(curOuterRels);
-	WRITE_NODE_FIELD(curOuterParams);
-	WRITE_BOOL_FIELD(partColsUpdated);
-}
-
-static void
-_outRelOptInfo(StringInfo str, const RelOptInfo *node)
-{
-	WRITE_NODE_TYPE("RELOPTINFO");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_ENUM_FIELD(reloptkind, RelOptKind);
-	WRITE_BITMAPSET_FIELD(relids);
-	WRITE_FLOAT_FIELD(rows, "%.0f");
-	WRITE_BOOL_FIELD(consider_startup);
-	WRITE_BOOL_FIELD(consider_param_startup);
-	WRITE_BOOL_FIELD(consider_parallel);
-	WRITE_NODE_FIELD(reltarget);
-	WRITE_NODE_FIELD(pathlist);
-	WRITE_NODE_FIELD(ppilist);
-	WRITE_NODE_FIELD(partial_pathlist);
-	WRITE_NODE_FIELD(cheapest_startup_path);
-	WRITE_NODE_FIELD(cheapest_total_path);
-	WRITE_NODE_FIELD(cheapest_unique_path);
-	WRITE_NODE_FIELD(cheapest_parameterized_paths);
-	WRITE_BITMAPSET_FIELD(direct_lateral_relids);
-	WRITE_BITMAPSET_FIELD(lateral_relids);
-	WRITE_UINT_FIELD(relid);
-	WRITE_OID_FIELD(reltablespace);
-	WRITE_ENUM_FIELD(rtekind, RTEKind);
-	WRITE_INT_FIELD(min_attr);
-	WRITE_INT_FIELD(max_attr);
-	WRITE_NODE_FIELD(lateral_vars);
-	WRITE_BITMAPSET_FIELD(lateral_referencers);
-	WRITE_NODE_FIELD(indexlist);
-	WRITE_NODE_FIELD(statlist);
-	WRITE_UINT_FIELD(pages);
-	WRITE_FLOAT_FIELD(tuples, "%.0f");
-	WRITE_FLOAT_FIELD(allvisfrac, "%.6f");
-	WRITE_BITMAPSET_FIELD(eclass_indexes);
-	WRITE_NODE_FIELD(subroot);
-	WRITE_NODE_FIELD(subplan_params);
-	WRITE_INT_FIELD(rel_parallel_workers);
-	WRITE_UINT_FIELD(amflags);
-	WRITE_OID_FIELD(serverid);
-	WRITE_OID_FIELD(userid);
-	WRITE_BOOL_FIELD(useridiscurrent);
-	/* we don't try to print fdwroutine or fdw_private */
-	/* can't print unique_for_rels/non_unique_for_rels; BMSes aren't Nodes */
-	WRITE_NODE_FIELD(baserestrictinfo);
-	WRITE_UINT_FIELD(baserestrict_min_security);
-	WRITE_NODE_FIELD(joininfo);
-	WRITE_BOOL_FIELD(has_eclass_joins);
-	WRITE_BOOL_FIELD(consider_partitionwise_join);
-	WRITE_BITMAPSET_FIELD(top_parent_relids);
-	WRITE_BOOL_FIELD(partbounds_merged);
-	WRITE_BITMAPSET_FIELD(live_parts);
-	WRITE_BITMAPSET_FIELD(all_partrels);
-}
-
-static void
-_outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
-{
-	WRITE_NODE_TYPE("INDEXOPTINFO");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_OID_FIELD(indexoid);
-	/* Do NOT print rel field, else infinite recursion */
-	WRITE_UINT_FIELD(pages);
-	WRITE_FLOAT_FIELD(tuples, "%.0f");
-	WRITE_INT_FIELD(tree_height);
-	WRITE_INT_FIELD(ncolumns);
-	/* array fields aren't really worth the trouble to print */
-	WRITE_OID_FIELD(relam);
-	/* indexprs is redundant since we print indextlist */
-	WRITE_NODE_FIELD(indpred);
-	WRITE_NODE_FIELD(indextlist);
-	WRITE_NODE_FIELD(indrestrictinfo);
-	WRITE_BOOL_FIELD(predOK);
-	WRITE_BOOL_FIELD(unique);
-	WRITE_BOOL_FIELD(immediate);
-	WRITE_BOOL_FIELD(hypothetical);
-	/* we don't bother with fields copied from the index AM's API struct */
-}
-#endif							/* OBSOLETE */
-
 static void
 _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
 {
@@ -2603,20 +386,6 @@ _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
 		appendStringInfo(str, " %d", list_length(node->rinfos[i]));
 }
 
-#ifdef OBSOLETE
-static void
-_outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node)
-{
-	WRITE_NODE_TYPE("STATISTICEXTINFO");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_OID_FIELD(statOid);
-	/* don't write rel, leads to infinite recursion in plan tree dump */
-	WRITE_CHAR_FIELD(kind);
-	WRITE_BITMAPSET_FIELD(keys);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
 {
@@ -2644,199 +413,6 @@ _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
 	WRITE_UINT_FIELD(ec_max_security);
 }
 
-#ifdef OBSOLETE
-static void
-_outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
-{
-	WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
-
-	WRITE_NODE_FIELD(em_expr);
-	WRITE_BITMAPSET_FIELD(em_relids);
-	WRITE_BITMAPSET_FIELD(em_nullable_relids);
-	WRITE_BOOL_FIELD(em_is_const);
-	WRITE_BOOL_FIELD(em_is_child);
-	WRITE_OID_FIELD(em_datatype);
-}
-
-static void
-_outPathKey(StringInfo str, const PathKey *node)
-{
-	WRITE_NODE_TYPE("PATHKEY");
-
-	WRITE_NODE_FIELD(pk_eclass);
-	WRITE_OID_FIELD(pk_opfamily);
-	WRITE_INT_FIELD(pk_strategy);
-	WRITE_BOOL_FIELD(pk_nulls_first);
-}
-
-static void
-_outPathTarget(StringInfo str, const PathTarget *node)
-{
-	WRITE_NODE_TYPE("PATHTARGET");
-
-	WRITE_NODE_FIELD(exprs);
-	WRITE_INDEX_ARRAY(sortgrouprefs, list_length(node->exprs));
-	WRITE_FLOAT_FIELD(cost.startup, "%.2f");
-	WRITE_FLOAT_FIELD(cost.per_tuple, "%.2f");
-	WRITE_INT_FIELD(width);
-	WRITE_ENUM_FIELD(has_volatile_expr, VolatileFunctionStatus);
-}
-
-static void
-_outParamPathInfo(StringInfo str, const ParamPathInfo *node)
-{
-	WRITE_NODE_TYPE("PARAMPATHINFO");
-
-	WRITE_BITMAPSET_FIELD(ppi_req_outer);
-	WRITE_FLOAT_FIELD(ppi_rows, "%.0f");
-	WRITE_NODE_FIELD(ppi_clauses);
-}
-
-static void
-_outRestrictInfo(StringInfo str, const RestrictInfo *node)
-{
-	WRITE_NODE_TYPE("RESTRICTINFO");
-
-	/* NB: this isn't a complete set of fields */
-	WRITE_NODE_FIELD(clause);
-	WRITE_BOOL_FIELD(is_pushed_down);
-	WRITE_BOOL_FIELD(outerjoin_delayed);
-	WRITE_BOOL_FIELD(can_join);
-	WRITE_BOOL_FIELD(pseudoconstant);
-	WRITE_BOOL_FIELD(leakproof);
-	WRITE_ENUM_FIELD(has_volatile, VolatileFunctionStatus);
-	WRITE_UINT_FIELD(security_level);
-	WRITE_BITMAPSET_FIELD(clause_relids);
-	WRITE_BITMAPSET_FIELD(required_relids);
-	WRITE_BITMAPSET_FIELD(outer_relids);
-	WRITE_BITMAPSET_FIELD(nullable_relids);
-	WRITE_BITMAPSET_FIELD(left_relids);
-	WRITE_BITMAPSET_FIELD(right_relids);
-	WRITE_NODE_FIELD(orclause);
-	/* don't write parent_ec, leads to infinite recursion in plan tree dump */
-	WRITE_FLOAT_FIELD(norm_selec, "%.4f");
-	WRITE_FLOAT_FIELD(outer_selec, "%.4f");
-	WRITE_NODE_FIELD(mergeopfamilies);
-	/* don't write left_ec, leads to infinite recursion in plan tree dump */
-	/* don't write right_ec, leads to infinite recursion in plan tree dump */
-	WRITE_NODE_FIELD(left_em);
-	WRITE_NODE_FIELD(right_em);
-	WRITE_BOOL_FIELD(outer_is_left);
-	WRITE_OID_FIELD(hashjoinoperator);
-	WRITE_OID_FIELD(left_hasheqoperator);
-	WRITE_OID_FIELD(right_hasheqoperator);
-}
-
-static void
-_outIndexClause(StringInfo str, const IndexClause *node)
-{
-	WRITE_NODE_TYPE("INDEXCLAUSE");
-
-	WRITE_NODE_FIELD(rinfo);
-	WRITE_NODE_FIELD(indexquals);
-	WRITE_BOOL_FIELD(lossy);
-	WRITE_INT_FIELD(indexcol);
-	WRITE_NODE_FIELD(indexcols);
-}
-
-static void
-_outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
-{
-	WRITE_NODE_TYPE("PLACEHOLDERVAR");
-
-	WRITE_NODE_FIELD(phexpr);
-	WRITE_BITMAPSET_FIELD(phrels);
-	WRITE_UINT_FIELD(phid);
-	WRITE_UINT_FIELD(phlevelsup);
-}
-
-static void
-_outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
-{
-	WRITE_NODE_TYPE("SPECIALJOININFO");
-
-	WRITE_BITMAPSET_FIELD(min_lefthand);
-	WRITE_BITMAPSET_FIELD(min_righthand);
-	WRITE_BITMAPSET_FIELD(syn_lefthand);
-	WRITE_BITMAPSET_FIELD(syn_righthand);
-	WRITE_ENUM_FIELD(jointype, JoinType);
-	WRITE_BOOL_FIELD(lhs_strict);
-	WRITE_BOOL_FIELD(delay_upper_joins);
-	WRITE_BOOL_FIELD(semi_can_btree);
-	WRITE_BOOL_FIELD(semi_can_hash);
-	WRITE_NODE_FIELD(semi_operators);
-	WRITE_NODE_FIELD(semi_rhs_exprs);
-}
-
-static void
-_outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
-{
-	WRITE_NODE_TYPE("APPENDRELINFO");
-
-	WRITE_UINT_FIELD(parent_relid);
-	WRITE_UINT_FIELD(child_relid);
-	WRITE_OID_FIELD(parent_reltype);
-	WRITE_OID_FIELD(child_reltype);
-	WRITE_NODE_FIELD(translated_vars);
-	WRITE_INT_FIELD(num_child_cols);
-	WRITE_ATTRNUMBER_ARRAY(parent_colnos, node->num_child_cols);
-	WRITE_OID_FIELD(parent_reloid);
-}
-
-static void
-_outRowIdentityVarInfo(StringInfo str, const RowIdentityVarInfo *node)
-{
-	WRITE_NODE_TYPE("ROWIDENTITYVARINFO");
-
-	WRITE_NODE_FIELD(rowidvar);
-	WRITE_INT_FIELD(rowidwidth);
-	WRITE_STRING_FIELD(rowidname);
-	WRITE_BITMAPSET_FIELD(rowidrels);
-}
-
-static void
-_outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
-{
-	WRITE_NODE_TYPE("PLACEHOLDERINFO");
-
-	WRITE_UINT_FIELD(phid);
-	WRITE_NODE_FIELD(ph_var);
-	WRITE_BITMAPSET_FIELD(ph_eval_at);
-	WRITE_BITMAPSET_FIELD(ph_lateral);
-	WRITE_BITMAPSET_FIELD(ph_needed);
-	WRITE_INT_FIELD(ph_width);
-}
-
-static void
-_outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
-{
-	WRITE_NODE_TYPE("MINMAXAGGINFO");
-
-	WRITE_OID_FIELD(aggfnoid);
-	WRITE_OID_FIELD(aggsortop);
-	WRITE_NODE_FIELD(target);
-	/* We intentionally omit subroot --- too large, not interesting enough */
-	WRITE_NODE_FIELD(path);
-	WRITE_FLOAT_FIELD(pathcost, "%.2f");
-	WRITE_NODE_FIELD(param);
-}
-
-static void
-_outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
-{
-	WRITE_NODE_TYPE("PLANNERPARAMITEM");
-
-	WRITE_NODE_FIELD(item);
-	WRITE_INT_FIELD(paramId);
-}
-#endif							/* OBSOLETE */
-
-/*****************************************************************************
- *
- *	Stuff from extensible.h
- *
- *****************************************************************************/
-
 static void
 _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
 {
@@ -2852,342 +428,6 @@ _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
 	methods->nodeOut(str, node);
 }
 
-#ifdef OBSOLETE
-/*****************************************************************************
- *
- *	Stuff from parsenodes.h.
- *
- *****************************************************************************/
-
-/*
- * print the basic stuff of all nodes that inherit from CreateStmt
- */
-static void
-_outCreateStmtInfo(StringInfo str, const CreateStmt *node)
-{
-	WRITE_NODE_FIELD(relation);
-	WRITE_NODE_FIELD(tableElts);
-	WRITE_NODE_FIELD(inhRelations);
-	WRITE_NODE_FIELD(partspec);
-	WRITE_NODE_FIELD(partbound);
-	WRITE_NODE_FIELD(ofTypename);
-	WRITE_NODE_FIELD(constraints);
-	WRITE_NODE_FIELD(options);
-	WRITE_ENUM_FIELD(oncommit, OnCommitAction);
-	WRITE_STRING_FIELD(tablespacename);
-	WRITE_STRING_FIELD(accessMethod);
-	WRITE_BOOL_FIELD(if_not_exists);
-}
-
-static void
-_outCreateStmt(StringInfo str, const CreateStmt *node)
-{
-	WRITE_NODE_TYPE("CREATESTMT");
-
-	_outCreateStmtInfo(str, (const CreateStmt *) node);
-}
-
-static void
-_outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
-{
-	WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
-
-	_outCreateStmtInfo(str, (const CreateStmt *) node);
-
-	WRITE_STRING_FIELD(servername);
-	WRITE_NODE_FIELD(options);
-}
-
-static void
-_outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node)
-{
-	WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT");
-
-	WRITE_STRING_FIELD(server_name);
-	WRITE_STRING_FIELD(remote_schema);
-	WRITE_STRING_FIELD(local_schema);
-	WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType);
-	WRITE_NODE_FIELD(table_list);
-	WRITE_NODE_FIELD(options);
-}
-
-static void
-_outIndexStmt(StringInfo str, const IndexStmt *node)
-{
-	WRITE_NODE_TYPE("INDEXSTMT");
-
-	WRITE_STRING_FIELD(idxname);
-	WRITE_NODE_FIELD(relation);
-	WRITE_STRING_FIELD(accessMethod);
-	WRITE_STRING_FIELD(tableSpace);
-	WRITE_NODE_FIELD(indexParams);
-	WRITE_NODE_FIELD(indexIncludingParams);
-	WRITE_NODE_FIELD(options);
-	WRITE_NODE_FIELD(whereClause);
-	WRITE_NODE_FIELD(excludeOpNames);
-	WRITE_STRING_FIELD(idxcomment);
-	WRITE_OID_FIELD(indexOid);
-	WRITE_OID_FIELD(oldNumber);
-	WRITE_UINT_FIELD(oldCreateSubid);
-	WRITE_UINT_FIELD(oldFirstRelfilelocatorSubid);
-	WRITE_BOOL_FIELD(unique);
-	WRITE_BOOL_FIELD(nulls_not_distinct);
-	WRITE_BOOL_FIELD(primary);
-	WRITE_BOOL_FIELD(isconstraint);
-	WRITE_BOOL_FIELD(deferrable);
-	WRITE_BOOL_FIELD(initdeferred);
-	WRITE_BOOL_FIELD(transformed);
-	WRITE_BOOL_FIELD(concurrent);
-	WRITE_BOOL_FIELD(if_not_exists);
-	WRITE_BOOL_FIELD(reset_default_tblspc);
-}
-
-static void
-_outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node)
-{
-	WRITE_NODE_TYPE("CREATESTATSSTMT");
-
-	WRITE_NODE_FIELD(defnames);
-	WRITE_NODE_FIELD(stat_types);
-	WRITE_NODE_FIELD(exprs);
-	WRITE_NODE_FIELD(relations);
-	WRITE_STRING_FIELD(stxcomment);
-	WRITE_BOOL_FIELD(transformed);
-	WRITE_BOOL_FIELD(if_not_exists);
-}
-
-static void
-_outAlterStatsStmt(StringInfo str, const AlterStatsStmt *node)
-{
-	WRITE_NODE_TYPE("ALTERSTATSSTMT");
-
-	WRITE_NODE_FIELD(defnames);
-	WRITE_INT_FIELD(stxstattarget);
-	WRITE_BOOL_FIELD(missing_ok);
-}
-
-static void
-_outNotifyStmt(StringInfo str, const NotifyStmt *node)
-{
-	WRITE_NODE_TYPE("NOTIFYSTMT");
-
-	WRITE_STRING_FIELD(conditionname);
-	WRITE_STRING_FIELD(payload);
-}
-
-static void
-_outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
-{
-	WRITE_NODE_TYPE("DECLARECURSORSTMT");
-
-	WRITE_STRING_FIELD(portalname);
-	WRITE_INT_FIELD(options);
-	WRITE_NODE_FIELD(query);
-}
-
-static void
-_outSelectStmt(StringInfo str, const SelectStmt *node)
-{
-	WRITE_NODE_TYPE("SELECT");
-
-	WRITE_NODE_FIELD(distinctClause);
-	WRITE_NODE_FIELD(intoClause);
-	WRITE_NODE_FIELD(targetList);
-	WRITE_NODE_FIELD(fromClause);
-	WRITE_NODE_FIELD(whereClause);
-	WRITE_NODE_FIELD(groupClause);
-	WRITE_BOOL_FIELD(groupDistinct);
-	WRITE_NODE_FIELD(havingClause);
-	WRITE_NODE_FIELD(windowClause);
-	WRITE_NODE_FIELD(valuesLists);
-	WRITE_NODE_FIELD(sortClause);
-	WRITE_NODE_FIELD(limitOffset);
-	WRITE_NODE_FIELD(limitCount);
-	WRITE_ENUM_FIELD(limitOption, LimitOption);
-	WRITE_NODE_FIELD(lockingClause);
-	WRITE_NODE_FIELD(withClause);
-	WRITE_ENUM_FIELD(op, SetOperation);
-	WRITE_BOOL_FIELD(all);
-	WRITE_NODE_FIELD(larg);
-	WRITE_NODE_FIELD(rarg);
-}
-
-static void
-_outReturnStmt(StringInfo str, const ReturnStmt *node)
-{
-	WRITE_NODE_TYPE("RETURN");
-
-	WRITE_NODE_FIELD(returnval);
-}
-
-static void
-_outPLAssignStmt(StringInfo str, const PLAssignStmt *node)
-{
-	WRITE_NODE_TYPE("PLASSIGN");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(indirection);
-	WRITE_INT_FIELD(nnames);
-	WRITE_NODE_FIELD(val);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outFuncCall(StringInfo str, const FuncCall *node)
-{
-	WRITE_NODE_TYPE("FUNCCALL");
-
-	WRITE_NODE_FIELD(funcname);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(agg_order);
-	WRITE_NODE_FIELD(agg_filter);
-	WRITE_NODE_FIELD(over);
-	WRITE_BOOL_FIELD(agg_within_group);
-	WRITE_BOOL_FIELD(agg_star);
-	WRITE_BOOL_FIELD(agg_distinct);
-	WRITE_BOOL_FIELD(func_variadic);
-	WRITE_ENUM_FIELD(funcformat, CoercionForm);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outDefElem(StringInfo str, const DefElem *node)
-{
-	WRITE_NODE_TYPE("DEFELEM");
-
-	WRITE_STRING_FIELD(defnamespace);
-	WRITE_STRING_FIELD(defname);
-	WRITE_NODE_FIELD(arg);
-	WRITE_ENUM_FIELD(defaction, DefElemAction);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outTableLikeClause(StringInfo str, const TableLikeClause *node)
-{
-	WRITE_NODE_TYPE("TABLELIKECLAUSE");
-
-	WRITE_NODE_FIELD(relation);
-	WRITE_UINT_FIELD(options);
-	WRITE_OID_FIELD(relationOid);
-}
-
-static void
-_outLockingClause(StringInfo str, const LockingClause *node)
-{
-	WRITE_NODE_TYPE("LOCKINGCLAUSE");
-
-	WRITE_NODE_FIELD(lockedRels);
-	WRITE_ENUM_FIELD(strength, LockClauseStrength);
-	WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
-}
-
-static void
-_outXmlSerialize(StringInfo str, const XmlSerialize *node)
-{
-	WRITE_NODE_TYPE("XMLSERIALIZE");
-
-	WRITE_ENUM_FIELD(xmloption, XmlOptionType);
-	WRITE_NODE_FIELD(expr);
-	WRITE_NODE_FIELD(typeName);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outTriggerTransition(StringInfo str, const TriggerTransition *node)
-{
-	WRITE_NODE_TYPE("TRIGGERTRANSITION");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_BOOL_FIELD(isNew);
-	WRITE_BOOL_FIELD(isTable);
-}
-
-static void
-_outColumnDef(StringInfo str, const ColumnDef *node)
-{
-	WRITE_NODE_TYPE("COLUMNDEF");
-
-	WRITE_STRING_FIELD(colname);
-	WRITE_NODE_FIELD(typeName);
-	WRITE_STRING_FIELD(compression);
-	WRITE_INT_FIELD(inhcount);
-	WRITE_BOOL_FIELD(is_local);
-	WRITE_BOOL_FIELD(is_not_null);
-	WRITE_BOOL_FIELD(is_from_type);
-	WRITE_CHAR_FIELD(storage);
-	WRITE_NODE_FIELD(raw_default);
-	WRITE_NODE_FIELD(cooked_default);
-	WRITE_CHAR_FIELD(identity);
-	WRITE_NODE_FIELD(identitySequence);
-	WRITE_CHAR_FIELD(generated);
-	WRITE_NODE_FIELD(collClause);
-	WRITE_OID_FIELD(collOid);
-	WRITE_NODE_FIELD(constraints);
-	WRITE_NODE_FIELD(fdwoptions);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outTypeName(StringInfo str, const TypeName *node)
-{
-	WRITE_NODE_TYPE("TYPENAME");
-
-	WRITE_NODE_FIELD(names);
-	WRITE_OID_FIELD(typeOid);
-	WRITE_BOOL_FIELD(setof);
-	WRITE_BOOL_FIELD(pct_type);
-	WRITE_NODE_FIELD(typmods);
-	WRITE_INT_FIELD(typemod);
-	WRITE_NODE_FIELD(arrayBounds);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outTypeCast(StringInfo str, const TypeCast *node)
-{
-	WRITE_NODE_TYPE("TYPECAST");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(typeName);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCollateClause(StringInfo str, const CollateClause *node)
-{
-	WRITE_NODE_TYPE("COLLATECLAUSE");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(collname);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outIndexElem(StringInfo str, const IndexElem *node)
-{
-	WRITE_NODE_TYPE("INDEXELEM");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(expr);
-	WRITE_STRING_FIELD(indexcolname);
-	WRITE_NODE_FIELD(collation);
-	WRITE_NODE_FIELD(opclass);
-	WRITE_NODE_FIELD(opclassopts);
-	WRITE_ENUM_FIELD(ordering, SortByDir);
-	WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
-}
-
-static void
-_outStatsElem(StringInfo str, const StatsElem *node)
-{
-	WRITE_NODE_TYPE("STATSELEM");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(expr);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outQuery(StringInfo str, const Query *node)
 {
@@ -3261,174 +501,6 @@ _outQuery(StringInfo str, const Query *node)
 	WRITE_INT_FIELD(stmt_len);
 }
 
-#ifdef OBSOLETE
-static void
-_outWithCheckOption(StringInfo str, const WithCheckOption *node)
-{
-	WRITE_NODE_TYPE("WITHCHECKOPTION");
-
-	WRITE_ENUM_FIELD(kind, WCOKind);
-	WRITE_STRING_FIELD(relname);
-	WRITE_STRING_FIELD(polname);
-	WRITE_NODE_FIELD(qual);
-	WRITE_BOOL_FIELD(cascaded);
-}
-
-static void
-_outSortGroupClause(StringInfo str, const SortGroupClause *node)
-{
-	WRITE_NODE_TYPE("SORTGROUPCLAUSE");
-
-	WRITE_UINT_FIELD(tleSortGroupRef);
-	WRITE_OID_FIELD(eqop);
-	WRITE_OID_FIELD(sortop);
-	WRITE_BOOL_FIELD(nulls_first);
-	WRITE_BOOL_FIELD(hashable);
-}
-
-static void
-_outGroupingSet(StringInfo str, const GroupingSet *node)
-{
-	WRITE_NODE_TYPE("GROUPINGSET");
-
-	WRITE_ENUM_FIELD(kind, GroupingSetKind);
-	WRITE_NODE_FIELD(content);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outWindowClause(StringInfo str, const WindowClause *node)
-{
-	WRITE_NODE_TYPE("WINDOWCLAUSE");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_STRING_FIELD(refname);
-	WRITE_NODE_FIELD(partitionClause);
-	WRITE_NODE_FIELD(orderClause);
-	WRITE_INT_FIELD(frameOptions);
-	WRITE_NODE_FIELD(startOffset);
-	WRITE_NODE_FIELD(endOffset);
-	WRITE_NODE_FIELD(runCondition);
-	WRITE_OID_FIELD(startInRangeFunc);
-	WRITE_OID_FIELD(endInRangeFunc);
-	WRITE_OID_FIELD(inRangeColl);
-	WRITE_BOOL_FIELD(inRangeAsc);
-	WRITE_BOOL_FIELD(inRangeNullsFirst);
-	WRITE_UINT_FIELD(winref);
-	WRITE_BOOL_FIELD(copiedOrder);
-}
-
-static void
-_outRowMarkClause(StringInfo str, const RowMarkClause *node)
-{
-	WRITE_NODE_TYPE("ROWMARKCLAUSE");
-
-	WRITE_UINT_FIELD(rti);
-	WRITE_ENUM_FIELD(strength, LockClauseStrength);
-	WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
-	WRITE_BOOL_FIELD(pushedDown);
-}
-
-static void
-_outWithClause(StringInfo str, const WithClause *node)
-{
-	WRITE_NODE_TYPE("WITHCLAUSE");
-
-	WRITE_NODE_FIELD(ctes);
-	WRITE_BOOL_FIELD(recursive);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCTESearchClause(StringInfo str, const CTESearchClause *node)
-{
-	WRITE_NODE_TYPE("CTESEARCHCLAUSE");
-
-	WRITE_NODE_FIELD(search_col_list);
-	WRITE_BOOL_FIELD(search_breadth_first);
-	WRITE_STRING_FIELD(search_seq_column);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outCTECycleClause(StringInfo str, const CTECycleClause *node)
-{
-	WRITE_NODE_TYPE("CTECYCLECLAUSE");
-
-	WRITE_NODE_FIELD(cycle_col_list);
-	WRITE_STRING_FIELD(cycle_mark_column);
-	WRITE_NODE_FIELD(cycle_mark_value);
-	WRITE_NODE_FIELD(cycle_mark_default);
-	WRITE_STRING_FIELD(cycle_path_column);
-	WRITE_LOCATION_FIELD(location);
-	WRITE_OID_FIELD(cycle_mark_type);
-	WRITE_INT_FIELD(cycle_mark_typmod);
-	WRITE_OID_FIELD(cycle_mark_collation);
-	WRITE_OID_FIELD(cycle_mark_neop);
-}
-
-static void
-_outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
-{
-	WRITE_NODE_TYPE("COMMONTABLEEXPR");
-
-	WRITE_STRING_FIELD(ctename);
-	WRITE_NODE_FIELD(aliascolnames);
-	WRITE_ENUM_FIELD(ctematerialized, CTEMaterialize);
-	WRITE_NODE_FIELD(ctequery);
-	WRITE_NODE_FIELD(search_clause);
-	WRITE_NODE_FIELD(cycle_clause);
-	WRITE_LOCATION_FIELD(location);
-	WRITE_BOOL_FIELD(cterecursive);
-	WRITE_INT_FIELD(cterefcount);
-	WRITE_NODE_FIELD(ctecolnames);
-	WRITE_NODE_FIELD(ctecoltypes);
-	WRITE_NODE_FIELD(ctecoltypmods);
-	WRITE_NODE_FIELD(ctecolcollations);
-}
-
-static void
-_outMergeWhenClause(StringInfo str, const MergeWhenClause *node)
-{
-	WRITE_NODE_TYPE("MERGEWHENCLAUSE");
-
-	WRITE_BOOL_FIELD(matched);
-	WRITE_ENUM_FIELD(commandType, CmdType);
-	WRITE_ENUM_FIELD(override, OverridingKind);
-	WRITE_NODE_FIELD(condition);
-	WRITE_NODE_FIELD(targetList);
-	WRITE_NODE_FIELD(values);
-}
-
-static void
-_outMergeAction(StringInfo str, const MergeAction *node)
-{
-	WRITE_NODE_TYPE("MERGEACTION");
-
-	WRITE_BOOL_FIELD(matched);
-	WRITE_ENUM_FIELD(commandType, CmdType);
-	WRITE_ENUM_FIELD(override, OverridingKind);
-	WRITE_NODE_FIELD(qual);
-	WRITE_NODE_FIELD(targetList);
-	WRITE_NODE_FIELD(updateColnos);
-}
-
-static void
-_outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
-{
-	WRITE_NODE_TYPE("SETOPERATIONSTMT");
-
-	WRITE_ENUM_FIELD(op, SetOperation);
-	WRITE_BOOL_FIELD(all);
-	WRITE_NODE_FIELD(larg);
-	WRITE_NODE_FIELD(rarg);
-	WRITE_NODE_FIELD(colTypes);
-	WRITE_NODE_FIELD(colTypmods);
-	WRITE_NODE_FIELD(colCollations);
-	WRITE_NODE_FIELD(groupClauses);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
 {
@@ -3508,32 +580,6 @@ _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
 	WRITE_NODE_FIELD(securityQuals);
 }
 
-#ifdef OBSOLETE
-static void
-_outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
-{
-	WRITE_NODE_TYPE("RANGETBLFUNCTION");
-
-	WRITE_NODE_FIELD(funcexpr);
-	WRITE_INT_FIELD(funccolcount);
-	WRITE_NODE_FIELD(funccolnames);
-	WRITE_NODE_FIELD(funccoltypes);
-	WRITE_NODE_FIELD(funccoltypmods);
-	WRITE_NODE_FIELD(funccolcollations);
-	WRITE_BITMAPSET_FIELD(funcparams);
-}
-
-static void
-_outTableSampleClause(StringInfo str, const TableSampleClause *node)
-{
-	WRITE_NODE_TYPE("TABLESAMPLECLAUSE");
-
-	WRITE_OID_FIELD(tsmhandler);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(repeatable);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outA_Expr(StringInfo str, const A_Expr *node)
 {
@@ -3651,40 +697,6 @@ _outBitString(StringInfo str, const BitString *node)
 	appendStringInfoString(str, node->bsval);
 }
 
-#ifdef OBSOLETE
-static void
-_outColumnRef(StringInfo str, const ColumnRef *node)
-{
-	WRITE_NODE_TYPE("COLUMNREF");
-
-	WRITE_NODE_FIELD(fields);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outParamRef(StringInfo str, const ParamRef *node)
-{
-	WRITE_NODE_TYPE("PARAMREF");
-
-	WRITE_INT_FIELD(number);
-	WRITE_LOCATION_FIELD(location);
-}
-
-/*
- * Node types found in raw parse trees (supported for debug purposes)
- */
-
-static void
-_outRawStmt(StringInfo str, const RawStmt *node)
-{
-	WRITE_NODE_TYPE("RAWSTMT");
-
-	WRITE_NODE_FIELD(stmt);
-	WRITE_LOCATION_FIELD(stmt_location);
-	WRITE_INT_FIELD(stmt_len);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outA_Const(StringInfo str, const A_Const *node)
 {
@@ -3700,153 +712,6 @@ _outA_Const(StringInfo str, const A_Const *node)
 	WRITE_LOCATION_FIELD(location);
 }
 
-#ifdef OBSOLETE
-static void
-_outA_Star(StringInfo str, const A_Star *node)
-{
-	WRITE_NODE_TYPE("A_STAR");
-}
-
-static void
-_outA_Indices(StringInfo str, const A_Indices *node)
-{
-	WRITE_NODE_TYPE("A_INDICES");
-
-	WRITE_BOOL_FIELD(is_slice);
-	WRITE_NODE_FIELD(lidx);
-	WRITE_NODE_FIELD(uidx);
-}
-
-static void
-_outA_Indirection(StringInfo str, const A_Indirection *node)
-{
-	WRITE_NODE_TYPE("A_INDIRECTION");
-
-	WRITE_NODE_FIELD(arg);
-	WRITE_NODE_FIELD(indirection);
-}
-
-static void
-_outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
-{
-	WRITE_NODE_TYPE("A_ARRAYEXPR");
-
-	WRITE_NODE_FIELD(elements);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outResTarget(StringInfo str, const ResTarget *node)
-{
-	WRITE_NODE_TYPE("RESTARGET");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(indirection);
-	WRITE_NODE_FIELD(val);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outMultiAssignRef(StringInfo str, const MultiAssignRef *node)
-{
-	WRITE_NODE_TYPE("MULTIASSIGNREF");
-
-	WRITE_NODE_FIELD(source);
-	WRITE_INT_FIELD(colno);
-	WRITE_INT_FIELD(ncolumns);
-}
-
-static void
-_outSortBy(StringInfo str, const SortBy *node)
-{
-	WRITE_NODE_TYPE("SORTBY");
-
-	WRITE_NODE_FIELD(node);
-	WRITE_ENUM_FIELD(sortby_dir, SortByDir);
-	WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
-	WRITE_NODE_FIELD(useOp);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outWindowDef(StringInfo str, const WindowDef *node)
-{
-	WRITE_NODE_TYPE("WINDOWDEF");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_STRING_FIELD(refname);
-	WRITE_NODE_FIELD(partitionClause);
-	WRITE_NODE_FIELD(orderClause);
-	WRITE_INT_FIELD(frameOptions);
-	WRITE_NODE_FIELD(startOffset);
-	WRITE_NODE_FIELD(endOffset);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outRangeSubselect(StringInfo str, const RangeSubselect *node)
-{
-	WRITE_NODE_TYPE("RANGESUBSELECT");
-
-	WRITE_BOOL_FIELD(lateral);
-	WRITE_NODE_FIELD(subquery);
-	WRITE_NODE_FIELD(alias);
-}
-
-static void
-_outRangeFunction(StringInfo str, const RangeFunction *node)
-{
-	WRITE_NODE_TYPE("RANGEFUNCTION");
-
-	WRITE_BOOL_FIELD(lateral);
-	WRITE_BOOL_FIELD(ordinality);
-	WRITE_BOOL_FIELD(is_rowsfrom);
-	WRITE_NODE_FIELD(functions);
-	WRITE_NODE_FIELD(alias);
-	WRITE_NODE_FIELD(coldeflist);
-}
-
-static void
-_outRangeTableSample(StringInfo str, const RangeTableSample *node)
-{
-	WRITE_NODE_TYPE("RANGETABLESAMPLE");
-
-	WRITE_NODE_FIELD(relation);
-	WRITE_NODE_FIELD(method);
-	WRITE_NODE_FIELD(args);
-	WRITE_NODE_FIELD(repeatable);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outRangeTableFunc(StringInfo str, const RangeTableFunc *node)
-{
-	WRITE_NODE_TYPE("RANGETABLEFUNC");
-
-	WRITE_BOOL_FIELD(lateral);
-	WRITE_NODE_FIELD(docexpr);
-	WRITE_NODE_FIELD(rowexpr);
-	WRITE_NODE_FIELD(namespaces);
-	WRITE_NODE_FIELD(columns);
-	WRITE_NODE_FIELD(alias);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node)
-{
-	WRITE_NODE_TYPE("RANGETABLEFUNCCOL");
-
-	WRITE_STRING_FIELD(colname);
-	WRITE_NODE_FIELD(typeName);
-	WRITE_BOOL_FIELD(for_ordinality);
-	WRITE_BOOL_FIELD(is_not_null);
-	WRITE_NODE_FIELD(colexpr);
-	WRITE_NODE_FIELD(coldefexpr);
-	WRITE_LOCATION_FIELD(location);
-}
-#endif							/* OBSOLETE */
-
 static void
 _outConstraint(StringInfo str, const Constraint *node)
 {
@@ -3968,68 +833,6 @@ _outConstraint(StringInfo str, const Constraint *node)
 	}
 }
 
-#ifdef OBSOLETE
-static void
-_outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node)
-{
-	WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO");
-
-	WRITE_OID_FIELD(conoid);
-	WRITE_OID_FIELD(conrelid);
-	WRITE_OID_FIELD(confrelid);
-	WRITE_INT_FIELD(nkeys);
-	WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
-	WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
-	WRITE_OID_ARRAY(conpfeqop, node->nkeys);
-}
-
-static void
-_outPartitionElem(StringInfo str, const PartitionElem *node)
-{
-	WRITE_NODE_TYPE("PARTITIONELEM");
-
-	WRITE_STRING_FIELD(name);
-	WRITE_NODE_FIELD(expr);
-	WRITE_NODE_FIELD(collation);
-	WRITE_NODE_FIELD(opclass);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outPartitionSpec(StringInfo str, const PartitionSpec *node)
-{
-	WRITE_NODE_TYPE("PARTITIONSPEC");
-
-	WRITE_STRING_FIELD(strategy);
-	WRITE_NODE_FIELD(partParams);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node)
-{
-	WRITE_NODE_TYPE("PARTITIONBOUNDSPEC");
-
-	WRITE_CHAR_FIELD(strategy);
-	WRITE_BOOL_FIELD(is_default);
-	WRITE_INT_FIELD(modulus);
-	WRITE_INT_FIELD(remainder);
-	WRITE_NODE_FIELD(listdatums);
-	WRITE_NODE_FIELD(lowerdatums);
-	WRITE_NODE_FIELD(upperdatums);
-	WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node)
-{
-	WRITE_NODE_TYPE("PARTITIONRANGEDATUM");
-
-	WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind);
-	WRITE_NODE_FIELD(value);
-	WRITE_LOCATION_FIELD(location);
-}
-#endif							/* OBSOLETE */
 
 /*
  * outNode -
@@ -4062,713 +865,6 @@ outNode(StringInfo str, const void *obj)
 		switch (nodeTag(obj))
 		{
 #include "outfuncs.switch.c"
-#ifdef OBSOLETE
-			case T_PlannedStmt:
-				_outPlannedStmt(str, obj);
-				break;
-			case T_Result:
-				_outResult(str, obj);
-				break;
-			case T_ProjectSet:
-				_outProjectSet(str, obj);
-				break;
-			case T_ModifyTable:
-				_outModifyTable(str, obj);
-				break;
-			case T_Append:
-				_outAppend(str, obj);
-				break;
-			case T_MergeAppend:
-				_outMergeAppend(str, obj);
-				break;
-			case T_RecursiveUnion:
-				_outRecursiveUnion(str, obj);
-				break;
-			case T_BitmapAnd:
-				_outBitmapAnd(str, obj);
-				break;
-			case T_BitmapOr:
-				_outBitmapOr(str, obj);
-				break;
-			case T_Gather:
-				_outGather(str, obj);
-				break;
-			case T_GatherMerge:
-				_outGatherMerge(str, obj);
-				break;
-			case T_Scan:
-				_outScan(str, obj);
-				break;
-			case T_SeqScan:
-				_outSeqScan(str, obj);
-				break;
-			case T_SampleScan:
-				_outSampleScan(str, obj);
-				break;
-			case T_IndexScan:
-				_outIndexScan(str, obj);
-				break;
-			case T_IndexOnlyScan:
-				_outIndexOnlyScan(str, obj);
-				break;
-			case T_BitmapIndexScan:
-				_outBitmapIndexScan(str, obj);
-				break;
-			case T_BitmapHeapScan:
-				_outBitmapHeapScan(str, obj);
-				break;
-			case T_TidScan:
-				_outTidScan(str, obj);
-				break;
-			case T_TidRangeScan:
-				_outTidRangeScan(str, obj);
-				break;
-			case T_SubqueryScan:
-				_outSubqueryScan(str, obj);
-				break;
-			case T_FunctionScan:
-				_outFunctionScan(str, obj);
-				break;
-			case T_TableFuncScan:
-				_outTableFuncScan(str, obj);
-				break;
-			case T_ValuesScan:
-				_outValuesScan(str, obj);
-				break;
-			case T_CteScan:
-				_outCteScan(str, obj);
-				break;
-			case T_NamedTuplestoreScan:
-				_outNamedTuplestoreScan(str, obj);
-				break;
-			case T_WorkTableScan:
-				_outWorkTableScan(str, obj);
-				break;
-			case T_ForeignScan:
-				_outForeignScan(str, obj);
-				break;
-			case T_CustomScan:
-				_outCustomScan(str, obj);
-				break;
-			case T_NestLoop:
-				_outNestLoop(str, obj);
-				break;
-			case T_MergeJoin:
-				_outMergeJoin(str, obj);
-				break;
-			case T_HashJoin:
-				_outHashJoin(str, obj);
-				break;
-			case T_Agg:
-				_outAgg(str, obj);
-				break;
-			case T_WindowAgg:
-				_outWindowAgg(str, obj);
-				break;
-			case T_Group:
-				_outGroup(str, obj);
-				break;
-			case T_Material:
-				_outMaterial(str, obj);
-				break;
-			case T_Memoize:
-				_outMemoize(str, obj);
-				break;
-			case T_Sort:
-				_outSort(str, obj);
-				break;
-			case T_IncrementalSort:
-				_outIncrementalSort(str, obj);
-				break;
-			case T_Unique:
-				_outUnique(str, obj);
-				break;
-			case T_Hash:
-				_outHash(str, obj);
-				break;
-			case T_SetOp:
-				_outSetOp(str, obj);
-				break;
-			case T_LockRows:
-				_outLockRows(str, obj);
-				break;
-			case T_Limit:
-				_outLimit(str, obj);
-				break;
-			case T_NestLoopParam:
-				_outNestLoopParam(str, obj);
-				break;
-			case T_PlanRowMark:
-				_outPlanRowMark(str, obj);
-				break;
-			case T_PartitionPruneInfo:
-				_outPartitionPruneInfo(str, obj);
-				break;
-			case T_PartitionedRelPruneInfo:
-				_outPartitionedRelPruneInfo(str, obj);
-				break;
-			case T_PartitionPruneStepOp:
-				_outPartitionPruneStepOp(str, obj);
-				break;
-			case T_PartitionPruneStepCombine:
-				_outPartitionPruneStepCombine(str, obj);
-				break;
-			case T_PlanInvalItem:
-				_outPlanInvalItem(str, obj);
-				break;
-			case T_Alias:
-				_outAlias(str, obj);
-				break;
-			case T_RangeVar:
-				_outRangeVar(str, obj);
-				break;
-			case T_TableFunc:
-				_outTableFunc(str, obj);
-				break;
-			case T_IntoClause:
-				_outIntoClause(str, obj);
-				break;
-			case T_Var:
-				_outVar(str, obj);
-				break;
-			case T_Const:
-				_outConst(str, obj);
-				break;
-			case T_Param:
-				_outParam(str, obj);
-				break;
-			case T_Aggref:
-				_outAggref(str, obj);
-				break;
-			case T_GroupingFunc:
-				_outGroupingFunc(str, obj);
-				break;
-			case T_WindowFunc:
-				_outWindowFunc(str, obj);
-				break;
-			case T_SubscriptingRef:
-				_outSubscriptingRef(str, obj);
-				break;
-			case T_FuncExpr:
-				_outFuncExpr(str, obj);
-				break;
-			case T_NamedArgExpr:
-				_outNamedArgExpr(str, obj);
-				break;
-			case T_OpExpr:
-				_outOpExpr(str, obj);
-				break;
-			case T_DistinctExpr:
-				_outDistinctExpr(str, obj);
-				break;
-			case T_NullIfExpr:
-				_outNullIfExpr(str, obj);
-				break;
-			case T_ScalarArrayOpExpr:
-				_outScalarArrayOpExpr(str, obj);
-				break;
-			case T_BoolExpr:
-				_outBoolExpr(str, obj);
-				break;
-			case T_SubLink:
-				_outSubLink(str, obj);
-				break;
-			case T_SubPlan:
-				_outSubPlan(str, obj);
-				break;
-			case T_AlternativeSubPlan:
-				_outAlternativeSubPlan(str, obj);
-				break;
-			case T_FieldSelect:
-				_outFieldSelect(str, obj);
-				break;
-			case T_FieldStore:
-				_outFieldStore(str, obj);
-				break;
-			case T_RelabelType:
-				_outRelabelType(str, obj);
-				break;
-			case T_CoerceViaIO:
-				_outCoerceViaIO(str, obj);
-				break;
-			case T_ArrayCoerceExpr:
-				_outArrayCoerceExpr(str, obj);
-				break;
-			case T_ConvertRowtypeExpr:
-				_outConvertRowtypeExpr(str, obj);
-				break;
-			case T_CollateExpr:
-				_outCollateExpr(str, obj);
-				break;
-			case T_CaseExpr:
-				_outCaseExpr(str, obj);
-				break;
-			case T_CaseWhen:
-				_outCaseWhen(str, obj);
-				break;
-			case T_CaseTestExpr:
-				_outCaseTestExpr(str, obj);
-				break;
-			case T_ArrayExpr:
-				_outArrayExpr(str, obj);
-				break;
-			case T_RowExpr:
-				_outRowExpr(str, obj);
-				break;
-			case T_RowCompareExpr:
-				_outRowCompareExpr(str, obj);
-				break;
-			case T_CoalesceExpr:
-				_outCoalesceExpr(str, obj);
-				break;
-			case T_MinMaxExpr:
-				_outMinMaxExpr(str, obj);
-				break;
-			case T_SQLValueFunction:
-				_outSQLValueFunction(str, obj);
-				break;
-			case T_XmlExpr:
-				_outXmlExpr(str, obj);
-				break;
-			case T_NullTest:
-				_outNullTest(str, obj);
-				break;
-			case T_BooleanTest:
-				_outBooleanTest(str, obj);
-				break;
-			case T_CoerceToDomain:
-				_outCoerceToDomain(str, obj);
-				break;
-			case T_CoerceToDomainValue:
-				_outCoerceToDomainValue(str, obj);
-				break;
-			case T_SetToDefault:
-				_outSetToDefault(str, obj);
-				break;
-			case T_CurrentOfExpr:
-				_outCurrentOfExpr(str, obj);
-				break;
-			case T_NextValueExpr:
-				_outNextValueExpr(str, obj);
-				break;
-			case T_InferenceElem:
-				_outInferenceElem(str, obj);
-				break;
-			case T_TargetEntry:
-				_outTargetEntry(str, obj);
-				break;
-			case T_RangeTblRef:
-				_outRangeTblRef(str, obj);
-				break;
-			case T_JoinExpr:
-				_outJoinExpr(str, obj);
-				break;
-			case T_FromExpr:
-				_outFromExpr(str, obj);
-				break;
-			case T_OnConflictExpr:
-				_outOnConflictExpr(str, obj);
-				break;
-			case T_Path:
-				_outPath(str, obj);
-				break;
-			case T_IndexPath:
-				_outIndexPath(str, obj);
-				break;
-			case T_BitmapHeapPath:
-				_outBitmapHeapPath(str, obj);
-				break;
-			case T_BitmapAndPath:
-				_outBitmapAndPath(str, obj);
-				break;
-			case T_BitmapOrPath:
-				_outBitmapOrPath(str, obj);
-				break;
-			case T_TidPath:
-				_outTidPath(str, obj);
-				break;
-			case T_TidRangePath:
-				_outTidRangePath(str, obj);
-				break;
-			case T_SubqueryScanPath:
-				_outSubqueryScanPath(str, obj);
-				break;
-			case T_ForeignPath:
-				_outForeignPath(str, obj);
-				break;
-			case T_CustomPath:
-				_outCustomPath(str, obj);
-				break;
-			case T_AppendPath:
-				_outAppendPath(str, obj);
-				break;
-			case T_MergeAppendPath:
-				_outMergeAppendPath(str, obj);
-				break;
-			case T_GroupResultPath:
-				_outGroupResultPath(str, obj);
-				break;
-			case T_MaterialPath:
-				_outMaterialPath(str, obj);
-				break;
-			case T_MemoizePath:
-				_outMemoizePath(str, obj);
-				break;
-			case T_UniquePath:
-				_outUniquePath(str, obj);
-				break;
-			case T_GatherPath:
-				_outGatherPath(str, obj);
-				break;
-			case T_ProjectionPath:
-				_outProjectionPath(str, obj);
-				break;
-			case T_ProjectSetPath:
-				_outProjectSetPath(str, obj);
-				break;
-			case T_SortPath:
-				_outSortPath(str, obj);
-				break;
-			case T_IncrementalSortPath:
-				_outIncrementalSortPath(str, obj);
-				break;
-			case T_GroupPath:
-				_outGroupPath(str, obj);
-				break;
-			case T_UpperUniquePath:
-				_outUpperUniquePath(str, obj);
-				break;
-			case T_AggPath:
-				_outAggPath(str, obj);
-				break;
-			case T_GroupingSetsPath:
-				_outGroupingSetsPath(str, obj);
-				break;
-			case T_MinMaxAggPath:
-				_outMinMaxAggPath(str, obj);
-				break;
-			case T_WindowAggPath:
-				_outWindowAggPath(str, obj);
-				break;
-			case T_SetOpPath:
-				_outSetOpPath(str, obj);
-				break;
-			case T_RecursiveUnionPath:
-				_outRecursiveUnionPath(str, obj);
-				break;
-			case T_LockRowsPath:
-				_outLockRowsPath(str, obj);
-				break;
-			case T_ModifyTablePath:
-				_outModifyTablePath(str, obj);
-				break;
-			case T_LimitPath:
-				_outLimitPath(str, obj);
-				break;
-			case T_GatherMergePath:
-				_outGatherMergePath(str, obj);
-				break;
-			case T_NestPath:
-				_outNestPath(str, obj);
-				break;
-			case T_MergePath:
-				_outMergePath(str, obj);
-				break;
-			case T_HashPath:
-				_outHashPath(str, obj);
-				break;
-			case T_PlannerGlobal:
-				_outPlannerGlobal(str, obj);
-				break;
-			case T_PlannerInfo:
-				_outPlannerInfo(str, obj);
-				break;
-			case T_RelOptInfo:
-				_outRelOptInfo(str, obj);
-				break;
-			case T_IndexOptInfo:
-				_outIndexOptInfo(str, obj);
-				break;
-			case T_ForeignKeyOptInfo:
-				_outForeignKeyOptInfo(str, obj);
-				break;
-			case T_EquivalenceClass:
-				_outEquivalenceClass(str, obj);
-				break;
-			case T_EquivalenceMember:
-				_outEquivalenceMember(str, obj);
-				break;
-			case T_PathKey:
-				_outPathKey(str, obj);
-				break;
-			case T_PathTarget:
-				_outPathTarget(str, obj);
-				break;
-			case T_ParamPathInfo:
-				_outParamPathInfo(str, obj);
-				break;
-			case T_RestrictInfo:
-				_outRestrictInfo(str, obj);
-				break;
-			case T_IndexClause:
-				_outIndexClause(str, obj);
-				break;
-			case T_PlaceHolderVar:
-				_outPlaceHolderVar(str, obj);
-				break;
-			case T_SpecialJoinInfo:
-				_outSpecialJoinInfo(str, obj);
-				break;
-			case T_AppendRelInfo:
-				_outAppendRelInfo(str, obj);
-				break;
-			case T_RowIdentityVarInfo:
-				_outRowIdentityVarInfo(str, obj);
-				break;
-			case T_PlaceHolderInfo:
-				_outPlaceHolderInfo(str, obj);
-				break;
-			case T_MinMaxAggInfo:
-				_outMinMaxAggInfo(str, obj);
-				break;
-			case T_PlannerParamItem:
-				_outPlannerParamItem(str, obj);
-				break;
-			case T_RollupData:
-				_outRollupData(str, obj);
-				break;
-			case T_GroupingSetData:
-				_outGroupingSetData(str, obj);
-				break;
-			case T_StatisticExtInfo:
-				_outStatisticExtInfo(str, obj);
-				break;
-			case T_ExtensibleNode:
-				_outExtensibleNode(str, obj);
-				break;
-			case T_CreateStmt:
-				_outCreateStmt(str, obj);
-				break;
-			case T_CreateForeignTableStmt:
-				_outCreateForeignTableStmt(str, obj);
-				break;
-			case T_ImportForeignSchemaStmt:
-				_outImportForeignSchemaStmt(str, obj);
-				break;
-			case T_IndexStmt:
-				_outIndexStmt(str, obj);
-				break;
-			case T_CreateStatsStmt:
-				_outCreateStatsStmt(str, obj);
-				break;
-			case T_AlterStatsStmt:
-				_outAlterStatsStmt(str, obj);
-				break;
-			case T_NotifyStmt:
-				_outNotifyStmt(str, obj);
-				break;
-			case T_DeclareCursorStmt:
-				_outDeclareCursorStmt(str, obj);
-				break;
-			case T_SelectStmt:
-				_outSelectStmt(str, obj);
-				break;
-			case T_ReturnStmt:
-				_outReturnStmt(str, obj);
-				break;
-			case T_PLAssignStmt:
-				_outPLAssignStmt(str, obj);
-				break;
-			case T_ColumnDef:
-				_outColumnDef(str, obj);
-				break;
-			case T_TypeName:
-				_outTypeName(str, obj);
-				break;
-			case T_TypeCast:
-				_outTypeCast(str, obj);
-				break;
-			case T_CollateClause:
-				_outCollateClause(str, obj);
-				break;
-			case T_IndexElem:
-				_outIndexElem(str, obj);
-				break;
-			case T_StatsElem:
-				_outStatsElem(str, obj);
-				break;
-			case T_Query:
-				_outQuery(str, obj);
-				break;
-			case T_WithCheckOption:
-				_outWithCheckOption(str, obj);
-				break;
-			case T_SortGroupClause:
-				_outSortGroupClause(str, obj);
-				break;
-			case T_GroupingSet:
-				_outGroupingSet(str, obj);
-				break;
-			case T_WindowClause:
-				_outWindowClause(str, obj);
-				break;
-			case T_RowMarkClause:
-				_outRowMarkClause(str, obj);
-				break;
-			case T_WithClause:
-				_outWithClause(str, obj);
-				break;
-			case T_CTESearchClause:
-				_outCTESearchClause(str, obj);
-				break;
-			case T_CTECycleClause:
-				_outCTECycleClause(str, obj);
-				break;
-			case T_CommonTableExpr:
-				_outCommonTableExpr(str, obj);
-				break;
-			case T_MergeWhenClause:
-				_outMergeWhenClause(str, obj);
-				break;
-			case T_MergeAction:
-				_outMergeAction(str, obj);
-				break;
-			case T_SetOperationStmt:
-				_outSetOperationStmt(str, obj);
-				break;
-			case T_RangeTblEntry:
-				_outRangeTblEntry(str, obj);
-				break;
-			case T_RangeTblFunction:
-				_outRangeTblFunction(str, obj);
-				break;
-			case T_TableSampleClause:
-				_outTableSampleClause(str, obj);
-				break;
-			case T_A_Expr:
-				_outA_Expr(str, obj);
-				break;
-			case T_ColumnRef:
-				_outColumnRef(str, obj);
-				break;
-			case T_ParamRef:
-				_outParamRef(str, obj);
-				break;
-			case T_RawStmt:
-				_outRawStmt(str, obj);
-				break;
-			case T_A_Const:
-				_outA_Const(str, obj);
-				break;
-			case T_A_Star:
-				_outA_Star(str, obj);
-				break;
-			case T_A_Indices:
-				_outA_Indices(str, obj);
-				break;
-			case T_A_Indirection:
-				_outA_Indirection(str, obj);
-				break;
-			case T_A_ArrayExpr:
-				_outA_ArrayExpr(str, obj);
-				break;
-			case T_ResTarget:
-				_outResTarget(str, obj);
-				break;
-			case T_MultiAssignRef:
-				_outMultiAssignRef(str, obj);
-				break;
-			case T_SortBy:
-				_outSortBy(str, obj);
-				break;
-			case T_WindowDef:
-				_outWindowDef(str, obj);
-				break;
-			case T_RangeSubselect:
-				_outRangeSubselect(str, obj);
-				break;
-			case T_RangeFunction:
-				_outRangeFunction(str, obj);
-				break;
-			case T_RangeTableSample:
-				_outRangeTableSample(str, obj);
-				break;
-			case T_RangeTableFunc:
-				_outRangeTableFunc(str, obj);
-				break;
-			case T_RangeTableFuncCol:
-				_outRangeTableFuncCol(str, obj);
-				break;
-			case T_Constraint:
-				_outConstraint(str, obj);
-				break;
-			case T_FuncCall:
-				_outFuncCall(str, obj);
-				break;
-			case T_DefElem:
-				_outDefElem(str, obj);
-				break;
-			case T_TableLikeClause:
-				_outTableLikeClause(str, obj);
-				break;
-			case T_LockingClause:
-				_outLockingClause(str, obj);
-				break;
-			case T_XmlSerialize:
-				_outXmlSerialize(str, obj);
-				break;
-			case T_ForeignKeyCacheInfo:
-				_outForeignKeyCacheInfo(str, obj);
-				break;
-			case T_TriggerTransition:
-				_outTriggerTransition(str, obj);
-				break;
-			case T_PartitionElem:
-				_outPartitionElem(str, obj);
-				break;
-			case T_PartitionSpec:
-				_outPartitionSpec(str, obj);
-				break;
-			case T_PartitionBoundSpec:
-				_outPartitionBoundSpec(str, obj);
-				break;
-			case T_PartitionRangeDatum:
-				_outPartitionRangeDatum(str, obj);
-				break;
-			case T_JsonFormat:
-				_outJsonFormat(str, obj);
-				break;
-			case T_JsonReturning:
-				_outJsonReturning(str, obj);
-				break;
-			case T_JsonValueExpr:
-				_outJsonValueExpr(str, obj);
-				break;
-			case T_JsonConstructorExpr:
-				_outJsonConstructorExpr(str, obj);
-				break;
-			case T_JsonIsPredicate:
-				_outJsonIsPredicate(str, obj);
-				break;
-			case T_JsonBehavior:
-				_outJsonBehavior(str, obj);
-				break;
-			case T_JsonExpr:
-				_outJsonExpr(str, obj);
-				break;
-			case T_JsonCoercion:
-				_outJsonCoercion(str, obj);
-				break;
-			case T_JsonItemCoercions:
-				_outJsonItemCoercions(str, obj);
-				break;
-			case T_JsonTableParent:
-				_outJsonTableParent(str, obj);
-				break;
-			case T_JsonTableSibling:
-				_outJsonTableSibling(str, obj);
-				break;
-#endif							/* OBSOLETE */
 
 			default:
 
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 21176cd4c0..67b0f798c1 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -238,9 +238,12 @@ readBitmapset(void)
 
 #include "readfuncs.funcs.c"
 
+
 /*
- * _readQuery
+ * Support functions for nodes with custom_read_write attribute or
+ * special_read_write attribute
  */
+
 static Query *
 _readQuery(void)
 {
@@ -291,350 +294,6 @@ _readQuery(void)
 	READ_DONE();
 }
 
-#ifdef OBSOLETE
-/*
- * _readNotifyStmt
- */
-static NotifyStmt *
-_readNotifyStmt(void)
-{
-	READ_LOCALS(NotifyStmt);
-
-	READ_STRING_FIELD(conditionname);
-	READ_STRING_FIELD(payload);
-
-	READ_DONE();
-}
-
-/*
- * _readDeclareCursorStmt
- */
-static DeclareCursorStmt *
-_readDeclareCursorStmt(void)
-{
-	READ_LOCALS(DeclareCursorStmt);
-
-	READ_STRING_FIELD(portalname);
-	READ_INT_FIELD(options);
-	READ_NODE_FIELD(query);
-
-	READ_DONE();
-}
-
-/*
- * _readWithCheckOption
- */
-static WithCheckOption *
-_readWithCheckOption(void)
-{
-	READ_LOCALS(WithCheckOption);
-
-	READ_ENUM_FIELD(kind, WCOKind);
-	READ_STRING_FIELD(relname);
-	READ_STRING_FIELD(polname);
-	READ_NODE_FIELD(qual);
-	READ_BOOL_FIELD(cascaded);
-
-	READ_DONE();
-}
-
-/*
- * _readSortGroupClause
- */
-static SortGroupClause *
-_readSortGroupClause(void)
-{
-	READ_LOCALS(SortGroupClause);
-
-	READ_UINT_FIELD(tleSortGroupRef);
-	READ_OID_FIELD(eqop);
-	READ_OID_FIELD(sortop);
-	READ_BOOL_FIELD(nulls_first);
-	READ_BOOL_FIELD(hashable);
-
-	READ_DONE();
-}
-
-/*
- * _readGroupingSet
- */
-static GroupingSet *
-_readGroupingSet(void)
-{
-	READ_LOCALS(GroupingSet);
-
-	READ_ENUM_FIELD(kind, GroupingSetKind);
-	READ_NODE_FIELD(content);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readWindowClause
- */
-static WindowClause *
-_readWindowClause(void)
-{
-	READ_LOCALS(WindowClause);
-
-	READ_STRING_FIELD(name);
-	READ_STRING_FIELD(refname);
-	READ_NODE_FIELD(partitionClause);
-	READ_NODE_FIELD(orderClause);
-	READ_INT_FIELD(frameOptions);
-	READ_NODE_FIELD(startOffset);
-	READ_NODE_FIELD(endOffset);
-	READ_NODE_FIELD(runCondition);
-	READ_OID_FIELD(startInRangeFunc);
-	READ_OID_FIELD(endInRangeFunc);
-	READ_OID_FIELD(inRangeColl);
-	READ_BOOL_FIELD(inRangeAsc);
-	READ_BOOL_FIELD(inRangeNullsFirst);
-	READ_UINT_FIELD(winref);
-	READ_BOOL_FIELD(copiedOrder);
-
-	READ_DONE();
-}
-
-/*
- * _readRowMarkClause
- */
-static RowMarkClause *
-_readRowMarkClause(void)
-{
-	READ_LOCALS(RowMarkClause);
-
-	READ_UINT_FIELD(rti);
-	READ_ENUM_FIELD(strength, LockClauseStrength);
-	READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
-	READ_BOOL_FIELD(pushedDown);
-
-	READ_DONE();
-}
-
-/*
- * _readCTESearchClause
- */
-static CTESearchClause *
-_readCTESearchClause(void)
-{
-	READ_LOCALS(CTESearchClause);
-
-	READ_NODE_FIELD(search_col_list);
-	READ_BOOL_FIELD(search_breadth_first);
-	READ_STRING_FIELD(search_seq_column);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCTECycleClause
- */
-static CTECycleClause *
-_readCTECycleClause(void)
-{
-	READ_LOCALS(CTECycleClause);
-
-	READ_NODE_FIELD(cycle_col_list);
-	READ_STRING_FIELD(cycle_mark_column);
-	READ_NODE_FIELD(cycle_mark_value);
-	READ_NODE_FIELD(cycle_mark_default);
-	READ_STRING_FIELD(cycle_path_column);
-	READ_LOCATION_FIELD(location);
-	READ_OID_FIELD(cycle_mark_type);
-	READ_INT_FIELD(cycle_mark_typmod);
-	READ_OID_FIELD(cycle_mark_collation);
-	READ_OID_FIELD(cycle_mark_neop);
-
-	READ_DONE();
-}
-
-/*
- * _readCommonTableExpr
- */
-static CommonTableExpr *
-_readCommonTableExpr(void)
-{
-	READ_LOCALS(CommonTableExpr);
-
-	READ_STRING_FIELD(ctename);
-	READ_NODE_FIELD(aliascolnames);
-	READ_ENUM_FIELD(ctematerialized, CTEMaterialize);
-	READ_NODE_FIELD(ctequery);
-	READ_NODE_FIELD(search_clause);
-	READ_NODE_FIELD(cycle_clause);
-	READ_LOCATION_FIELD(location);
-	READ_BOOL_FIELD(cterecursive);
-	READ_INT_FIELD(cterefcount);
-	READ_NODE_FIELD(ctecolnames);
-	READ_NODE_FIELD(ctecoltypes);
-	READ_NODE_FIELD(ctecoltypmods);
-	READ_NODE_FIELD(ctecolcollations);
-
-	READ_DONE();
-}
-
-/*
- * _readMergeWhenClause
- */
-static MergeWhenClause *
-_readMergeWhenClause(void)
-{
-	READ_LOCALS(MergeWhenClause);
-
-	READ_BOOL_FIELD(matched);
-	READ_ENUM_FIELD(commandType, CmdType);
-	READ_ENUM_FIELD(override, OverridingKind);
-	READ_NODE_FIELD(condition);
-	READ_NODE_FIELD(targetList);
-	READ_NODE_FIELD(values);
-
-	READ_DONE();
-}
-
-/*
- * _readMergeAction
- */
-static MergeAction *
-_readMergeAction(void)
-{
-	READ_LOCALS(MergeAction);
-
-	READ_BOOL_FIELD(matched);
-	READ_ENUM_FIELD(commandType, CmdType);
-	READ_ENUM_FIELD(override, OverridingKind);
-	READ_NODE_FIELD(qual);
-	READ_NODE_FIELD(targetList);
-	READ_NODE_FIELD(updateColnos);
-
-	READ_DONE();
-}
-
-/*
- * _readSetOperationStmt
- */
-static SetOperationStmt *
-_readSetOperationStmt(void)
-{
-	READ_LOCALS(SetOperationStmt);
-
-	READ_ENUM_FIELD(op, SetOperation);
-	READ_BOOL_FIELD(all);
-	READ_NODE_FIELD(larg);
-	READ_NODE_FIELD(rarg);
-	READ_NODE_FIELD(colTypes);
-	READ_NODE_FIELD(colTypmods);
-	READ_NODE_FIELD(colCollations);
-	READ_NODE_FIELD(groupClauses);
-
-	READ_DONE();
-}
-
-
-/*
- *	Stuff from primnodes.h.
- */
-
-static Alias *
-_readAlias(void)
-{
-	READ_LOCALS(Alias);
-
-	READ_STRING_FIELD(aliasname);
-	READ_NODE_FIELD(colnames);
-
-	READ_DONE();
-}
-
-static RangeVar *
-_readRangeVar(void)
-{
-	READ_LOCALS(RangeVar);
-
-	local_node->catalogname = NULL; /* not currently saved in output format */
-
-	READ_STRING_FIELD(schemaname);
-	READ_STRING_FIELD(relname);
-	READ_BOOL_FIELD(inh);
-	READ_CHAR_FIELD(relpersistence);
-	READ_NODE_FIELD(alias);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readTableFunc
- */
-static TableFunc *
-_readTableFunc(void)
-{
-	READ_LOCALS(TableFunc);
-
-	READ_ENUM_FIELD(functype, TableFuncType);
-	READ_NODE_FIELD(ns_uris);
-	READ_NODE_FIELD(ns_names);
-	READ_NODE_FIELD(docexpr);
-	READ_NODE_FIELD(rowexpr);
-	READ_NODE_FIELD(colnames);
-	READ_NODE_FIELD(coltypes);
-	READ_NODE_FIELD(coltypmods);
-	READ_NODE_FIELD(colcollations);
-	READ_NODE_FIELD(colexprs);
-	READ_NODE_FIELD(coldefexprs);
-	READ_NODE_FIELD(colvalexprs);
-	READ_BITMAPSET_FIELD(notnulls);
-	READ_NODE_FIELD(plan);
-	READ_INT_FIELD(ordinalitycol);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-static IntoClause *
-_readIntoClause(void)
-{
-	READ_LOCALS(IntoClause);
-
-	READ_NODE_FIELD(rel);
-	READ_NODE_FIELD(colNames);
-	READ_STRING_FIELD(accessMethod);
-	READ_NODE_FIELD(options);
-	READ_ENUM_FIELD(onCommit, OnCommitAction);
-	READ_STRING_FIELD(tableSpaceName);
-	READ_NODE_FIELD(viewQuery);
-	READ_BOOL_FIELD(skipData);
-
-	READ_DONE();
-}
-
-/*
- * _readVar
- */
-static Var *
-_readVar(void)
-{
-	READ_LOCALS(Var);
-
-	READ_INT_FIELD(varno);
-	READ_INT_FIELD(varattno);
-	READ_OID_FIELD(vartype);
-	READ_INT_FIELD(vartypmod);
-	READ_OID_FIELD(varcollid);
-	READ_UINT_FIELD(varlevelsup);
-	READ_UINT_FIELD(varnosyn);
-	READ_INT_FIELD(varattnosyn);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-#endif							/* OBSOLETE */
-
-/*
- * _readConst
- */
 static Const *
 _readConst(void)
 {
@@ -657,237 +316,6 @@ _readConst(void)
 	READ_DONE();
 }
 
-#ifdef OBSOLETE
-/*
- * _readParam
- */
-static Param *
-_readParam(void)
-{
-	READ_LOCALS(Param);
-
-	READ_ENUM_FIELD(paramkind, ParamKind);
-	READ_INT_FIELD(paramid);
-	READ_OID_FIELD(paramtype);
-	READ_INT_FIELD(paramtypmod);
-	READ_OID_FIELD(paramcollid);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readAggref
- */
-static Aggref *
-_readAggref(void)
-{
-	READ_LOCALS(Aggref);
-
-	READ_OID_FIELD(aggfnoid);
-	READ_OID_FIELD(aggtype);
-	READ_OID_FIELD(aggcollid);
-	READ_OID_FIELD(inputcollid);
-	READ_OID_FIELD(aggtranstype);
-	READ_NODE_FIELD(aggargtypes);
-	READ_NODE_FIELD(aggdirectargs);
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(aggorder);
-	READ_NODE_FIELD(aggdistinct);
-	READ_NODE_FIELD(aggfilter);
-	READ_BOOL_FIELD(aggstar);
-	READ_BOOL_FIELD(aggvariadic);
-	READ_CHAR_FIELD(aggkind);
-	READ_UINT_FIELD(agglevelsup);
-	READ_ENUM_FIELD(aggsplit, AggSplit);
-	READ_INT_FIELD(aggno);
-	READ_INT_FIELD(aggtransno);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readGroupingFunc
- */
-static GroupingFunc *
-_readGroupingFunc(void)
-{
-	READ_LOCALS(GroupingFunc);
-
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(refs);
-	READ_NODE_FIELD(cols);
-	READ_UINT_FIELD(agglevelsup);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readWindowFunc
- */
-static WindowFunc *
-_readWindowFunc(void)
-{
-	READ_LOCALS(WindowFunc);
-
-	READ_OID_FIELD(winfnoid);
-	READ_OID_FIELD(wintype);
-	READ_OID_FIELD(wincollid);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(aggfilter);
-	READ_UINT_FIELD(winref);
-	READ_BOOL_FIELD(winstar);
-	READ_BOOL_FIELD(winagg);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readSubscriptingRef
- */
-static SubscriptingRef *
-_readSubscriptingRef(void)
-{
-	READ_LOCALS(SubscriptingRef);
-
-	READ_OID_FIELD(refcontainertype);
-	READ_OID_FIELD(refelemtype);
-	READ_OID_FIELD(refrestype);
-	READ_INT_FIELD(reftypmod);
-	READ_OID_FIELD(refcollid);
-	READ_NODE_FIELD(refupperindexpr);
-	READ_NODE_FIELD(reflowerindexpr);
-	READ_NODE_FIELD(refexpr);
-	READ_NODE_FIELD(refassgnexpr);
-
-	READ_DONE();
-}
-
-/*
- * _readFuncExpr
- */
-static FuncExpr *
-_readFuncExpr(void)
-{
-	READ_LOCALS(FuncExpr);
-
-	READ_OID_FIELD(funcid);
-	READ_OID_FIELD(funcresulttype);
-	READ_BOOL_FIELD(funcretset);
-	READ_BOOL_FIELD(funcvariadic);
-	READ_ENUM_FIELD(funcformat, CoercionForm);
-	READ_OID_FIELD(funccollid);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readNamedArgExpr
- */
-static NamedArgExpr *
-_readNamedArgExpr(void)
-{
-	READ_LOCALS(NamedArgExpr);
-
-	READ_NODE_FIELD(arg);
-	READ_STRING_FIELD(name);
-	READ_INT_FIELD(argnumber);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readOpExpr
- */
-static OpExpr *
-_readOpExpr(void)
-{
-	READ_LOCALS(OpExpr);
-
-	READ_OID_FIELD(opno);
-	READ_OID_FIELD(opfuncid);
-	READ_OID_FIELD(opresulttype);
-	READ_BOOL_FIELD(opretset);
-	READ_OID_FIELD(opcollid);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readDistinctExpr
- */
-static DistinctExpr *
-_readDistinctExpr(void)
-{
-	READ_LOCALS(DistinctExpr);
-
-	READ_OID_FIELD(opno);
-	READ_OID_FIELD(opfuncid);
-	READ_OID_FIELD(opresulttype);
-	READ_BOOL_FIELD(opretset);
-	READ_OID_FIELD(opcollid);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readNullIfExpr
- */
-static NullIfExpr *
-_readNullIfExpr(void)
-{
-	READ_LOCALS(NullIfExpr);
-
-	READ_OID_FIELD(opno);
-	READ_OID_FIELD(opfuncid);
-	READ_OID_FIELD(opresulttype);
-	READ_BOOL_FIELD(opretset);
-	READ_OID_FIELD(opcollid);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readScalarArrayOpExpr
- */
-static ScalarArrayOpExpr *
-_readScalarArrayOpExpr(void)
-{
-	READ_LOCALS(ScalarArrayOpExpr);
-
-	READ_OID_FIELD(opno);
-	READ_OID_FIELD(opfuncid);
-	READ_OID_FIELD(hashfuncid);
-	READ_OID_FIELD(negfuncid);
-	READ_BOOL_FIELD(useOr);
-	READ_OID_FIELD(inputcollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-#endif							/* OBSOLETE */
-
-/*
- * _readBoolExpr
- */
 static BoolExpr *
 _readBoolExpr(void)
 {
@@ -911,754 +339,6 @@ _readBoolExpr(void)
 	READ_DONE();
 }
 
-#ifdef OBSOLETE
-/*
- * _readSubLink
- */
-static SubLink *
-_readSubLink(void)
-{
-	READ_LOCALS(SubLink);
-
-	READ_ENUM_FIELD(subLinkType, SubLinkType);
-	READ_INT_FIELD(subLinkId);
-	READ_NODE_FIELD(testexpr);
-	READ_NODE_FIELD(operName);
-	READ_NODE_FIELD(subselect);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readSubPlan is not needed since it doesn't appear in stored rules.
- */
-
-/*
- * _readFieldSelect
- */
-static FieldSelect *
-_readFieldSelect(void)
-{
-	READ_LOCALS(FieldSelect);
-
-	READ_NODE_FIELD(arg);
-	READ_INT_FIELD(fieldnum);
-	READ_OID_FIELD(resulttype);
-	READ_INT_FIELD(resulttypmod);
-	READ_OID_FIELD(resultcollid);
-
-	READ_DONE();
-}
-
-/*
- * _readFieldStore
- */
-static FieldStore *
-_readFieldStore(void)
-{
-	READ_LOCALS(FieldStore);
-
-	READ_NODE_FIELD(arg);
-	READ_NODE_FIELD(newvals);
-	READ_NODE_FIELD(fieldnums);
-	READ_OID_FIELD(resulttype);
-
-	READ_DONE();
-}
-
-/*
- * _readRelabelType
- */
-static RelabelType *
-_readRelabelType(void)
-{
-	READ_LOCALS(RelabelType);
-
-	READ_NODE_FIELD(arg);
-	READ_OID_FIELD(resulttype);
-	READ_INT_FIELD(resulttypmod);
-	READ_OID_FIELD(resultcollid);
-	READ_ENUM_FIELD(relabelformat, CoercionForm);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCoerceViaIO
- */
-static CoerceViaIO *
-_readCoerceViaIO(void)
-{
-	READ_LOCALS(CoerceViaIO);
-
-	READ_NODE_FIELD(arg);
-	READ_OID_FIELD(resulttype);
-	READ_OID_FIELD(resultcollid);
-	READ_ENUM_FIELD(coerceformat, CoercionForm);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readArrayCoerceExpr
- */
-static ArrayCoerceExpr *
-_readArrayCoerceExpr(void)
-{
-	READ_LOCALS(ArrayCoerceExpr);
-
-	READ_NODE_FIELD(arg);
-	READ_NODE_FIELD(elemexpr);
-	READ_OID_FIELD(resulttype);
-	READ_INT_FIELD(resulttypmod);
-	READ_OID_FIELD(resultcollid);
-	READ_ENUM_FIELD(coerceformat, CoercionForm);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readConvertRowtypeExpr
- */
-static ConvertRowtypeExpr *
-_readConvertRowtypeExpr(void)
-{
-	READ_LOCALS(ConvertRowtypeExpr);
-
-	READ_NODE_FIELD(arg);
-	READ_OID_FIELD(resulttype);
-	READ_ENUM_FIELD(convertformat, CoercionForm);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCollateExpr
- */
-static CollateExpr *
-_readCollateExpr(void)
-{
-	READ_LOCALS(CollateExpr);
-
-	READ_NODE_FIELD(arg);
-	READ_OID_FIELD(collOid);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCaseExpr
- */
-static CaseExpr *
-_readCaseExpr(void)
-{
-	READ_LOCALS(CaseExpr);
-
-	READ_OID_FIELD(casetype);
-	READ_OID_FIELD(casecollid);
-	READ_NODE_FIELD(arg);
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(defresult);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCaseWhen
- */
-static CaseWhen *
-_readCaseWhen(void)
-{
-	READ_LOCALS(CaseWhen);
-
-	READ_NODE_FIELD(expr);
-	READ_NODE_FIELD(result);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCaseTestExpr
- */
-static CaseTestExpr *
-_readCaseTestExpr(void)
-{
-	READ_LOCALS(CaseTestExpr);
-
-	READ_OID_FIELD(typeId);
-	READ_INT_FIELD(typeMod);
-	READ_OID_FIELD(collation);
-
-	READ_DONE();
-}
-
-/*
- * _readArrayExpr
- */
-static ArrayExpr *
-_readArrayExpr(void)
-{
-	READ_LOCALS(ArrayExpr);
-
-	READ_OID_FIELD(array_typeid);
-	READ_OID_FIELD(array_collid);
-	READ_OID_FIELD(element_typeid);
-	READ_NODE_FIELD(elements);
-	READ_BOOL_FIELD(multidims);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readRowExpr
- */
-static RowExpr *
-_readRowExpr(void)
-{
-	READ_LOCALS(RowExpr);
-
-	READ_NODE_FIELD(args);
-	READ_OID_FIELD(row_typeid);
-	READ_ENUM_FIELD(row_format, CoercionForm);
-	READ_NODE_FIELD(colnames);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readRowCompareExpr
- */
-static RowCompareExpr *
-_readRowCompareExpr(void)
-{
-	READ_LOCALS(RowCompareExpr);
-
-	READ_ENUM_FIELD(rctype, RowCompareType);
-	READ_NODE_FIELD(opnos);
-	READ_NODE_FIELD(opfamilies);
-	READ_NODE_FIELD(inputcollids);
-	READ_NODE_FIELD(largs);
-	READ_NODE_FIELD(rargs);
-
-	READ_DONE();
-}
-
-/*
- * _readCoalesceExpr
- */
-static CoalesceExpr *
-_readCoalesceExpr(void)
-{
-	READ_LOCALS(CoalesceExpr);
-
-	READ_OID_FIELD(coalescetype);
-	READ_OID_FIELD(coalescecollid);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readMinMaxExpr
- */
-static MinMaxExpr *
-_readMinMaxExpr(void)
-{
-	READ_LOCALS(MinMaxExpr);
-
-	READ_OID_FIELD(minmaxtype);
-	READ_OID_FIELD(minmaxcollid);
-	READ_OID_FIELD(inputcollid);
-	READ_ENUM_FIELD(op, MinMaxOp);
-	READ_NODE_FIELD(args);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readSQLValueFunction
- */
-static SQLValueFunction *
-_readSQLValueFunction(void)
-{
-	READ_LOCALS(SQLValueFunction);
-
-	READ_ENUM_FIELD(op, SQLValueFunctionOp);
-	READ_OID_FIELD(type);
-	READ_INT_FIELD(typmod);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readXmlExpr
- */
-static XmlExpr *
-_readXmlExpr(void)
-{
-	READ_LOCALS(XmlExpr);
-
-	READ_ENUM_FIELD(op, XmlExprOp);
-	READ_STRING_FIELD(name);
-	READ_NODE_FIELD(named_args);
-	READ_NODE_FIELD(arg_names);
-	READ_NODE_FIELD(args);
-	READ_ENUM_FIELD(xmloption, XmlOptionType);
-	READ_OID_FIELD(type);
-	READ_INT_FIELD(typmod);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readNullTest
- */
-static NullTest *
-_readNullTest(void)
-{
-	READ_LOCALS(NullTest);
-
-	READ_NODE_FIELD(arg);
-	READ_ENUM_FIELD(nulltesttype, NullTestType);
-	READ_BOOL_FIELD(argisrow);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readBooleanTest
- */
-static BooleanTest *
-_readBooleanTest(void)
-{
-	READ_LOCALS(BooleanTest);
-
-	READ_NODE_FIELD(arg);
-	READ_ENUM_FIELD(booltesttype, BoolTestType);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCoerceToDomain
- */
-static CoerceToDomain *
-_readCoerceToDomain(void)
-{
-	READ_LOCALS(CoerceToDomain);
-
-	READ_NODE_FIELD(arg);
-	READ_OID_FIELD(resulttype);
-	READ_INT_FIELD(resulttypmod);
-	READ_OID_FIELD(resultcollid);
-	READ_ENUM_FIELD(coercionformat, CoercionForm);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCoerceToDomainValue
- */
-static CoerceToDomainValue *
-_readCoerceToDomainValue(void)
-{
-	READ_LOCALS(CoerceToDomainValue);
-
-	READ_OID_FIELD(typeId);
-	READ_INT_FIELD(typeMod);
-	READ_OID_FIELD(collation);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readSetToDefault
- */
-static SetToDefault *
-_readSetToDefault(void)
-{
-	READ_LOCALS(SetToDefault);
-
-	READ_OID_FIELD(typeId);
-	READ_INT_FIELD(typeMod);
-	READ_OID_FIELD(collation);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readCurrentOfExpr
- */
-static CurrentOfExpr *
-_readCurrentOfExpr(void)
-{
-	READ_LOCALS(CurrentOfExpr);
-
-	READ_UINT_FIELD(cvarno);
-	READ_STRING_FIELD(cursor_name);
-	READ_INT_FIELD(cursor_param);
-
-	READ_DONE();
-}
-
-/*
- * _readNextValueExpr
- */
-static NextValueExpr *
-_readNextValueExpr(void)
-{
-	READ_LOCALS(NextValueExpr);
-
-	READ_OID_FIELD(seqid);
-	READ_OID_FIELD(typeId);
-
-	READ_DONE();
-}
-
-/*
- * _readInferenceElem
- */
-static InferenceElem *
-_readInferenceElem(void)
-{
-	READ_LOCALS(InferenceElem);
-
-	READ_NODE_FIELD(expr);
-	READ_OID_FIELD(infercollid);
-	READ_OID_FIELD(inferopclass);
-
-	READ_DONE();
-}
-
-/*
- * _readTargetEntry
- */
-static TargetEntry *
-_readTargetEntry(void)
-{
-	READ_LOCALS(TargetEntry);
-
-	READ_NODE_FIELD(expr);
-	READ_INT_FIELD(resno);
-	READ_STRING_FIELD(resname);
-	READ_UINT_FIELD(ressortgroupref);
-	READ_OID_FIELD(resorigtbl);
-	READ_INT_FIELD(resorigcol);
-	READ_BOOL_FIELD(resjunk);
-
-	READ_DONE();
-}
-
-/*
- * _readRangeTblRef
- */
-static RangeTblRef *
-_readRangeTblRef(void)
-{
-	READ_LOCALS(RangeTblRef);
-
-	READ_INT_FIELD(rtindex);
-
-	READ_DONE();
-}
-
-/*
- * _readJoinExpr
- */
-static JoinExpr *
-_readJoinExpr(void)
-{
-	READ_LOCALS(JoinExpr);
-
-	READ_ENUM_FIELD(jointype, JoinType);
-	READ_BOOL_FIELD(isNatural);
-	READ_NODE_FIELD(larg);
-	READ_NODE_FIELD(rarg);
-	READ_NODE_FIELD(usingClause);
-	READ_NODE_FIELD(join_using_alias);
-	READ_NODE_FIELD(quals);
-	READ_NODE_FIELD(alias);
-	READ_INT_FIELD(rtindex);
-
-	READ_DONE();
-}
-
-/*
- * _readFromExpr
- */
-static FromExpr *
-_readFromExpr(void)
-{
-	READ_LOCALS(FromExpr);
-
-	READ_NODE_FIELD(fromlist);
-	READ_NODE_FIELD(quals);
-
-	READ_DONE();
-}
-
-/*
- * _readOnConflictExpr
- */
-static OnConflictExpr *
-_readOnConflictExpr(void)
-{
-	READ_LOCALS(OnConflictExpr);
-
-	READ_ENUM_FIELD(action, OnConflictAction);
-	READ_NODE_FIELD(arbiterElems);
-	READ_NODE_FIELD(arbiterWhere);
-	READ_OID_FIELD(constraint);
-	READ_NODE_FIELD(onConflictSet);
-	READ_NODE_FIELD(onConflictWhere);
-	READ_INT_FIELD(exclRelIndex);
-	READ_NODE_FIELD(exclRelTlist);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonFormat
- */
-static JsonFormat *
-_readJsonFormat(void)
-{
-	READ_LOCALS(JsonFormat);
-
-	READ_ENUM_FIELD(format_type, JsonFormatType);
-	READ_ENUM_FIELD(encoding, JsonEncoding);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonReturning
- */
-static JsonReturning *
-_readJsonReturning(void)
-{
-	READ_LOCALS(JsonReturning);
-
-	READ_NODE_FIELD(format);
-	READ_OID_FIELD(typid);
-	READ_INT_FIELD(typmod);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonValueExpr
- */
-static JsonValueExpr *
-_readJsonValueExpr(void)
-{
-	READ_LOCALS(JsonValueExpr);
-
-	READ_NODE_FIELD(raw_expr);
-	READ_NODE_FIELD(formatted_expr);
-	READ_NODE_FIELD(format);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonConstructorExpr
- */
-static JsonConstructorExpr *
-_readJsonConstructorExpr(void)
-{
-	READ_LOCALS(JsonConstructorExpr);
-
-	READ_ENUM_FIELD(type, JsonConstructorType);
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(func);
-	READ_NODE_FIELD(coercion);
-	READ_NODE_FIELD(returning);
-	READ_BOOL_FIELD(absent_on_null);
-	READ_BOOL_FIELD(unique);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonBehavior
- */
-static JsonBehavior *
-_readJsonBehavior(void)
-{
-	READ_LOCALS(JsonBehavior);
-
-	READ_ENUM_FIELD(btype, JsonBehaviorType);
-	READ_NODE_FIELD(default_expr);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonExpr
- */
-static JsonExpr *
-_readJsonExpr(void)
-{
-	READ_LOCALS(JsonExpr);
-
-	READ_ENUM_FIELD(op, JsonExprOp);
-	READ_NODE_FIELD(formatted_expr);
-	READ_NODE_FIELD(result_coercion);
-	READ_NODE_FIELD(format);
-	READ_NODE_FIELD(path_spec);
-	READ_NODE_FIELD(passing_names);
-	READ_NODE_FIELD(passing_values);
-	READ_NODE_FIELD(returning);
-	READ_NODE_FIELD(on_empty);
-	READ_NODE_FIELD(on_error);
-	READ_NODE_FIELD(coercions);
-	READ_ENUM_FIELD(wrapper, JsonWrapper);
-	READ_BOOL_FIELD(omit_quotes);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-static JsonTableParent *
-_readJsonTableParent(void)
-{
-	READ_LOCALS(JsonTableParent);
-
-	READ_NODE_FIELD(path);
-	READ_STRING_FIELD(name);
-	READ_NODE_FIELD(child);
-	READ_BOOL_FIELD(outerJoin);
-	READ_INT_FIELD(colMin);
-	READ_INT_FIELD(colMax);
-	READ_BOOL_FIELD(errorOnError);
-
-	READ_DONE();
-}
-
-static JsonTableSibling *
-_readJsonTableSibling(void)
-{
-	READ_LOCALS(JsonTableSibling);
-
-	READ_NODE_FIELD(larg);
-	READ_NODE_FIELD(rarg);
-	READ_BOOL_FIELD(cross);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonCoercion
- */
-static JsonCoercion *
-_readJsonCoercion(void)
-{
-	READ_LOCALS(JsonCoercion);
-
-	READ_NODE_FIELD(expr);
-	READ_BOOL_FIELD(via_populate);
-	READ_BOOL_FIELD(via_io);
-	READ_OID_FIELD(collation);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonItemCoercions
- */
-static JsonItemCoercions *
-_readJsonItemCoercions(void)
-{
-	READ_LOCALS(JsonItemCoercions);
-
-	READ_NODE_FIELD(null);
-	READ_NODE_FIELD(string);
-	READ_NODE_FIELD(numeric);
-	READ_NODE_FIELD(boolean);
-	READ_NODE_FIELD(date);
-	READ_NODE_FIELD(time);
-	READ_NODE_FIELD(timetz);
-	READ_NODE_FIELD(timestamp);
-	READ_NODE_FIELD(timestamptz);
-	READ_NODE_FIELD(composite);
-
-	READ_DONE();
-}
-
-/*
- * _readJsonIsPredicate
- */
-static JsonIsPredicate *
-_readJsonIsPredicate()
-{
-	READ_LOCALS(JsonIsPredicate);
-
-	READ_NODE_FIELD(expr);
-	READ_NODE_FIELD(format);
-	READ_ENUM_FIELD(item_type, JsonValueType);
-	READ_BOOL_FIELD(unique_keys);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- *	Stuff from pathnodes.h.
- *
- * Mostly we don't need to read planner nodes back in again, but some
- * of these also end up in plan trees.
- */
-
-/*
- * _readAppendRelInfo
- */
-static AppendRelInfo *
-_readAppendRelInfo(void)
-{
-	READ_LOCALS(AppendRelInfo);
-
-	READ_UINT_FIELD(parent_relid);
-	READ_UINT_FIELD(child_relid);
-	READ_OID_FIELD(parent_reltype);
-	READ_OID_FIELD(child_reltype);
-	READ_NODE_FIELD(translated_vars);
-	READ_INT_FIELD(num_child_cols);
-	READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols);
-	READ_OID_FIELD(parent_reloid);
-
-	READ_DONE();
-}
-
-/*
- *	Stuff from parsenodes.h.
- */
-#endif							/* OBSOLETE */
-
-/*
- * _readRangeTblEntry
- */
 static RangeTblEntry *
 _readRangeTblEntry(void)
 {
@@ -1750,1114 +430,6 @@ _readRangeTblEntry(void)
 	READ_DONE();
 }
 
-#ifdef OBSOLETE
-/*
- * _readRangeTblFunction
- */
-static RangeTblFunction *
-_readRangeTblFunction(void)
-{
-	READ_LOCALS(RangeTblFunction);
-
-	READ_NODE_FIELD(funcexpr);
-	READ_INT_FIELD(funccolcount);
-	READ_NODE_FIELD(funccolnames);
-	READ_NODE_FIELD(funccoltypes);
-	READ_NODE_FIELD(funccoltypmods);
-	READ_NODE_FIELD(funccolcollations);
-	READ_BITMAPSET_FIELD(funcparams);
-
-	READ_DONE();
-}
-
-/*
- * _readTableSampleClause
- */
-static TableSampleClause *
-_readTableSampleClause(void)
-{
-	READ_LOCALS(TableSampleClause);
-
-	READ_OID_FIELD(tsmhandler);
-	READ_NODE_FIELD(args);
-	READ_NODE_FIELD(repeatable);
-
-	READ_DONE();
-}
-
-/*
- * _readDefElem
- */
-static DefElem *
-_readDefElem(void)
-{
-	READ_LOCALS(DefElem);
-
-	READ_STRING_FIELD(defnamespace);
-	READ_STRING_FIELD(defname);
-	READ_NODE_FIELD(arg);
-	READ_ENUM_FIELD(defaction, DefElemAction);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- *	Stuff from plannodes.h.
- */
-
-/*
- * _readPlannedStmt
- */
-static PlannedStmt *
-_readPlannedStmt(void)
-{
-	READ_LOCALS(PlannedStmt);
-
-	READ_ENUM_FIELD(commandType, CmdType);
-	READ_UINT64_FIELD(queryId);
-	READ_BOOL_FIELD(hasReturning);
-	READ_BOOL_FIELD(hasModifyingCTE);
-	READ_BOOL_FIELD(canSetTag);
-	READ_BOOL_FIELD(transientPlan);
-	READ_BOOL_FIELD(dependsOnRole);
-	READ_BOOL_FIELD(parallelModeNeeded);
-	READ_INT_FIELD(jitFlags);
-	READ_NODE_FIELD(planTree);
-	READ_NODE_FIELD(rtable);
-	READ_NODE_FIELD(resultRelations);
-	READ_NODE_FIELD(appendRelations);
-	READ_NODE_FIELD(subplans);
-	READ_BITMAPSET_FIELD(rewindPlanIDs);
-	READ_NODE_FIELD(rowMarks);
-	READ_NODE_FIELD(relationOids);
-	READ_NODE_FIELD(invalItems);
-	READ_NODE_FIELD(paramExecTypes);
-	READ_NODE_FIELD(utilityStmt);
-	READ_LOCATION_FIELD(stmt_location);
-	READ_INT_FIELD(stmt_len);
-
-	READ_DONE();
-}
-
-/*
- * ReadCommonPlan
- *	Assign the basic stuff of all nodes that inherit from Plan
- */
-static void
-ReadCommonPlan(Plan *local_node)
-{
-	READ_TEMP_LOCALS();
-
-	READ_FLOAT_FIELD(startup_cost);
-	READ_FLOAT_FIELD(total_cost);
-	READ_FLOAT_FIELD(plan_rows);
-	READ_INT_FIELD(plan_width);
-	READ_BOOL_FIELD(parallel_aware);
-	READ_BOOL_FIELD(parallel_safe);
-	READ_BOOL_FIELD(async_capable);
-	READ_INT_FIELD(plan_node_id);
-	READ_NODE_FIELD(targetlist);
-	READ_NODE_FIELD(qual);
-	READ_NODE_FIELD(lefttree);
-	READ_NODE_FIELD(righttree);
-	READ_NODE_FIELD(initPlan);
-	READ_BITMAPSET_FIELD(extParam);
-	READ_BITMAPSET_FIELD(allParam);
-}
-
-/*
- * _readResult
- */
-static Result *
-_readResult(void)
-{
-	READ_LOCALS(Result);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_NODE_FIELD(resconstantqual);
-
-	READ_DONE();
-}
-
-/*
- * _readProjectSet
- */
-static ProjectSet *
-_readProjectSet(void)
-{
-	READ_LOCALS_NO_FIELDS(ProjectSet);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_DONE();
-}
-
-/*
- * _readModifyTable
- */
-static ModifyTable *
-_readModifyTable(void)
-{
-	READ_LOCALS(ModifyTable);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_ENUM_FIELD(operation, CmdType);
-	READ_BOOL_FIELD(canSetTag);
-	READ_UINT_FIELD(nominalRelation);
-	READ_UINT_FIELD(rootRelation);
-	READ_BOOL_FIELD(partColsUpdated);
-	READ_NODE_FIELD(resultRelations);
-	READ_NODE_FIELD(updateColnosLists);
-	READ_NODE_FIELD(withCheckOptionLists);
-	READ_NODE_FIELD(returningLists);
-	READ_NODE_FIELD(fdwPrivLists);
-	READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
-	READ_NODE_FIELD(rowMarks);
-	READ_INT_FIELD(epqParam);
-	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
-	READ_NODE_FIELD(arbiterIndexes);
-	READ_NODE_FIELD(onConflictSet);
-	READ_NODE_FIELD(onConflictCols);
-	READ_NODE_FIELD(onConflictWhere);
-	READ_UINT_FIELD(exclRelRTI);
-	READ_NODE_FIELD(exclRelTlist);
-	READ_NODE_FIELD(mergeActionLists);
-
-	READ_DONE();
-}
-
-/*
- * _readAppend
- */
-static Append *
-_readAppend(void)
-{
-	READ_LOCALS(Append);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_BITMAPSET_FIELD(apprelids);
-	READ_NODE_FIELD(appendplans);
-	READ_INT_FIELD(nasyncplans);
-	READ_INT_FIELD(first_partial_plan);
-	READ_NODE_FIELD(part_prune_info);
-
-	READ_DONE();
-}
-
-/*
- * _readMergeAppend
- */
-static MergeAppend *
-_readMergeAppend(void)
-{
-	READ_LOCALS(MergeAppend);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_BITMAPSET_FIELD(apprelids);
-	READ_NODE_FIELD(mergeplans);
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
-	READ_OID_ARRAY(sortOperators, local_node->numCols);
-	READ_OID_ARRAY(collations, local_node->numCols);
-	READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
-	READ_NODE_FIELD(part_prune_info);
-
-	READ_DONE();
-}
-
-/*
- * _readRecursiveUnion
- */
-static RecursiveUnion *
-_readRecursiveUnion(void)
-{
-	READ_LOCALS(RecursiveUnion);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(wtParam);
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
-	READ_OID_ARRAY(dupOperators, local_node->numCols);
-	READ_OID_ARRAY(dupCollations, local_node->numCols);
-	READ_LONG_FIELD(numGroups);
-
-	READ_DONE();
-}
-
-/*
- * _readBitmapAnd
- */
-static BitmapAnd *
-_readBitmapAnd(void)
-{
-	READ_LOCALS(BitmapAnd);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_NODE_FIELD(bitmapplans);
-
-	READ_DONE();
-}
-
-/*
- * _readBitmapOr
- */
-static BitmapOr *
-_readBitmapOr(void)
-{
-	READ_LOCALS(BitmapOr);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_BOOL_FIELD(isshared);
-	READ_NODE_FIELD(bitmapplans);
-
-	READ_DONE();
-}
-
-/*
- * ReadCommonScan
- *	Assign the basic stuff of all nodes that inherit from Scan
- */
-static void
-ReadCommonScan(Scan *local_node)
-{
-	READ_TEMP_LOCALS();
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_UINT_FIELD(scanrelid);
-}
-
-/*
- * _readScan
- */
-static Scan *
-_readScan(void)
-{
-	READ_LOCALS_NO_FIELDS(Scan);
-
-	ReadCommonScan(local_node);
-
-	READ_DONE();
-}
-
-/*
- * _readSeqScan
- */
-static SeqScan *
-_readSeqScan(void)
-{
-	READ_LOCALS_NO_FIELDS(SeqScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_DONE();
-}
-
-/*
- * _readSampleScan
- */
-static SampleScan *
-_readSampleScan(void)
-{
-	READ_LOCALS(SampleScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(tablesample);
-
-	READ_DONE();
-}
-
-/*
- * _readIndexScan
- */
-static IndexScan *
-_readIndexScan(void)
-{
-	READ_LOCALS(IndexScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_OID_FIELD(indexid);
-	READ_NODE_FIELD(indexqual);
-	READ_NODE_FIELD(indexqualorig);
-	READ_NODE_FIELD(indexorderby);
-	READ_NODE_FIELD(indexorderbyorig);
-	READ_NODE_FIELD(indexorderbyops);
-	READ_ENUM_FIELD(indexorderdir, ScanDirection);
-
-	READ_DONE();
-}
-
-/*
- * _readIndexOnlyScan
- */
-static IndexOnlyScan *
-_readIndexOnlyScan(void)
-{
-	READ_LOCALS(IndexOnlyScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_OID_FIELD(indexid);
-	READ_NODE_FIELD(indexqual);
-	READ_NODE_FIELD(recheckqual);
-	READ_NODE_FIELD(indexorderby);
-	READ_NODE_FIELD(indextlist);
-	READ_ENUM_FIELD(indexorderdir, ScanDirection);
-
-	READ_DONE();
-}
-
-/*
- * _readBitmapIndexScan
- */
-static BitmapIndexScan *
-_readBitmapIndexScan(void)
-{
-	READ_LOCALS(BitmapIndexScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_OID_FIELD(indexid);
-	READ_BOOL_FIELD(isshared);
-	READ_NODE_FIELD(indexqual);
-	READ_NODE_FIELD(indexqualorig);
-
-	READ_DONE();
-}
-
-/*
- * _readBitmapHeapScan
- */
-static BitmapHeapScan *
-_readBitmapHeapScan(void)
-{
-	READ_LOCALS(BitmapHeapScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(bitmapqualorig);
-
-	READ_DONE();
-}
-
-/*
- * _readTidScan
- */
-static TidScan *
-_readTidScan(void)
-{
-	READ_LOCALS(TidScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(tidquals);
-
-	READ_DONE();
-}
-
-/*
- * _readTidRangeScan
- */
-static TidRangeScan *
-_readTidRangeScan(void)
-{
-	READ_LOCALS(TidRangeScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(tidrangequals);
-
-	READ_DONE();
-}
-
-/*
- * _readSubqueryScan
- */
-static SubqueryScan *
-_readSubqueryScan(void)
-{
-	READ_LOCALS(SubqueryScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(subplan);
-	READ_ENUM_FIELD(scanstatus, SubqueryScanStatus);
-
-	READ_DONE();
-}
-
-/*
- * _readFunctionScan
- */
-static FunctionScan *
-_readFunctionScan(void)
-{
-	READ_LOCALS(FunctionScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(functions);
-	READ_BOOL_FIELD(funcordinality);
-
-	READ_DONE();
-}
-
-/*
- * _readValuesScan
- */
-static ValuesScan *
-_readValuesScan(void)
-{
-	READ_LOCALS(ValuesScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(values_lists);
-
-	READ_DONE();
-}
-
-/*
- * _readTableFuncScan
- */
-static TableFuncScan *
-_readTableFuncScan(void)
-{
-	READ_LOCALS(TableFuncScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_NODE_FIELD(tablefunc);
-
-	READ_DONE();
-}
-
-/*
- * _readCteScan
- */
-static CteScan *
-_readCteScan(void)
-{
-	READ_LOCALS(CteScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_INT_FIELD(ctePlanId);
-	READ_INT_FIELD(cteParam);
-
-	READ_DONE();
-}
-
-/*
- * _readNamedTuplestoreScan
- */
-static NamedTuplestoreScan *
-_readNamedTuplestoreScan(void)
-{
-	READ_LOCALS(NamedTuplestoreScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_STRING_FIELD(enrname);
-
-	READ_DONE();
-}
-
-/*
- * _readWorkTableScan
- */
-static WorkTableScan *
-_readWorkTableScan(void)
-{
-	READ_LOCALS(WorkTableScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_INT_FIELD(wtParam);
-
-	READ_DONE();
-}
-
-/*
- * _readForeignScan
- */
-static ForeignScan *
-_readForeignScan(void)
-{
-	READ_LOCALS(ForeignScan);
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_ENUM_FIELD(operation, CmdType);
-	READ_UINT_FIELD(resultRelation);
-	READ_OID_FIELD(fs_server);
-	READ_NODE_FIELD(fdw_exprs);
-	READ_NODE_FIELD(fdw_private);
-	READ_NODE_FIELD(fdw_scan_tlist);
-	READ_NODE_FIELD(fdw_recheck_quals);
-	READ_BITMAPSET_FIELD(fs_relids);
-	READ_BOOL_FIELD(fsSystemCol);
-
-	READ_DONE();
-}
-
-/*
- * _readCustomScan
- */
-static CustomScan *
-_readCustomScan(void)
-{
-	READ_LOCALS(CustomScan);
-	char	   *custom_name;
-	const CustomScanMethods *methods;
-
-	ReadCommonScan(&local_node->scan);
-
-	READ_UINT_FIELD(flags);
-	READ_NODE_FIELD(custom_plans);
-	READ_NODE_FIELD(custom_exprs);
-	READ_NODE_FIELD(custom_private);
-	READ_NODE_FIELD(custom_scan_tlist);
-	READ_BITMAPSET_FIELD(custom_relids);
-
-	/* Lookup CustomScanMethods by CustomName */
-	token = pg_strtok(&length); /* skip methods: */
-	token = pg_strtok(&length); /* CustomName */
-	custom_name = nullable_string(token, length);
-	methods = GetCustomScanMethods(custom_name, false);
-	local_node->methods = methods;
-
-	READ_DONE();
-}
-
-/*
- * ReadCommonJoin
- *	Assign the basic stuff of all nodes that inherit from Join
- */
-static void
-ReadCommonJoin(Join *local_node)
-{
-	READ_TEMP_LOCALS();
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_ENUM_FIELD(jointype, JoinType);
-	READ_BOOL_FIELD(inner_unique);
-	READ_NODE_FIELD(joinqual);
-}
-
-/*
- * _readNestLoop
- */
-static NestLoop *
-_readNestLoop(void)
-{
-	READ_LOCALS(NestLoop);
-
-	ReadCommonJoin(&local_node->join);
-
-	READ_NODE_FIELD(nestParams);
-
-	READ_DONE();
-}
-
-/*
- * _readMergeJoin
- */
-static MergeJoin *
-_readMergeJoin(void)
-{
-	int			numCols;
-
-	READ_LOCALS(MergeJoin);
-
-	ReadCommonJoin(&local_node->join);
-
-	READ_BOOL_FIELD(skip_mark_restore);
-	READ_NODE_FIELD(mergeclauses);
-
-	numCols = list_length(local_node->mergeclauses);
-
-	READ_OID_ARRAY(mergeFamilies, numCols);
-	READ_OID_ARRAY(mergeCollations, numCols);
-	READ_INT_ARRAY(mergeStrategies, numCols);
-	READ_BOOL_ARRAY(mergeNullsFirst, numCols);
-
-	READ_DONE();
-}
-
-/*
- * _readHashJoin
- */
-static HashJoin *
-_readHashJoin(void)
-{
-	READ_LOCALS(HashJoin);
-
-	ReadCommonJoin(&local_node->join);
-
-	READ_NODE_FIELD(hashclauses);
-	READ_NODE_FIELD(hashoperators);
-	READ_NODE_FIELD(hashcollations);
-	READ_NODE_FIELD(hashkeys);
-
-	READ_DONE();
-}
-
-/*
- * _readMaterial
- */
-static Material *
-_readMaterial(void)
-{
-	READ_LOCALS_NO_FIELDS(Material);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_DONE();
-}
-
-/*
- * _readMemoize
- */
-static Memoize *
-_readMemoize(void)
-{
-	READ_LOCALS(Memoize);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(numKeys);
-	READ_OID_ARRAY(hashOperators, local_node->numKeys);
-	READ_OID_ARRAY(collations, local_node->numKeys);
-	READ_NODE_FIELD(param_exprs);
-	READ_BOOL_FIELD(singlerow);
-	READ_BOOL_FIELD(binary_mode);
-	READ_UINT_FIELD(est_entries);
-	READ_BITMAPSET_FIELD(keyparamids);
-
-	READ_DONE();
-}
-
-/*
- * ReadCommonSort
- *	Assign the basic stuff of all nodes that inherit from Sort
- */
-static void
-ReadCommonSort(Sort *local_node)
-{
-	READ_TEMP_LOCALS();
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
-	READ_OID_ARRAY(sortOperators, local_node->numCols);
-	READ_OID_ARRAY(collations, local_node->numCols);
-	READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
-}
-
-/*
- * _readSort
- */
-static Sort *
-_readSort(void)
-{
-	READ_LOCALS_NO_FIELDS(Sort);
-
-	ReadCommonSort(local_node);
-
-	READ_DONE();
-}
-
-/*
- * _readIncrementalSort
- */
-static IncrementalSort *
-_readIncrementalSort(void)
-{
-	READ_LOCALS(IncrementalSort);
-
-	ReadCommonSort(&local_node->sort);
-
-	READ_INT_FIELD(nPresortedCols);
-
-	READ_DONE();
-}
-
-/*
- * _readGroup
- */
-static Group *
-_readGroup(void)
-{
-	READ_LOCALS(Group);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
-	READ_OID_ARRAY(grpOperators, local_node->numCols);
-	READ_OID_ARRAY(grpCollations, local_node->numCols);
-
-	READ_DONE();
-}
-
-/*
- * _readAgg
- */
-static Agg *
-_readAgg(void)
-{
-	READ_LOCALS(Agg);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_ENUM_FIELD(aggstrategy, AggStrategy);
-	READ_ENUM_FIELD(aggsplit, AggSplit);
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
-	READ_OID_ARRAY(grpOperators, local_node->numCols);
-	READ_OID_ARRAY(grpCollations, local_node->numCols);
-	READ_LONG_FIELD(numGroups);
-	READ_UINT64_FIELD(transitionSpace);
-	READ_BITMAPSET_FIELD(aggParams);
-	READ_NODE_FIELD(groupingSets);
-	READ_NODE_FIELD(chain);
-
-	READ_DONE();
-}
-
-/*
- * _readWindowAgg
- */
-static WindowAgg *
-_readWindowAgg(void)
-{
-	READ_LOCALS(WindowAgg);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_UINT_FIELD(winref);
-	READ_INT_FIELD(partNumCols);
-	READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
-	READ_OID_ARRAY(partOperators, local_node->partNumCols);
-	READ_OID_ARRAY(partCollations, local_node->partNumCols);
-	READ_INT_FIELD(ordNumCols);
-	READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
-	READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
-	READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
-	READ_INT_FIELD(frameOptions);
-	READ_NODE_FIELD(startOffset);
-	READ_NODE_FIELD(endOffset);
-	READ_NODE_FIELD(runCondition);
-	READ_NODE_FIELD(runConditionOrig);
-	READ_OID_FIELD(startInRangeFunc);
-	READ_OID_FIELD(endInRangeFunc);
-	READ_OID_FIELD(inRangeColl);
-	READ_BOOL_FIELD(inRangeAsc);
-	READ_BOOL_FIELD(inRangeNullsFirst);
-	READ_BOOL_FIELD(topWindow);
-
-	READ_DONE();
-}
-
-/*
- * _readUnique
- */
-static Unique *
-_readUnique(void)
-{
-	READ_LOCALS(Unique);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
-	READ_OID_ARRAY(uniqOperators, local_node->numCols);
-	READ_OID_ARRAY(uniqCollations, local_node->numCols);
-
-	READ_DONE();
-}
-
-/*
- * _readGather
- */
-static Gather *
-_readGather(void)
-{
-	READ_LOCALS(Gather);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(num_workers);
-	READ_INT_FIELD(rescan_param);
-	READ_BOOL_FIELD(single_copy);
-	READ_BOOL_FIELD(invisible);
-	READ_BITMAPSET_FIELD(initParam);
-
-	READ_DONE();
-}
-
-/*
- * _readGatherMerge
- */
-static GatherMerge *
-_readGatherMerge(void)
-{
-	READ_LOCALS(GatherMerge);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_INT_FIELD(num_workers);
-	READ_INT_FIELD(rescan_param);
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
-	READ_OID_ARRAY(sortOperators, local_node->numCols);
-	READ_OID_ARRAY(collations, local_node->numCols);
-	READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
-	READ_BITMAPSET_FIELD(initParam);
-
-	READ_DONE();
-}
-
-/*
- * _readHash
- */
-static Hash *
-_readHash(void)
-{
-	READ_LOCALS(Hash);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_NODE_FIELD(hashkeys);
-	READ_OID_FIELD(skewTable);
-	READ_INT_FIELD(skewColumn);
-	READ_BOOL_FIELD(skewInherit);
-	READ_FLOAT_FIELD(rows_total);
-
-	READ_DONE();
-}
-
-/*
- * _readSetOp
- */
-static SetOp *
-_readSetOp(void)
-{
-	READ_LOCALS(SetOp);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_ENUM_FIELD(cmd, SetOpCmd);
-	READ_ENUM_FIELD(strategy, SetOpStrategy);
-	READ_INT_FIELD(numCols);
-	READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
-	READ_OID_ARRAY(dupOperators, local_node->numCols);
-	READ_OID_ARRAY(dupCollations, local_node->numCols);
-	READ_INT_FIELD(flagColIdx);
-	READ_INT_FIELD(firstFlag);
-	READ_LONG_FIELD(numGroups);
-
-	READ_DONE();
-}
-
-/*
- * _readLockRows
- */
-static LockRows *
-_readLockRows(void)
-{
-	READ_LOCALS(LockRows);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_NODE_FIELD(rowMarks);
-	READ_INT_FIELD(epqParam);
-
-	READ_DONE();
-}
-
-/*
- * _readLimit
- */
-static Limit *
-_readLimit(void)
-{
-	READ_LOCALS(Limit);
-
-	ReadCommonPlan(&local_node->plan);
-
-	READ_NODE_FIELD(limitOffset);
-	READ_NODE_FIELD(limitCount);
-	READ_ENUM_FIELD(limitOption, LimitOption);
-	READ_INT_FIELD(uniqNumCols);
-	READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols);
-	READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols);
-	READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols);
-
-	READ_DONE();
-}
-
-/*
- * _readNestLoopParam
- */
-static NestLoopParam *
-_readNestLoopParam(void)
-{
-	READ_LOCALS(NestLoopParam);
-
-	READ_INT_FIELD(paramno);
-	READ_NODE_FIELD(paramval);
-
-	READ_DONE();
-}
-
-/*
- * _readPlanRowMark
- */
-static PlanRowMark *
-_readPlanRowMark(void)
-{
-	READ_LOCALS(PlanRowMark);
-
-	READ_UINT_FIELD(rti);
-	READ_UINT_FIELD(prti);
-	READ_UINT_FIELD(rowmarkId);
-	READ_ENUM_FIELD(markType, RowMarkType);
-	READ_INT_FIELD(allMarkTypes);
-	READ_ENUM_FIELD(strength, LockClauseStrength);
-	READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
-	READ_BOOL_FIELD(isParent);
-
-	READ_DONE();
-}
-
-static PartitionPruneInfo *
-_readPartitionPruneInfo(void)
-{
-	READ_LOCALS(PartitionPruneInfo);
-
-	READ_NODE_FIELD(prune_infos);
-	READ_BITMAPSET_FIELD(other_subplans);
-
-	READ_DONE();
-}
-
-static PartitionedRelPruneInfo *
-_readPartitionedRelPruneInfo(void)
-{
-	READ_LOCALS(PartitionedRelPruneInfo);
-
-	READ_UINT_FIELD(rtindex);
-	READ_BITMAPSET_FIELD(present_parts);
-	READ_INT_FIELD(nparts);
-	READ_INT_ARRAY(subplan_map, local_node->nparts);
-	READ_INT_ARRAY(subpart_map, local_node->nparts);
-	READ_OID_ARRAY(relid_map, local_node->nparts);
-	READ_NODE_FIELD(initial_pruning_steps);
-	READ_NODE_FIELD(exec_pruning_steps);
-	READ_BITMAPSET_FIELD(execparamids);
-
-	READ_DONE();
-}
-
-static PartitionPruneStepOp *
-_readPartitionPruneStepOp(void)
-{
-	READ_LOCALS(PartitionPruneStepOp);
-
-	READ_INT_FIELD(step.step_id);
-	READ_INT_FIELD(opstrategy);
-	READ_NODE_FIELD(exprs);
-	READ_NODE_FIELD(cmpfns);
-	READ_BITMAPSET_FIELD(nullkeys);
-
-	READ_DONE();
-}
-
-static PartitionPruneStepCombine *
-_readPartitionPruneStepCombine(void)
-{
-	READ_LOCALS(PartitionPruneStepCombine);
-
-	READ_INT_FIELD(step.step_id);
-	READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
-	READ_NODE_FIELD(source_stepids);
-
-	READ_DONE();
-}
-
-/*
- * _readPlanInvalItem
- */
-static PlanInvalItem *
-_readPlanInvalItem(void)
-{
-	READ_LOCALS(PlanInvalItem);
-
-	READ_INT_FIELD(cacheId);
-	READ_UINT_FIELD(hashValue);
-
-	READ_DONE();
-}
-
-/*
- * _readSubPlan
- */
-static SubPlan *
-_readSubPlan(void)
-{
-	READ_LOCALS(SubPlan);
-
-	READ_ENUM_FIELD(subLinkType, SubLinkType);
-	READ_NODE_FIELD(testexpr);
-	READ_NODE_FIELD(paramIds);
-	READ_INT_FIELD(plan_id);
-	READ_STRING_FIELD(plan_name);
-	READ_OID_FIELD(firstColType);
-	READ_INT_FIELD(firstColTypmod);
-	READ_OID_FIELD(firstColCollation);
-	READ_BOOL_FIELD(useHashTable);
-	READ_BOOL_FIELD(unknownEqFalse);
-	READ_BOOL_FIELD(parallel_safe);
-	READ_NODE_FIELD(setParam);
-	READ_NODE_FIELD(parParam);
-	READ_NODE_FIELD(args);
-	READ_FLOAT_FIELD(startup_cost);
-	READ_FLOAT_FIELD(per_call_cost);
-
-	READ_DONE();
-}
-
-/*
- * _readAlternativeSubPlan
- */
-static AlternativeSubPlan *
-_readAlternativeSubPlan(void)
-{
-	READ_LOCALS(AlternativeSubPlan);
-
-	READ_NODE_FIELD(subplans);
-
-	READ_DONE();
-}
-#endif							/* OBSOLETE */
-
-/*
- * _readExtensibleNode
- */
 static ExtensibleNode *
 _readExtensibleNode(void)
 {
@@ -2885,42 +457,6 @@ _readExtensibleNode(void)
 	READ_DONE();
 }
 
-#ifdef OBSOLETE
-/*
- * _readPartitionBoundSpec
- */
-static PartitionBoundSpec *
-_readPartitionBoundSpec(void)
-{
-	READ_LOCALS(PartitionBoundSpec);
-
-	READ_CHAR_FIELD(strategy);
-	READ_BOOL_FIELD(is_default);
-	READ_INT_FIELD(modulus);
-	READ_INT_FIELD(remainder);
-	READ_NODE_FIELD(listdatums);
-	READ_NODE_FIELD(lowerdatums);
-	READ_NODE_FIELD(upperdatums);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-
-/*
- * _readPartitionRangeDatum
- */
-static PartitionRangeDatum *
-_readPartitionRangeDatum(void)
-{
-	READ_LOCALS(PartitionRangeDatum);
-
-	READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
-	READ_NODE_FIELD(value);
-	READ_LOCATION_FIELD(location);
-
-	READ_DONE();
-}
-#endif							/* OBSOLETE */
 
 /*
  * parseNodeString
@@ -2948,278 +484,6 @@ parseNodeString(void)
 	if (false)
 		;
 #include "readfuncs.switch.c"
-#ifdef OBSOLETE
-	else if (MATCH("QUERY", 5))
-		return_value = _readQuery();
-	else if (MATCH("WITHCHECKOPTION", 15))
-		return_value = _readWithCheckOption();
-	else if (MATCH("SORTGROUPCLAUSE", 15))
-		return_value = _readSortGroupClause();
-	else if (MATCH("GROUPINGSET", 11))
-		return_value = _readGroupingSet();
-	else if (MATCH("WINDOWCLAUSE", 12))
-		return_value = _readWindowClause();
-	else if (MATCH("ROWMARKCLAUSE", 13))
-		return_value = _readRowMarkClause();
-	else if (MATCH("CTESEARCHCLAUSE", 15))
-		return_value = _readCTESearchClause();
-	else if (MATCH("CTECYCLECLAUSE", 14))
-		return_value = _readCTECycleClause();
-	else if (MATCH("COMMONTABLEEXPR", 15))
-		return_value = _readCommonTableExpr();
-	else if (MATCH("MERGEWHENCLAUSE", 15))
-		return_value = _readMergeWhenClause();
-	else if (MATCH("MERGEACTION", 11))
-		return_value = _readMergeAction();
-	else if (MATCH("SETOPERATIONSTMT", 16))
-		return_value = _readSetOperationStmt();
-	else if (MATCH("ALIAS", 5))
-		return_value = _readAlias();
-	else if (MATCH("RANGEVAR", 8))
-		return_value = _readRangeVar();
-	else if (MATCH("INTOCLAUSE", 10))
-		return_value = _readIntoClause();
-	else if (MATCH("TABLEFUNC", 9))
-		return_value = _readTableFunc();
-	else if (MATCH("VAR", 3))
-		return_value = _readVar();
-	else if (MATCH("CONST", 5))
-		return_value = _readConst();
-	else if (MATCH("PARAM", 5))
-		return_value = _readParam();
-	else if (MATCH("AGGREF", 6))
-		return_value = _readAggref();
-	else if (MATCH("GROUPINGFUNC", 12))
-		return_value = _readGroupingFunc();
-	else if (MATCH("WINDOWFUNC", 10))
-		return_value = _readWindowFunc();
-	else if (MATCH("SUBSCRIPTINGREF", 15))
-		return_value = _readSubscriptingRef();
-	else if (MATCH("FUNCEXPR", 8))
-		return_value = _readFuncExpr();
-	else if (MATCH("NAMEDARGEXPR", 12))
-		return_value = _readNamedArgExpr();
-	else if (MATCH("OPEXPR", 6))
-		return_value = _readOpExpr();
-	else if (MATCH("DISTINCTEXPR", 12))
-		return_value = _readDistinctExpr();
-	else if (MATCH("NULLIFEXPR", 10))
-		return_value = _readNullIfExpr();
-	else if (MATCH("SCALARARRAYOPEXPR", 17))
-		return_value = _readScalarArrayOpExpr();
-	else if (MATCH("BOOLEXPR", 8))
-		return_value = _readBoolExpr();
-	else if (MATCH("SUBLINK", 7))
-		return_value = _readSubLink();
-	else if (MATCH("FIELDSELECT", 11))
-		return_value = _readFieldSelect();
-	else if (MATCH("FIELDSTORE", 10))
-		return_value = _readFieldStore();
-	else if (MATCH("RELABELTYPE", 11))
-		return_value = _readRelabelType();
-	else if (MATCH("COERCEVIAIO", 11))
-		return_value = _readCoerceViaIO();
-	else if (MATCH("ARRAYCOERCEEXPR", 15))
-		return_value = _readArrayCoerceExpr();
-	else if (MATCH("CONVERTROWTYPEEXPR", 18))
-		return_value = _readConvertRowtypeExpr();
-	else if (MATCH("COLLATEEXPR", 11))
-		return_value = _readCollateExpr();
-	else if (MATCH("CASEEXPR", 8))
-		return_value = _readCaseExpr();
-	else if (MATCH("CASEWHEN", 8))
-		return_value = _readCaseWhen();
-	else if (MATCH("CASETESTEXPR", 12))
-		return_value = _readCaseTestExpr();
-	else if (MATCH("ARRAYEXPR", 9))
-		return_value = _readArrayExpr();
-	else if (MATCH("ROWEXPR", 7))
-		return_value = _readRowExpr();
-	else if (MATCH("ROWCOMPAREEXPR", 14))
-		return_value = _readRowCompareExpr();
-	else if (MATCH("COALESCEEXPR", 12))
-		return_value = _readCoalesceExpr();
-	else if (MATCH("MINMAXEXPR", 10))
-		return_value = _readMinMaxExpr();
-	else if (MATCH("SQLVALUEFUNCTION", 16))
-		return_value = _readSQLValueFunction();
-	else if (MATCH("XMLEXPR", 7))
-		return_value = _readXmlExpr();
-	else if (MATCH("NULLTEST", 8))
-		return_value = _readNullTest();
-	else if (MATCH("BOOLEANTEST", 11))
-		return_value = _readBooleanTest();
-	else if (MATCH("COERCETODOMAIN", 14))
-		return_value = _readCoerceToDomain();
-	else if (MATCH("COERCETODOMAINVALUE", 19))
-		return_value = _readCoerceToDomainValue();
-	else if (MATCH("SETTODEFAULT", 12))
-		return_value = _readSetToDefault();
-	else if (MATCH("CURRENTOFEXPR", 13))
-		return_value = _readCurrentOfExpr();
-	else if (MATCH("NEXTVALUEEXPR", 13))
-		return_value = _readNextValueExpr();
-	else if (MATCH("INFERENCEELEM", 13))
-		return_value = _readInferenceElem();
-	else if (MATCH("TARGETENTRY", 11))
-		return_value = _readTargetEntry();
-	else if (MATCH("RANGETBLREF", 11))
-		return_value = _readRangeTblRef();
-	else if (MATCH("JOINEXPR", 8))
-		return_value = _readJoinExpr();
-	else if (MATCH("FROMEXPR", 8))
-		return_value = _readFromExpr();
-	else if (MATCH("ONCONFLICTEXPR", 14))
-		return_value = _readOnConflictExpr();
-	else if (MATCH("APPENDRELINFO", 13))
-		return_value = _readAppendRelInfo();
-	else if (MATCH("RANGETBLENTRY", 13))
-		return_value = _readRangeTblEntry();
-	else if (MATCH("RANGETBLFUNCTION", 16))
-		return_value = _readRangeTblFunction();
-	else if (MATCH("TABLESAMPLECLAUSE", 17))
-		return_value = _readTableSampleClause();
-	else if (MATCH("NOTIFYSTMT", 10))
-		return_value = _readNotifyStmt();
-	else if (MATCH("DEFELEM", 7))
-		return_value = _readDefElem();
-	else if (MATCH("DECLARECURSORSTMT", 17))
-		return_value = _readDeclareCursorStmt();
-	else if (MATCH("PLANNEDSTMT", 11))
-		return_value = _readPlannedStmt();
-	else if (MATCH("RESULT", 6))
-		return_value = _readResult();
-	else if (MATCH("PROJECTSET", 10))
-		return_value = _readProjectSet();
-	else if (MATCH("MODIFYTABLE", 11))
-		return_value = _readModifyTable();
-	else if (MATCH("APPEND", 6))
-		return_value = _readAppend();
-	else if (MATCH("MERGEAPPEND", 11))
-		return_value = _readMergeAppend();
-	else if (MATCH("RECURSIVEUNION", 14))
-		return_value = _readRecursiveUnion();
-	else if (MATCH("BITMAPAND", 9))
-		return_value = _readBitmapAnd();
-	else if (MATCH("BITMAPOR", 8))
-		return_value = _readBitmapOr();
-	else if (MATCH("SCAN", 4))
-		return_value = _readScan();
-	else if (MATCH("SEQSCAN", 7))
-		return_value = _readSeqScan();
-	else if (MATCH("SAMPLESCAN", 10))
-		return_value = _readSampleScan();
-	else if (MATCH("INDEXSCAN", 9))
-		return_value = _readIndexScan();
-	else if (MATCH("INDEXONLYSCAN", 13))
-		return_value = _readIndexOnlyScan();
-	else if (MATCH("BITMAPINDEXSCAN", 15))
-		return_value = _readBitmapIndexScan();
-	else if (MATCH("BITMAPHEAPSCAN", 14))
-		return_value = _readBitmapHeapScan();
-	else if (MATCH("TIDSCAN", 7))
-		return_value = _readTidScan();
-	else if (MATCH("TIDRANGESCAN", 12))
-		return_value = _readTidRangeScan();
-	else if (MATCH("SUBQUERYSCAN", 12))
-		return_value = _readSubqueryScan();
-	else if (MATCH("FUNCTIONSCAN", 12))
-		return_value = _readFunctionScan();
-	else if (MATCH("VALUESSCAN", 10))
-		return_value = _readValuesScan();
-	else if (MATCH("TABLEFUNCSCAN", 13))
-		return_value = _readTableFuncScan();
-	else if (MATCH("CTESCAN", 7))
-		return_value = _readCteScan();
-	else if (MATCH("NAMEDTUPLESTORESCAN", 19))
-		return_value = _readNamedTuplestoreScan();
-	else if (MATCH("WORKTABLESCAN", 13))
-		return_value = _readWorkTableScan();
-	else if (MATCH("FOREIGNSCAN", 11))
-		return_value = _readForeignScan();
-	else if (MATCH("CUSTOMSCAN", 10))
-		return_value = _readCustomScan();
-	else if (MATCH("NESTLOOP", 8))
-		return_value = _readNestLoop();
-	else if (MATCH("MERGEJOIN", 9))
-		return_value = _readMergeJoin();
-	else if (MATCH("HASHJOIN", 8))
-		return_value = _readHashJoin();
-	else if (MATCH("MATERIAL", 8))
-		return_value = _readMaterial();
-	else if (MATCH("MEMOIZE", 7))
-		return_value = _readMemoize();
-	else if (MATCH("SORT", 4))
-		return_value = _readSort();
-	else if (MATCH("INCREMENTALSORT", 15))
-		return_value = _readIncrementalSort();
-	else if (MATCH("GROUP", 5))
-		return_value = _readGroup();
-	else if (MATCH("AGG", 3))
-		return_value = _readAgg();
-	else if (MATCH("WINDOWAGG", 9))
-		return_value = _readWindowAgg();
-	else if (MATCH("UNIQUE", 6))
-		return_value = _readUnique();
-	else if (MATCH("GATHER", 6))
-		return_value = _readGather();
-	else if (MATCH("GATHERMERGE", 11))
-		return_value = _readGatherMerge();
-	else if (MATCH("HASH", 4))
-		return_value = _readHash();
-	else if (MATCH("SETOP", 5))
-		return_value = _readSetOp();
-	else if (MATCH("LOCKROWS", 8))
-		return_value = _readLockRows();
-	else if (MATCH("LIMIT", 5))
-		return_value = _readLimit();
-	else if (MATCH("NESTLOOPPARAM", 13))
-		return_value = _readNestLoopParam();
-	else if (MATCH("PLANROWMARK", 11))
-		return_value = _readPlanRowMark();
-	else if (MATCH("PARTITIONPRUNEINFO", 18))
-		return_value = _readPartitionPruneInfo();
-	else if (MATCH("PARTITIONEDRELPRUNEINFO", 23))
-		return_value = _readPartitionedRelPruneInfo();
-	else if (MATCH("PARTITIONPRUNESTEPOP", 20))
-		return_value = _readPartitionPruneStepOp();
-	else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25))
-		return_value = _readPartitionPruneStepCombine();
-	else if (MATCH("PLANINVALITEM", 13))
-		return_value = _readPlanInvalItem();
-	else if (MATCH("SUBPLAN", 7))
-		return_value = _readSubPlan();
-	else if (MATCH("ALTERNATIVESUBPLAN", 18))
-		return_value = _readAlternativeSubPlan();
-	else if (MATCH("EXTENSIBLENODE", 14))
-		return_value = _readExtensibleNode();
-	else if (MATCH("PARTITIONBOUNDSPEC", 18))
-		return_value = _readPartitionBoundSpec();
-	else if (MATCH("PARTITIONRANGEDATUM", 19))
-		return_value = _readPartitionRangeDatum();
-	else if (MATCH("JSONFORMAT", 10))
-		return_value = _readJsonFormat();
-	else if (MATCH("JSONRETURNING", 13))
-		return_value = _readJsonReturning();
-	else if (MATCH("JSONVALUEEXPR", 13))
-		return_value = _readJsonValueExpr();
-	else if (MATCH("JSONCONSTRUCTOREXPR", 19))
-		return_value = _readJsonConstructorExpr();
-	else if (MATCH("JSONISPREDICATE", 15))
-		return_value = _readJsonIsPredicate();
-	else if (MATCH("JSONBEHAVIOR", 12))
-		return_value = _readJsonBehavior();
-	else if (MATCH("JSONEXPR", 8))
-		return_value = _readJsonExpr();
-	else if (MATCH("JSONCOERCION", 12))
-		return_value = _readJsonCoercion();
-	else if (MATCH("JSONITEMCOERCIONS", 17))
-		return_value = _readJsonItemCoercions();
-	else if (MATCH("JSONTABLEPARENT", 15))
-		return_value = _readJsonTableParent();
-	else if (MATCH("JSONTABLESIBLING", 16))
-		return_value = _readJsonTableSibling();
-#endif							/* OBSOLETE */
 	else
 	{
 		elog(ERROR, "badly formatted node string \"%.32s\"...", token);
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 9999336eb4..adc549002a 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -28,537 +28,6 @@ typedef enum NodeTag
 	T_Invalid = 0,
 
 #include "nodes/nodetags.h"
-#ifdef OBSOLETE
-
-	/*
-	 * TAGS FOR EXECUTOR NODES (execnodes.h)
-	 */
-	T_IndexInfo,
-	T_ExprContext,
-	T_ProjectionInfo,
-	T_JunkFilter,
-	T_OnConflictSetState,
-	T_MergeActionState,
-	T_ResultRelInfo,
-	T_EState,
-	T_TupleTableSlot,
-
-	/*
-	 * TAGS FOR PLAN NODES (plannodes.h)
-	 */
-	T_Result,
-	T_ProjectSet,
-	T_ModifyTable,
-	T_Append,
-	T_MergeAppend,
-	T_RecursiveUnion,
-	T_BitmapAnd,
-	T_BitmapOr,
-	T_Scan,
-	T_SeqScan,
-	T_SampleScan,
-	T_IndexScan,
-	T_IndexOnlyScan,
-	T_BitmapIndexScan,
-	T_BitmapHeapScan,
-	T_TidScan,
-	T_TidRangeScan,
-	T_SubqueryScan,
-	T_FunctionScan,
-	T_ValuesScan,
-	T_TableFuncScan,
-	T_CteScan,
-	T_NamedTuplestoreScan,
-	T_WorkTableScan,
-	T_ForeignScan,
-	T_CustomScan,
-	T_NestLoop,
-	T_MergeJoin,
-	T_HashJoin,
-	T_Material,
-	T_Memoize,
-	T_Sort,
-	T_IncrementalSort,
-	T_Group,
-	T_Agg,
-	T_WindowAgg,
-	T_Unique,
-	T_Gather,
-	T_GatherMerge,
-	T_Hash,
-	T_SetOp,
-	T_LockRows,
-	T_Limit,
-	/* these aren't subclasses of Plan: */
-	T_NestLoopParam,
-	T_PlanRowMark,
-	T_PartitionPruneInfo,
-	T_PartitionedRelPruneInfo,
-	T_PartitionPruneStepOp,
-	T_PartitionPruneStepCombine,
-	T_PlanInvalItem,
-
-	/*
-	 * TAGS FOR PLAN STATE NODES (execnodes.h)
-	 *
-	 * These should correspond one-to-one with Plan node types.
-	 */
-	T_PlanState,
-	T_ResultState,
-	T_ProjectSetState,
-	T_ModifyTableState,
-	T_AppendState,
-	T_MergeAppendState,
-	T_RecursiveUnionState,
-	T_BitmapAndState,
-	T_BitmapOrState,
-	T_ScanState,
-	T_SeqScanState,
-	T_SampleScanState,
-	T_IndexScanState,
-	T_IndexOnlyScanState,
-	T_BitmapIndexScanState,
-	T_BitmapHeapScanState,
-	T_TidScanState,
-	T_TidRangeScanState,
-	T_SubqueryScanState,
-	T_FunctionScanState,
-	T_TableFuncScanState,
-	T_ValuesScanState,
-	T_CteScanState,
-	T_NamedTuplestoreScanState,
-	T_WorkTableScanState,
-	T_ForeignScanState,
-	T_CustomScanState,
-	T_JoinState,
-	T_NestLoopState,
-	T_MergeJoinState,
-	T_HashJoinState,
-	T_MaterialState,
-	T_MemoizeState,
-	T_SortState,
-	T_IncrementalSortState,
-	T_GroupState,
-	T_AggState,
-	T_WindowAggState,
-	T_UniqueState,
-	T_GatherState,
-	T_GatherMergeState,
-	T_HashState,
-	T_SetOpState,
-	T_LockRowsState,
-	T_LimitState,
-
-	/*
-	 * TAGS FOR PRIMITIVE NODES (primnodes.h)
-	 */
-	T_Alias,
-	T_RangeVar,
-	T_TableFunc,
-	T_Var,
-	T_Const,
-	T_Param,
-	T_Aggref,
-	T_GroupingFunc,
-	T_WindowFunc,
-	T_SubscriptingRef,
-	T_FuncExpr,
-	T_NamedArgExpr,
-	T_OpExpr,
-	T_DistinctExpr,
-	T_NullIfExpr,
-	T_ScalarArrayOpExpr,
-	T_BoolExpr,
-	T_SubLink,
-	T_SubPlan,
-	T_AlternativeSubPlan,
-	T_FieldSelect,
-	T_FieldStore,
-	T_RelabelType,
-	T_CoerceViaIO,
-	T_ArrayCoerceExpr,
-	T_ConvertRowtypeExpr,
-	T_CollateExpr,
-	T_CaseExpr,
-	T_CaseWhen,
-	T_CaseTestExpr,
-	T_ArrayExpr,
-	T_RowExpr,
-	T_RowCompareExpr,
-	T_CoalesceExpr,
-	T_MinMaxExpr,
-	T_SQLValueFunction,
-	T_XmlExpr,
-	T_NullTest,
-	T_BooleanTest,
-	T_CoerceToDomain,
-	T_CoerceToDomainValue,
-	T_SetToDefault,
-	T_CurrentOfExpr,
-	T_NextValueExpr,
-	T_InferenceElem,
-	T_TargetEntry,
-	T_RangeTblRef,
-	T_JoinExpr,
-	T_FromExpr,
-	T_OnConflictExpr,
-	T_IntoClause,
-	T_JsonFormat,
-	T_JsonReturning,
-	T_JsonValueExpr,
-	T_JsonParseExpr,
-	T_JsonScalarExpr,
-	T_JsonSerializeExpr,
-	T_JsonConstructorExpr,
-	T_JsonExpr,
-	T_JsonCoercion,
-	T_JsonItemCoercions,
-	T_JsonTableParent,
-	T_JsonTableSibling,
-
-	/*
-	 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
-	 */
-	T_ExprState,
-	T_WindowFuncExprState,
-	T_SetExprState,
-	T_SubPlanState,
-	T_DomainConstraintState,
-
-	/*
-	 * TAGS FOR PLANNER NODES (pathnodes.h)
-	 */
-	T_PlannerInfo,
-	T_PlannerGlobal,
-	T_RelOptInfo,
-	T_IndexOptInfo,
-	T_ForeignKeyOptInfo,
-	T_ParamPathInfo,
-	T_Path,
-	T_IndexPath,
-	T_BitmapHeapPath,
-	T_BitmapAndPath,
-	T_BitmapOrPath,
-	T_TidPath,
-	T_TidRangePath,
-	T_SubqueryScanPath,
-	T_ForeignPath,
-	T_CustomPath,
-	T_NestPath,
-	T_MergePath,
-	T_HashPath,
-	T_AppendPath,
-	T_MergeAppendPath,
-	T_GroupResultPath,
-	T_MaterialPath,
-	T_MemoizePath,
-	T_UniquePath,
-	T_GatherPath,
-	T_GatherMergePath,
-	T_ProjectionPath,
-	T_ProjectSetPath,
-	T_SortPath,
-	T_IncrementalSortPath,
-	T_GroupPath,
-	T_UpperUniquePath,
-	T_AggPath,
-	T_GroupingSetsPath,
-	T_MinMaxAggPath,
-	T_WindowAggPath,
-	T_SetOpPath,
-	T_RecursiveUnionPath,
-	T_LockRowsPath,
-	T_ModifyTablePath,
-	T_LimitPath,
-	/* these aren't subclasses of Path: */
-	T_EquivalenceClass,
-	T_EquivalenceMember,
-	T_PathKey,
-	T_PathKeyInfo,
-	T_PathTarget,
-	T_RestrictInfo,
-	T_IndexClause,
-	T_PlaceHolderVar,
-	T_SpecialJoinInfo,
-	T_AppendRelInfo,
-	T_RowIdentityVarInfo,
-	T_PlaceHolderInfo,
-	T_MinMaxAggInfo,
-	T_PlannerParamItem,
-	T_RollupData,
-	T_GroupingSetData,
-	T_StatisticExtInfo,
-	T_MergeAction,
-
-	/*
-	 * TAGS FOR MEMORY NODES (memnodes.h)
-	 */
-	T_AllocSetContext,
-	T_SlabContext,
-	T_GenerationContext,
-
-	/*
-	 * TAGS FOR VALUE NODES (value.h)
-	 */
-	T_Integer,
-	T_Float,
-	T_Boolean,
-	T_String,
-	T_BitString,
-
-	/*
-	 * TAGS FOR LIST NODES (pg_list.h)
-	 */
-	T_List,
-	T_IntList,
-	T_OidList,
-	T_XidList,
-
-	/*
-	 * TAGS FOR EXTENSIBLE NODES (extensible.h)
-	 */
-	T_ExtensibleNode,
-
-	/*
-	 * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
-	 */
-	T_RawStmt,
-	T_Query,
-	T_PlannedStmt,
-	T_InsertStmt,
-	T_DeleteStmt,
-	T_UpdateStmt,
-	T_MergeStmt,
-	T_SelectStmt,
-	T_ReturnStmt,
-	T_PLAssignStmt,
-	T_AlterTableStmt,
-	T_AlterTableCmd,
-	T_AlterDomainStmt,
-	T_SetOperationStmt,
-	T_GrantStmt,
-	T_GrantRoleStmt,
-	T_AlterDefaultPrivilegesStmt,
-	T_ClosePortalStmt,
-	T_ClusterStmt,
-	T_CopyStmt,
-	T_CreateStmt,
-	T_DefineStmt,
-	T_DropStmt,
-	T_TruncateStmt,
-	T_CommentStmt,
-	T_FetchStmt,
-	T_IndexStmt,
-	T_CreateFunctionStmt,
-	T_AlterFunctionStmt,
-	T_DoStmt,
-	T_RenameStmt,
-	T_RuleStmt,
-	T_NotifyStmt,
-	T_ListenStmt,
-	T_UnlistenStmt,
-	T_TransactionStmt,
-	T_ViewStmt,
-	T_LoadStmt,
-	T_CreateDomainStmt,
-	T_CreatedbStmt,
-	T_DropdbStmt,
-	T_VacuumStmt,
-	T_ExplainStmt,
-	T_CreateTableAsStmt,
-	T_CreateSeqStmt,
-	T_AlterSeqStmt,
-	T_VariableSetStmt,
-	T_VariableShowStmt,
-	T_DiscardStmt,
-	T_CreateTrigStmt,
-	T_CreatePLangStmt,
-	T_CreateRoleStmt,
-	T_AlterRoleStmt,
-	T_DropRoleStmt,
-	T_LockStmt,
-	T_ConstraintsSetStmt,
-	T_ReindexStmt,
-	T_CheckPointStmt,
-	T_CreateSchemaStmt,
-	T_AlterDatabaseStmt,
-	T_AlterDatabaseRefreshCollStmt,
-	T_AlterDatabaseSetStmt,
-	T_AlterRoleSetStmt,
-	T_CreateConversionStmt,
-	T_CreateCastStmt,
-	T_CreateOpClassStmt,
-	T_CreateOpFamilyStmt,
-	T_AlterOpFamilyStmt,
-	T_PrepareStmt,
-	T_ExecuteStmt,
-	T_DeallocateStmt,
-	T_DeclareCursorStmt,
-	T_CreateTableSpaceStmt,
-	T_DropTableSpaceStmt,
-	T_AlterObjectDependsStmt,
-	T_AlterObjectSchemaStmt,
-	T_AlterOwnerStmt,
-	T_AlterOperatorStmt,
-	T_AlterTypeStmt,
-	T_DropOwnedStmt,
-	T_ReassignOwnedStmt,
-	T_CompositeTypeStmt,
-	T_CreateEnumStmt,
-	T_CreateRangeStmt,
-	T_AlterEnumStmt,
-	T_AlterTSDictionaryStmt,
-	T_AlterTSConfigurationStmt,
-	T_CreateFdwStmt,
-	T_AlterFdwStmt,
-	T_CreateForeignServerStmt,
-	T_AlterForeignServerStmt,
-	T_CreateUserMappingStmt,
-	T_AlterUserMappingStmt,
-	T_DropUserMappingStmt,
-	T_AlterTableSpaceOptionsStmt,
-	T_AlterTableMoveAllStmt,
-	T_SecLabelStmt,
-	T_CreateForeignTableStmt,
-	T_ImportForeignSchemaStmt,
-	T_CreateExtensionStmt,
-	T_AlterExtensionStmt,
-	T_AlterExtensionContentsStmt,
-	T_CreateEventTrigStmt,
-	T_AlterEventTrigStmt,
-	T_RefreshMatViewStmt,
-	T_ReplicaIdentityStmt,
-	T_AlterSystemStmt,
-	T_CreatePolicyStmt,
-	T_AlterPolicyStmt,
-	T_CreateTransformStmt,
-	T_CreateAmStmt,
-	T_CreatePublicationStmt,
-	T_AlterPublicationStmt,
-	T_CreateSubscriptionStmt,
-	T_AlterSubscriptionStmt,
-	T_DropSubscriptionStmt,
-	T_CreateStatsStmt,
-	T_AlterCollationStmt,
-	T_CallStmt,
-	T_AlterStatsStmt,
-
-	/*
-	 * TAGS FOR PARSE TREE NODES (parsenodes.h)
-	 */
-	T_A_Expr,
-	T_ColumnRef,
-	T_ParamRef,
-	T_A_Const,
-	T_FuncCall,
-	T_A_Star,
-	T_A_Indices,
-	T_A_Indirection,
-	T_A_ArrayExpr,
-	T_ResTarget,
-	T_MultiAssignRef,
-	T_TypeCast,
-	T_CollateClause,
-	T_SortBy,
-	T_WindowDef,
-	T_RangeSubselect,
-	T_RangeFunction,
-	T_RangeTableSample,
-	T_RangeTableFunc,
-	T_RangeTableFuncCol,
-	T_TypeName,
-	T_ColumnDef,
-	T_IndexElem,
-	T_StatsElem,
-	T_Constraint,
-	T_DefElem,
-	T_RangeTblEntry,
-	T_RangeTblFunction,
-	T_TableSampleClause,
-	T_WithCheckOption,
-	T_SortGroupClause,
-	T_GroupingSet,
-	T_WindowClause,
-	T_ObjectWithArgs,
-	T_AccessPriv,
-	T_CreateOpClassItem,
-	T_TableLikeClause,
-	T_FunctionParameter,
-	T_LockingClause,
-	T_RowMarkClause,
-	T_XmlSerialize,
-	T_WithClause,
-	T_InferClause,
-	T_OnConflictClause,
-	T_CTESearchClause,
-	T_CTECycleClause,
-	T_CommonTableExpr,
-	T_MergeWhenClause,
-	T_RoleSpec,
-	T_TriggerTransition,
-	T_PartitionElem,
-	T_PartitionSpec,
-	T_PartitionBoundSpec,
-	T_PartitionRangeDatum,
-	T_PartitionCmd,
-	T_VacuumRelation,
-	T_PublicationObjSpec,
-	T_PublicationTable,
-	T_JsonObjectConstructor,
-	T_JsonArrayConstructor,
-	T_JsonArrayQueryConstructor,
-	T_JsonAggConstructor,
-	T_JsonObjectAgg,
-	T_JsonArrayAgg,
-	T_JsonFuncExpr,
-	T_JsonIsPredicate,
-	T_JsonTable,
-	T_JsonTableColumn,
-	T_JsonTablePlan,
-	T_JsonCommon,
-	T_JsonArgument,
-	T_JsonKeyValue,
-	T_JsonBehavior,
-	T_JsonOutput,
-
-	/*
-	 * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h)
-	 */
-	T_IdentifySystemCmd,
-	T_BaseBackupCmd,
-	T_CreateReplicationSlotCmd,
-	T_DropReplicationSlotCmd,
-	T_ReadReplicationSlotCmd,
-	T_StartReplicationCmd,
-	T_TimeLineHistoryCmd,
-
-	/*
-	 * TAGS FOR RANDOM OTHER STUFF
-	 *
-	 * These are objects that aren't part of parse/plan/execute node tree
-	 * structures, but we give them NodeTags anyway for identification
-	 * purposes (usually because they are involved in APIs where we want to
-	 * pass multiple object types through the same pointer).
-	 */
-	T_TriggerData,				/* in commands/trigger.h */
-	T_EventTriggerData,			/* in commands/event_trigger.h */
-	T_ReturnSetInfo,			/* in nodes/execnodes.h */
-	T_WindowObjectData,			/* private in nodeWindowAgg.c */
-	T_TIDBitmap,				/* in nodes/tidbitmap.h */
-	T_InlineCodeBlock,			/* in nodes/parsenodes.h */
-	T_FdwRoutine,				/* in foreign/fdwapi.h */
-	T_IndexAmRoutine,			/* in access/amapi.h */
-	T_TableAmRoutine,			/* in access/tableam.h */
-	T_TsmRoutine,				/* in access/tsmapi.h */
-	T_ForeignKeyCacheInfo,		/* in utils/rel.h */
-	T_CallContext,				/* in nodes/parsenodes.h */
-	T_SupportRequestSimplify,	/* in nodes/supportnodes.h */
-	T_SupportRequestSelectivity,	/* in nodes/supportnodes.h */
-	T_SupportRequestCost,		/* in nodes/supportnodes.h */
-	T_SupportRequestRows,		/* in nodes/supportnodes.h */
-	T_SupportRequestIndexCondition, /* in nodes/supportnodes.h */
-	T_SupportRequestWFuncMonotonic	/* in nodes/supportnodes.h */
-#endif							/* OBSOLETE */
 } NodeTag;
 
 /*