text: /*-------------------------------------------------------------------------
   *
   * 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-2021, PostgreSQL Global Development Group
   * Portions Copyright (c) 1994, Regents of the University of California
   *
   * IDENTIFICATION
   *	  src/backend/nodes/copyfuncs.c
   *
   *-------------------------------------------------------------------------
   */
  
  #include "postgres.h"
  
  #include "miscadmin.h"
  #include "nodes/extensible.h"
  #include "nodes/pathnodes.h"
  #include "nodes/plannodes.h"
  #include "utils/datum.h"
  #include "utils/rel.h"
  
  
  /*
   * Macros to simplify copying of different kinds of fields.  Use these
   * wherever possible to reduce the chance for silly typos.  Note that these
   * hard-wire the convention that the local variables in a Copy routine are
   * named 'newnode' and 'from'.
   */
  
  /* Copy a simple scalar field (int, float, bool, enum, etc) */
  #define COPY_SCALAR_FIELD(fldname) \
  	(newnode->fldname = from->fldname)
  
  /* Copy a field that is a pointer to some kind of Node or Node tree */
  #define COPY_NODE_FIELD(fldname) \
  	(newnode->fldname = copyObjectImpl(from->fldname))
  
  /* Copy a field that is a pointer to a Bitmapset */
  #define COPY_BITMAPSET_FIELD(fldname) \
  	(newnode->fldname = bms_copy(from->fldname))
  
  /* Copy a field that is a pointer to a C string, or perhaps NULL */
  #define COPY_STRING_FIELD(fldname) \
  	(newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
  
  /* Copy a field that is a pointer to a simple palloc'd object of size sz */
  #define COPY_POINTER_FIELD(fldname, sz) \
  	do { \
  		Size	_size = (sz); \
  		newnode->fldname = palloc(_size); \
  		memcpy(newnode->fldname, from->fldname, _size); \
  	} while (0)
  
  /* Copy a parse location field (for Copy, this is same as scalar case) */
  #define COPY_LOCATION_FIELD(fldname) \
  	(newnode->fldname = from->fldname)
  
  
  /* ****************************************************************
   *					 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);
  }
  
  /*
   * _copyPlan
   */
  static Plan *
  _copyPlan(const Plan *from)
  {
  	Plan	   *newnode = makeNode(Plan);
  
  	/*
  	 * copy node superclass fields
  	 */
  	CopyPlanFields(from, newnode);
  
  	return newnode;
  }
  
  
  /*
   * _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(onConflictWhere);
  	COPY_SCALAR_FIELD(exclRelRTI);
  	COPY_NODE_FIELD(exclRelTlist);
  
  	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);
  	if (from->numCols > 0)
  	{
  		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(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);
  
  	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(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);
  	COPY_SCALAR_FIELD(resultRelation);
  
  	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);
  }
  
  
  /*
   * _copyJoin
   */
  static Join *
  _copyJoin(const Join *from)
  {
  	Join	   *newnode = makeNode(Join);
  
  	/*
  	 * copy node superclass fields
  	 */
  	CopyJoinFields(from, newnode);
  
  	return newnode;
  }
  
  
  /*
   * _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);
  	if (numCols > 0)
  	{
  		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;
  }
  
  
  /*
   * 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);
  	if (from->numCols > 0)
  	{
  		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);
  	if (from->partNumCols > 0)
  	{
  		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);
  	if (from->ordNumCols > 0)
  	{
  		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_SCALAR_FIELD(startInRangeFunc);
  	COPY_SCALAR_FIELD(endInRangeFunc);
  	COPY_SCALAR_FIELD(inRangeColl);
  	COPY_SCALAR_FIELD(inRangeAsc);
  	COPY_SCALAR_FIELD(inRangeNullsFirst);
  
  	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_NODE_FIELD(ns_uris);
  	COPY_NODE_FIELD(ns_names);
  	COPY_NODE_FIELD(docexpr);
  	COPY_NODE_FIELD(rowexpr);
  	COPY_NODE_FIELD(colnames);
  	COPY_NODE_FIELD(coltypes);
  	COPY_NODE_FIELD(coltypmods);
  	COPY_NODE_FIELD(colcollations);
  	COPY_NODE_FIELD(colexprs);
  	COPY_NODE_FIELD(coldefexprs);
  	COPY_BITMAPSET_FIELD(notnulls);
  	COPY_SCALAR_FIELD(ordinalitycol);
  	COPY_LOCATION_FIELD(location);
  
  	return newnode;
  }
  
  /*
   * _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;
  }
  
  /*
   * _copyConst
   */
  static Const *
  _copyConst(const Const *from)
  {
  	Const	   *newnode = makeNode(Const);
  
  	COPY_SCALAR_FIELD(consttype);
  	COPY_SCALAR_FIELD(consttypmod);
  	COPY_SCALAR_FIELD(constcollid);
  	COPY_SCALAR_FIELD(constlen);
  
  	if (from->constbyval || from->constisnull)
  	{
  		/*
  		 * passed by value so just copy the datum. Also, don't try to copy
  		 * struct when value is null!
  		 */
  		newnode->constvalue = from->constvalue;
  	}
  	else
  	{
  		/*
  		 * passed by reference.  We need a palloc'd copy.
  		 */
  		newnode->constvalue = datumCopy(from->constvalue,
  										from->constbyval,
  										from->constlen);
  	}
  
  	COPY_SCALAR_FIELD(constisnull);
  	COPY_SCALAR_FIELD(constbyval);
  	COPY_LOCATION_FIELD(location);
  
  	return newnode;
  }
  
  /*
   * _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(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;
  }
  
  /* ****************************************************************
   *						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);
  
  	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_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 A_Expr *
  _copyAExpr(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;
  }
  
  static A_Const *
  _copyAConst(const A_Const *from)
  {
  	A_Const    *newnode = makeNode(A_Const);
  
  	/* This part must duplicate _copyValue */
  	COPY_SCALAR_FIELD(val.type);
  	switch (from->val.type)
  	{
  		case T_Integer:
  			COPY_SCALAR_FIELD(val.val.ival);
  			break;
  		case T_Float:
  		case T_String:
  		case T_BitString:
  			COPY_STRING_FIELD(val.val.str);
  			break;
  		case T_Null:
  			/* nothing to do */
  			break;
  		default:
  			elog(ERROR, "unrecognized node type: %d",
  				 (int) from->val.type);
  			break;
  	}
  
  	COPY_LOCATION_FIELD(location);
  
  	return newnode;
  }
  
  static FuncCall *
  _copyFuncCall(const FuncCall *from)
  {
  	FuncCall   *newnode = makeNode(FuncCall);
  
  	COPY_NODE_FIELD(funcname);
  	COPY_NODE_FIELD(args);
  	COPY_NODE_FIELD(agg_order);
  	COPY_NODE_FIELD(agg_filter);
  	COPY_NODE_FIELD(over);
  	COPY_SCALAR_FIELD(agg_within_group);
  	COPY_SCALAR_FIELD(agg_star);
  	COPY_SCALAR_FIELD(agg_distinct);
  	COPY_SCALAR_FIELD(func_variadic);
  	COPY_SCALAR_FIELD(funcformat);
  	COPY_LOCATION_FIELD(location);
  
  	return newnode;
  }
  
  static A_Star *
  _copyAStar(const A_Star *from)
  {
  	A_Star	   *newnode = makeNode(A_Star);
  
  	return newnode;
  }
  
  static A_Indices *
  _copyAIndices(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_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(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_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_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 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 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_NODE_FIELD(object);
  	COPY_SCALAR_FIELD(num);
  	COPY_NODE_FIELD(newowner);
  	COPY_NODE_FIELD(def);
  	COPY_SCALAR_FIELD(behavior);
  	COPY_SCALAR_FIELD(missing_ok);
  
  	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_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);
  
  	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(oldNode);
  	COPY_SCALAR_FIELD(oldCreateSubid);
  	COPY_SCALAR_FIELD(oldFirstRelfilenodeSubid);
  	COPY_SCALAR_FIELD(unique);
  	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(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);
  
  	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 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 CreatePublicationStmt *
  _copyCreatePublicationStmt(const CreatePublicationStmt *from)
  {
  	CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);
  
  	COPY_STRING_FIELD(pubname);
  	COPY_NODE_FIELD(options);
  	COPY_NODE_FIELD(tables);
  	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(tables);
  	COPY_SCALAR_FIELD(for_all_tables);
  	COPY_SCALAR_FIELD(tableAction);
  
  	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;
  }
  
  /* ****************************************************************
   *					extensible.h copy functions
   * ****************************************************************
   */
  static ExtensibleNode *
  _copyExtensibleNode(const ExtensibleNode *from)
  {
  	ExtensibleNode *newnode;
  	const ExtensibleNodeMethods *methods;
  
  	methods = GetExtensibleNodeMethods(from->extnodename, false);
  	newnode = (ExtensibleNode *) newNode(methods->node_size,
  										 T_ExtensibleNode);
  	COPY_STRING_FIELD(extnodename);
  
  	/* copy the private fields */
  	methods->nodeCopy(newnode, from);
  
  	return newnode;
  }
  
  /* ****************************************************************
   *					value.h copy functions
   * ****************************************************************
   */
  static Value *
  _copyValue(const Value *from)
  {
  	Value	   *newnode = makeNode(Value);
  
  	/* See also _copyAConst when changing this code! */
  
  	COPY_SCALAR_FIELD(type);
  	switch (from->type)
  	{
  		case T_Integer:
  			COPY_SCALAR_FIELD(val.ival);
  			break;
  		case T_Float:
  		case T_String:
  		case T_BitString:
  			COPY_STRING_FIELD(val.str);
  			break;
  		case T_Null:
  			/* nothing to do */
  			break;
  		default:
  			elog(ERROR, "unrecognized node type: %d",
  				 (int) from->type);
  			break;
  	}
  	return newnode;
  }
  
  
  static ForeignKeyCacheInfo *
  _copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from)
  {
  	ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo);
  
  	COPY_SCALAR_FIELD(conoid);
  	COPY_SCALAR_FIELD(conrelid);
  	COPY_SCALAR_FIELD(confrelid);
  	COPY_SCALAR_FIELD(nkeys);
  	/* COPY_SCALAR_FIELD might work for these, but let's not assume that */
  	memcpy(newnode->conkey, from->conkey, sizeof(newnode->conkey));
  	memcpy(newnode->confkey, from->confkey, sizeof(newnode->confkey));
  	memcpy(newnode->conpfeqop, from->conpfeqop, sizeof(newnode->conpfeqop));
  
  	return newnode;
  }
  
  
  /*
   * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
   *
   * Create a copy of a Node tree or list.  This is a "deep" copy: all
   * substructure is copied too, recursively.
   */
  void *
  copyObjectImpl(const void *from)
  {
  	void	   *retval;
  
  	if (from == NULL)
  		return NULL;
  
  	/* Guard against stack overflow due to overly complex expressions */
  	check_stack_depth();
  
  	switch (nodeTag(from))
  	{
  			/*
  			 * PLAN NODES
  			 */
  		case T_PlannedStmt:
  			retval = _copyPlannedStmt(from);
  			break;
  		case T_Plan:
  			retval = _copyPlan(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_Join:
  			retval = _copyJoin(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_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;
  
  			/*
  			 * 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:
  		case T_Float:
  		case T_String:
  		case T_BitString:
  		case T_Null:
  			retval = _copyValue(from);
  			break;
  
  			/*
  			 * LIST NODES
  			 */
  		case T_List:
  			retval = list_copy_deep(from);
  			break;
  
  			/*
  			 * Lists of integers and OIDs don't need to be deep-copied, so we
  			 * perform a shallow copy via list_copy()
  			 */
  		case T_IntList:
  		case T_OidList:
  			retval = list_copy(from);
  			break;
  
  			/*
  			 * 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_SelectStmt:
  			retval = _copySelectStmt(from);
  			break;
  		case T_SetOperationStmt:
  			retval = _copySetOperationStmt(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_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_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 = _copyAExpr(from);
  			break;
  		case T_ColumnRef:
  			retval = _copyColumnRef(from);
  			break;
  		case T_ParamRef:
  			retval = _copyParamRef(from);
  			break;
  		case T_A_Const:
  			retval = _copyAConst(from);
  			break;
  		case T_FuncCall:
  			retval = _copyFuncCall(from);
  			break;
  		case T_A_Star:
  			retval = _copyAStar(from);
  			break;
  		case T_A_Indices:
  			retval = _copyAIndices(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_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;
  
  			/*
  			 * MISCELLANEOUS NODES
  			 */
  		case T_ForeignKeyCacheInfo:
  			retval = _copyForeignKeyCacheInfo(from);
  			break;
  
  		default:
  			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
  			retval = 0;			/* keep compiler quiet */
  			break;
  	}
  
  	return retval;
  }
  