Restructure the code in copyfuncs and equalfuncs to put much heavier

reliance on macros, in hopes of eliminating silly typos (like copying
to the wrong field) and just generally making it easier to see the forest
instead of the trees.  As an example, here is the new code for A_Indices:

static A_Indices *
_copyAIndices(A_Indices *from)
{
	A_Indices  *newnode = makeNode(A_Indices);

	COPY_NODE_FIELD(lidx);
	COPY_NODE_FIELD(uidx);

	return newnode;
}

static bool
_equalAIndices(A_Indices *a, A_Indices *b)
{
	COMPARE_NODE_FIELD(lidx);
	COMPARE_NODE_FIELD(uidx);

	return true;
}

I plan to redo outfuncs/readfuncs in a similar style, but am committing
what I've got.

1 files changed, 874 insertions, 1075 deletions

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index da3bf7b7213..0f02b5d119b 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.221 2002/11/24 21:52:13 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.222 2002/11/25 03:33:27 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,11 +28,44 @@
 
 
 /*
- * Node_Copy
- *	  a macro to simplify calling of copyObject on the specified field
+ * 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'.
  */
-#define Node_Copy(from, newnode, field) \
-	((newnode)->field = copyObject((from)->field))
+
+/* 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 = copyObject(from->fldname))
+
+/* Copy a field that is a pointer to a list of integers */
+#define COPY_INTLIST_FIELD(fldname) \
+	(newnode->fldname = listCopy(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)
+
+/* Special hack for fixing subplan lists of Plan nodes (ick) */
+#define FIX_SUBPLAN_LINKS(subplanfldname, fldname) \
+	do { \
+		if (from->subplanfldname != NIL) \
+			newnode->subplanfldname = \
+				nconc(newnode->subplanfldname, \
+					  pull_subplans((Node *) (newnode->fldname))); \
+	} while (0)
 
 
 /*
@@ -73,41 +106,37 @@ listCopy(List *list)
  * ****************************************************************
  */
 
-/* ----------------
- *		CopyPlanFields
+/*
+ * 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(Plan *from, Plan *newnode)
 {
-	newnode->startup_cost = from->startup_cost;
-	newnode->total_cost = from->total_cost;
-	newnode->plan_rows = from->plan_rows;
-	newnode->plan_width = from->plan_width;
-	/* state is NOT copied */
-	Node_Copy(from, newnode, targetlist);
-	Node_Copy(from, newnode, qual);
-	Node_Copy(from, newnode, lefttree);
-	Node_Copy(from, newnode, righttree);
-	newnode->extParam = listCopy(from->extParam);
-	newnode->locParam = listCopy(from->locParam);
-	newnode->chgParam = listCopy(from->chgParam);
-	Node_Copy(from, newnode, initPlan);
+	COPY_SCALAR_FIELD(startup_cost);
+	COPY_SCALAR_FIELD(total_cost);
+	COPY_SCALAR_FIELD(plan_rows);
+	COPY_SCALAR_FIELD(plan_width);
+	/* execution state is NOT copied */
+	COPY_NODE_FIELD(targetlist);
+	COPY_NODE_FIELD(qual);
+	COPY_NODE_FIELD(lefttree);
+	COPY_NODE_FIELD(righttree);
+	COPY_INTLIST_FIELD(extParam);
+	COPY_INTLIST_FIELD(locParam);
+	COPY_INTLIST_FIELD(chgParam);
+	COPY_NODE_FIELD(initPlan);
 	/* subPlan list must point to subplans in the new subtree, not the old */
-	if (from->subPlan != NIL)
-		newnode->subPlan = nconc(pull_subplans((Node *) newnode->targetlist),
-								 pull_subplans((Node *) newnode->qual));
-	else
-		newnode->subPlan = NIL;
-	newnode->nParamExec = from->nParamExec;
+	newnode->subPlan = NIL;
+	FIX_SUBPLAN_LINKS(subPlan, targetlist);
+	FIX_SUBPLAN_LINKS(subPlan, qual);
+	COPY_SCALAR_FIELD(nParamExec);
 }
 
-/* ----------------
- *		_copyPlan
- * ----------------
+/*
+ * _copyPlan
  */
 static Plan *
 _copyPlan(Plan *from)
@@ -115,7 +144,7 @@ _copyPlan(Plan *from)
 	Plan	   *newnode = makeNode(Plan);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
 	CopyPlanFields(from, newnode);
 
@@ -123,9 +152,8 @@ _copyPlan(Plan *from)
 }
 
 
-/* ----------------
- *		_copyResult
- * ----------------
+/*
+ * _copyResult
  */
 static Result *
 _copyResult(Result *from)
@@ -140,22 +168,16 @@ _copyResult(Result *from)
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, resconstantqual);
+	COPY_NODE_FIELD(resconstantqual);
 
-	/*
-	 * We must add subplans in resconstantqual to the new plan's subPlan
-	 * list
-	 */
-	if (from->plan.subPlan != NIL)
-		newnode->plan.subPlan = nconc(newnode->plan.subPlan,
-								pull_subplans(newnode->resconstantqual));
+	/* subPlan list must point to subplans in the new subtree, not the old */
+	FIX_SUBPLAN_LINKS(plan.subPlan, resconstantqual);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyAppend
- * ----------------
+/*
+ * _copyAppend
  */
 static Append *
 _copyAppend(Append *from)
@@ -170,30 +192,29 @@ _copyAppend(Append *from)
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, appendplans);
-	newnode->isTarget = from->isTarget;
+	COPY_NODE_FIELD(appendplans);
+	COPY_SCALAR_FIELD(isTarget);
 
 	return newnode;
 }
 
 
-/* ----------------
- *		CopyScanFields
+/*
+ * 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(Scan *from, Scan *newnode)
 {
-	newnode->scanrelid = from->scanrelid;
-	return;
+	CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+	COPY_SCALAR_FIELD(scanrelid);
 }
 
-/* ----------------
- *		_copyScan
- * ----------------
+/*
+ * _copyScan
  */
 static Scan *
 _copyScan(Scan *from)
@@ -203,15 +224,13 @@ _copyScan(Scan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copySeqScan
- * ----------------
+/*
+ * _copySeqScan
  */
 static SeqScan *
 _copySeqScan(SeqScan *from)
@@ -221,15 +240,13 @@ _copySeqScan(SeqScan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyIndexScan
- * ----------------
+/*
+ * _copyIndexScan
  */
 static IndexScan *
 _copyIndexScan(IndexScan *from)
@@ -239,34 +256,25 @@ _copyIndexScan(IndexScan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	newnode->indxid = listCopy(from->indxid);
-	Node_Copy(from, newnode, indxqual);
-	Node_Copy(from, newnode, indxqualorig);
-	newnode->indxorderdir = from->indxorderdir;
+	COPY_INTLIST_FIELD(indxid);
+	COPY_NODE_FIELD(indxqual);
+	COPY_NODE_FIELD(indxqualorig);
+	COPY_SCALAR_FIELD(indxorderdir);
 
-	/*
-	 * We must add subplans in index quals to the new plan's subPlan list
-	 */
-	if (from->scan.plan.subPlan != NIL)
-	{
-		newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan,
-							  pull_subplans((Node *) newnode->indxqual));
-		newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan,
-						  pull_subplans((Node *) newnode->indxqualorig));
-	}
+	/* subPlan list must point to subplans in the new subtree, not the old */
+	FIX_SUBPLAN_LINKS(scan.plan.subPlan, indxqual);
+	FIX_SUBPLAN_LINKS(scan.plan.subPlan, indxqualorig);
 
 	return newnode;
 }
 
-/* ----------------
- *				_copyTidScan
- * ----------------
+/*
+ * _copyTidScan
  */
 static TidScan *
 _copyTidScan(TidScan *from)
@@ -276,21 +284,22 @@ _copyTidScan(TidScan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	newnode->needRescan = from->needRescan;
-	Node_Copy(from, newnode, tideval);
+	COPY_SCALAR_FIELD(needRescan);
+	COPY_NODE_FIELD(tideval);
+
+	/* subPlan list must point to subplans in the new subtree, not the old */
+	FIX_SUBPLAN_LINKS(scan.plan.subPlan, tideval);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copySubqueryScan
- * ----------------
+/*
+ * _copySubqueryScan
  */
 static SubqueryScan *
 _copySubqueryScan(SubqueryScan *from)
@@ -300,20 +309,18 @@ _copySubqueryScan(SubqueryScan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, subplan);
+	COPY_NODE_FIELD(subplan);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyFunctionScan
- * ----------------
+/*
+ * _copyFunctionScan
  */
 static FunctionScan *
 _copyFunctionScan(FunctionScan *from)
@@ -323,34 +330,32 @@ _copyFunctionScan(FunctionScan *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyScanFields((Scan *) from, (Scan *) newnode);
 
 	return newnode;
 }
 
-/* ----------------
- *		CopyJoinFields
+/*
+ * 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(Join *from, Join *newnode)
 {
-	newnode->jointype = from->jointype;
-	Node_Copy(from, newnode, joinqual);
+	CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+	COPY_SCALAR_FIELD(jointype);
+	COPY_NODE_FIELD(joinqual);
+
 	/* subPlan list must point to subplans in the new subtree, not the old */
-	if (from->plan.subPlan != NIL)
-		newnode->plan.subPlan = nconc(newnode->plan.subPlan,
-							  pull_subplans((Node *) newnode->joinqual));
+	FIX_SUBPLAN_LINKS(plan.subPlan, joinqual);
 }
 
 
-/* ----------------
- *		_copyJoin
- * ----------------
+/*
+ * _copyJoin
  */
 static Join *
 _copyJoin(Join *from)
@@ -360,16 +365,14 @@ _copyJoin(Join *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyJoinFields(from, newnode);
 
 	return newnode;
 }
 
 
-/* ----------------
- *		_copyNestLoop
- * ----------------
+/*
+ * _copyNestLoop
  */
 static NestLoop *
 _copyNestLoop(NestLoop *from)
@@ -379,16 +382,14 @@ _copyNestLoop(NestLoop *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyJoinFields((Join *) from, (Join *) newnode);
 
 	return newnode;
 }
 
 
-/* ----------------
- *		_copyMergeJoin
- * ----------------
+/*
+ * _copyMergeJoin
  */
 static MergeJoin *
 _copyMergeJoin(MergeJoin *from)
@@ -398,27 +399,21 @@ _copyMergeJoin(MergeJoin *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyJoinFields((Join *) from, (Join *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, mergeclauses);
+	COPY_NODE_FIELD(mergeclauses);
 
-	/*
-	 * We must add subplans in mergeclauses to the new plan's subPlan list
-	 */
-	if (from->join.plan.subPlan != NIL)
-		newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan,
-						  pull_subplans((Node *) newnode->mergeclauses));
+	/* subPlan list must point to subplans in the new subtree, not the old */
+	FIX_SUBPLAN_LINKS(join.plan.subPlan, mergeclauses);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyHashJoin
- * ----------------
+/*
+ * _copyHashJoin
  */
 static HashJoin *
 _copyHashJoin(HashJoin *from)
@@ -428,29 +423,23 @@ _copyHashJoin(HashJoin *from)
 	/*
 	 * copy node superclass fields
 	 */
-	CopyPlanFields((Plan *) from, (Plan *) newnode);
 	CopyJoinFields((Join *) from, (Join *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, hashclauses);
-	newnode->hashjoinop = from->hashjoinop;
+	COPY_NODE_FIELD(hashclauses);
+	COPY_SCALAR_FIELD(hashjoinop);
 
-	/*
-	 * We must add subplans in hashclauses to the new plan's subPlan list
-	 */
-	if (from->join.plan.subPlan != NIL)
-		newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan,
-						   pull_subplans((Node *) newnode->hashclauses));
+	/* subPlan list must point to subplans in the new subtree, not the old */
+	FIX_SUBPLAN_LINKS(join.plan.subPlan, hashclauses);
 
 	return newnode;
 }
 
 
-/* ----------------
- *		_copyMaterial
- * ----------------
+/*
+ * _copyMaterial
  */
 static Material *
 _copyMaterial(Material *from)
@@ -466,9 +455,8 @@ _copyMaterial(Material *from)
 }
 
 
-/* ----------------
- *		_copySort
- * ----------------
+/*
+ * _copySort
  */
 static Sort *
 _copySort(Sort *from)
@@ -480,15 +468,14 @@ _copySort(Sort *from)
 	 */
 	CopyPlanFields((Plan *) from, (Plan *) newnode);
 
-	newnode->keycount = from->keycount;
+	COPY_SCALAR_FIELD(keycount);
 
 	return newnode;
 }
 
 
-/* ----------------
- *		_copyGroup
- * ----------------
+/*
+ * _copyGroup
  */
 static Group *
 _copyGroup(Group *from)
@@ -497,17 +484,14 @@ _copyGroup(Group *from)
 
 	CopyPlanFields((Plan *) from, (Plan *) newnode);
 
-	newnode->numCols = from->numCols;
-	newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber));
-	memcpy(newnode->grpColIdx, from->grpColIdx,
-		   from->numCols * sizeof(AttrNumber));
+	COPY_SCALAR_FIELD(numCols);
+	COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
 
 	return newnode;
 }
 
-/* ---------------
- *	_copyAgg
- * --------------
+/*
+ * _copyAgg
  */
 static Agg *
 _copyAgg(Agg *from)
@@ -516,37 +500,17 @@ _copyAgg(Agg *from)
 
 	CopyPlanFields((Plan *) from, (Plan *) newnode);
 
-	newnode->aggstrategy = from->aggstrategy;
-	newnode->numCols = from->numCols;
+	COPY_SCALAR_FIELD(aggstrategy);
+	COPY_SCALAR_FIELD(numCols);
 	if (from->numCols > 0)
-	{
-		newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber));
-		memcpy(newnode->grpColIdx, from->grpColIdx,
-			   from->numCols * sizeof(AttrNumber));
-	}
-	newnode->numGroups = from->numGroups;
-
-	return newnode;
-}
-
-/* ---------------
- *	_copyGroupClause
- * --------------
- */
-static GroupClause *
-_copyGroupClause(GroupClause *from)
-{
-	GroupClause *newnode = makeNode(GroupClause);
-
-	newnode->tleSortGroupRef = from->tleSortGroupRef;
-	newnode->sortop = from->sortop;
+		COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
+	COPY_SCALAR_FIELD(numGroups);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyUnique
- * ----------------
+/*
+ * _copyUnique
  */
 static Unique *
 _copyUnique(Unique *from)
@@ -561,16 +525,14 @@ _copyUnique(Unique *from)
 	/*
 	 * copy remainder of node
 	 */
-	newnode->numCols = from->numCols;
-	newnode->uniqColIdx = palloc(from->numCols * sizeof(AttrNumber));
-	memcpy(newnode->uniqColIdx, from->uniqColIdx, from->numCols * sizeof(AttrNumber));
+	COPY_SCALAR_FIELD(numCols);
+	COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
 
 	return newnode;
 }
 
-/* ----------------
- *		_copySetOp
- * ----------------
+/*
+ * _copySetOp
  */
 static SetOp *
 _copySetOp(SetOp *from)
@@ -585,18 +547,16 @@ _copySetOp(SetOp *from)
 	/*
 	 * copy remainder of node
 	 */
-	newnode->cmd = from->cmd;
-	newnode->numCols = from->numCols;
-	newnode->dupColIdx = palloc(from->numCols * sizeof(AttrNumber));
-	memcpy(newnode->dupColIdx, from->dupColIdx, from->numCols * sizeof(AttrNumber));
-	newnode->flagColIdx = from->flagColIdx;
+	COPY_SCALAR_FIELD(cmd);
+	COPY_SCALAR_FIELD(numCols);
+	COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
+	COPY_SCALAR_FIELD(flagColIdx);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyLimit
- * ----------------
+/*
+ * _copyLimit
  */
 static Limit *
 _copyLimit(Limit *from)
@@ -611,15 +571,14 @@ _copyLimit(Limit *from)
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, limitOffset);
-	Node_Copy(from, newnode, limitCount);
+	COPY_NODE_FIELD(limitOffset);
+	COPY_NODE_FIELD(limitCount);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyHash
- * ----------------
+/*
+ * _copyHash
  */
 static Hash *
 _copyHash(Hash *from)
@@ -634,7 +593,9 @@ _copyHash(Hash *from)
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, hashkey);
+	COPY_NODE_FIELD(hashkey);
+
+	/* XXX could the hashkey contain subplans?  Not at present... */
 
 	return newnode;
 }
@@ -644,12 +605,12 @@ _copySubPlan(SubPlan *from)
 {
 	SubPlan    *newnode = makeNode(SubPlan);
 
-	Node_Copy(from, newnode, plan);
-	newnode->plan_id = from->plan_id;
-	Node_Copy(from, newnode, rtable);
-	newnode->setParam = listCopy(from->setParam);
-	newnode->parParam = listCopy(from->parParam);
-	Node_Copy(from, newnode, sublink);
+	COPY_NODE_FIELD(plan);
+	COPY_SCALAR_FIELD(plan_id);
+	COPY_NODE_FIELD(rtable);
+	COPY_INTLIST_FIELD(setParam);
+	COPY_INTLIST_FIELD(parParam);
+	COPY_NODE_FIELD(sublink);
 
 	/* do not copy execution state */
 	newnode->needShutdown = false;
@@ -663,24 +624,22 @@ _copySubPlan(SubPlan *from)
  * ****************************************************************
  */
 
-/* ----------------
- *		_copyResdom
- * ----------------
+/*
+ * _copyResdom
  */
 static Resdom *
 _copyResdom(Resdom *from)
 {
 	Resdom	   *newnode = makeNode(Resdom);
 
-	newnode->resno = from->resno;
-	newnode->restype = from->restype;
-	newnode->restypmod = from->restypmod;
-	if (from->resname != NULL)
-		newnode->resname = pstrdup(from->resname);
-	newnode->ressortgroupref = from->ressortgroupref;
-	newnode->reskey = from->reskey;
-	newnode->reskeyop = from->reskeyop;
-	newnode->resjunk = from->resjunk;
+	COPY_SCALAR_FIELD(resno);
+	COPY_SCALAR_FIELD(restype);
+	COPY_SCALAR_FIELD(restypmod);
+	COPY_STRING_FIELD(resname);
+	COPY_SCALAR_FIELD(ressortgroupref);
+	COPY_SCALAR_FIELD(reskey);
+	COPY_SCALAR_FIELD(reskeyop);
+	COPY_SCALAR_FIELD(resjunk);
 
 	return newnode;
 }
@@ -690,112 +649,105 @@ _copyFjoin(Fjoin *from)
 {
 	Fjoin	   *newnode = makeNode(Fjoin);
 
-	/*
-	 * copy node superclass fields
-	 */
+	COPY_SCALAR_FIELD(fj_initialized);
+	COPY_SCALAR_FIELD(fj_nNodes);
+	COPY_NODE_FIELD(fj_innerNode);
+	COPY_POINTER_FIELD(fj_results, from->fj_nNodes * sizeof(Datum));
+	COPY_POINTER_FIELD(fj_alwaysDone, from->fj_nNodes * sizeof(bool));
 
-	newnode->fj_initialized = from->fj_initialized;
-	newnode->fj_nNodes = from->fj_nNodes;
+	return newnode;
+}
 
-	Node_Copy(from, newnode, fj_innerNode);
+static Alias *
+_copyAlias(Alias *from)
+{
+	Alias	   *newnode = makeNode(Alias);
 
-	newnode->fj_results = (DatumPtr)
-		palloc((from->fj_nNodes) * sizeof(Datum));
-	memmove(from->fj_results,
-			newnode->fj_results,
-			(from->fj_nNodes) * sizeof(Datum));
+	COPY_STRING_FIELD(aliasname);
+	COPY_NODE_FIELD(colnames);
 
-	newnode->fj_alwaysDone = (BoolPtr)
-		palloc((from->fj_nNodes) * sizeof(bool));
-	memmove(from->fj_alwaysDone,
-			newnode->fj_alwaysDone,
-			(from->fj_nNodes) * sizeof(bool));
+	return newnode;
+}
 
+static RangeVar *
+_copyRangeVar(RangeVar *from)
+{
+	RangeVar   *newnode = makeNode(RangeVar);
+
+	COPY_STRING_FIELD(catalogname);
+	COPY_STRING_FIELD(schemaname);
+	COPY_STRING_FIELD(relname);
+	COPY_SCALAR_FIELD(inhOpt);
+	COPY_SCALAR_FIELD(istemp);
+	COPY_NODE_FIELD(alias);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyExpr
- * ----------------
+/*
+ * _copyExpr
  */
 static Expr *
 _copyExpr(Expr *from)
 {
 	Expr	   *newnode = makeNode(Expr);
 
-	/*
-	 * copy node superclass fields
-	 */
-	newnode->typeOid = from->typeOid;
-	newnode->opType = from->opType;
-
-	Node_Copy(from, newnode, oper);
-	Node_Copy(from, newnode, args);
+	COPY_SCALAR_FIELD(typeOid);
+	COPY_SCALAR_FIELD(opType);
+	COPY_NODE_FIELD(oper);
+	COPY_NODE_FIELD(args);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyVar
- * ----------------
+/*
+ * _copyVar
  */
 static Var *
 _copyVar(Var *from)
 {
 	Var		   *newnode = makeNode(Var);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->varno = from->varno;
-	newnode->varattno = from->varattno;
-	newnode->vartype = from->vartype;
-	newnode->vartypmod = from->vartypmod;
-	newnode->varlevelsup = from->varlevelsup;
-
-	newnode->varnoold = from->varnoold;
-	newnode->varoattno = from->varoattno;
+	COPY_SCALAR_FIELD(varno);
+	COPY_SCALAR_FIELD(varattno);
+	COPY_SCALAR_FIELD(vartype);
+	COPY_SCALAR_FIELD(vartypmod);
+	COPY_SCALAR_FIELD(varlevelsup);
+	COPY_SCALAR_FIELD(varnoold);
+	COPY_SCALAR_FIELD(varoattno);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyOper
- * ----------------
+/*
+ * _copyOper
  */
 static Oper *
 _copyOper(Oper *from)
 {
 	Oper	   *newnode = makeNode(Oper);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->opno = from->opno;
-	newnode->opid = from->opid;
-	newnode->opresulttype = from->opresulttype;
-	newnode->opretset = from->opretset;
+	COPY_SCALAR_FIELD(opno);
+	COPY_SCALAR_FIELD(opid);
+	COPY_SCALAR_FIELD(opresulttype);
+	COPY_SCALAR_FIELD(opretset);
+
 	/* Do not copy the run-time state, if any */
 	newnode->op_fcache = NULL;
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyConst
- * ----------------
+/*
+ * _copyConst
  */
 static Const *
 _copyConst(Const *from)
 {
 	Const	   *newnode = makeNode(Const);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->consttype = from->consttype;
-	newnode->constlen = from->constlen;
+	COPY_SCALAR_FIELD(consttype);
+	COPY_SCALAR_FIELD(constlen);
 
 	if (from->constbyval || from->constisnull)
 	{
@@ -808,141 +760,119 @@ _copyConst(Const *from)
 	else
 	{
 		/*
-		 * not passed by value.  We need a palloc'd copy.
+		 * passed by reference.  We need a palloc'd copy.
 		 */
 		newnode->constvalue = datumCopy(from->constvalue,
 										from->constbyval,
 										from->constlen);
 	}
 
-	newnode->constisnull = from->constisnull;
-	newnode->constbyval = from->constbyval;
-	newnode->constisset = from->constisset;
-	newnode->constiscast = from->constiscast;
+	COPY_SCALAR_FIELD(constisnull);
+	COPY_SCALAR_FIELD(constbyval);
+	COPY_SCALAR_FIELD(constisset);
+	COPY_SCALAR_FIELD(constiscast);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyParam
- * ----------------
+/*
+ * _copyParam
  */
 static Param *
 _copyParam(Param *from)
 {
 	Param	   *newnode = makeNode(Param);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->paramkind = from->paramkind;
-	newnode->paramid = from->paramid;
-
-	if (from->paramname != NULL)
-		newnode->paramname = pstrdup(from->paramname);
-	newnode->paramtype = from->paramtype;
+	COPY_SCALAR_FIELD(paramkind);
+	COPY_SCALAR_FIELD(paramid);
+	COPY_STRING_FIELD(paramname);
+	COPY_SCALAR_FIELD(paramtype);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyFunc
- * ----------------
+/*
+ * _copyFunc
  */
 static Func *
 _copyFunc(Func *from)
 {
 	Func	   *newnode = makeNode(Func);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->funcid = from->funcid;
-	newnode->funcresulttype = from->funcresulttype;
-	newnode->funcretset = from->funcretset;
-	newnode->funcformat = from->funcformat;
+	COPY_SCALAR_FIELD(funcid);
+	COPY_SCALAR_FIELD(funcresulttype);
+	COPY_SCALAR_FIELD(funcretset);
+	COPY_SCALAR_FIELD(funcformat);
+
 	/* Do not copy the run-time state, if any */
 	newnode->func_fcache = NULL;
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyAggref
- * ----------------
+/*
+ * _copyAggref
  */
 static Aggref *
 _copyAggref(Aggref *from)
 {
 	Aggref	   *newnode = makeNode(Aggref);
 
-	newnode->aggfnoid = from->aggfnoid;
-	newnode->aggtype = from->aggtype;
-	Node_Copy(from, newnode, target);
-	newnode->aggstar = from->aggstar;
-	newnode->aggdistinct = from->aggdistinct;
-	newnode->aggno = from->aggno;		/* probably not needed */
+	COPY_SCALAR_FIELD(aggfnoid);
+	COPY_SCALAR_FIELD(aggtype);
+	COPY_NODE_FIELD(target);
+	COPY_SCALAR_FIELD(aggstar);
+	COPY_SCALAR_FIELD(aggdistinct);
+	COPY_SCALAR_FIELD(aggno);	/* probably not necessary */
 
 	return newnode;
 }
 
-/* ----------------
- *		_copySubLink
- * ----------------
+/*
+ * _copySubLink
  */
 static SubLink *
 _copySubLink(SubLink *from)
 {
 	SubLink    *newnode = makeNode(SubLink);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->subLinkType = from->subLinkType;
-	newnode->useor = from->useor;
-	Node_Copy(from, newnode, lefthand);
-	Node_Copy(from, newnode, oper);
-	Node_Copy(from, newnode, subselect);
+	COPY_SCALAR_FIELD(subLinkType);
+	COPY_SCALAR_FIELD(useor);
+	COPY_NODE_FIELD(lefthand);
+	COPY_NODE_FIELD(oper);
+	COPY_NODE_FIELD(subselect);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyFieldSelect
- * ----------------
+/*
+ * _copyFieldSelect
  */
 static FieldSelect *
 _copyFieldSelect(FieldSelect *from)
 {
 	FieldSelect *newnode = makeNode(FieldSelect);
 
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, arg);
-	newnode->fieldnum = from->fieldnum;
-	newnode->resulttype = from->resulttype;
-	newnode->resulttypmod = from->resulttypmod;
+	COPY_NODE_FIELD(arg);
+	COPY_SCALAR_FIELD(fieldnum);
+	COPY_SCALAR_FIELD(resulttype);
+	COPY_SCALAR_FIELD(resulttypmod);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyRelabelType
- * ----------------
+/*
+ * _copyRelabelType
  */
 static RelabelType *
 _copyRelabelType(RelabelType *from)
 {
 	RelabelType *newnode = makeNode(RelabelType);
 
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, arg);
-	newnode->resulttype = from->resulttype;
-	newnode->resulttypmod = from->resulttypmod;
-	newnode->relabelformat = from->relabelformat;
+	COPY_NODE_FIELD(arg);
+	COPY_SCALAR_FIELD(resulttype);
+	COPY_SCALAR_FIELD(resulttypmod);
+	COPY_SCALAR_FIELD(relabelformat);
 
 	return newnode;
 }
@@ -952,18 +882,7 @@ _copyRangeTblRef(RangeTblRef *from)
 {
 	RangeTblRef *newnode = makeNode(RangeTblRef);
 
-	newnode->rtindex = from->rtindex;
-
-	return newnode;
-}
-
-static FromExpr *
-_copyFromExpr(FromExpr *from)
-{
-	FromExpr   *newnode = makeNode(FromExpr);
-
-	Node_Copy(from, newnode, fromlist);
-	Node_Copy(from, newnode, quals);
+	COPY_SCALAR_FIELD(rtindex);
 
 	return newnode;
 }
@@ -973,114 +892,25 @@ _copyJoinExpr(JoinExpr *from)
 {
 	JoinExpr   *newnode = makeNode(JoinExpr);
 
-	newnode->jointype = from->jointype;
-	newnode->isNatural = from->isNatural;
-	Node_Copy(from, newnode, larg);
-	Node_Copy(from, newnode, rarg);
-	Node_Copy(from, newnode, using);
-	Node_Copy(from, newnode, quals);
-	Node_Copy(from, newnode, alias);
-	newnode->rtindex = from->rtindex;
-
-	return newnode;
-}
-
-static CaseExpr *
-_copyCaseExpr(CaseExpr *from)
-{
-	CaseExpr   *newnode = makeNode(CaseExpr);
-
-	/*
-	 * copy remainder of node
-	 */
-	newnode->casetype = from->casetype;
-
-	Node_Copy(from, newnode, arg);
-	Node_Copy(from, newnode, args);
-	Node_Copy(from, newnode, defresult);
-
-	return newnode;
-}
-
-static CaseWhen *
-_copyCaseWhen(CaseWhen *from)
-{
-	CaseWhen   *newnode = makeNode(CaseWhen);
-
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, expr);
-	Node_Copy(from, newnode, result);
+	COPY_SCALAR_FIELD(jointype);
+	COPY_SCALAR_FIELD(isNatural);
+	COPY_NODE_FIELD(larg);
+	COPY_NODE_FIELD(rarg);
+	COPY_NODE_FIELD(using);
+	COPY_NODE_FIELD(quals);
+	COPY_NODE_FIELD(alias);
+	COPY_SCALAR_FIELD(rtindex);
 
 	return newnode;
 }
 
-static NullTest *
-_copyNullTest(NullTest *from)
-{
-	NullTest   *newnode = makeNode(NullTest);
-
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, arg);
-	newnode->nulltesttype = from->nulltesttype;
-
-	return newnode;
-}
-
-static BooleanTest *
-_copyBooleanTest(BooleanTest *from)
-{
-	BooleanTest *newnode = makeNode(BooleanTest);
-
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, arg);
-	newnode->booltesttype = from->booltesttype;
-
-	return newnode;
-}
-
-static ConstraintTest *
-_copyConstraintTest(ConstraintTest *from)
-{
-	ConstraintTest *newnode = makeNode(ConstraintTest);
-
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, arg);
-	newnode->testtype = from->testtype;
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	if (from->domname)
-		newnode->domname = pstrdup(from->domname);
-	Node_Copy(from, newnode, check_expr);
-
-	return newnode;
-}
-
-static ConstraintTestValue *
-_copyConstraintTestValue(ConstraintTestValue *from)
+static FromExpr *
+_copyFromExpr(FromExpr *from)
 {
-	ConstraintTestValue *newnode = makeNode(ConstraintTestValue);
-
-	/*
-	 * copy remainder of node
-	 */
-	newnode->typeId = from->typeId;
-	newnode->typeMod = from->typeMod;
-
-	return newnode;
-}
+	FromExpr   *newnode = makeNode(FromExpr);
 
-static DomainConstraintValue *
-_copyDomainConstraintValue(DomainConstraintValue *from)
-{
-	DomainConstraintValue *newnode = makeNode(DomainConstraintValue);
+	COPY_NODE_FIELD(fromlist);
+	COPY_NODE_FIELD(quals);
 
 	return newnode;
 }
@@ -1090,130 +920,112 @@ _copyArrayRef(ArrayRef *from)
 {
 	ArrayRef   *newnode = makeNode(ArrayRef);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->refrestype = from->refrestype;
-	newnode->refattrlength = from->refattrlength;
-	newnode->refelemlength = from->refelemlength;
-	newnode->refelembyval = from->refelembyval;
-	newnode->refelemalign = from->refelemalign;
-
-	Node_Copy(from, newnode, refupperindexpr);
-	Node_Copy(from, newnode, reflowerindexpr);
-	Node_Copy(from, newnode, refexpr);
-	Node_Copy(from, newnode, refassgnexpr);
+	COPY_SCALAR_FIELD(refrestype);
+	COPY_SCALAR_FIELD(refattrlength);
+	COPY_SCALAR_FIELD(refelemlength);
+	COPY_SCALAR_FIELD(refelembyval);
+	COPY_SCALAR_FIELD(refelemalign);
+	COPY_NODE_FIELD(refupperindexpr);
+	COPY_NODE_FIELD(reflowerindexpr);
+	COPY_NODE_FIELD(refexpr);
+	COPY_NODE_FIELD(refassgnexpr);
 
 	return newnode;
 }
 
 /* ****************************************************************
  *						relation.h copy functions
+ *
+ * XXX the code to copy RelOptInfo and Path nodes is really completely bogus,
+ * because it makes no attempt to deal with multiple links from RelOptInfo
+ * to Paths, nor with back-links from Paths to their parent RelOptInfo.
+ * Currently, since we never actually try to copy a RelOptInfo, this is okay.
  * ****************************************************************
  */
 
-/* ----------------
- *		_copyRelOptInfo
- * ----------------
+/*
+ * _copyRelOptInfo
  */
 static RelOptInfo *
 _copyRelOptInfo(RelOptInfo *from)
 {
 	RelOptInfo *newnode = makeNode(RelOptInfo);
 
-	newnode->reloptkind = from->reloptkind;
-
-	newnode->relids = listCopy(from->relids);
-
-	newnode->rows = from->rows;
-	newnode->width = from->width;
-
-	Node_Copy(from, newnode, targetlist);
-	Node_Copy(from, newnode, pathlist);
+	COPY_SCALAR_FIELD(reloptkind);
+	COPY_INTLIST_FIELD(relids);
+	COPY_SCALAR_FIELD(rows);
+	COPY_SCALAR_FIELD(width);
+	COPY_NODE_FIELD(targetlist);
+	COPY_NODE_FIELD(pathlist);
 	/* XXX cheapest-path fields should point to members of pathlist? */
-	Node_Copy(from, newnode, cheapest_startup_path);
-	Node_Copy(from, newnode, cheapest_total_path);
-	newnode->pruneable = from->pruneable;
-
-	newnode->rtekind = from->rtekind;
-	Node_Copy(from, newnode, indexlist);
-	newnode->pages = from->pages;
-	newnode->tuples = from->tuples;
-	Node_Copy(from, newnode, subplan);
-
-	newnode->joinrti = from->joinrti;
-	newnode->joinrteids = listCopy(from->joinrteids);
-
-	Node_Copy(from, newnode, baserestrictinfo);
-	newnode->baserestrictcost = from->baserestrictcost;
-	newnode->outerjoinset = listCopy(from->outerjoinset);
-	Node_Copy(from, newnode, joininfo);
-
-	newnode->index_outer_relids = listCopy(from->index_outer_relids);
-	Node_Copy(from, newnode, index_inner_paths);
+	COPY_NODE_FIELD(cheapest_startup_path);
+	COPY_NODE_FIELD(cheapest_total_path);
+	COPY_SCALAR_FIELD(pruneable);
+	COPY_SCALAR_FIELD(rtekind);
+	COPY_NODE_FIELD(indexlist);
+	COPY_SCALAR_FIELD(pages);
+	COPY_SCALAR_FIELD(tuples);
+	COPY_NODE_FIELD(subplan);
+	COPY_SCALAR_FIELD(joinrti);
+	COPY_INTLIST_FIELD(joinrteids);
+	COPY_NODE_FIELD(baserestrictinfo);
+	COPY_SCALAR_FIELD(baserestrictcost);
+	COPY_INTLIST_FIELD(outerjoinset);
+	COPY_NODE_FIELD(joininfo);
+	COPY_INTLIST_FIELD(index_outer_relids);
+	COPY_NODE_FIELD(index_inner_paths);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyIndexOptInfo
- * ----------------
+/*
+ * _copyIndexOptInfo
  */
 static IndexOptInfo *
 _copyIndexOptInfo(IndexOptInfo *from)
 {
 	IndexOptInfo *newnode = makeNode(IndexOptInfo);
-	Size		len;
-
-	newnode->indexoid = from->indexoid;
-	newnode->pages = from->pages;
-	newnode->tuples = from->tuples;
 
-	newnode->ncolumns = from->ncolumns;
-	newnode->nkeys = from->nkeys;
+	COPY_SCALAR_FIELD(indexoid);
+	COPY_SCALAR_FIELD(pages);
+	COPY_SCALAR_FIELD(tuples);
+	COPY_SCALAR_FIELD(ncolumns);
+	COPY_SCALAR_FIELD(nkeys);
 
 	if (from->classlist)
 	{
 		/* copy the trailing zero too */
-		len = (from->ncolumns + 1) * sizeof(Oid);
-		newnode->classlist = (Oid *) palloc(len);
-		memcpy(newnode->classlist, from->classlist, len);
+		COPY_POINTER_FIELD(classlist, (from->ncolumns + 1) * sizeof(Oid));
 	}
 
 	if (from->indexkeys)
 	{
 		/* copy the trailing zero too */
-		len = (from->nkeys + 1) * sizeof(int);
-		newnode->indexkeys = (int *) palloc(len);
-		memcpy(newnode->indexkeys, from->indexkeys, len);
+		COPY_POINTER_FIELD(indexkeys, (from->nkeys + 1) * sizeof(int));
 	}
 
 	if (from->ordering)
 	{
 		/* copy the trailing zero too */
-		len = (from->ncolumns + 1) * sizeof(Oid);
-		newnode->ordering = (Oid *) palloc(len);
-		memcpy(newnode->ordering, from->ordering, len);
+		COPY_POINTER_FIELD(ordering, (from->ncolumns + 1) * sizeof(Oid));
 	}
 
-	newnode->relam = from->relam;
-	newnode->amcostestimate = from->amcostestimate;
-	newnode->indproc = from->indproc;
-	Node_Copy(from, newnode, indpred);
-	newnode->unique = from->unique;
-
-	newnode->outer_relids = listCopy(from->outer_relids);
-	Node_Copy(from, newnode, inner_paths);
+	COPY_SCALAR_FIELD(relam);
+	COPY_SCALAR_FIELD(amcostestimate);
+	COPY_SCALAR_FIELD(indproc);
+	COPY_NODE_FIELD(indpred);
+	COPY_SCALAR_FIELD(unique);
+	COPY_INTLIST_FIELD(outer_relids);
+	COPY_NODE_FIELD(inner_paths);
 
 	return newnode;
 }
 
-/* ----------------
- *		CopyPathFields
+/*
+ * CopyPathFields
  *
  *		This function copies the fields of the Path node.  It is used by
  *		all the copy functions for classes which inherit from Path.
- * ----------------
  */
 static void
 CopyPathFields(Path *from, Path *newnode)
@@ -1221,21 +1033,18 @@ CopyPathFields(Path *from, Path *newnode)
 	/*
 	 * Modify the next line, since it causes the copying to cycle (i.e.
 	 * the parent points right back here! -- JMH, 7/7/92. Old version:
-	 * Node_Copy(from, newnode, parent);
+	 * COPY_NODE_FIELD(parent);
 	 */
-	newnode->parent = from->parent;
-
-	newnode->startup_cost = from->startup_cost;
-	newnode->total_cost = from->total_cost;
+	COPY_SCALAR_FIELD(parent);
 
-	newnode->pathtype = from->pathtype;
-
-	Node_Copy(from, newnode, pathkeys);
+	COPY_SCALAR_FIELD(startup_cost);
+	COPY_SCALAR_FIELD(total_cost);
+	COPY_SCALAR_FIELD(pathtype);
+	COPY_NODE_FIELD(pathkeys);
 }
 
-/* ----------------
- *		_copyPath
- * ----------------
+/*
+ * _copyPath
  */
 static Path *
 _copyPath(Path *from)
@@ -1247,9 +1056,8 @@ _copyPath(Path *from)
 	return newnode;
 }
 
-/* ----------------
- *		_copyIndexPath
- * ----------------
+/*
+ * _copyIndexPath
  */
 static IndexPath *
 _copyIndexPath(IndexPath *from)
@@ -1257,24 +1065,23 @@ _copyIndexPath(IndexPath *from)
 	IndexPath  *newnode = makeNode(IndexPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
 	CopyPathFields((Path *) from, (Path *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, indexinfo);
-	Node_Copy(from, newnode, indexqual);
-	newnode->indexscandir = from->indexscandir;
-	newnode->rows = from->rows;
+	COPY_NODE_FIELD(indexinfo);
+	COPY_NODE_FIELD(indexqual);
+	COPY_SCALAR_FIELD(indexscandir);
+	COPY_SCALAR_FIELD(rows);
 
 	return newnode;
 }
 
-/* ----------------
- *				_copyTidPath
- * ----------------
+/*
+ * _copyTidPath
  */
 static TidPath *
 _copyTidPath(TidPath *from)
@@ -1282,22 +1089,21 @@ _copyTidPath(TidPath *from)
 	TidPath    *newnode = makeNode(TidPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
 	CopyPathFields((Path *) from, (Path *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, tideval);
-	newnode->unjoined_relids = listCopy(from->unjoined_relids);
+	COPY_NODE_FIELD(tideval);
+	COPY_INTLIST_FIELD(unjoined_relids);
 
 	return newnode;
 }
 
-/* ----------------
- *				_copyAppendPath
- * ----------------
+/*
+ * _copyAppendPath
  */
 static AppendPath *
 _copyAppendPath(AppendPath *from)
@@ -1305,21 +1111,20 @@ _copyAppendPath(AppendPath *from)
 	AppendPath *newnode = makeNode(AppendPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
 	CopyPathFields((Path *) from, (Path *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, subpaths);
+	COPY_NODE_FIELD(subpaths);
 
 	return newnode;
 }
 
-/* ----------------
- *				_copyResultPath
- * ----------------
+/*
+ * _copyResultPath
  */
 static ResultPath *
 _copyResultPath(ResultPath *from)
@@ -1327,38 +1132,38 @@ _copyResultPath(ResultPath *from)
 	ResultPath    *newnode = makeNode(ResultPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
 	CopyPathFields((Path *) from, (Path *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, subpath);
-	Node_Copy(from, newnode, constantqual);
+	COPY_NODE_FIELD(subpath);
+	COPY_NODE_FIELD(constantqual);
 
 	return newnode;
 }
 
-/* ----------------
- *		CopyJoinPathFields
+/*
+ * CopyJoinPathFields
  *
  *		This function copies the fields of the JoinPath node.  It is used by
  *		all the copy functions for classes which inherit from JoinPath.
- * ----------------
  */
 static void
 CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
 {
-	newnode->jointype = from->jointype;
-	Node_Copy(from, newnode, outerjoinpath);
-	Node_Copy(from, newnode, innerjoinpath);
-	Node_Copy(from, newnode, joinrestrictinfo);
+	CopyPathFields((Path *) from, (Path *) newnode);
+
+	COPY_SCALAR_FIELD(jointype);
+	COPY_NODE_FIELD(outerjoinpath);
+	COPY_NODE_FIELD(innerjoinpath);
+	COPY_NODE_FIELD(joinrestrictinfo);
 }
 
-/* ----------------
- *		_copyNestPath
- * ----------------
+/*
+ * _copyNestPath
  */
 static NestPath *
 _copyNestPath(NestPath *from)
@@ -1366,17 +1171,15 @@ _copyNestPath(NestPath *from)
 	NestPath   *newnode = makeNode(NestPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
-	CopyPathFields((Path *) from, (Path *) newnode);
 	CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyMergePath
- * ----------------
+/*
+ * _copyMergePath
  */
 static MergePath *
 _copyMergePath(MergePath *from)
@@ -1384,24 +1187,22 @@ _copyMergePath(MergePath *from)
 	MergePath  *newnode = makeNode(MergePath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
-	CopyPathFields((Path *) from, (Path *) newnode);
 	CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
 
 	/*
-	 * copy the remainder of the node
+	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, path_mergeclauses);
-	Node_Copy(from, newnode, outersortkeys);
-	Node_Copy(from, newnode, innersortkeys);
+	COPY_NODE_FIELD(path_mergeclauses);
+	COPY_NODE_FIELD(outersortkeys);
+	COPY_NODE_FIELD(innersortkeys);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyHashPath
- * ----------------
+/*
+ * _copyHashPath
  */
 static HashPath *
 _copyHashPath(HashPath *from)
@@ -1409,57 +1210,48 @@ _copyHashPath(HashPath *from)
 	HashPath   *newnode = makeNode(HashPath);
 
 	/*
-	 * copy the node superclass fields
+	 * copy node superclass fields
 	 */
-	CopyPathFields((Path *) from, (Path *) newnode);
 	CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
 
 	/*
 	 * copy remainder of node
 	 */
-	Node_Copy(from, newnode, path_hashclauses);
+	COPY_NODE_FIELD(path_hashclauses);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyPathKeyItem
- * ----------------
+/*
+ * _copyPathKeyItem
  */
 static PathKeyItem *
 _copyPathKeyItem(PathKeyItem *from)
 {
 	PathKeyItem *newnode = makeNode(PathKeyItem);
 
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, key);
-	newnode->sortop = from->sortop;
+	COPY_NODE_FIELD(key);
+	COPY_SCALAR_FIELD(sortop);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyRestrictInfo
- * ----------------
+/*
+ * _copyRestrictInfo
  */
 static RestrictInfo *
 _copyRestrictInfo(RestrictInfo *from)
 {
 	RestrictInfo *newnode = makeNode(RestrictInfo);
 
-	/*
-	 * copy remainder of node
-	 */
-	Node_Copy(from, newnode, clause);
-	newnode->ispusheddown = from->ispusheddown;
-	Node_Copy(from, newnode, subclauseindices);
-	newnode->eval_cost = from->eval_cost;
-	newnode->this_selec = from->this_selec;
-	newnode->mergejoinoperator = from->mergejoinoperator;
-	newnode->left_sortop = from->left_sortop;
-	newnode->right_sortop = from->right_sortop;
+	COPY_NODE_FIELD(clause);
+	COPY_SCALAR_FIELD(ispusheddown);
+	COPY_NODE_FIELD(subclauseindices); /* XXX probably bad */
+	COPY_SCALAR_FIELD(eval_cost);
+	COPY_SCALAR_FIELD(this_selec);
+	COPY_SCALAR_FIELD(mergejoinoperator);
+	COPY_SCALAR_FIELD(left_sortop);
+	COPY_SCALAR_FIELD(right_sortop);
 
 	/*
 	 * Do not copy pathkeys, since they'd not be canonical in a copied
@@ -1467,48 +1259,41 @@ _copyRestrictInfo(RestrictInfo *from)
 	 */
 	newnode->left_pathkey = NIL;
 	newnode->right_pathkey = NIL;
-	newnode->left_mergescansel = from->left_mergescansel;
-	newnode->right_mergescansel = from->right_mergescansel;
-	newnode->hashjoinoperator = from->hashjoinoperator;
-	newnode->left_bucketsize = from->left_bucketsize;
-	newnode->right_bucketsize = from->right_bucketsize;
+
+	COPY_SCALAR_FIELD(left_mergescansel);
+	COPY_SCALAR_FIELD(right_mergescansel);
+	COPY_SCALAR_FIELD(hashjoinoperator);
+	COPY_SCALAR_FIELD(left_bucketsize);
+	COPY_SCALAR_FIELD(right_bucketsize);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyJoinInfo
- * ----------------
+/*
+ * _copyJoinInfo
  */
 static JoinInfo *
 _copyJoinInfo(JoinInfo *from)
 {
 	JoinInfo   *newnode = makeNode(JoinInfo);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->unjoined_relids = listCopy(from->unjoined_relids);
-	Node_Copy(from, newnode, jinfo_restrictinfo);
+	COPY_INTLIST_FIELD(unjoined_relids);
+	COPY_NODE_FIELD(jinfo_restrictinfo);
 
 	return newnode;
 }
 
-/* ----------------
- *		_copyInnerIndexscanInfo
- * ----------------
+/*
+ * _copyInnerIndexscanInfo
  */
 static InnerIndexscanInfo *
 _copyInnerIndexscanInfo(InnerIndexscanInfo *from)
 {
 	InnerIndexscanInfo   *newnode = makeNode(InnerIndexscanInfo);
 
-	/*
-	 * copy remainder of node
-	 */
-	newnode->other_relids = listCopy(from->other_relids);
-	newnode->isouterjoin = from->isouterjoin;
-	Node_Copy(from, newnode, best_innerpath);
+	COPY_INTLIST_FIELD(other_relids);
+	COPY_SCALAR_FIELD(isouterjoin);
+	COPY_NODE_FIELD(best_innerpath);
 
 	return newnode;
 }
@@ -1523,9 +1308,10 @@ _copyTargetEntry(TargetEntry *from)
 {
 	TargetEntry *newnode = makeNode(TargetEntry);
 
-	Node_Copy(from, newnode, resdom);
-	Node_Copy(from, newnode, fjoin);
-	Node_Copy(from, newnode, expr);
+	COPY_NODE_FIELD(resdom);
+	COPY_NODE_FIELD(fjoin);
+	COPY_NODE_FIELD(expr);
+
 	return newnode;
 }
 
@@ -1534,20 +1320,20 @@ _copyRangeTblEntry(RangeTblEntry *from)
 {
 	RangeTblEntry *newnode = makeNode(RangeTblEntry);
 
-	newnode->rtekind = from->rtekind;
-	newnode->relid = from->relid;
-	Node_Copy(from, newnode, subquery);
-	Node_Copy(from, newnode, funcexpr);
-	Node_Copy(from, newnode, coldeflist);
-	newnode->jointype = from->jointype;
-	Node_Copy(from, newnode, joinaliasvars);
-	Node_Copy(from, newnode, alias);
-	Node_Copy(from, newnode, eref);
-	newnode->inh = from->inh;
-	newnode->inFromCl = from->inFromCl;
-	newnode->checkForRead = from->checkForRead;
-	newnode->checkForWrite = from->checkForWrite;
-	newnode->checkAsUser = from->checkAsUser;
+	COPY_SCALAR_FIELD(rtekind);
+	COPY_SCALAR_FIELD(relid);
+	COPY_NODE_FIELD(subquery);
+	COPY_NODE_FIELD(funcexpr);
+	COPY_NODE_FIELD(coldeflist);
+	COPY_SCALAR_FIELD(jointype);
+	COPY_NODE_FIELD(joinaliasvars);
+	COPY_NODE_FIELD(alias);
+	COPY_NODE_FIELD(eref);
+	COPY_SCALAR_FIELD(inh);
+	COPY_SCALAR_FIELD(inFromCl);
+	COPY_SCALAR_FIELD(checkForRead);
+	COPY_SCALAR_FIELD(checkForWrite);
+	COPY_SCALAR_FIELD(checkAsUser);
 
 	return newnode;
 }
@@ -1557,17 +1343,16 @@ _copyFkConstraint(FkConstraint *from)
 {
 	FkConstraint *newnode = makeNode(FkConstraint);
 
-	if (from->constr_name)
-		newnode->constr_name = pstrdup(from->constr_name);
-	Node_Copy(from, newnode, pktable);
-	Node_Copy(from, newnode, fk_attrs);
-	Node_Copy(from, newnode, pk_attrs);
-	newnode->fk_matchtype = from->fk_matchtype;
-	newnode->fk_upd_action = from->fk_upd_action;
-	newnode->fk_del_action = from->fk_del_action;
-	newnode->deferrable = from->deferrable;
-	newnode->initdeferred = from->initdeferred;
-	newnode->skip_validation = from->skip_validation;
+	COPY_STRING_FIELD(constr_name);
+	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_SCALAR_FIELD(deferrable);
+	COPY_SCALAR_FIELD(initdeferred);
+	COPY_SCALAR_FIELD(skip_validation);
 
 	return newnode;
 }
@@ -1577,8 +1362,19 @@ _copySortClause(SortClause *from)
 {
 	SortClause *newnode = makeNode(SortClause);
 
-	newnode->tleSortGroupRef = from->tleSortGroupRef;
-	newnode->sortop = from->sortop;
+	COPY_SCALAR_FIELD(tleSortGroupRef);
+	COPY_SCALAR_FIELD(sortop);
+
+	return newnode;
+}
+
+static GroupClause *
+_copyGroupClause(GroupClause *from)
+{
+	GroupClause *newnode = makeNode(GroupClause);
+
+	COPY_SCALAR_FIELD(tleSortGroupRef);
+	COPY_SCALAR_FIELD(sortop);
 
 	return newnode;
 }
@@ -1588,10 +1384,10 @@ _copyAExpr(A_Expr *from)
 {
 	A_Expr	   *newnode = makeNode(A_Expr);
 
-	newnode->oper = from->oper;
-	Node_Copy(from, newnode, name);
-	Node_Copy(from, newnode, lexpr);
-	Node_Copy(from, newnode, rexpr);
+	COPY_SCALAR_FIELD(oper);
+	COPY_NODE_FIELD(name);
+	COPY_NODE_FIELD(lexpr);
+	COPY_NODE_FIELD(rexpr);
 
 	return newnode;
 }
@@ -1601,8 +1397,8 @@ _copyColumnRef(ColumnRef *from)
 {
 	ColumnRef  *newnode = makeNode(ColumnRef);
 
-	Node_Copy(from, newnode, fields);
-	Node_Copy(from, newnode, indirection);
+	COPY_NODE_FIELD(fields);
+	COPY_NODE_FIELD(indirection);
 
 	return newnode;
 }
@@ -1612,9 +1408,9 @@ _copyParamRef(ParamRef *from)
 {
 	ParamRef   *newnode = makeNode(ParamRef);
 
-	newnode->number = from->number;
-	Node_Copy(from, newnode, fields);
-	Node_Copy(from, newnode, indirection);
+	COPY_SCALAR_FIELD(number);
+	COPY_NODE_FIELD(fields);
+	COPY_NODE_FIELD(indirection);
 
 	return newnode;
 }
@@ -1625,16 +1421,16 @@ _copyAConst(A_Const *from)
 	A_Const    *newnode = makeNode(A_Const);
 
 	/* This part must duplicate _copyValue */
-	newnode->val.type = from->val.type;
+	COPY_SCALAR_FIELD(val.type);
 	switch (from->val.type)
 	{
 		case T_Integer:
-			newnode->val.val.ival = from->val.val.ival;
+			COPY_SCALAR_FIELD(val.val.ival);
 			break;
 		case T_Float:
 		case T_String:
 		case T_BitString:
-			newnode->val.val.str = pstrdup(from->val.val.str);
+			COPY_STRING_FIELD(val.val.str);
 			break;
 		case T_Null:
 			/* nothing to do */
@@ -1644,7 +1440,7 @@ _copyAConst(A_Const *from)
 			break;
 	}
 
-	Node_Copy(from, newnode, typename);
+	COPY_NODE_FIELD(typename);
 
 	return newnode;
 }
@@ -1654,10 +1450,10 @@ _copyFuncCall(FuncCall *from)
 {
 	FuncCall   *newnode = makeNode(FuncCall);
 
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, args);
-	newnode->agg_star = from->agg_star;
-	newnode->agg_distinct = from->agg_distinct;
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(agg_star);
+	COPY_SCALAR_FIELD(agg_distinct);
 
 	return newnode;
 }
@@ -1667,8 +1463,8 @@ _copyAIndices(A_Indices *from)
 {
 	A_Indices  *newnode = makeNode(A_Indices);
 
-	Node_Copy(from, newnode, lidx);
-	Node_Copy(from, newnode, uidx);
+	COPY_NODE_FIELD(lidx);
+	COPY_NODE_FIELD(uidx);
 
 	return newnode;
 }
@@ -1678,9 +1474,9 @@ _copyExprFieldSelect(ExprFieldSelect *from)
 {
 	ExprFieldSelect *newnode = makeNode(ExprFieldSelect);
 
-	Node_Copy(from, newnode, arg);
-	Node_Copy(from, newnode, fields);
-	Node_Copy(from, newnode, indirection);
+	COPY_NODE_FIELD(arg);
+	COPY_NODE_FIELD(fields);
+	COPY_NODE_FIELD(indirection);
 
 	return newnode;
 }
@@ -1690,10 +1486,9 @@ _copyResTarget(ResTarget *from)
 {
 	ResTarget  *newnode = makeNode(ResTarget);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, indirection);
-	Node_Copy(from, newnode, val);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(indirection);
+	COPY_NODE_FIELD(val);
 
 	return newnode;
 }
@@ -1703,13 +1498,13 @@ _copyTypeName(TypeName *from)
 {
 	TypeName   *newnode = makeNode(TypeName);
 
-	Node_Copy(from, newnode, names);
-	newnode->typeid = from->typeid;
-	newnode->timezone = from->timezone;
-	newnode->setof = from->setof;
-	newnode->pct_type = from->pct_type;
-	newnode->typmod = from->typmod;
-	Node_Copy(from, newnode, arrayBounds);
+	COPY_NODE_FIELD(names);
+	COPY_SCALAR_FIELD(typeid);
+	COPY_SCALAR_FIELD(timezone);
+	COPY_SCALAR_FIELD(setof);
+	COPY_SCALAR_FIELD(pct_type);
+	COPY_SCALAR_FIELD(typmod);
+	COPY_NODE_FIELD(arrayBounds);
 
 	return newnode;
 }
@@ -1719,38 +1514,8 @@ _copySortGroupBy(SortGroupBy *from)
 {
 	SortGroupBy *newnode = makeNode(SortGroupBy);
 
-	Node_Copy(from, newnode, useOp);
-	Node_Copy(from, newnode, node);
-
-	return newnode;
-}
-
-static Alias *
-_copyAlias(Alias *from)
-{
-	Alias	   *newnode = makeNode(Alias);
-
-	if (from->aliasname)
-		newnode->aliasname = pstrdup(from->aliasname);
-	Node_Copy(from, newnode, colnames);
-
-	return newnode;
-}
-
-static RangeVar *
-_copyRangeVar(RangeVar *from)
-{
-	RangeVar   *newnode = makeNode(RangeVar);
-
-	if (from->catalogname)
-		newnode->catalogname = pstrdup(from->catalogname);
-	if (from->schemaname)
-		newnode->schemaname = pstrdup(from->schemaname);
-	if (from->relname)
-		newnode->relname = pstrdup(from->relname);
-	newnode->inhOpt = from->inhOpt;
-	newnode->istemp = from->istemp;
-	Node_Copy(from, newnode, alias);
+	COPY_NODE_FIELD(useOp);
+	COPY_NODE_FIELD(node);
 
 	return newnode;
 }
@@ -1760,8 +1525,8 @@ _copyRangeSubselect(RangeSubselect *from)
 {
 	RangeSubselect *newnode = makeNode(RangeSubselect);
 
-	Node_Copy(from, newnode, subquery);
-	Node_Copy(from, newnode, alias);
+	COPY_NODE_FIELD(subquery);
+	COPY_NODE_FIELD(alias);
 
 	return newnode;
 }
@@ -1771,9 +1536,9 @@ _copyRangeFunction(RangeFunction *from)
 {
 	RangeFunction *newnode = makeNode(RangeFunction);
 
-	Node_Copy(from, newnode, funccallnode);
-	Node_Copy(from, newnode, alias);
-	Node_Copy(from, newnode, coldeflist);
+	COPY_NODE_FIELD(funccallnode);
+	COPY_NODE_FIELD(alias);
+	COPY_NODE_FIELD(coldeflist);
 
 	return newnode;
 }
@@ -1783,8 +1548,8 @@ _copyTypeCast(TypeCast *from)
 {
 	TypeCast   *newnode = makeNode(TypeCast);
 
-	Node_Copy(from, newnode, arg);
-	Node_Copy(from, newnode, typename);
+	COPY_NODE_FIELD(arg);
+	COPY_NODE_FIELD(typename);
 
 	return newnode;
 }
@@ -1794,11 +1559,10 @@ _copyIndexElem(IndexElem *from)
 {
 	IndexElem  *newnode = makeNode(IndexElem);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, args);
-	Node_Copy(from, newnode, opclass);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(args);
+	COPY_NODE_FIELD(opclass);
 
 	return newnode;
 }
@@ -1808,17 +1572,15 @@ _copyColumnDef(ColumnDef *from)
 {
 	ColumnDef  *newnode = makeNode(ColumnDef);
 
-	if (from->colname)
-		newnode->colname = pstrdup(from->colname);
-	Node_Copy(from, newnode, typename);
-	newnode->inhcount = from->inhcount;
-	newnode->is_local = from->is_local;
-	newnode->is_not_null = from->is_not_null;
-	Node_Copy(from, newnode, raw_default);
-	if (from->cooked_default)
-		newnode->cooked_default = pstrdup(from->cooked_default);
-	Node_Copy(from, newnode, constraints);
-	Node_Copy(from, newnode, support);
+	COPY_STRING_FIELD(colname);
+	COPY_NODE_FIELD(typename);
+	COPY_SCALAR_FIELD(inhcount);
+	COPY_SCALAR_FIELD(is_local);
+	COPY_SCALAR_FIELD(is_not_null);
+	COPY_NODE_FIELD(raw_default);
+	COPY_STRING_FIELD(cooked_default);
+	COPY_NODE_FIELD(constraints);
+	COPY_NODE_FIELD(support);
 
 	return newnode;
 }
@@ -1828,62 +1590,131 @@ _copyConstraint(Constraint *from)
 {
 	Constraint *newnode = makeNode(Constraint);
 
-	newnode->contype = from->contype;
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, raw_expr);
-	if (from->cooked_expr)
-		newnode->cooked_expr = pstrdup(from->cooked_expr);
-	Node_Copy(from, newnode, keys);
+	COPY_SCALAR_FIELD(contype);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(raw_expr);
+	COPY_STRING_FIELD(cooked_expr);
+	COPY_NODE_FIELD(keys);
 
 	return newnode;
 }
 
-static DefElem *
-_copyDefElem(DefElem *from)
+static CaseExpr *
+_copyCaseExpr(CaseExpr *from)
 {
-	DefElem    *newnode = makeNode(DefElem);
+	CaseExpr   *newnode = makeNode(CaseExpr);
 
-	if (from->defname)
-		newnode->defname = pstrdup(from->defname);
-	Node_Copy(from, newnode, arg);
+	COPY_SCALAR_FIELD(casetype);
+	COPY_NODE_FIELD(arg);
+	COPY_NODE_FIELD(args);
+	COPY_NODE_FIELD(defresult);
 
 	return newnode;
 }
 
-static Query *
-_copyQuery(Query *from)
+static CaseWhen *
+_copyCaseWhen(CaseWhen *from)
 {
-	Query	   *newnode = makeNode(Query);
+	CaseWhen   *newnode = makeNode(CaseWhen);
 
-	newnode->commandType = from->commandType;
-	newnode->querySource = from->querySource;
-	Node_Copy(from, newnode, utilityStmt);
-	newnode->resultRelation = from->resultRelation;
-	Node_Copy(from, newnode, into);
-	newnode->isPortal = from->isPortal;
-	newnode->isBinary = from->isBinary;
-	newnode->hasAggs = from->hasAggs;
-	newnode->hasSubLinks = from->hasSubLinks;
+	COPY_NODE_FIELD(expr);
+	COPY_NODE_FIELD(result);
 
-	Node_Copy(from, newnode, rtable);
-	Node_Copy(from, newnode, jointree);
+	return newnode;
+}
 
-	newnode->rowMarks = listCopy(from->rowMarks);
+static NullTest *
+_copyNullTest(NullTest *from)
+{
+	NullTest   *newnode = makeNode(NullTest);
 
-	Node_Copy(from, newnode, targetList);
+	COPY_NODE_FIELD(arg);
+	COPY_SCALAR_FIELD(nulltesttype);
 
-	Node_Copy(from, newnode, groupClause);
-	Node_Copy(from, newnode, havingQual);
-	Node_Copy(from, newnode, distinctClause);
-	Node_Copy(from, newnode, sortClause);
+	return newnode;
+}
 
-	Node_Copy(from, newnode, limitOffset);
-	Node_Copy(from, newnode, limitCount);
+static BooleanTest *
+_copyBooleanTest(BooleanTest *from)
+{
+	BooleanTest *newnode = makeNode(BooleanTest);
 
-	Node_Copy(from, newnode, setOperations);
+	COPY_NODE_FIELD(arg);
+	COPY_SCALAR_FIELD(booltesttype);
+
+	return newnode;
+}
+
+static ConstraintTest *
+_copyConstraintTest(ConstraintTest *from)
+{
+	ConstraintTest *newnode = makeNode(ConstraintTest);
+
+	COPY_NODE_FIELD(arg);
+	COPY_SCALAR_FIELD(testtype);
+	COPY_STRING_FIELD(name);
+	COPY_STRING_FIELD(domname);
+	COPY_NODE_FIELD(check_expr);
+
+	return newnode;
+}
+
+static DomainConstraintValue *
+_copyDomainConstraintValue(DomainConstraintValue *from)
+{
+	DomainConstraintValue *newnode = makeNode(DomainConstraintValue);
+
+	return newnode;
+}
+
+static ConstraintTestValue *
+_copyConstraintTestValue(ConstraintTestValue *from)
+{
+	ConstraintTestValue *newnode = makeNode(ConstraintTestValue);
 
-	newnode->resultRelations = listCopy(from->resultRelations);
+	COPY_SCALAR_FIELD(typeId);
+	COPY_SCALAR_FIELD(typeMod);
+
+	return newnode;
+}
+
+static DefElem *
+_copyDefElem(DefElem *from)
+{
+	DefElem    *newnode = makeNode(DefElem);
+
+	COPY_STRING_FIELD(defname);
+	COPY_NODE_FIELD(arg);
+
+	return newnode;
+}
+
+static Query *
+_copyQuery(Query *from)
+{
+	Query	   *newnode = makeNode(Query);
+
+	COPY_SCALAR_FIELD(commandType);
+	COPY_SCALAR_FIELD(querySource);
+	COPY_NODE_FIELD(utilityStmt);
+	COPY_SCALAR_FIELD(resultRelation);
+	COPY_NODE_FIELD(into);
+	COPY_SCALAR_FIELD(isPortal);
+	COPY_SCALAR_FIELD(isBinary);
+	COPY_SCALAR_FIELD(hasAggs);
+	COPY_SCALAR_FIELD(hasSubLinks);
+	COPY_NODE_FIELD(rtable);
+	COPY_NODE_FIELD(jointree);
+	COPY_INTLIST_FIELD(rowMarks);
+	COPY_NODE_FIELD(targetList);
+	COPY_NODE_FIELD(groupClause);
+	COPY_NODE_FIELD(havingQual);
+	COPY_NODE_FIELD(distinctClause);
+	COPY_NODE_FIELD(sortClause);
+	COPY_NODE_FIELD(limitOffset);
+	COPY_NODE_FIELD(limitCount);
+	COPY_NODE_FIELD(setOperations);
+	COPY_INTLIST_FIELD(resultRelations);
 
 	/*
 	 * We do not copy the planner internal fields: base_rel_list,
@@ -1899,10 +1730,10 @@ _copyInsertStmt(InsertStmt *from)
 {
 	InsertStmt *newnode = makeNode(InsertStmt);
 
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, cols);
-	Node_Copy(from, newnode, targetList);
-	Node_Copy(from, newnode, selectStmt);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(cols);
+	COPY_NODE_FIELD(targetList);
+	COPY_NODE_FIELD(selectStmt);
 
 	return newnode;
 }
@@ -1912,8 +1743,8 @@ _copyDeleteStmt(DeleteStmt *from)
 {
 	DeleteStmt *newnode = makeNode(DeleteStmt);
 
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, whereClause);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(whereClause);
 
 	return newnode;
 }
@@ -1923,10 +1754,10 @@ _copyUpdateStmt(UpdateStmt *from)
 {
 	UpdateStmt *newnode = makeNode(UpdateStmt);
 
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, targetList);
-	Node_Copy(from, newnode, whereClause);
-	Node_Copy(from, newnode, fromClause);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(targetList);
+	COPY_NODE_FIELD(whereClause);
+	COPY_NODE_FIELD(fromClause);
 
 	return newnode;
 }
@@ -1936,25 +1767,24 @@ _copySelectStmt(SelectStmt *from)
 {
 	SelectStmt *newnode = makeNode(SelectStmt);
 
-	Node_Copy(from, newnode, distinctClause);
-	Node_Copy(from, newnode, into);
-	Node_Copy(from, newnode, intoColNames);
-	Node_Copy(from, newnode, targetList);
-	Node_Copy(from, newnode, fromClause);
-	Node_Copy(from, newnode, whereClause);
-	Node_Copy(from, newnode, groupClause);
-	Node_Copy(from, newnode, havingClause);
-	Node_Copy(from, newnode, sortClause);
-	if (from->portalname)
-		newnode->portalname = pstrdup(from->portalname);
-	newnode->binary = from->binary;
-	Node_Copy(from, newnode, limitOffset);
-	Node_Copy(from, newnode, limitCount);
-	Node_Copy(from, newnode, forUpdate);
-	newnode->op = from->op;
-	newnode->all = from->all;
-	Node_Copy(from, newnode, larg);
-	Node_Copy(from, newnode, rarg);
+	COPY_NODE_FIELD(distinctClause);
+	COPY_NODE_FIELD(into);
+	COPY_NODE_FIELD(intoColNames);
+	COPY_NODE_FIELD(targetList);
+	COPY_NODE_FIELD(fromClause);
+	COPY_NODE_FIELD(whereClause);
+	COPY_NODE_FIELD(groupClause);
+	COPY_NODE_FIELD(havingClause);
+	COPY_NODE_FIELD(sortClause);
+	COPY_STRING_FIELD(portalname);
+	COPY_SCALAR_FIELD(binary);
+	COPY_NODE_FIELD(limitOffset);
+	COPY_NODE_FIELD(limitCount);
+	COPY_NODE_FIELD(forUpdate);
+	COPY_SCALAR_FIELD(op);
+	COPY_SCALAR_FIELD(all);
+	COPY_NODE_FIELD(larg);
+	COPY_NODE_FIELD(rarg);
 
 	return newnode;
 }
@@ -1964,11 +1794,11 @@ _copySetOperationStmt(SetOperationStmt *from)
 {
 	SetOperationStmt *newnode = makeNode(SetOperationStmt);
 
-	newnode->op = from->op;
-	newnode->all = from->all;
-	Node_Copy(from, newnode, larg);
-	Node_Copy(from, newnode, rarg);
-	newnode->colTypes = listCopy(from->colTypes);
+	COPY_SCALAR_FIELD(op);
+	COPY_SCALAR_FIELD(all);
+	COPY_NODE_FIELD(larg);
+	COPY_NODE_FIELD(rarg);
+	COPY_INTLIST_FIELD(colTypes);
 
 	return newnode;
 }
@@ -1978,12 +1808,11 @@ _copyAlterTableStmt(AlterTableStmt *from)
 {
 	AlterTableStmt *newnode = makeNode(AlterTableStmt);
 
-	newnode->subtype = from->subtype;
-	Node_Copy(from, newnode, relation);
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, def);
-	newnode->behavior = from->behavior;
+	COPY_SCALAR_FIELD(subtype);
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(def);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -1993,11 +1822,11 @@ _copyGrantStmt(GrantStmt *from)
 {
 	GrantStmt  *newnode = makeNode(GrantStmt);
 
-	newnode->is_grant = from->is_grant;
-	newnode->objtype = from->objtype;
-	Node_Copy(from, newnode, objects);
-	newnode->privileges = listCopy(from->privileges);
-	Node_Copy(from, newnode, grantees);
+	COPY_SCALAR_FIELD(is_grant);
+	COPY_SCALAR_FIELD(objtype);
+	COPY_NODE_FIELD(objects);
+	COPY_INTLIST_FIELD(privileges);
+	COPY_NODE_FIELD(grantees);
 
 	return newnode;
 }
@@ -2007,10 +1836,8 @@ _copyPrivGrantee(PrivGrantee *from)
 {
 	PrivGrantee *newnode = makeNode(PrivGrantee);
 
-	if (from->username)
-		newnode->username = pstrdup(from->username);
-	if (from->groupname)
-		newnode->groupname = pstrdup(from->groupname);
+	COPY_STRING_FIELD(username);
+	COPY_STRING_FIELD(groupname);
 
 	return newnode;
 }
@@ -2020,8 +1847,8 @@ _copyFuncWithArgs(FuncWithArgs *from)
 {
 	FuncWithArgs *newnode = makeNode(FuncWithArgs);
 
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, funcargs);
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(funcargs);
 
 	return newnode;
 }
@@ -2040,8 +1867,7 @@ _copyClosePortalStmt(ClosePortalStmt *from)
 {
 	ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
 
-	if (from->portalname)
-		newnode->portalname = pstrdup(from->portalname);
+	COPY_STRING_FIELD(portalname);
 
 	return newnode;
 }
@@ -2051,9 +1877,8 @@ _copyClusterStmt(ClusterStmt *from)
 {
 	ClusterStmt *newnode = makeNode(ClusterStmt);
 
-	Node_Copy(from, newnode, relation);
-	if (from->indexname)
-		newnode->indexname = pstrdup(from->indexname);
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(indexname);
 
 	return newnode;
 }
@@ -2063,12 +1888,11 @@ _copyCopyStmt(CopyStmt *from)
 {
 	CopyStmt   *newnode = makeNode(CopyStmt);
 
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, attlist);
-	newnode->is_from = from->is_from;
-	if (from->filename)
-		newnode->filename = pstrdup(from->filename);
-	Node_Copy(from, newnode, options);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(attlist);
+	COPY_SCALAR_FIELD(is_from);
+	COPY_STRING_FIELD(filename);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2078,12 +1902,12 @@ _copyCreateStmt(CreateStmt *from)
 {
 	CreateStmt *newnode = makeNode(CreateStmt);
 
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, tableElts);
-	Node_Copy(from, newnode, inhRelations);
-	Node_Copy(from, newnode, constraints);
-	newnode->hasoids = from->hasoids;
-	newnode->oncommit = from->oncommit;
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(tableElts);
+	COPY_NODE_FIELD(inhRelations);
+	COPY_NODE_FIELD(constraints);
+	COPY_SCALAR_FIELD(hasoids);
+	COPY_SCALAR_FIELD(oncommit);
 
 	return newnode;
 }
@@ -2093,9 +1917,9 @@ _copyDefineStmt(DefineStmt *from)
 {
 	DefineStmt *newnode = makeNode(DefineStmt);
 
-	newnode->defType = from->defType;
-	Node_Copy(from, newnode, defnames);
-	Node_Copy(from, newnode, definition);
+	COPY_SCALAR_FIELD(defType);
+	COPY_NODE_FIELD(defnames);
+	COPY_NODE_FIELD(definition);
 
 	return newnode;
 }
@@ -2105,9 +1929,9 @@ _copyDropStmt(DropStmt *from)
 {
 	DropStmt   *newnode = makeNode(DropStmt);
 
-	Node_Copy(from, newnode, objects);
-	newnode->removeType = from->removeType;
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(objects);
+	COPY_SCALAR_FIELD(removeType);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2117,7 +1941,7 @@ _copyTruncateStmt(TruncateStmt *from)
 {
 	TruncateStmt *newnode = makeNode(TruncateStmt);
 
-	Node_Copy(from, newnode, relation);
+	COPY_NODE_FIELD(relation);
 
 	return newnode;
 }
@@ -2127,11 +1951,10 @@ _copyCommentStmt(CommentStmt *from)
 {
 	CommentStmt *newnode = makeNode(CommentStmt);
 
-	newnode->objtype = from->objtype;
-	Node_Copy(from, newnode, objname);
-	Node_Copy(from, newnode, objargs);
-	if (from->comment)
-		newnode->comment = pstrdup(from->comment);
+	COPY_SCALAR_FIELD(objtype);
+	COPY_NODE_FIELD(objname);
+	COPY_NODE_FIELD(objargs);
+	COPY_STRING_FIELD(comment);
 
 	return newnode;
 }
@@ -2141,10 +1964,10 @@ _copyFetchStmt(FetchStmt *from)
 {
 	FetchStmt  *newnode = makeNode(FetchStmt);
 
-	newnode->direction = from->direction;
-	newnode->howMany = from->howMany;
-	newnode->portalname = pstrdup(from->portalname);
-	newnode->ismove = from->ismove;
+	COPY_SCALAR_FIELD(direction);
+	COPY_SCALAR_FIELD(howMany);
+	COPY_STRING_FIELD(portalname);
+	COPY_SCALAR_FIELD(ismove);
 
 	return newnode;
 }
@@ -2154,15 +1977,15 @@ _copyIndexStmt(IndexStmt *from)
 {
 	IndexStmt  *newnode = makeNode(IndexStmt);
 
-	newnode->idxname = pstrdup(from->idxname);
-	Node_Copy(from, newnode, relation);
-	newnode->accessMethod = pstrdup(from->accessMethod);
-	Node_Copy(from, newnode, indexParams);
-	Node_Copy(from, newnode, whereClause);
-	Node_Copy(from, newnode, rangetable);
-	newnode->unique = from->unique;
-	newnode->primary = from->primary;
-	newnode->isconstraint = from->isconstraint;
+	COPY_STRING_FIELD(idxname);
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(accessMethod);
+	COPY_NODE_FIELD(indexParams);
+	COPY_NODE_FIELD(whereClause);
+	COPY_NODE_FIELD(rangetable);
+	COPY_SCALAR_FIELD(unique);
+	COPY_SCALAR_FIELD(primary);
+	COPY_SCALAR_FIELD(isconstraint);
 
 	return newnode;
 }
@@ -2172,12 +1995,12 @@ _copyCreateFunctionStmt(CreateFunctionStmt *from)
 {
 	CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
 
-	newnode->replace = from->replace;
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, argTypes);
-	Node_Copy(from, newnode, returnType);
-	Node_Copy(from, newnode, options);
-	Node_Copy(from, newnode, withClause);
+	COPY_SCALAR_FIELD(replace);
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(argTypes);
+	COPY_NODE_FIELD(returnType);
+	COPY_NODE_FIELD(options);
+	COPY_NODE_FIELD(withClause);
 
 	return newnode;
 }
@@ -2187,9 +2010,9 @@ _copyRemoveAggrStmt(RemoveAggrStmt *from)
 {
 	RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
 
-	Node_Copy(from, newnode, aggname);
-	Node_Copy(from, newnode, aggtype);
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(aggname);
+	COPY_NODE_FIELD(aggtype);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2199,9 +2022,9 @@ _copyRemoveFuncStmt(RemoveFuncStmt *from)
 {
 	RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
 
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, args);
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2211,9 +2034,9 @@ _copyRemoveOperStmt(RemoveOperStmt *from)
 {
 	RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
 
-	Node_Copy(from, newnode, opname);
-	Node_Copy(from, newnode, args);
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(opname);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2223,10 +2046,9 @@ _copyRemoveOpClassStmt(RemoveOpClassStmt *from)
 {
 	RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
 
-	Node_Copy(from, newnode, opclassname);
-	if (from->amname)
-		newnode->amname = pstrdup(from->amname);
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(opclassname);
+	COPY_STRING_FIELD(amname);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2236,12 +2058,10 @@ _copyRenameStmt(RenameStmt *from)
 {
 	RenameStmt *newnode = makeNode(RenameStmt);
 
-	Node_Copy(from, newnode, relation);
-	if (from->oldname)
-		newnode->oldname = pstrdup(from->oldname);
-	if (from->newname)
-		newnode->newname = pstrdup(from->newname);
-	newnode->renameType = from->renameType;
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(oldname);
+	COPY_STRING_FIELD(newname);
+	COPY_SCALAR_FIELD(renameType);
 
 	return newnode;
 }
@@ -2251,13 +2071,13 @@ _copyRuleStmt(RuleStmt *from)
 {
 	RuleStmt   *newnode = makeNode(RuleStmt);
 
-	Node_Copy(from, newnode, relation);
-	newnode->rulename = pstrdup(from->rulename);
-	Node_Copy(from, newnode, whereClause);
-	newnode->event = from->event;
-	newnode->instead = from->instead;
-	newnode->replace = from->replace;
-	Node_Copy(from, newnode, actions);
+	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;
 }
@@ -2267,7 +2087,7 @@ _copyNotifyStmt(NotifyStmt *from)
 {
 	NotifyStmt *newnode = makeNode(NotifyStmt);
 
-	Node_Copy(from, newnode, relation);
+	COPY_NODE_FIELD(relation);
 
 	return newnode;
 }
@@ -2277,7 +2097,7 @@ _copyListenStmt(ListenStmt *from)
 {
 	ListenStmt *newnode = makeNode(ListenStmt);
 
-	Node_Copy(from, newnode, relation);
+	COPY_NODE_FIELD(relation);
 
 	return newnode;
 }
@@ -2287,7 +2107,7 @@ _copyUnlistenStmt(UnlistenStmt *from)
 {
 	UnlistenStmt *newnode = makeNode(UnlistenStmt);
 
-	Node_Copy(from, newnode, relation);
+	COPY_NODE_FIELD(relation);
 
 	return newnode;
 }
@@ -2297,8 +2117,8 @@ _copyTransactionStmt(TransactionStmt *from)
 {
 	TransactionStmt *newnode = makeNode(TransactionStmt);
 
-	newnode->command = from->command;
-	Node_Copy(from, newnode, options);
+	COPY_SCALAR_FIELD(command);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2308,8 +2128,8 @@ _copyCompositeTypeStmt(CompositeTypeStmt *from)
 {
 	CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
 
-	Node_Copy(from, newnode, typevar);
-	Node_Copy(from, newnode, coldeflist);
+	COPY_NODE_FIELD(typevar);
+	COPY_NODE_FIELD(coldeflist);
 
 	return newnode;
 }
@@ -2319,10 +2139,10 @@ _copyViewStmt(ViewStmt *from)
 {
 	ViewStmt   *newnode = makeNode(ViewStmt);
 
-	Node_Copy(from, newnode, view);
-	Node_Copy(from, newnode, aliases);
-	Node_Copy(from, newnode, query);
-	newnode->replace = from->replace;
+	COPY_NODE_FIELD(view);
+	COPY_NODE_FIELD(aliases);
+	COPY_NODE_FIELD(query);
+	COPY_SCALAR_FIELD(replace);
 
 	return newnode;
 }
@@ -2332,8 +2152,7 @@ _copyLoadStmt(LoadStmt *from)
 {
 	LoadStmt   *newnode = makeNode(LoadStmt);
 
-	if (from->filename)
-		newnode->filename = pstrdup(from->filename);
+	COPY_STRING_FIELD(filename);
 
 	return newnode;
 }
@@ -2343,9 +2162,9 @@ _copyCreateDomainStmt(CreateDomainStmt *from)
 {
 	CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
 
-	Node_Copy(from, newnode, domainname);
-	Node_Copy(from, newnode, typename);
-	Node_Copy(from, newnode, constraints);
+	COPY_NODE_FIELD(domainname);
+	COPY_NODE_FIELD(typename);
+	COPY_NODE_FIELD(constraints);
 
 	return newnode;
 }
@@ -2355,12 +2174,11 @@ _copyCreateOpClassStmt(CreateOpClassStmt *from)
 {
 	CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
 
-	Node_Copy(from, newnode, opclassname);
-	if (from->amname)
-		newnode->amname = pstrdup(from->amname);
-	Node_Copy(from, newnode, datatype);
-	Node_Copy(from, newnode, items);
-	newnode->isDefault = from->isDefault;
+	COPY_NODE_FIELD(opclassname);
+	COPY_STRING_FIELD(amname);
+	COPY_NODE_FIELD(datatype);
+	COPY_NODE_FIELD(items);
+	COPY_SCALAR_FIELD(isDefault);
 
 	return newnode;
 }
@@ -2370,12 +2188,12 @@ _copyCreateOpClassItem(CreateOpClassItem *from)
 {
 	CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
 
-	newnode->itemtype = from->itemtype;
-	Node_Copy(from, newnode, name);
-	Node_Copy(from, newnode, args);
-	newnode->number = from->number;
-	newnode->recheck = from->recheck;
-	Node_Copy(from, newnode, storedtype);
+	COPY_SCALAR_FIELD(itemtype);
+	COPY_NODE_FIELD(name);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(number);
+	COPY_SCALAR_FIELD(recheck);
+	COPY_NODE_FIELD(storedtype);
 
 	return newnode;
 }
@@ -2385,9 +2203,8 @@ _copyCreatedbStmt(CreatedbStmt *from)
 {
 	CreatedbStmt *newnode = makeNode(CreatedbStmt);
 
-	if (from->dbname)
-		newnode->dbname = pstrdup(from->dbname);
-	Node_Copy(from, newnode, options);
+	COPY_STRING_FIELD(dbname);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2397,11 +2214,9 @@ _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
 {
 	AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
 
-	if (from->dbname)
-		newnode->dbname = pstrdup(from->dbname);
-	if (from->variable)
-		newnode->variable = pstrdup(from->variable);
-	Node_Copy(from, newnode, value);
+	COPY_STRING_FIELD(dbname);
+	COPY_STRING_FIELD(variable);
+	COPY_NODE_FIELD(value);
 
 	return newnode;
 }
@@ -2411,8 +2226,7 @@ _copyDropdbStmt(DropdbStmt *from)
 {
 	DropdbStmt *newnode = makeNode(DropdbStmt);
 
-	if (from->dbname)
-		newnode->dbname = pstrdup(from->dbname);
+	COPY_STRING_FIELD(dbname);
 
 	return newnode;
 }
@@ -2422,13 +2236,13 @@ _copyVacuumStmt(VacuumStmt *from)
 {
 	VacuumStmt *newnode = makeNode(VacuumStmt);
 
-	newnode->vacuum = from->vacuum;
-	newnode->full = from->full;
-	newnode->analyze = from->analyze;
-	newnode->freeze = from->freeze;
-	newnode->verbose = from->verbose;
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, va_cols);
+	COPY_SCALAR_FIELD(vacuum);
+	COPY_SCALAR_FIELD(full);
+	COPY_SCALAR_FIELD(analyze);
+	COPY_SCALAR_FIELD(freeze);
+	COPY_SCALAR_FIELD(verbose);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(va_cols);
 
 	return newnode;
 }
@@ -2438,9 +2252,9 @@ _copyExplainStmt(ExplainStmt *from)
 {
 	ExplainStmt *newnode = makeNode(ExplainStmt);
 
-	Node_Copy(from, newnode, query);
-	newnode->verbose = from->verbose;
-	newnode->analyze = from->analyze;
+	COPY_NODE_FIELD(query);
+	COPY_SCALAR_FIELD(verbose);
+	COPY_SCALAR_FIELD(analyze);
 
 	return newnode;
 }
@@ -2450,8 +2264,8 @@ _copyCreateSeqStmt(CreateSeqStmt *from)
 {
 	CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
 
-	Node_Copy(from, newnode, sequence);
-	Node_Copy(from, newnode, options);
+	COPY_NODE_FIELD(sequence);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2461,10 +2275,9 @@ _copyVariableSetStmt(VariableSetStmt *from)
 {
 	VariableSetStmt *newnode = makeNode(VariableSetStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, args);
-	newnode->is_local = from->is_local;
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(is_local);
 
 	return newnode;
 }
@@ -2474,8 +2287,7 @@ _copyVariableShowStmt(VariableShowStmt *from)
 {
 	VariableShowStmt *newnode = makeNode(VariableShowStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
+	COPY_STRING_FIELD(name);
 
 	return newnode;
 }
@@ -2485,8 +2297,7 @@ _copyVariableResetStmt(VariableResetStmt *from)
 {
 	VariableResetStmt *newnode = makeNode(VariableResetStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
+	COPY_STRING_FIELD(name);
 
 	return newnode;
 }
@@ -2496,18 +2307,17 @@ _copyCreateTrigStmt(CreateTrigStmt *from)
 {
 	CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
 
-	if (from->trigname)
-		newnode->trigname = pstrdup(from->trigname);
-	Node_Copy(from, newnode, relation);
-	Node_Copy(from, newnode, funcname);
-	Node_Copy(from, newnode, args);
-	newnode->before = from->before;
-	newnode->row = from->row;
-	memcpy(newnode->actions, from->actions, sizeof(from->actions));
-	newnode->isconstraint = from->isconstraint;
-	newnode->deferrable = from->deferrable;
-	newnode->initdeferred = from->initdeferred;
-	Node_Copy(from, newnode, constrrel);
+	COPY_STRING_FIELD(trigname);
+	COPY_NODE_FIELD(relation);
+	COPY_NODE_FIELD(funcname);
+	COPY_NODE_FIELD(args);
+	COPY_SCALAR_FIELD(before);
+	COPY_SCALAR_FIELD(row);
+	strcpy(newnode->actions, from->actions); /* in-line string field */
+	COPY_SCALAR_FIELD(isconstraint);
+	COPY_SCALAR_FIELD(deferrable);
+	COPY_SCALAR_FIELD(initdeferred);
+	COPY_NODE_FIELD(constrrel);
 
 	return newnode;
 }
@@ -2517,11 +2327,10 @@ _copyDropPropertyStmt(DropPropertyStmt *from)
 {
 	DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
 
-	Node_Copy(from, newnode, relation);
-	if (from->property)
-		newnode->property = pstrdup(from->property);
-	newnode->removeType = from->removeType;
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(property);
+	COPY_SCALAR_FIELD(removeType);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2531,11 +2340,10 @@ _copyCreatePLangStmt(CreatePLangStmt *from)
 {
 	CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
 
-	if (from->plname)
-		newnode->plname = pstrdup(from->plname);
-	Node_Copy(from, newnode, plhandler);
-	Node_Copy(from, newnode, plvalidator);
-	newnode->pltrusted = from->pltrusted;
+	COPY_STRING_FIELD(plname);
+	COPY_NODE_FIELD(plhandler);
+	COPY_NODE_FIELD(plvalidator);
+	COPY_SCALAR_FIELD(pltrusted);
 
 	return newnode;
 }
@@ -2545,9 +2353,8 @@ _copyDropPLangStmt(DropPLangStmt *from)
 {
 	DropPLangStmt *newnode = makeNode(DropPLangStmt);
 
-	if (from->plname)
-		newnode->plname = pstrdup(from->plname);
-	newnode->behavior = from->behavior;
+	COPY_STRING_FIELD(plname);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2557,9 +2364,8 @@ _copyCreateUserStmt(CreateUserStmt *from)
 {
 	CreateUserStmt *newnode = makeNode(CreateUserStmt);
 
-	if (from->user)
-		newnode->user = pstrdup(from->user);
-	Node_Copy(from, newnode, options);
+	COPY_STRING_FIELD(user);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2569,9 +2375,8 @@ _copyAlterUserStmt(AlterUserStmt *from)
 {
 	AlterUserStmt *newnode = makeNode(AlterUserStmt);
 
-	if (from->user)
-		newnode->user = pstrdup(from->user);
-	Node_Copy(from, newnode, options);
+	COPY_STRING_FIELD(user);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2581,11 +2386,9 @@ _copyAlterUserSetStmt(AlterUserSetStmt *from)
 {
 	AlterUserSetStmt *newnode = makeNode(AlterUserSetStmt);
 
-	if (from->user)
-		newnode->user = pstrdup(from->user);
-	if (from->variable)
-		newnode->variable = pstrdup(from->variable);
-	Node_Copy(from, newnode, value);
+	COPY_STRING_FIELD(user);
+	COPY_STRING_FIELD(variable);
+	COPY_NODE_FIELD(value);
 
 	return newnode;
 }
@@ -2595,7 +2398,7 @@ _copyDropUserStmt(DropUserStmt *from)
 {
 	DropUserStmt *newnode = makeNode(DropUserStmt);
 
-	Node_Copy(from, newnode, users);
+	COPY_NODE_FIELD(users);
 
 	return newnode;
 }
@@ -2605,9 +2408,8 @@ _copyLockStmt(LockStmt *from)
 {
 	LockStmt   *newnode = makeNode(LockStmt);
 
-	Node_Copy(from, newnode, relations);
-
-	newnode->mode = from->mode;
+	COPY_NODE_FIELD(relations);
+	COPY_SCALAR_FIELD(mode);
 
 	return newnode;
 }
@@ -2617,8 +2419,8 @@ _copyConstraintsSetStmt(ConstraintsSetStmt *from)
 {
 	ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
 
-	Node_Copy(from, newnode, constraints);
-	newnode->deferred = from->deferred;
+	COPY_NODE_FIELD(constraints);
+	COPY_SCALAR_FIELD(deferred);
 
 	return newnode;
 }
@@ -2628,9 +2430,8 @@ _copyCreateGroupStmt(CreateGroupStmt *from)
 {
 	CreateGroupStmt *newnode = makeNode(CreateGroupStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, options);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(options);
 
 	return newnode;
 }
@@ -2640,10 +2441,9 @@ _copyAlterGroupStmt(AlterGroupStmt *from)
 {
 	AlterGroupStmt *newnode = makeNode(AlterGroupStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	newnode->action = from->action;
-	Node_Copy(from, newnode, listUsers);
+	COPY_STRING_FIELD(name);
+	COPY_SCALAR_FIELD(action);
+	COPY_NODE_FIELD(listUsers);
 
 	return newnode;
 }
@@ -2653,8 +2453,7 @@ _copyDropGroupStmt(DropGroupStmt *from)
 {
 	DropGroupStmt *newnode = makeNode(DropGroupStmt);
 
-	if (from->name)
-		newnode->name = pstrdup(from->name);
+	COPY_STRING_FIELD(name);
 
 	return newnode;
 }
@@ -2664,12 +2463,11 @@ _copyReindexStmt(ReindexStmt *from)
 {
 	ReindexStmt *newnode = makeNode(ReindexStmt);
 
-	newnode->reindexType = from->reindexType;
-	Node_Copy(from, newnode, relation);
-	if (from->name)
-		newnode->name = pstrdup(from->name);
-	newnode->force = from->force;
-	newnode->all = from->all;
+	COPY_SCALAR_FIELD(reindexType);
+	COPY_NODE_FIELD(relation);
+	COPY_STRING_FIELD(name);
+	COPY_SCALAR_FIELD(force);
+	COPY_SCALAR_FIELD(all);
 
 	return newnode;
 }
@@ -2679,10 +2477,9 @@ _copyCreateSchemaStmt(CreateSchemaStmt *from)
 {
 	CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
 
-	newnode->schemaname = pstrdup(from->schemaname);
-	if (from->authid)
-		newnode->authid = pstrdup(from->authid);
-	Node_Copy(from, newnode, schemaElts);
+	COPY_STRING_FIELD(schemaname);
+	COPY_STRING_FIELD(authid);
+	COPY_NODE_FIELD(schemaElts);
 
 	return newnode;
 }
@@ -2692,11 +2489,11 @@ _copyCreateConversionStmt(CreateConversionStmt *from)
 {
 	CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
 
-	Node_Copy(from, newnode, conversion_name);
-	newnode->for_encoding_name = pstrdup(from->for_encoding_name);
-	newnode->to_encoding_name = pstrdup(from->to_encoding_name);
-	Node_Copy(from, newnode, func_name);
-	newnode->def = from->def;
+	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;
 }
@@ -2706,10 +2503,10 @@ _copyCreateCastStmt(CreateCastStmt *from)
 {
 	CreateCastStmt *newnode = makeNode(CreateCastStmt);
 
-	Node_Copy(from, newnode, sourcetype);
-	Node_Copy(from, newnode, targettype);
-	Node_Copy(from, newnode, func);
-	newnode->context = from->context;
+	COPY_NODE_FIELD(sourcetype);
+	COPY_NODE_FIELD(targettype);
+	COPY_NODE_FIELD(func);
+	COPY_SCALAR_FIELD(context);
 
 	return newnode;
 }
@@ -2719,9 +2516,9 @@ _copyDropCastStmt(DropCastStmt *from)
 {
 	DropCastStmt *newnode = makeNode(DropCastStmt);
 
-	Node_Copy(from, newnode, sourcetype);
-	Node_Copy(from, newnode, targettype);
-	newnode->behavior = from->behavior;
+	COPY_NODE_FIELD(sourcetype);
+	COPY_NODE_FIELD(targettype);
+	COPY_SCALAR_FIELD(behavior);
 
 	return newnode;
 }
@@ -2731,10 +2528,10 @@ _copyPrepareStmt(PrepareStmt *from)
 {
 	PrepareStmt *newnode = makeNode(PrepareStmt);
 
-	newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, argtypes);
-	newnode->argtype_oids = listCopy(from->argtype_oids);
-	Node_Copy(from, newnode, query);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(argtypes);
+	COPY_INTLIST_FIELD(argtype_oids);
+	COPY_NODE_FIELD(query);
 
 	return newnode;
 }
@@ -2744,9 +2541,9 @@ _copyExecuteStmt(ExecuteStmt *from)
 {
 	ExecuteStmt *newnode = makeNode(ExecuteStmt);
 
-	newnode->name = pstrdup(from->name);
-	Node_Copy(from, newnode, into);
-	Node_Copy(from, newnode, params);
+	COPY_STRING_FIELD(name);
+	COPY_NODE_FIELD(into);
+	COPY_NODE_FIELD(params);
 
 	return newnode;
 }
@@ -2756,7 +2553,7 @@ _copyDeallocateStmt(DeallocateStmt *from)
 {
 	DeallocateStmt *newnode = makeNode(DeallocateStmt);
 
-	newnode->name = pstrdup(from->name);
+	COPY_STRING_FIELD(name);
 
 	return newnode;
 }
@@ -2774,16 +2571,16 @@ _copyValue(Value *from)
 
 	/* See also _copyAConst when changing this code! */
 
-	newnode->type = from->type;
+	COPY_SCALAR_FIELD(type);
 	switch (from->type)
 	{
 		case T_Integer:
-			newnode->val.ival = from->val.ival;
+			COPY_SCALAR_FIELD(val.ival);
 			break;
 		case T_Float:
 		case T_String:
 		case T_BitString:
-			newnode->val.str = pstrdup(from->val.str);
+			COPY_STRING_FIELD(val.str);
 			break;
 		case T_Null:
 			/* nothing to do */
@@ -2795,10 +2592,11 @@ _copyValue(Value *from)
 	return newnode;
 }
 
-/* ----------------
- *		copyObject returns a copy of the node or list. If it is a list, it
- *		recursively copies its items.
- * ----------------
+/*
+ * copyObject
+ *
+ * Create a copy of a Node tree or list.  This is a "deep" copy: all
+ * substructure is copied too, recursively.
  */
 void *
 copyObject(void *from)
@@ -2889,6 +2687,12 @@ copyObject(void *from)
 		case T_Fjoin:
 			retval = _copyFjoin(from);
 			break;
+		case T_Alias:
+			retval = _copyAlias(from);
+			break;
+		case T_RangeVar:
+			retval = _copyRangeVar(from);
+			break;
 		case T_Expr:
 			retval = _copyExpr(from);
 			break;
@@ -2904,18 +2708,15 @@ copyObject(void *from)
 		case T_Param:
 			retval = _copyParam(from);
 			break;
+		case T_Func:
+			retval = _copyFunc(from);
+			break;
 		case T_Aggref:
 			retval = _copyAggref(from);
 			break;
 		case T_SubLink:
 			retval = _copySubLink(from);
 			break;
-		case T_Func:
-			retval = _copyFunc(from);
-			break;
-		case T_ArrayRef:
-			retval = _copyArrayRef(from);
-			break;
 		case T_FieldSelect:
 			retval = _copyFieldSelect(from);
 			break;
@@ -2925,11 +2726,14 @@ copyObject(void *from)
 		case T_RangeTblRef:
 			retval = _copyRangeTblRef(from);
 			break;
+		case T_JoinExpr:
+			retval = _copyJoinExpr(from);
+			break;
 		case T_FromExpr:
 			retval = _copyFromExpr(from);
 			break;
-		case T_JoinExpr:
-			retval = _copyJoinExpr(from);
+		case T_ArrayRef:
+			retval = _copyArrayRef(from);
 			break;
 
 			/*
@@ -3239,12 +3043,6 @@ copyObject(void *from)
 		case T_SortGroupBy:
 			retval = _copySortGroupBy(from);
 			break;
-		case T_Alias:
-			retval = _copyAlias(from);
-			break;
-		case T_RangeVar:
-			retval = _copyRangeVar(from);
-			break;
 		case T_RangeSubselect:
 			retval = _copyRangeSubselect(from);
 			break;
@@ -3318,5 +3116,6 @@ copyObject(void *from)
 			retval = from;		/* keep compiler quiet */
 			break;
 	}
+
 	return retval;
 }