Restructure outfuncs and readfuncs to use macros in the same style as

just done for copyfuncs/equalfuncs.  Read functions in particular get
a lot shorter than before, and it's much easier to compare an out function
with the corresponding read function to make sure they agree.
initdb forced due to small changes in nodestring format (regularizing
a few cases that were formerly idiosyncratic).

5 files changed, 1138 insertions, 2770 deletions

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 8df0783fb89..3302e5f942c 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1,17 +1,23 @@
-/*
+/*-------------------------------------------------------------------------
+ *
  * outfuncs.c
- *	  routines to convert a node to ascii representation
+ *	  Output functions for Postgres tree nodes.
  *
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.181 2002/11/24 21:52:13 tgl Exp $
+ *
+ * IDENTIFICATION
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.182 2002/11/25 18:12:09 tgl Exp $
  *
  * NOTES
- *	  Every (plan) node in POSTGRES has an associated "out" routine which
- *	  knows how to create its ascii representation. These functions are
- *	  useful for debugging as well as for storing plans in the system
- *	  catalogs (eg. views).
+ *	  Every node type that can appear in stored rules' parsetrees *must*
+ *	  have an output function defined here (as well as an input function
+ *	  in readfuncs.c).  For use in debugging, we also provide output
+ *	  functions for nodes that appear in raw parsetrees and plan trees.
+ *	  These nodes however need not have input functions.
+ *
+ *-------------------------------------------------------------------------
  */
 #include "postgres.h"
 
@@ -27,6 +33,72 @@
 #include "utils/datum.h"
 
 
+/*
+ * Macros to simplify output of different kinds of fields.  Use these
+ * wherever possible to reduce the chance for silly typos.  Note that these
+ * hard-wire conventions about the names of the local variables in an Out
+ * routine.
+ */
+
+/* Write the label for the node type */
+#define WRITE_NODE_TYPE(nodelabel) \
+	appendStringInfo(str, nodelabel)
+
+/* Write an integer field (anything written as ":fldname %d") */
+#define WRITE_INT_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
+
+/* Write an unsigned integer field (anything written as ":fldname %u") */
+#define WRITE_UINT_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
+
+/* Write an OID field (don't hard-wire assumption that OID is same as uint) */
+#define WRITE_OID_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
+
+/* Write a long-integer field */
+#define WRITE_LONG_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
+
+/* Write a char field (ie, one ascii character) */
+#define WRITE_CHAR_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %c", node->fldname)
+
+/* Write an enumerated-type field as an integer code */
+#define WRITE_ENUM_FIELD(fldname, enumtype) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %d", \
+					 (int) node->fldname)
+
+/* Write a float field --- caller must give format to define precision */
+#define WRITE_FLOAT_FIELD(fldname,format) \
+	appendStringInfo(str, " :" CppAsString(fldname) " " format, node->fldname)
+
+/* Write a boolean field */
+#define WRITE_BOOL_FIELD(fldname) \
+	appendStringInfo(str, " :" CppAsString(fldname) " %s", \
+					 booltostr(node->fldname))
+
+/* Write a character-string (possibly NULL) field */
+#define WRITE_STRING_FIELD(fldname) \
+	(appendStringInfo(str, " :" CppAsString(fldname) " "), \
+	 _outToken(str, node->fldname))
+
+/* Write a Node field */
+#define WRITE_NODE_FIELD(fldname) \
+	(appendStringInfo(str, " :" CppAsString(fldname) " "), \
+	 _outNode(str, node->fldname))
+
+/* Write an integer-list field */
+#define WRITE_INTLIST_FIELD(fldname) \
+	(appendStringInfo(str, " :" CppAsString(fldname) " "), \
+	 _outIntList(str, node->fldname))
+
+/* Write an OID-list field */
+#define WRITE_OIDLIST_FIELD(fldname) \
+	(appendStringInfo(str, " :" CppAsString(fldname) " "), \
+	 _outOidList(str, node->fldname))
+
+
 #define booltostr(x)  ((x) ? "true" : "false")
 
 static void _outDatum(StringInfo str, Datum value, int typlen, bool typbyval);
@@ -105,133 +177,117 @@ _outOidList(StringInfo str, List *list)
 static void
 _outCreateStmt(StringInfo str, CreateStmt *node)
 {
-	appendStringInfo(str, " CREATE :relation ");
-	_outNode(str, node->relation);
-
-	appendStringInfo(str, "	:tableElts ");
-	_outNode(str, node->tableElts);
-
-	appendStringInfo(str, " :inhRelations ");
-	_outNode(str, node->inhRelations);
-
-	appendStringInfo(str, " :constraints ");
-	_outNode(str, node->constraints);
+	WRITE_NODE_TYPE("CREATE");
 
-	appendStringInfo(str, " :hasoids %s :oncommit %d ",
-					 booltostr(node->hasoids),
-					 (int) node->oncommit);
+	WRITE_NODE_FIELD(relation);
+	WRITE_NODE_FIELD(tableElts);
+	WRITE_NODE_FIELD(inhRelations);
+	WRITE_NODE_FIELD(constraints);
+	WRITE_BOOL_FIELD(hasoids);
+	WRITE_ENUM_FIELD(oncommit, OnCommitAction);
 }
 
 static void
 _outIndexStmt(StringInfo str, IndexStmt *node)
 {
-	appendStringInfo(str, " INDEX :idxname ");
-	_outToken(str, node->idxname);
-	appendStringInfo(str, " :relation ");
-	_outNode(str, node->relation);
-	appendStringInfo(str, " :accessMethod ");
-	_outToken(str, node->accessMethod);
-	appendStringInfo(str, " :indexParams ");
-	_outNode(str, node->indexParams);
-	appendStringInfo(str, " :whereClause ");
-	_outNode(str, node->whereClause);
-	appendStringInfo(str, " :rangetable ");
-	_outNode(str, node->rangetable);
-	appendStringInfo(str, " :unique %s :primary %s :isconstraint %s ",
-					 booltostr(node->unique),
-					 booltostr(node->primary),
-					 booltostr(node->isconstraint));
+	WRITE_NODE_TYPE("INDEX");
+
+	WRITE_STRING_FIELD(idxname);
+	WRITE_NODE_FIELD(relation);
+	WRITE_STRING_FIELD(accessMethod);
+	WRITE_NODE_FIELD(indexParams);
+	WRITE_NODE_FIELD(whereClause);
+	WRITE_NODE_FIELD(rangetable);
+	WRITE_BOOL_FIELD(unique);
+	WRITE_BOOL_FIELD(primary);
+	WRITE_BOOL_FIELD(isconstraint);
 }
 
 static void
 _outNotifyStmt(StringInfo str, NotifyStmt *node)
 {
-	appendStringInfo(str, " NOTIFY :relation ");
-	_outNode(str, node->relation);
+	WRITE_NODE_TYPE("NOTIFY");
+
+	WRITE_NODE_FIELD(relation);
 }
 
 static void
 _outSelectStmt(StringInfo str, SelectStmt *node)
 {
+	WRITE_NODE_TYPE("SELECT");
+
 	/* XXX this is pretty durn incomplete */
-	appendStringInfo(str, " SELECT :where ");
-	_outNode(str, node->whereClause);
+	WRITE_NODE_FIELD(whereClause);
 }
 
 static void
 _outFuncCall(StringInfo str, FuncCall *node)
 {
-	appendStringInfo(str, " FUNCCALL ");
-	_outNode(str, node->funcname);
-	appendStringInfo(str, " :args ");
-	_outNode(str, node->args);
-	appendStringInfo(str, " :agg_star %s :agg_distinct %s ",
-					 booltostr(node->agg_star),
-					 booltostr(node->agg_distinct));
+	WRITE_NODE_TYPE("FUNCCALL");
+
+	WRITE_NODE_FIELD(funcname);
+	WRITE_NODE_FIELD(args);
+	WRITE_BOOL_FIELD(agg_star);
+	WRITE_BOOL_FIELD(agg_distinct);
 }
 
 static void
 _outColumnDef(StringInfo str, ColumnDef *node)
 {
-	appendStringInfo(str, " COLUMNDEF :colname ");
-	_outToken(str, node->colname);
-	appendStringInfo(str, " :typename ");
-	_outNode(str, node->typename);
-	appendStringInfo(str, " :inhcount %d :is_local %s :is_not_null %s :raw_default ",
-					 node->inhcount,
-					 booltostr(node->is_local),
-					 booltostr(node->is_not_null));
-	_outNode(str, node->raw_default);
-	appendStringInfo(str, " :cooked_default ");
-	_outToken(str, node->cooked_default);
-	appendStringInfo(str, " :constraints ");
-	_outNode(str, node->constraints);
-	appendStringInfo(str, " :support ");
-	_outNode(str, node->support);
+	WRITE_NODE_TYPE("COLUMNDEF");
+
+	WRITE_STRING_FIELD(colname);
+	WRITE_NODE_FIELD(typename);
+	WRITE_INT_FIELD(inhcount);
+	WRITE_BOOL_FIELD(is_local);
+	WRITE_BOOL_FIELD(is_not_null);
+	WRITE_NODE_FIELD(raw_default);
+	WRITE_STRING_FIELD(cooked_default);
+	WRITE_NODE_FIELD(constraints);
+	WRITE_NODE_FIELD(support);
 }
 
 static void
 _outTypeName(StringInfo str, TypeName *node)
 {
-	appendStringInfo(str, " TYPENAME :names ");
-	_outNode(str, node->names);
-	appendStringInfo(str, " :typeid %u :timezone %s :setof %s"
-					 " :pct_type %s :typmod %d :arrayBounds ",
-					 node->typeid,
-					 booltostr(node->timezone),
-					 booltostr(node->setof),
-					 booltostr(node->pct_type),
-					 node->typmod);
-	_outNode(str, node->arrayBounds);
+	WRITE_NODE_TYPE("TYPENAME");
+
+	WRITE_NODE_FIELD(names);
+	WRITE_OID_FIELD(typeid);
+	WRITE_BOOL_FIELD(timezone);
+	WRITE_BOOL_FIELD(setof);
+	WRITE_BOOL_FIELD(pct_type);
+	WRITE_INT_FIELD(typmod);
+	WRITE_NODE_FIELD(arrayBounds);
 }
 
 static void
 _outTypeCast(StringInfo str, TypeCast *node)
 {
-	appendStringInfo(str, " TYPECAST :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str, " :typename ");
-	_outNode(str, node->typename);
+	WRITE_NODE_TYPE("TYPECAST");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_NODE_FIELD(typename);
 }
 
 static void
 _outIndexElem(StringInfo str, IndexElem *node)
 {
-	appendStringInfo(str, " INDEXELEM :name ");
-	_outToken(str, node->name);
-	appendStringInfo(str, " :funcname ");
-	_outNode(str, node->funcname);
-	appendStringInfo(str, " :args ");
-	_outNode(str, node->args);
-	appendStringInfo(str, " :opclass ");
-	_outNode(str, node->opclass);
+	WRITE_NODE_TYPE("INDEXELEM");
+
+	WRITE_STRING_FIELD(name);
+	WRITE_NODE_FIELD(funcname);
+	WRITE_NODE_FIELD(args);
+	WRITE_NODE_FIELD(opclass);
 }
 
 static void
 _outQuery(StringInfo str, Query *node)
 {
-	appendStringInfo(str, " QUERY :command %d :source %d :utility ",
-					 (int) node->commandType, (int) node->querySource);
+	WRITE_NODE_TYPE("QUERY");
+
+	WRITE_ENUM_FIELD(commandType, CmdType);
+	WRITE_ENUM_FIELD(querySource, QuerySource);
 
 	/*
 	 * Hack to work around missing outfuncs routines for a lot of the
@@ -247,60 +303,34 @@ _outQuery(StringInfo str, Query *node)
 			case T_CreateStmt:
 			case T_IndexStmt:
 			case T_NotifyStmt:
-				_outNode(str, node->utilityStmt);
+				WRITE_NODE_FIELD(utilityStmt);
 				break;
 			default:
-				appendStringInfo(str, "?");
+				appendStringInfo(str, " :utilityStmt ?");
 				break;
 		}
 	}
 	else
-		appendStringInfo(str, "<>");
-
-	appendStringInfo(str, " :resultRelation %d :into ",
-					 node->resultRelation);
-	_outNode(str, node->into);
-
-	appendStringInfo(str, " :isPortal %s :isBinary %s"
-					 " :hasAggs %s :hasSubLinks %s :rtable ",
-					 booltostr(node->isPortal),
-					 booltostr(node->isBinary),
-					 booltostr(node->hasAggs),
-					 booltostr(node->hasSubLinks));
-	_outNode(str, node->rtable);
-
-	appendStringInfo(str, " :jointree ");
-	_outNode(str, node->jointree);
-
-	appendStringInfo(str, " :rowMarks ");
-	_outIntList(str, node->rowMarks);
-
-	appendStringInfo(str, " :targetList ");
-	_outNode(str, node->targetList);
-
-	appendStringInfo(str, " :groupClause ");
-	_outNode(str, node->groupClause);
-
-	appendStringInfo(str, " :havingQual ");
-	_outNode(str, node->havingQual);
-
-	appendStringInfo(str, " :distinctClause ");
-	_outNode(str, node->distinctClause);
-
-	appendStringInfo(str, " :sortClause ");
-	_outNode(str, node->sortClause);
-
-	appendStringInfo(str, " :limitOffset ");
-	_outNode(str, node->limitOffset);
-
-	appendStringInfo(str, " :limitCount ");
-	_outNode(str, node->limitCount);
-
-	appendStringInfo(str, " :setOperations ");
-	_outNode(str, node->setOperations);
-
-	appendStringInfo(str, " :resultRelations ");
-	_outIntList(str, node->resultRelations);
+		appendStringInfo(str, " :utilityStmt <>");
+
+	WRITE_INT_FIELD(resultRelation);
+	WRITE_NODE_FIELD(into);
+	WRITE_BOOL_FIELD(isPortal);
+	WRITE_BOOL_FIELD(isBinary);
+	WRITE_BOOL_FIELD(hasAggs);
+	WRITE_BOOL_FIELD(hasSubLinks);
+	WRITE_NODE_FIELD(rtable);
+	WRITE_NODE_FIELD(jointree);
+	WRITE_INTLIST_FIELD(rowMarks);
+	WRITE_NODE_FIELD(targetList);
+	WRITE_NODE_FIELD(groupClause);
+	WRITE_NODE_FIELD(havingQual);
+	WRITE_NODE_FIELD(distinctClause);
+	WRITE_NODE_FIELD(sortClause);
+	WRITE_NODE_FIELD(limitOffset);
+	WRITE_NODE_FIELD(limitCount);
+	WRITE_NODE_FIELD(setOperations);
+	WRITE_INTLIST_FIELD(resultRelations);
 
 	/* planner-internal fields are not written out */
 }
@@ -308,31 +338,38 @@ _outQuery(StringInfo str, Query *node)
 static void
 _outSortClause(StringInfo str, SortClause *node)
 {
-	appendStringInfo(str, " SORTCLAUSE :tleSortGroupRef %u :sortop %u ",
-					 node->tleSortGroupRef, node->sortop);
+	WRITE_NODE_TYPE("SORTCLAUSE");
+
+	WRITE_UINT_FIELD(tleSortGroupRef);
+	WRITE_OID_FIELD(sortop);
 }
 
 static void
 _outGroupClause(StringInfo str, GroupClause *node)
 {
-	appendStringInfo(str, " GROUPCLAUSE :tleSortGroupRef %u :sortop %u ",
-					 node->tleSortGroupRef, node->sortop);
+	WRITE_NODE_TYPE("GROUPCLAUSE");
+
+	WRITE_UINT_FIELD(tleSortGroupRef);
+	WRITE_OID_FIELD(sortop);
 }
 
 static void
 _outSetOperationStmt(StringInfo str, SetOperationStmt *node)
 {
-	appendStringInfo(str, " SETOPERATIONSTMT :op %d :all %s :larg ",
-					 (int) node->op,
-					 booltostr(node->all));
-	_outNode(str, node->larg);
-	appendStringInfo(str, " :rarg ");
-	_outNode(str, node->rarg);
-	appendStringInfo(str, " :colTypes ");
-	_outOidList(str, node->colTypes);
+	WRITE_NODE_TYPE("SETOPERATIONSTMT");
+
+	WRITE_ENUM_FIELD(op, SetOperation);
+	WRITE_BOOL_FIELD(all);
+	WRITE_NODE_FIELD(larg);
+	WRITE_NODE_FIELD(rarg);
+	WRITE_OIDLIST_FIELD(colTypes);
 }
 
 /*
+ *	Stuff from plannodes.h
+ */
+
+/*
  * print the basic stuff of all nodes that inherit from Plan
  *
  * NOTE: we deliberately omit the execution state (EState)
@@ -340,274 +377,208 @@ _outSetOperationStmt(StringInfo str, SetOperationStmt *node)
 static void
 _outPlanInfo(StringInfo str, Plan *node)
 {
-	appendStringInfo(str,
-					 ":startup_cost %.2f :total_cost %.2f :rows %.0f :width %d :qptargetlist ",
-					 node->startup_cost,
-					 node->total_cost,
-					 node->plan_rows,
-					 node->plan_width);
-	_outNode(str, node->targetlist);
-
-	appendStringInfo(str, " :qpqual ");
-	_outNode(str, node->qual);
-
-	appendStringInfo(str, " :lefttree ");
-	_outNode(str, node->lefttree);
-
-	appendStringInfo(str, " :righttree ");
-	_outNode(str, node->righttree);
-
-	appendStringInfo(str, " :extprm ");
-	_outIntList(str, node->extParam);
-
-	appendStringInfo(str, " :locprm ");
-	_outIntList(str, node->locParam);
+	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
+	WRITE_FLOAT_FIELD(total_cost, "%.2f");
+	WRITE_FLOAT_FIELD(plan_rows, "%.0f");
+	WRITE_INT_FIELD(plan_width);
+	WRITE_NODE_FIELD(targetlist);
+	WRITE_NODE_FIELD(qual);
+	WRITE_NODE_FIELD(lefttree);
+	WRITE_NODE_FIELD(righttree);
+	WRITE_INTLIST_FIELD(extParam);
+	WRITE_INTLIST_FIELD(locParam);
+	/* chgParam is execution state too */
+	WRITE_NODE_FIELD(initPlan);
+	/* we don't write subPlan; reader must reconstruct list */
+	WRITE_INT_FIELD(nParamExec);
+}
 
-	appendStringInfo(str, " :initplan ");
-	_outNode(str, node->initPlan);
+/*
+ * print the basic stuff of all nodes that inherit from Scan
+ */
+static void
+_outScanInfo(StringInfo str, Scan *node)
+{
+	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :nprm %d ", node->nParamExec);
+	WRITE_UINT_FIELD(scanrelid);
 }
 
 /*
- *	Stuff from plannodes.h
+ * print the basic stuff of all nodes that inherit from Join
  */
 static void
+_outJoinPlanInfo(StringInfo str, Join *node)
+{
+	_outPlanInfo(str, (Plan *) node);
+
+	WRITE_ENUM_FIELD(jointype, JoinType);
+	WRITE_NODE_FIELD(joinqual);
+}
+
+
+static void
 _outPlan(StringInfo str, Plan *node)
 {
-	appendStringInfo(str, " PLAN ");
+	WRITE_NODE_TYPE("PLAN");
+
 	_outPlanInfo(str, (Plan *) node);
 }
 
 static void
 _outResult(StringInfo str, Result *node)
 {
-	appendStringInfo(str, " RESULT ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("RESULT");
 
-	appendStringInfo(str, " :resconstantqual ");
-	_outNode(str, node->resconstantqual);
+	_outPlanInfo(str, (Plan *) node);
 
+	WRITE_NODE_FIELD(resconstantqual);
 }
 
-/*
- *	Append is a subclass of Plan.
- */
 static void
 _outAppend(StringInfo str, Append *node)
 {
-	appendStringInfo(str, " APPEND ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("APPEND");
 
-	appendStringInfo(str, " :appendplans ");
-	_outNode(str, node->appendplans);
+	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :isTarget %s ",
-					 booltostr(node->isTarget));
+	WRITE_NODE_FIELD(appendplans);
+	WRITE_BOOL_FIELD(isTarget);
 }
 
-/*
- *	Join is a subclass of Plan
- */
 static void
-_outJoin(StringInfo str, Join *node)
+_outScan(StringInfo str, Scan *node)
 {
-	appendStringInfo(str, " JOIN ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :jointype %d :joinqual ",
-					 (int) node->jointype);
-	_outNode(str, node->joinqual);
+	WRITE_NODE_TYPE("SCAN");
+
+	_outScanInfo(str, (Scan *) node);
 }
 
-/*
- *	NestLoop is a subclass of Join
- */
 static void
-_outNestLoop(StringInfo str, NestLoop *node)
+_outSeqScan(StringInfo str, SeqScan *node)
 {
-	appendStringInfo(str, " NESTLOOP ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :jointype %d :joinqual ",
-					 (int) node->join.jointype);
-	_outNode(str, node->join.joinqual);
+	WRITE_NODE_TYPE("SEQSCAN");
+
+	_outScanInfo(str, (Scan *) node);
 }
 
-/*
- *	MergeJoin is a subclass of Join
- */
 static void
-_outMergeJoin(StringInfo str, MergeJoin *node)
+_outIndexScan(StringInfo str, IndexScan *node)
 {
-	appendStringInfo(str, " MERGEJOIN ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :jointype %d :joinqual ",
-					 (int) node->join.jointype);
-	_outNode(str, node->join.joinqual);
+	WRITE_NODE_TYPE("INDEXSCAN");
 
-	appendStringInfo(str, " :mergeclauses ");
-	_outNode(str, node->mergeclauses);
+	_outScanInfo(str, (Scan *) node);
+
+	WRITE_OIDLIST_FIELD(indxid);
+	WRITE_NODE_FIELD(indxqual);
+	WRITE_NODE_FIELD(indxqualorig);
+	WRITE_ENUM_FIELD(indxorderdir, ScanDirection);
 }
 
-/*
- *	HashJoin is a subclass of Join.
- */
 static void
-_outHashJoin(StringInfo str, HashJoin *node)
+_outTidScan(StringInfo str, TidScan *node)
 {
-	appendStringInfo(str, " HASHJOIN ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :jointype %d :joinqual ",
-					 (int) node->join.jointype);
-	_outNode(str, node->join.joinqual);
+	WRITE_NODE_TYPE("TIDSCAN");
+
+	_outScanInfo(str, (Scan *) node);
 
-	appendStringInfo(str, " :hashclauses ");
-	_outNode(str, node->hashclauses);
-	appendStringInfo(str, " :hashjoinop %u ",
-					 node->hashjoinop);
+	WRITE_BOOL_FIELD(needRescan);
+	WRITE_NODE_FIELD(tideval);
 }
 
 static void
-_outSubPlan(StringInfo str, SubPlan *node)
+_outSubqueryScan(StringInfo str, SubqueryScan *node)
 {
-	appendStringInfo(str, " SUBPLAN :plan ");
-	_outNode(str, node->plan);
-
-	appendStringInfo(str, " :planid %d :rtable ", node->plan_id);
-	_outNode(str, node->rtable);
+	WRITE_NODE_TYPE("SUBQUERYSCAN");
 
-	appendStringInfo(str, " :setprm ");
-	_outIntList(str, node->setParam);
+	_outScanInfo(str, (Scan *) node);
 
-	appendStringInfo(str, " :parprm ");
-	_outIntList(str, node->parParam);
-
-	appendStringInfo(str, " :slink ");
-	_outNode(str, node->sublink);
+	WRITE_NODE_FIELD(subplan);
 }
 
-/*
- *	Scan is a subclass of Node
- */
 static void
-_outScan(StringInfo str, Scan *node)
+_outFunctionScan(StringInfo str, FunctionScan *node)
 {
-	appendStringInfo(str, " SCAN ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("FUNCTIONSCAN");
 
-	appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
+	_outScanInfo(str, (Scan *) node);
 }
 
-/*
- *	SeqScan is a subclass of Scan
- */
 static void
-_outSeqScan(StringInfo str, SeqScan *node)
+_outJoin(StringInfo str, Join *node)
 {
-	appendStringInfo(str, " SEQSCAN ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("JOIN");
 
-	appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
+	_outJoinPlanInfo(str, (Join *) node);
 }
 
-/*
- *	IndexScan is a subclass of Scan
- */
 static void
-_outIndexScan(StringInfo str, IndexScan *node)
+_outNestLoop(StringInfo str, NestLoop *node)
 {
-	appendStringInfo(str, " INDEXSCAN ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("NESTLOOP");
 
-	appendStringInfo(str, " :scanrelid %u :indxid ", node->scan.scanrelid);
-	_outOidList(str, node->indxid);
+	_outJoinPlanInfo(str, (Join *) node);
+}
 
-	appendStringInfo(str, " :indxqual ");
-	_outNode(str, node->indxqual);
+static void
+_outMergeJoin(StringInfo str, MergeJoin *node)
+{
+	WRITE_NODE_TYPE("MERGEJOIN");
 
-	appendStringInfo(str, " :indxqualorig ");
-	_outNode(str, node->indxqualorig);
+	_outJoinPlanInfo(str, (Join *) node);
 
-	appendStringInfo(str, " :indxorderdir %d ", node->indxorderdir);
+	WRITE_NODE_FIELD(mergeclauses);
 }
 
-/*
- *	TidScan is a subclass of Scan
- */
 static void
-_outTidScan(StringInfo str, TidScan *node)
+_outHashJoin(StringInfo str, HashJoin *node)
 {
-	appendStringInfo(str, " TIDSCAN ");
-	_outPlanInfo(str, (Plan *) node);
+	WRITE_NODE_TYPE("HASHJOIN");
 
-	appendStringInfo(str, " :scanrelid %u ", node->scan.scanrelid);
-	appendStringInfo(str, " :needrescan %d ", node->needRescan);
-
-	appendStringInfo(str, " :tideval ");
-	_outNode(str, node->tideval);
+	_outJoinPlanInfo(str, (Join *) node);
 
+	WRITE_NODE_FIELD(hashclauses);
+	WRITE_OID_FIELD(hashjoinop);
 }
 
-/*
- *	SubqueryScan is a subclass of Scan
- */
 static void
-_outSubqueryScan(StringInfo str, SubqueryScan *node)
+_outAgg(StringInfo str, Agg *node)
 {
-	appendStringInfo(str, " SUBQUERYSCAN ");
+	WRITE_NODE_TYPE("AGG");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :scanrelid %u :subplan ", node->scan.scanrelid);
-	_outNode(str, node->subplan);
+	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
+	WRITE_INT_FIELD(numCols);
+	WRITE_LONG_FIELD(numGroups);
 }
 
-/*
- *	FunctionScan is a subclass of Scan
- */
 static void
-_outFunctionScan(StringInfo str, FunctionScan *node)
+_outGroup(StringInfo str, Group *node)
 {
-	appendStringInfo(str, " FUNCTIONSCAN ");
+	WRITE_NODE_TYPE("GRP");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :scanrelid %u ", node->scan.scanrelid);
+	WRITE_INT_FIELD(numCols);
 }
 
-/*
- *	Material is a subclass of Plan
- */
 static void
 _outMaterial(StringInfo str, Material *node)
 {
-	appendStringInfo(str, " MATERIAL ");
+	WRITE_NODE_TYPE("MATERIAL");
+
 	_outPlanInfo(str, (Plan *) node);
 }
 
-/*
- *	Sort is a subclass of Plan
- */
 static void
 _outSort(StringInfo str, Sort *node)
 {
-	appendStringInfo(str, " SORT ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :keycount %d ", node->keycount);
-}
+	WRITE_NODE_TYPE("SORT");
 
-static void
-_outAgg(StringInfo str, Agg *node)
-{
-	appendStringInfo(str, " AGG ");
 	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :aggstrategy %d :numCols %d :numGroups %ld ",
-					 (int) node->aggstrategy, node->numCols, node->numGroups);
-}
 
-static void
-_outGroup(StringInfo str, Group *node)
-{
-	appendStringInfo(str, " GRP ");
-	_outPlanInfo(str, (Plan *) node);
-	appendStringInfo(str, " :numCols %d ", node->numCols);
+	WRITE_INT_FIELD(keycount);
 }
 
 static void
@@ -615,13 +586,15 @@ _outUnique(StringInfo str, Unique *node)
 {
 	int			i;
 
-	appendStringInfo(str, " UNIQUE ");
+	WRITE_NODE_TYPE("UNIQUE");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :numCols %d :uniqColIdx ",
-					 node->numCols);
+	WRITE_INT_FIELD(numCols);
+
+	appendStringInfo(str, " :uniqColIdx");
 	for (i = 0; i < node->numCols; i++)
-		appendStringInfo(str, "%d ", (int) node->uniqColIdx[i]);
+		appendStringInfo(str, " %d", node->uniqColIdx[i]);
 }
 
 static void
@@ -629,40 +602,52 @@ _outSetOp(StringInfo str, SetOp *node)
 {
 	int			i;
 
-	appendStringInfo(str, " SETOP ");
+	WRITE_NODE_TYPE("SETOP");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :cmd %d :numCols %d :dupColIdx ",
-					 (int) node->cmd, node->numCols);
+	WRITE_ENUM_FIELD(cmd, SetOpCmd);
+	WRITE_INT_FIELD(numCols);
+
+	appendStringInfo(str, " :dupColIdx");
 	for (i = 0; i < node->numCols; i++)
-		appendStringInfo(str, "%d ", (int) node->dupColIdx[i]);
-	appendStringInfo(str, " :flagColIdx %d ",
-					 (int) node->flagColIdx);
+		appendStringInfo(str, " %d", node->dupColIdx[i]);
+
+	WRITE_INT_FIELD(flagColIdx);
 }
 
 static void
 _outLimit(StringInfo str, Limit *node)
 {
-	appendStringInfo(str, " LIMIT ");
+	WRITE_NODE_TYPE("LIMIT");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :limitOffset ");
-	_outNode(str, node->limitOffset);
-	appendStringInfo(str, " :limitCount ");
-	_outNode(str, node->limitCount);
+	WRITE_NODE_FIELD(limitOffset);
+	WRITE_NODE_FIELD(limitCount);
 }
 
-/*
- *	Hash is a subclass of Plan
- */
 static void
 _outHash(StringInfo str, Hash *node)
 {
-	appendStringInfo(str, " HASH ");
+	WRITE_NODE_TYPE("HASH");
+
 	_outPlanInfo(str, (Plan *) node);
 
-	appendStringInfo(str, " :hashkey ");
-	_outNode(str, node->hashkey);
+	WRITE_NODE_FIELD(hashkey);
+}
+
+static void
+_outSubPlan(StringInfo str, SubPlan *node)
+{
+	WRITE_NODE_TYPE("SUBPLAN");
+
+	WRITE_NODE_FIELD(plan);
+	WRITE_INT_FIELD(plan_id);
+	WRITE_NODE_FIELD(rtable);
+	WRITE_INTLIST_FIELD(setParam);
+	WRITE_INTLIST_FIELD(parParam);
+	WRITE_NODE_FIELD(sublink);
 }
 
 /*****************************************************************************
@@ -671,56 +656,31 @@ _outHash(StringInfo str, Hash *node)
  *
  *****************************************************************************/
 
-/*
- *	Resdom is a subclass of Node
- */
 static void
 _outResdom(StringInfo str, Resdom *node)
 {
-	appendStringInfo(str,
-				 " RESDOM :resno %d :restype %u :restypmod %d :resname ",
-					 node->resno,
-					 node->restype,
-					 node->restypmod);
-	_outToken(str, node->resname);
-	appendStringInfo(str, " :reskey %u :reskeyop %u :ressortgroupref %u :resjunk %s ",
-					 node->reskey,
-					 node->reskeyop,
-					 node->ressortgroupref,
-					 booltostr(node->resjunk));
-}
+	WRITE_NODE_TYPE("RESDOM");
 
-static void
-_outFjoin(StringInfo str, Fjoin *node)
-{
-	int			i;
-
-	appendStringInfo(str, " FJOIN :initialized %s :nNodes %d ",
-					 booltostr(node->fj_initialized),
-					 node->fj_nNodes);
-
-	appendStringInfo(str, " :innerNode ");
-	_outNode(str, node->fj_innerNode);
-
-	appendStringInfo(str, " :results @ 0x%p :alwaysdone",
-					 node->fj_results);
-
-	for (i = 0; i < node->fj_nNodes; i++)
-		appendStringInfo(str,
-						 booltostr(node->fj_alwaysDone[i]));
+	WRITE_INT_FIELD(resno);
+	WRITE_OID_FIELD(restype);
+	WRITE_INT_FIELD(restypmod);
+	WRITE_STRING_FIELD(resname);
+	WRITE_UINT_FIELD(ressortgroupref);
+	WRITE_UINT_FIELD(reskey);
+	WRITE_OID_FIELD(reskeyop);
+	WRITE_BOOL_FIELD(resjunk);
 }
 
-/*
- *	Expr is a subclass of Node
- */
 static void
 _outExpr(StringInfo str, Expr *node)
 {
 	char	   *opstr = NULL;
 
-	appendStringInfo(str, " EXPR :typeOid %u ",
-					 node->typeOid);
+	WRITE_NODE_TYPE("EXPR");
+
+	WRITE_OID_FIELD(typeOid);
 
+	/* do-it-yourself enum representation */
 	switch (node->opType)
 	{
 		case OP_EXPR:
@@ -747,504 +707,371 @@ _outExpr(StringInfo str, Expr *node)
 	}
 	appendStringInfo(str, " :opType ");
 	_outToken(str, opstr);
-	appendStringInfo(str, " :oper ");
-	_outNode(str, node->oper);
 
-	appendStringInfo(str, " :args ");
-	_outNode(str, node->args);
+	WRITE_NODE_FIELD(oper);
+	WRITE_NODE_FIELD(args);
 }
 
-/*
- *	Var is a subclass of Expr
- */
 static void
 _outVar(StringInfo str, Var *node)
 {
-	appendStringInfo(str,
-				" VAR :varno %u :varattno %d :vartype %u :vartypmod %d ",
-					 node->varno,
-					 node->varattno,
-					 node->vartype,
-					 node->vartypmod);
+	WRITE_NODE_TYPE("VAR");
 
-	appendStringInfo(str, " :varlevelsup %u :varnoold %u :varoattno %d",
-					 node->varlevelsup,
-					 node->varnoold,
-					 node->varoattno);
+	WRITE_UINT_FIELD(varno);
+	WRITE_INT_FIELD(varattno);
+	WRITE_OID_FIELD(vartype);
+	WRITE_INT_FIELD(vartypmod);
+	WRITE_UINT_FIELD(varlevelsup);
+	WRITE_UINT_FIELD(varnoold);
+	WRITE_INT_FIELD(varoattno);
 }
 
-/*
- *	Const is a subclass of Expr
- */
 static void
 _outConst(StringInfo str, Const *node)
 {
-	appendStringInfo(str,
-					 " CONST :consttype %u :constlen %d :constbyval %s"
-					 " :constisnull %s :constvalue ",
-					 node->consttype,
-					 node->constlen,
-					 booltostr(node->constbyval),
-					 booltostr(node->constisnull));
+	WRITE_NODE_TYPE("CONST");
+
+	WRITE_OID_FIELD(consttype);
+	WRITE_INT_FIELD(constlen);
+	WRITE_BOOL_FIELD(constbyval);
+	WRITE_BOOL_FIELD(constisnull);
+	/* XXX what about constisset, constiscast? */
 
+	appendStringInfo(str, " :constvalue ");
 	if (node->constisnull)
 		appendStringInfo(str, "<>");
 	else
 		_outDatum(str, node->constvalue, node->constlen, node->constbyval);
 }
 
-/*
- *	Aggref
- */
 static void
 _outAggref(StringInfo str, Aggref *node)
 {
-	appendStringInfo(str, " AGGREG :aggfnoid %u :aggtype %u :target ",
-					 node->aggfnoid, node->aggtype);
-	_outNode(str, node->target);
+	WRITE_NODE_TYPE("AGGREF");
 
-	appendStringInfo(str, " :aggstar %s :aggdistinct %s ",
-					 booltostr(node->aggstar),
-					 booltostr(node->aggdistinct));
-	/* aggno is not dumped */
+	WRITE_OID_FIELD(aggfnoid);
+	WRITE_OID_FIELD(aggtype);
+	WRITE_NODE_FIELD(target);
+	WRITE_BOOL_FIELD(aggstar);
+	WRITE_BOOL_FIELD(aggdistinct);
+	/* aggno is not saved since it is just executor state */
 }
 
-/*
- *	SubLink
- */
 static void
 _outSubLink(StringInfo str, SubLink *node)
 {
-	appendStringInfo(str,
-					 " SUBLINK :subLinkType %d :useor %s :lefthand ",
-					 node->subLinkType,
-					 booltostr(node->useor));
-	_outNode(str, node->lefthand);
-
-	appendStringInfo(str, " :oper ");
-	_outNode(str, node->oper);
+	WRITE_NODE_TYPE("SUBLINK");
 
-	appendStringInfo(str, " :subselect ");
-	_outNode(str, node->subselect);
+	WRITE_ENUM_FIELD(subLinkType, SubLinkType);
+	WRITE_BOOL_FIELD(useor);
+	WRITE_NODE_FIELD(lefthand);
+	WRITE_NODE_FIELD(oper);
+	WRITE_NODE_FIELD(subselect);
 }
 
-/*
- *	ArrayRef is a subclass of Expr
- */
 static void
 _outArrayRef(StringInfo str, ArrayRef *node)
 {
-	appendStringInfo(str,
-		 " ARRAYREF :refrestype %u :refattrlength %d :refelemlength %d ",
-					 node->refrestype,
-					 node->refattrlength,
-					 node->refelemlength);
+	WRITE_NODE_TYPE("ARRAYREF");
 
-	appendStringInfo(str,
-				   ":refelembyval %s :refelemalign %c :refupperindexpr ",
-					 booltostr(node->refelembyval),
-					 node->refelemalign);
-	_outNode(str, node->refupperindexpr);
-
-	appendStringInfo(str, " :reflowerindexpr ");
-	_outNode(str, node->reflowerindexpr);
-
-	appendStringInfo(str, " :refexpr ");
-	_outNode(str, node->refexpr);
-
-	appendStringInfo(str, " :refassgnexpr ");
-	_outNode(str, node->refassgnexpr);
+	WRITE_OID_FIELD(refrestype);
+	WRITE_INT_FIELD(refattrlength);
+	WRITE_INT_FIELD(refelemlength);
+	WRITE_BOOL_FIELD(refelembyval);
+	WRITE_CHAR_FIELD(refelemalign);
+	WRITE_NODE_FIELD(refupperindexpr);
+	WRITE_NODE_FIELD(reflowerindexpr);
+	WRITE_NODE_FIELD(refexpr);
+	WRITE_NODE_FIELD(refassgnexpr);
 }
 
-/*
- *	Func is a subclass of Expr
- */
 static void
 _outFunc(StringInfo str, Func *node)
 {
-	appendStringInfo(str,
-		" FUNC :funcid %u :funcresulttype %u :funcretset %s :funcformat %d ",
-					 node->funcid,
-					 node->funcresulttype,
-					 booltostr(node->funcretset),
-					 (int) node->funcformat);
+	WRITE_NODE_TYPE("FUNC");
+
+	WRITE_OID_FIELD(funcid);
+	WRITE_OID_FIELD(funcresulttype);
+	WRITE_BOOL_FIELD(funcretset);
+	WRITE_ENUM_FIELD(funcformat, CoercionForm);
 }
 
-/*
- *	Oper is a subclass of Expr
- */
 static void
 _outOper(StringInfo str, Oper *node)
 {
-	appendStringInfo(str,
-				" OPER :opno %u :opid %u :opresulttype %u :opretset %s ",
-					 node->opno,
-					 node->opid,
-					 node->opresulttype,
-					 booltostr(node->opretset));
+	WRITE_NODE_TYPE("OPER");
+
+	WRITE_OID_FIELD(opno);
+	WRITE_OID_FIELD(opid);
+	WRITE_OID_FIELD(opresulttype);
+	WRITE_BOOL_FIELD(opretset);
 }
 
-/*
- *	Param is a subclass of Expr
- */
 static void
 _outParam(StringInfo str, Param *node)
 {
-	appendStringInfo(str, " PARAM :paramkind %d :paramid %d :paramname ",
-					 node->paramkind,
-					 node->paramid);
-	_outToken(str, node->paramname);
-	appendStringInfo(str, " :paramtype %u ", node->paramtype);
+	WRITE_NODE_TYPE("PARAM");
+
+	WRITE_INT_FIELD(paramkind);
+	WRITE_INT_FIELD(paramid);
+	WRITE_STRING_FIELD(paramname);
+	WRITE_OID_FIELD(paramtype);
 }
 
-/*
- *	FieldSelect
- */
 static void
 _outFieldSelect(StringInfo str, FieldSelect *node)
 {
-	appendStringInfo(str, " FIELDSELECT :arg ");
-	_outNode(str, node->arg);
+	WRITE_NODE_TYPE("FIELDSELECT");
 
-	appendStringInfo(str, " :fieldnum %d :resulttype %u :resulttypmod %d ",
-				   node->fieldnum, node->resulttype, node->resulttypmod);
+	WRITE_NODE_FIELD(arg);
+	WRITE_INT_FIELD(fieldnum);
+	WRITE_OID_FIELD(resulttype);
+	WRITE_INT_FIELD(resulttypmod);
 }
 
-/*
- *	RelabelType
- */
 static void
 _outRelabelType(StringInfo str, RelabelType *node)
 {
-	appendStringInfo(str, " RELABELTYPE :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str,
-					 " :resulttype %u :resulttypmod %d :relabelformat %d ",
-					 node->resulttype,
-					 node->resulttypmod,
-					 (int) node->relabelformat);
+	WRITE_NODE_TYPE("RELABELTYPE");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_OID_FIELD(resulttype);
+	WRITE_INT_FIELD(resulttypmod);
+	WRITE_ENUM_FIELD(relabelformat, CoercionForm);
 }
 
-/*
- *	RangeTblRef
- */
 static void
 _outRangeTblRef(StringInfo str, RangeTblRef *node)
 {
-	appendStringInfo(str, " RANGETBLREF %d ",
-					 node->rtindex);
+	WRITE_NODE_TYPE("RANGETBLREF");
+
+	WRITE_INT_FIELD(rtindex);
 }
 
-/*
- *	FromExpr
- */
 static void
-_outFromExpr(StringInfo str, FromExpr *node)
+_outJoinExpr(StringInfo str, JoinExpr *node)
 {
-	appendStringInfo(str, " FROMEXPR :fromlist ");
-	_outNode(str, node->fromlist);
-	appendStringInfo(str, " :quals ");
-	_outNode(str, node->quals);
+	WRITE_NODE_TYPE("JOINEXPR");
+
+	WRITE_ENUM_FIELD(jointype, JoinType);
+	WRITE_BOOL_FIELD(isNatural);
+	WRITE_NODE_FIELD(larg);
+	WRITE_NODE_FIELD(rarg);
+	WRITE_NODE_FIELD(using);
+	WRITE_NODE_FIELD(quals);
+	WRITE_NODE_FIELD(alias);
+	WRITE_INT_FIELD(rtindex);
 }
 
-/*
- *	JoinExpr
- */
 static void
-_outJoinExpr(StringInfo str, JoinExpr *node)
+_outFromExpr(StringInfo str, FromExpr *node)
 {
-	appendStringInfo(str, " JOINEXPR :jointype %d :isNatural %s :larg ",
-					 (int) node->jointype,
-					 booltostr(node->isNatural));
-	_outNode(str, node->larg);
-	appendStringInfo(str, " :rarg ");
-	_outNode(str, node->rarg);
-	appendStringInfo(str, " :using ");
-	_outNode(str, node->using);
-	appendStringInfo(str, " :quals ");
-	_outNode(str, node->quals);
-	appendStringInfo(str, " :alias ");
-	_outNode(str, node->alias);
-	appendStringInfo(str, " :rtindex %d ", node->rtindex);
+	WRITE_NODE_TYPE("FROMEXPR");
+
+	WRITE_NODE_FIELD(fromlist);
+	WRITE_NODE_FIELD(quals);
 }
 
-/*
- *	TargetEntry is a subclass of Node.
- */
 static void
 _outTargetEntry(StringInfo str, TargetEntry *node)
 {
-	appendStringInfo(str, " TARGETENTRY :resdom ");
-	_outNode(str, node->resdom);
+	WRITE_NODE_TYPE("TARGETENTRY");
 
-	appendStringInfo(str, " :expr ");
-	_outNode(str, node->expr);
+	WRITE_NODE_FIELD(resdom);
+	/* fjoin not supported ... */
+	WRITE_NODE_FIELD(expr);
 }
 
 static void
 _outAlias(StringInfo str, Alias *node)
 {
-	appendStringInfo(str, " ALIAS :aliasname ");
-	_outToken(str, node->aliasname);
-	appendStringInfo(str, " :colnames ");
-	_outNode(str, node->colnames);
+	WRITE_NODE_TYPE("ALIAS");
+
+	WRITE_STRING_FIELD(aliasname);
+	WRITE_NODE_FIELD(colnames);
 }
 
 static void
 _outRangeTblEntry(StringInfo str, RangeTblEntry *node)
 {
+	WRITE_NODE_TYPE("RTE");
+
 	/* put alias + eref first to make dump more legible */
-	appendStringInfo(str, " RTE :alias ");
-	_outNode(str, node->alias);
-	appendStringInfo(str, " :eref ");
-	_outNode(str, node->eref);
-	appendStringInfo(str, " :rtekind %d ",
-					 (int) node->rtekind);
+	WRITE_NODE_FIELD(alias);
+	WRITE_NODE_FIELD(eref);
+	WRITE_ENUM_FIELD(rtekind, RTEKind);
+
 	switch (node->rtekind)
 	{
 		case RTE_RELATION:
 		case RTE_SPECIAL:
-			appendStringInfo(str, ":relid %u", node->relid);
+			WRITE_OID_FIELD(relid);
 			break;
 		case RTE_SUBQUERY:
-			appendStringInfo(str, ":subquery ");
-			_outNode(str, node->subquery);
+			WRITE_NODE_FIELD(subquery);
 			break;
 		case RTE_FUNCTION:
-			appendStringInfo(str, ":funcexpr ");
-			_outNode(str, node->funcexpr);
-			appendStringInfo(str, " :coldeflist ");
-			_outNode(str, node->coldeflist);
+			WRITE_NODE_FIELD(funcexpr);
+			WRITE_NODE_FIELD(coldeflist);
 			break;
 		case RTE_JOIN:
-			appendStringInfo(str, ":jointype %d :joinaliasvars ",
-							 (int) node->jointype);
-			_outNode(str, node->joinaliasvars);
+			WRITE_ENUM_FIELD(jointype, JoinType);
+			WRITE_NODE_FIELD(joinaliasvars);
 			break;
 		default:
 			elog(ERROR, "bogus rte kind %d", (int) node->rtekind);
 			break;
 	}
-	appendStringInfo(str, " :inh %s :inFromCl %s :checkForRead %s"
-					 " :checkForWrite %s :checkAsUser %u",
-					 booltostr(node->inh),
-					 booltostr(node->inFromCl),
-					 booltostr(node->checkForRead),
-					 booltostr(node->checkForWrite),
-					 node->checkAsUser);
+
+	WRITE_BOOL_FIELD(inh);
+	WRITE_BOOL_FIELD(inFromCl);
+	WRITE_BOOL_FIELD(checkForRead);
+	WRITE_BOOL_FIELD(checkForWrite);
+	WRITE_OID_FIELD(checkAsUser);
 }
 
 /*
- *	Path is a subclass of Node.
+ * print the basic stuff of all nodes that inherit from Path
  */
 static void
-_outPath(StringInfo str, Path *node)
+_outPathInfo(StringInfo str, Path *node)
 {
-	appendStringInfo(str,
-	 " PATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->pathtype,
-					 node->startup_cost,
-					 node->total_cost);
-	_outNode(str, node->pathkeys);
+	WRITE_ENUM_FIELD(pathtype, NodeTag);
+	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
+	WRITE_FLOAT_FIELD(total_cost, "%.2f");
+	WRITE_NODE_FIELD(pathkeys);
 }
 
 /*
- *	IndexPath is a subclass of Path.
+ * print the basic stuff of all nodes that inherit from JoinPath
  */
 static void
-_outIndexPath(StringInfo str, IndexPath *node)
+_outJoinPathInfo(StringInfo str, JoinPath *node)
 {
-	appendStringInfo(str,
-					 " INDEXPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->path.pathtype,
-					 node->path.startup_cost,
-					 node->path.total_cost);
-	_outNode(str, node->path.pathkeys);
+	_outPathInfo(str, (Path *) node);
 
-	appendStringInfo(str, " :indexinfo ");
-	_outNode(str, node->indexinfo);
+	WRITE_ENUM_FIELD(jointype, JoinType);
+	WRITE_NODE_FIELD(outerjoinpath);
+	WRITE_NODE_FIELD(innerjoinpath);
+	WRITE_NODE_FIELD(joinrestrictinfo);
+}
 
-	appendStringInfo(str, " :indexqual ");
-	_outNode(str, node->indexqual);
+static void
+_outPath(StringInfo str, Path *node)
+{
+	WRITE_NODE_TYPE("PATH");
 
-	appendStringInfo(str, " :indexscandir %d :rows %.2f ",
-					 (int) node->indexscandir,
-					 node->rows);
+	_outPathInfo(str, (Path *) node);
 }
 
 /*
- *	TidPath is a subclass of Path.
+ *	IndexPath is a subclass of Path.
  */
 static void
+_outIndexPath(StringInfo str, IndexPath *node)
+{
+	WRITE_NODE_TYPE("INDEXPATH");
+
+	_outPathInfo(str, (Path *) node);
+
+	WRITE_NODE_FIELD(indexinfo);
+	WRITE_NODE_FIELD(indexqual);
+	WRITE_ENUM_FIELD(indexscandir, ScanDirection);
+	WRITE_FLOAT_FIELD(rows, "%.2f");
+}
+
+static void
 _outTidPath(StringInfo str, TidPath *node)
 {
-	appendStringInfo(str,
-					 " TIDPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->path.pathtype,
-					 node->path.startup_cost,
-					 node->path.total_cost);
-	_outNode(str, node->path.pathkeys);
+	WRITE_NODE_TYPE("TIDPATH");
 
-	appendStringInfo(str, " :tideval ");
-	_outNode(str, node->tideval);
+	_outPathInfo(str, (Path *) node);
 
-	appendStringInfo(str, " :unjoined_relids ");
-	_outIntList(str, node->unjoined_relids);
+	WRITE_NODE_FIELD(tideval);
+	WRITE_INTLIST_FIELD(unjoined_relids);
 }
 
-/*
- *	AppendPath is a subclass of Path.
- */
 static void
 _outAppendPath(StringInfo str, AppendPath *node)
 {
-	appendStringInfo(str,
-					 " APPENDPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->path.pathtype,
-					 node->path.startup_cost,
-					 node->path.total_cost);
-	_outNode(str, node->path.pathkeys);
+	WRITE_NODE_TYPE("APPENDPATH");
+
+	_outPathInfo(str, (Path *) node);
 
-	appendStringInfo(str, " :subpaths ");
-	_outNode(str, node->subpaths);
+	WRITE_NODE_FIELD(subpaths);
 }
 
-/*
- *	ResultPath is a subclass of Path.
- */
 static void
 _outResultPath(StringInfo str, ResultPath *node)
 {
-	appendStringInfo(str,
-					 " RESULTPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->path.pathtype,
-					 node->path.startup_cost,
-					 node->path.total_cost);
-	_outNode(str, node->path.pathkeys);
+	WRITE_NODE_TYPE("RESULTPATH");
 
-	appendStringInfo(str, " :subpath ");
-	_outNode(str, node->subpath);
+	_outPathInfo(str, (Path *) node);
 
-	appendStringInfo(str, " :constantqual ");
-	_outNode(str, node->constantqual);
+	WRITE_NODE_FIELD(subpath);
+	WRITE_NODE_FIELD(constantqual);
 }
 
-/*
- *	NestPath is a subclass of Path
- */
 static void
 _outNestPath(StringInfo str, NestPath *node)
 {
-	appendStringInfo(str,
-					 " NESTPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->path.pathtype,
-					 node->path.startup_cost,
-					 node->path.total_cost);
-	_outNode(str, node->path.pathkeys);
-	appendStringInfo(str, " :jointype %d :outerjoinpath ",
-					 (int) node->jointype);
-	_outNode(str, node->outerjoinpath);
-	appendStringInfo(str, " :innerjoinpath ");
-	_outNode(str, node->innerjoinpath);
-	appendStringInfo(str, " :joinrestrictinfo ");
-	_outNode(str, node->joinrestrictinfo);
+	WRITE_NODE_TYPE("NESTPATH");
+
+	_outJoinPathInfo(str, (JoinPath *) node);
 }
 
-/*
- *	MergePath is a subclass of NestPath.
- */
 static void
 _outMergePath(StringInfo str, MergePath *node)
 {
-	appendStringInfo(str,
-					 " MERGEPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->jpath.path.pathtype,
-					 node->jpath.path.startup_cost,
-					 node->jpath.path.total_cost);
-	_outNode(str, node->jpath.path.pathkeys);
-	appendStringInfo(str, " :jointype %d :outerjoinpath ",
-					 (int) node->jpath.jointype);
-	_outNode(str, node->jpath.outerjoinpath);
-	appendStringInfo(str, " :innerjoinpath ");
-	_outNode(str, node->jpath.innerjoinpath);
-	appendStringInfo(str, " :joinrestrictinfo ");
-	_outNode(str, node->jpath.joinrestrictinfo);
+	WRITE_NODE_TYPE("MERGEPATH");
 
-	appendStringInfo(str, " :path_mergeclauses ");
-	_outNode(str, node->path_mergeclauses);
+	_outJoinPathInfo(str, (JoinPath *) node);
 
-	appendStringInfo(str, " :outersortkeys ");
-	_outNode(str, node->outersortkeys);
-
-	appendStringInfo(str, " :innersortkeys ");
-	_outNode(str, node->innersortkeys);
+	WRITE_NODE_FIELD(path_mergeclauses);
+	WRITE_NODE_FIELD(outersortkeys);
+	WRITE_NODE_FIELD(innersortkeys);
 }
 
-/*
- *	HashPath is a subclass of NestPath.
- */
 static void
 _outHashPath(StringInfo str, HashPath *node)
 {
-	appendStringInfo(str,
-					 " HASHPATH :pathtype %d :startup_cost %.2f :total_cost %.2f :pathkeys ",
-					 node->jpath.path.pathtype,
-					 node->jpath.path.startup_cost,
-					 node->jpath.path.total_cost);
-	_outNode(str, node->jpath.path.pathkeys);
-	appendStringInfo(str, " :jointype %d :outerjoinpath ",
-					 (int) node->jpath.jointype);
-	_outNode(str, node->jpath.outerjoinpath);
-	appendStringInfo(str, " :innerjoinpath ");
-	_outNode(str, node->jpath.innerjoinpath);
-	appendStringInfo(str, " :joinrestrictinfo ");
-	_outNode(str, node->jpath.joinrestrictinfo);
+	WRITE_NODE_TYPE("HASHPATH");
+
+	_outJoinPathInfo(str, (JoinPath *) node);
 
-	appendStringInfo(str, " :path_hashclauses ");
-	_outNode(str, node->path_hashclauses);
+	WRITE_NODE_FIELD(path_hashclauses);
 }
 
-/*
- *	PathKeyItem is a subclass of Node.
- */
 static void
 _outPathKeyItem(StringInfo str, PathKeyItem *node)
 {
-	appendStringInfo(str, " PATHKEYITEM :sortop %u :key ",
-					 node->sortop);
-	_outNode(str, node->key);
+	WRITE_NODE_TYPE("PATHKEYITEM");
+
+	WRITE_NODE_FIELD(key);
+	WRITE_OID_FIELD(sortop);
 }
 
-/*
- *	RestrictInfo is a subclass of Node.
- */
 static void
 _outRestrictInfo(StringInfo str, RestrictInfo *node)
 {
-	appendStringInfo(str, " RESTRICTINFO :clause ");
-	_outNode(str, node->clause);
+	WRITE_NODE_TYPE("RESTRICTINFO");
 
-	appendStringInfo(str, " :ispusheddown %s :subclauseindices ",
-					 booltostr(node->ispusheddown));
-	_outNode(str, node->subclauseindices);
-
-	appendStringInfo(str, " :mergejoinoperator %u ", node->mergejoinoperator);
-	appendStringInfo(str, " :left_sortop %u ", node->left_sortop);
-	appendStringInfo(str, " :right_sortop %u ", node->right_sortop);
-	appendStringInfo(str, " :hashjoinoperator %u ", node->hashjoinoperator);
+	WRITE_NODE_FIELD(clause);
+	WRITE_BOOL_FIELD(ispusheddown);
+	WRITE_NODE_FIELD(subclauseindices);
+	WRITE_OID_FIELD(mergejoinoperator);
+	WRITE_OID_FIELD(left_sortop);
+	WRITE_OID_FIELD(right_sortop);
+	WRITE_OID_FIELD(hashjoinoperator);
 }
 
-/*
- *	JoinInfo is a subclass of Node.
- */
 static void
 _outJoinInfo(StringInfo str, JoinInfo *node)
 {
-	appendStringInfo(str, " JINFO :unjoined_relids ");
-	_outIntList(str, node->unjoined_relids);
+	WRITE_NODE_TYPE("JOININFO");
 
-	appendStringInfo(str, " :jinfo_restrictinfo ");
-	_outNode(str, node->jinfo_restrictinfo);
+	WRITE_INTLIST_FIELD(unjoined_relids);
+	WRITE_NODE_FIELD(jinfo_restrictinfo);
 }
 
 /*
@@ -1262,22 +1089,22 @@ _outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
 	if (typbyval)
 	{
 		s = (char *) (&value);
-		appendStringInfo(str, " %u [ ", (unsigned int) length);
+		appendStringInfo(str, "%u [ ", (unsigned int) length);
 		for (i = 0; i < (Size) sizeof(Datum); i++)
 			appendStringInfo(str, "%d ", (int) (s[i]));
-		appendStringInfo(str, "] ");
+		appendStringInfo(str, "]");
 	}
 	else
 	{
 		s = (char *) DatumGetPointer(value);
 		if (!PointerIsValid(s))
-			appendStringInfo(str, " 0 [ ] ");
+			appendStringInfo(str, "0 [ ]");
 		else
 		{
-			appendStringInfo(str, " %u [ ", (unsigned int) length);
+			appendStringInfo(str, "%u [ ", (unsigned int) length);
 			for (i = 0; i < length; i++)
 				appendStringInfo(str, "%d ", (int) (s[i]));
-			appendStringInfo(str, "] ");
+			appendStringInfo(str, "]");
 		}
 	}
 }
@@ -1285,29 +1112,30 @@ _outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
 static void
 _outAExpr(StringInfo str, A_Expr *node)
 {
-	appendStringInfo(str, " AEXPR ");
+	WRITE_NODE_TYPE("AEXPR");
+
 	switch (node->oper)
 	{
 		case AND:
-			appendStringInfo(str, "AND ");
+			appendStringInfo(str, " AND");
 			break;
 		case OR:
-			appendStringInfo(str, "OR ");
+			appendStringInfo(str, " OR");
 			break;
 		case NOT:
-			appendStringInfo(str, "NOT ");
+			appendStringInfo(str, " NOT");
 			break;
 		case OP:
-			_outNode(str, node->name);
 			appendStringInfo(str, " ");
+			WRITE_NODE_FIELD(name);
 			break;
 		default:
-			appendStringInfo(str, "?? ");
+			appendStringInfo(str, " ??");
 			break;
 	}
-	_outNode(str, node->lexpr);
-	appendStringInfo(str, " ");
-	_outNode(str, node->rexpr);
+
+	WRITE_NODE_FIELD(lexpr);
+	WRITE_NODE_FIELD(rexpr);
 }
 
 static void
@@ -1316,7 +1144,7 @@ _outValue(StringInfo str, Value *value)
 	switch (value->type)
 	{
 		case T_Integer:
-			appendStringInfo(str, " %ld ", value->val.ival);
+			appendStringInfo(str, "%ld", value->val.ival);
 			break;
 		case T_Float:
 
@@ -1324,19 +1152,19 @@ _outValue(StringInfo str, Value *value)
 			 * We assume the value is a valid numeric literal and so does
 			 * not need quoting.
 			 */
-			appendStringInfo(str, " %s ", value->val.str);
+			appendStringInfo(str, "%s", value->val.str);
 			break;
 		case T_String:
-			appendStringInfo(str, " \"");
+			appendStringInfoChar(str, '"');
 			_outToken(str, value->val.str);
-			appendStringInfo(str, "\" ");
+			appendStringInfoChar(str, '"');
 			break;
 		case T_BitString:
 			/* internal representation already has leading 'b' */
-			appendStringInfo(str, " %s ", value->val.str);
+			appendStringInfo(str, "%s", value->val.str);
 			break;
 		default:
-			elog(WARNING, "_outValue: don't know how to print type %d ",
+			elog(WARNING, "_outValue: don't know how to print type %d",
 				 value->type);
 			break;
 	}
@@ -1345,86 +1173,82 @@ _outValue(StringInfo str, Value *value)
 static void
 _outRangeVar(StringInfo str, RangeVar *node)
 {
-	appendStringInfo(str, " RANGEVAR :relation ");
+	WRITE_NODE_TYPE("RANGEVAR");
 
 	/*
 	 * we deliberately ignore catalogname here, since it is presently not
 	 * semantically meaningful
 	 */
-	_outToken(str, node->schemaname);
-	appendStringInfo(str, " . ");
-	_outToken(str, node->relname);
-	appendStringInfo(str, " :inhopt %d :istemp %s",
-					 (int) node->inhOpt,
-					 booltostr(node->istemp));
-	appendStringInfo(str, " :alias ");
-	_outNode(str, node->alias);
+	WRITE_STRING_FIELD(schemaname);
+	WRITE_STRING_FIELD(relname);
+	WRITE_ENUM_FIELD(inhOpt, InhOption);
+	WRITE_BOOL_FIELD(istemp);
+	WRITE_NODE_FIELD(alias);
 }
 
 static void
 _outColumnRef(StringInfo str, ColumnRef *node)
 {
-	appendStringInfo(str, " COLUMNREF :fields ");
-	_outNode(str, node->fields);
-	appendStringInfo(str, " :indirection ");
-	_outNode(str, node->indirection);
+	WRITE_NODE_TYPE("COLUMNREF");
+
+	WRITE_NODE_FIELD(fields);
+	WRITE_NODE_FIELD(indirection);
 }
 
 static void
 _outParamRef(StringInfo str, ParamRef *node)
 {
-	appendStringInfo(str, " PARAMREF :number %d :fields ", node->number);
-	_outNode(str, node->fields);
-	appendStringInfo(str, " :indirection ");
-	_outNode(str, node->indirection);
+	WRITE_NODE_TYPE("PARAMREF");
+
+	WRITE_INT_FIELD(number);
+	WRITE_NODE_FIELD(fields);
+	WRITE_NODE_FIELD(indirection);
 }
 
 static void
 _outAConst(StringInfo str, A_Const *node)
 {
-	appendStringInfo(str, "CONST ");
+	WRITE_NODE_TYPE("CONST ");
+
 	_outValue(str, &(node->val));
-	appendStringInfo(str, " :typename ");
-	_outNode(str, node->typename);
+	WRITE_NODE_FIELD(typename);
 }
 
 static void
 _outExprFieldSelect(StringInfo str, ExprFieldSelect *node)
 {
-	appendStringInfo(str, " EXPRFIELDSELECT :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str, " :fields ");
-	_outNode(str, node->fields);
-	appendStringInfo(str, " :indirection ");
-	_outNode(str, node->indirection);
+	WRITE_NODE_TYPE("EXPRFIELDSELECT");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_NODE_FIELD(fields);
+	WRITE_NODE_FIELD(indirection);
 }
 
 static void
 _outConstraint(StringInfo str, Constraint *node)
 {
-	appendStringInfo(str, " CONSTRAINT :name ");
-	_outToken(str, node->name);
-	appendStringInfo(str, " :type ");
+	WRITE_NODE_TYPE("CONSTRAINT");
+
+	WRITE_STRING_FIELD(name);
 
+	appendStringInfo(str, " :contype ");
 	switch (node->contype)
 	{
 		case CONSTR_PRIMARY:
-			appendStringInfo(str, "PRIMARY_KEY :keys ");
-			_outNode(str, node->keys);
+			appendStringInfo(str, "PRIMARY_KEY");
+			WRITE_NODE_FIELD(keys);
 			break;
 
 		case CONSTR_CHECK:
-			appendStringInfo(str, "CHECK :raw ");
-			_outNode(str, node->raw_expr);
-			appendStringInfo(str, " :cooked ");
-			_outToken(str, node->cooked_expr);
+			appendStringInfo(str, "CHECK");
+			WRITE_NODE_FIELD(raw_expr);
+			WRITE_STRING_FIELD(cooked_expr);
 			break;
 
 		case CONSTR_DEFAULT:
-			appendStringInfo(str, "DEFAULT :raw ");
-			_outNode(str, node->raw_expr);
-			appendStringInfo(str, " :cooked ");
-			_outToken(str, node->cooked_expr);
+			appendStringInfo(str, "DEFAULT");
+			WRITE_NODE_FIELD(raw_expr);
+			WRITE_STRING_FIELD(cooked_expr);
 			break;
 
 		case CONSTR_NOTNULL:
@@ -1432,8 +1256,8 @@ _outConstraint(StringInfo str, Constraint *node)
 			break;
 
 		case CONSTR_UNIQUE:
-			appendStringInfo(str, "UNIQUE :keys ");
-			_outNode(str, node->keys);
+			appendStringInfo(str, "UNIQUE");
+			WRITE_NODE_FIELD(keys);
 			break;
 
 		default:
@@ -1445,108 +1269,86 @@ _outConstraint(StringInfo str, Constraint *node)
 static void
 _outFkConstraint(StringInfo str, FkConstraint *node)
 {
-	appendStringInfo(str, " FKCONSTRAINT :constr_name ");
-	_outToken(str, node->constr_name);
-	appendStringInfo(str, " :pktable ");
-	_outNode(str, node->pktable);
-	appendStringInfo(str, " :fk_attrs ");
-	_outNode(str, node->fk_attrs);
-	appendStringInfo(str, " :pk_attrs ");
-	_outNode(str, node->pk_attrs);
-	appendStringInfo(str, " :fk_matchtype %c :fk_upd_action %c :fk_del_action %c :deferrable %s :initdeferred %s :skip_validation %s",
-					 node->fk_matchtype,
-					 node->fk_upd_action,
-					 node->fk_del_action,
-					 booltostr(node->deferrable),
-					 booltostr(node->initdeferred),
-					 booltostr(node->skip_validation));
+	WRITE_NODE_TYPE("FKCONSTRAINT");
+
+	WRITE_STRING_FIELD(constr_name);
+	WRITE_NODE_FIELD(pktable);
+	WRITE_NODE_FIELD(fk_attrs);
+	WRITE_NODE_FIELD(pk_attrs);
+	WRITE_CHAR_FIELD(fk_matchtype);
+	WRITE_CHAR_FIELD(fk_upd_action);
+	WRITE_CHAR_FIELD(fk_del_action);
+	WRITE_BOOL_FIELD(deferrable);
+	WRITE_BOOL_FIELD(initdeferred);
+	WRITE_BOOL_FIELD(skip_validation);
 }
 
 static void
 _outCaseExpr(StringInfo str, CaseExpr *node)
 {
-	appendStringInfo(str, " CASE :casetype %u :arg ",
-					 node->casetype);
-	_outNode(str, node->arg);
-
-	appendStringInfo(str, " :args ");
-	_outNode(str, node->args);
+	WRITE_NODE_TYPE("CASE");
 
-	appendStringInfo(str, " :defresult ");
-	_outNode(str, node->defresult);
+	WRITE_OID_FIELD(casetype);
+	WRITE_NODE_FIELD(arg);
+	WRITE_NODE_FIELD(args);
+	WRITE_NODE_FIELD(defresult);
 }
 
 static void
 _outCaseWhen(StringInfo str, CaseWhen *node)
 {
-	appendStringInfo(str, " WHEN ");
-	_outNode(str, node->expr);
+	WRITE_NODE_TYPE("WHEN");
 
-	appendStringInfo(str, " :then ");
-	_outNode(str, node->result);
+	WRITE_NODE_FIELD(expr);
+	WRITE_NODE_FIELD(result);
 }
 
-/*
- *	NullTest
- */
 static void
 _outNullTest(StringInfo str, NullTest *node)
 {
-	appendStringInfo(str, " NULLTEST :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str, " :nulltesttype %d ",
-					 (int) node->nulltesttype);
+	WRITE_NODE_TYPE("NULLTEST");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_ENUM_FIELD(nulltesttype, NullTestType);
 }
 
-/*
- *	BooleanTest
- */
 static void
 _outBooleanTest(StringInfo str, BooleanTest *node)
 {
-	appendStringInfo(str, " BOOLEANTEST :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str, " :booltesttype %d ",
-					 (int) node->booltesttype);
+	WRITE_NODE_TYPE("BOOLEANTEST");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_ENUM_FIELD(booltesttype, BoolTestType);
 }
 
-/*
- *	ConstraintTest
- */
 static void
 _outConstraintTest(StringInfo str, ConstraintTest *node)
 {
-	appendStringInfo(str, " CONSTRAINTTEST :arg ");
-	_outNode(str, node->arg);
-	appendStringInfo(str, " :testtype %d :name ",
-					 (int) node->testtype);
-	_outToken(str, node->name);
-	appendStringInfo(str, " :domain ");
-	_outToken(str, node->domname);
-	appendStringInfo(str, " :check_expr ");
-	_outNode(str, node->check_expr);
+	WRITE_NODE_TYPE("CONSTRAINTTEST");
+
+	WRITE_NODE_FIELD(arg);
+	WRITE_ENUM_FIELD(testtype, ConstraintTestType);
+	WRITE_STRING_FIELD(name);
+	WRITE_STRING_FIELD(domname);
+	WRITE_NODE_FIELD(check_expr);
 }
 
-/*
- *	ConstraintTestValue
- */
 static void
-_outConstraintTestValue(StringInfo str, ConstraintTestValue *node)
+_outDomainConstraintValue(StringInfo str, DomainConstraintValue *node)
 {
-	appendStringInfo(str, " CONSTRAINTTESTVALUE :typeid %u :typemod %d ",
-					 node->typeId,
-					 node->typeMod);
+	WRITE_NODE_TYPE("DOMAINCONSTRAINTVALUE");
 }
 
-/*
- *	DomainConstraintValue
- */
 static void
-_outDomainConstraintValue(StringInfo str, DomainConstraintValue *node)
+_outConstraintTestValue(StringInfo str, ConstraintTestValue *node)
 {
-	appendStringInfo(str, " DOMAINCONSTRAINTVALUE ");
+	WRITE_NODE_TYPE("CONSTRAINTTESTVALUE");
+
+	WRITE_OID_FIELD(typeId);
+	WRITE_INT_FIELD(typeMod);
 }
 
+
 /*
  * _outNode -
  *	  converts a Node into ascii string and append it to 'str'
@@ -1573,7 +1375,10 @@ _outNode(StringInfo str, void *obj)
 		}
 		appendStringInfoChar(str, ')');
 	}
-	else if (IsA(obj, Integer) || IsA(obj, Float) || IsA(obj, String) || IsA(obj, BitString))
+	else if (IsA(obj, Integer) ||
+			 IsA(obj, Float) ||
+			 IsA(obj, String) ||
+			 IsA(obj, BitString))
 	{
 		/* nodeRead does not want to see { } around these! */
 		_outValue(str, obj);
@@ -1688,9 +1493,6 @@ _outNode(StringInfo str, void *obj)
 			case T_Resdom:
 				_outResdom(str, obj);
 				break;
-			case T_Fjoin:
-				_outFjoin(str, obj);
-				break;
 			case T_Expr:
 				_outExpr(str, obj);
 				break;
@@ -1825,7 +1627,7 @@ _outNode(StringInfo str, void *obj)
 				break;
 
 			default:
-				elog(WARNING, "_outNode: don't know how to print type %d ",
+				elog(WARNING, "_outNode: don't know how to print type %d",
 					 nodeTag(obj));
 				break;
 		}
diff --git a/src/backend/nodes/read.c b/src/backend/nodes/read.c
index 44a0b688dd2..f1d07ebf490 100644
--- a/src/backend/nodes/read.c
+++ b/src/backend/nodes/read.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.32 2002/06/20 20:29:29 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.33 2002/11/25 18:12:10 tgl Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -183,7 +183,7 @@ debackslash(char *token, int length)
 
 #define RIGHT_PAREN (1000000 + 1)
 #define LEFT_PAREN	(1000000 + 2)
-#define PLAN_SYM	(1000000 + 3)
+#define NODE_SYM	(1000000 + 3)
 #define AT_SYMBOL	(1000000 + 4)
 #define ATOM_TOKEN	(1000000 + 5)
 
@@ -193,7 +193,7 @@ debackslash(char *token, int length)
  *	  It returns one of the following valid NodeTags:
  *		T_Integer, T_Float, T_String, T_BitString
  *	  and some of its own:
- *		RIGHT_PAREN, LEFT_PAREN, PLAN_SYM, AT_SYMBOL, ATOM_TOKEN
+ *		RIGHT_PAREN, LEFT_PAREN, NODE_SYM, AT_SYMBOL, ATOM_TOKEN
  *
  *	  Assumption: the ascii representation is legal
  */
@@ -244,7 +244,7 @@ nodeTokenType(char *token, int length)
 	else if (*token == ')')
 		retval = RIGHT_PAREN;
 	else if (*token == '{')
-		retval = PLAN_SYM;
+		retval = NODE_SYM;
 	else if (*token == '@' && length == 1)
 		retval = AT_SYMBOL;
 	else if (*token == '\"' && length > 1 && token[length - 1] == '\"')
@@ -263,7 +263,7 @@ nodeTokenType(char *token, int length)
  * This routine applies some semantic knowledge on top of the purely
  * lexical tokenizer pg_strtok().	It can read
  *	* Value token nodes (integers, floats, or strings);
- *	* Plan nodes (via parsePlanString() from readfuncs.c);
+ *	* General nodes (via parseNodeString() from readfuncs.c);
  *	* Lists of the above.
  *
  * We assume pg_strtok is already initialized with a string to read (hence
@@ -289,11 +289,11 @@ nodeRead(bool read_car_only)
 
 	switch (type)
 	{
-		case PLAN_SYM:
-			this_value = parsePlanString();
+		case NODE_SYM:
+			this_value = parseNodeString();
 			token = pg_strtok(&tok_len);
 			if (token == NULL || token[0] != '}')
-				elog(ERROR, "nodeRead: did not find '}' at end of plan node");
+				elog(ERROR, "nodeRead: did not find '}' at end of node");
 			if (!read_car_only)
 				make_dotted_pair_cell = true;
 			else
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 43fe5bbd35f..ab5d1821ce5 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -8,18 +8,12 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.138 2002/11/24 21:52:13 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.139 2002/11/25 18:12:10 tgl Exp $
  *
  * NOTES
- *	  Most of the read functions for plan nodes are tested. (In fact, they
- *	  pass the regression test as of 11/8/94.) The rest (for path selection)
- *	  are probably never used. No effort has been made to get them to work.
- *	  The simplest way to test these functions is by doing the following in
- *	  ProcessQuery (before executing the plan):
- *				plan = stringToNode(nodeToString(plan));
- *	  Then, run the regression test. Let's just say you'll notice if either
- *	  of the above function are not properly done.
- *														- ay 11/94
+ *	  Path and Plan nodes do not have any readfuncs support, because we
+ *	  never have occasion to read them in.  (There was once code here that
+ *	  claimed to read them, but it was broken as well as unused.)
  *
  *-------------------------------------------------------------------------
  */
@@ -27,9 +21,98 @@
 
 #include <math.h>
 
-#include "nodes/plannodes.h"
+#include "nodes/parsenodes.h"
 #include "nodes/readfuncs.h"
-#include "nodes/relation.h"
+
+
+/*
+ * Macros to simplify reading of different kinds of fields.  Use these
+ * wherever possible to reduce the chance for silly typos.  Note that these
+ * hard-wire conventions about the names of the local variables in a Read
+ * routine.
+ */
+
+/* Declare appropriate local variables */
+#define READ_LOCALS(nodeTypeName) \
+	nodeTypeName *local_node = makeNode(nodeTypeName); \
+	char	   *token; \
+	int			length
+
+/* A few guys need only local_node */
+#define READ_LOCALS_NO_FIELDS(nodeTypeName) \
+	nodeTypeName *local_node = makeNode(nodeTypeName)
+
+/* And a few guys need only the pg_strtok support fields */
+#define READ_TEMP_LOCALS() \
+	char	   *token; \
+	int			length
+
+/* Read an integer field (anything written as ":fldname %d") */
+#define READ_INT_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = atoi(token)
+
+/* Read an unsigned integer field (anything written as ":fldname %u") */
+#define READ_UINT_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = atoui(token)
+
+/* Read an OID field (don't hard-wire assumption that OID is same as uint) */
+#define READ_OID_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = atooid(token)
+
+/* Read a char field (ie, one ascii character) */
+#define READ_CHAR_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = token[0]
+
+/* Read an enumerated-type field that was written as an integer code */
+#define READ_ENUM_FIELD(fldname, enumtype) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = (enumtype) atoi(token)
+
+/* Read a float field */
+#define READ_FLOAT_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = atof(token)
+
+/* Read a boolean field */
+#define READ_BOOL_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = strtobool(token)
+
+/* Read a character-string field */
+#define READ_STRING_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	token = pg_strtok(&length);		/* get field value */ \
+	local_node->fldname = nullable_string(token, length)
+
+/* Read a Node field */
+#define READ_NODE_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	local_node->fldname = nodeRead(true)
+
+/* Read an integer-list field */
+#define READ_INTLIST_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	local_node->fldname = toIntList(nodeRead(true))
+
+/* Read an OID-list field */
+#define READ_OIDLIST_FIELD(fldname) \
+	token = pg_strtok(&length);		/* skip :fldname */ \
+	local_node->fldname = toOidList(nodeRead(true))
+
+/* Routine exit */
+#define READ_DONE() \
+	return local_node
 
 
 /*
@@ -51,11 +134,6 @@
 static Datum readDatum(bool typbyval);
 
 
-/* ----------------
- *		node creator declarations
- * ----------------
- */
-
 /* Convert Value list returned by nodeRead into list of integers */
 static List *
 toIntList(List *list)
@@ -106,694 +184,137 @@ toOidList(List *list)
 	return list;
 }
 
-/* ----------------
- *		_readQuery
- * ----------------
+/*
+ * _readQuery
  */
 static Query *
 _readQuery(void)
 {
-	Query	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Query);
-
-	token = pg_strtok(&length); /* skip :command */
-	token = pg_strtok(&length); /* get commandType */
-	local_node->commandType = atoi(token);
-
-	token = pg_strtok(&length); /* skip :source */
-	token = pg_strtok(&length); /* get querySource */
-	local_node->querySource = atoi(token);
-
-	token = pg_strtok(&length); /* skip :utility */
-	local_node->utilityStmt = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :resultRelation */
-	token = pg_strtok(&length); /* get the resultRelation */
-	local_node->resultRelation = atoi(token);
-
-	token = pg_strtok(&length); /* skip :into */
-	local_node->into = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :isPortal */
-	token = pg_strtok(&length); /* get isPortal */
-	local_node->isPortal = strtobool(token);
-
-	token = pg_strtok(&length); /* skip :isBinary */
-	token = pg_strtok(&length); /* get isBinary */
-	local_node->isBinary = strtobool(token);
-
-	token = pg_strtok(&length); /* skip the :hasAggs */
-	token = pg_strtok(&length); /* get hasAggs */
-	local_node->hasAggs = strtobool(token);
-
-	token = pg_strtok(&length); /* skip the :hasSubLinks */
-	token = pg_strtok(&length); /* get hasSubLinks */
-	local_node->hasSubLinks = strtobool(token);
-
-	token = pg_strtok(&length); /* skip :rtable */
-	local_node->rtable = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :jointree */
-	local_node->jointree = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :rowMarks */
-	local_node->rowMarks = toIntList(nodeRead(true));
-
-	token = pg_strtok(&length); /* skip :targetlist */
-	local_node->targetList = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :groupClause */
-	local_node->groupClause = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :havingQual */
-	local_node->havingQual = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :distinctClause */
-	local_node->distinctClause = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :sortClause */
-	local_node->sortClause = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :limitOffset */
-	local_node->limitOffset = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :limitCount */
-	local_node->limitCount = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :setOperations */
-	local_node->setOperations = nodeRead(true);
-
-	token = pg_strtok(&length); /* skip :resultRelations */
-	local_node->resultRelations = toIntList(nodeRead(true));
+	READ_LOCALS(Query);
+
+	READ_ENUM_FIELD(commandType, CmdType);
+	READ_ENUM_FIELD(querySource, QuerySource);
+	READ_NODE_FIELD(utilityStmt);
+	READ_INT_FIELD(resultRelation);
+	READ_NODE_FIELD(into);
+	READ_BOOL_FIELD(isPortal);
+	READ_BOOL_FIELD(isBinary);
+	READ_BOOL_FIELD(hasAggs);
+	READ_BOOL_FIELD(hasSubLinks);
+	READ_NODE_FIELD(rtable);
+	READ_NODE_FIELD(jointree);
+	READ_INTLIST_FIELD(rowMarks);
+	READ_NODE_FIELD(targetList);
+	READ_NODE_FIELD(groupClause);
+	READ_NODE_FIELD(havingQual);
+	READ_NODE_FIELD(distinctClause);
+	READ_NODE_FIELD(sortClause);
+	READ_NODE_FIELD(limitOffset);
+	READ_NODE_FIELD(limitCount);
+	READ_NODE_FIELD(setOperations);
+	READ_INTLIST_FIELD(resultRelations);
 
 	/* planner-internal fields are left zero */
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readNotifyStmt
- * ----------------
+/*
+ * _readNotifyStmt
  */
 static NotifyStmt *
 _readNotifyStmt(void)
 {
-	NotifyStmt *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(NotifyStmt);
 
-	local_node = makeNode(NotifyStmt);
+	READ_NODE_FIELD(relation);
 
-	token = pg_strtok(&length); /* skip :relation */
-	local_node->relation = nodeRead(true);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readSortClause
- * ----------------
+/*
+ * _readSortClause
  */
 static SortClause *
 _readSortClause(void)
 {
-	SortClause *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(SortClause);
-
-	token = pg_strtok(&length); /* skip :tleSortGroupRef */
-	token = pg_strtok(&length); /* get tleSortGroupRef */
-	local_node->tleSortGroupRef = atoui(token);
+	READ_LOCALS(SortClause);
 
-	token = pg_strtok(&length); /* skip :sortop */
-	token = pg_strtok(&length); /* get sortop */
-	local_node->sortop = atooid(token);
+	READ_UINT_FIELD(tleSortGroupRef);
+	READ_OID_FIELD(sortop);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readGroupClause
- * ----------------
+/*
+ * _readGroupClause
  */
 static GroupClause *
 _readGroupClause(void)
 {
-	GroupClause *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(GroupClause);
 
-	local_node = makeNode(GroupClause);
+	READ_UINT_FIELD(tleSortGroupRef);
+	READ_OID_FIELD(sortop);
 
-	token = pg_strtok(&length); /* skip :tleSortGroupRef */
-	token = pg_strtok(&length); /* get tleSortGroupRef */
-	local_node->tleSortGroupRef = atoui(token);
-
-	token = pg_strtok(&length); /* skip :sortop */
-	token = pg_strtok(&length); /* get sortop */
-	local_node->sortop = atooid(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readSetOperationStmt
- * ----------------
+/*
+ * _readSetOperationStmt
  */
 static SetOperationStmt *
 _readSetOperationStmt(void)
 {
-	SetOperationStmt *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(SetOperationStmt);
-
-	token = pg_strtok(&length); /* eat :op */
-	token = pg_strtok(&length); /* get op */
-	local_node->op = (SetOperation) atoi(token);
-
-	token = pg_strtok(&length); /* eat :all */
-	token = pg_strtok(&length); /* get all */
-	local_node->all = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :larg */
-	local_node->larg = nodeRead(true);	/* get larg */
-
-	token = pg_strtok(&length); /* eat :rarg */
-	local_node->rarg = nodeRead(true);	/* get rarg */
-
-	token = pg_strtok(&length); /* eat :colTypes */
-	local_node->colTypes = toOidList(nodeRead(true));
-
-	return local_node;
-}
-
-/* ----------------
- *		_getPlan
- * ----------------
- */
-static void
-_getPlan(Plan *node)
-{
-	char	   *token;
-	int			length;
-
-	token = pg_strtok(&length); /* first token is :startup_cost */
-	token = pg_strtok(&length); /* next is the actual cost */
-	node->startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* skip the :total_cost */
-	token = pg_strtok(&length); /* next is the actual cost */
-	node->total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* skip the :rows */
-	token = pg_strtok(&length); /* get the plan_rows */
-	node->plan_rows = atof(token);
-
-	token = pg_strtok(&length); /* skip the :width */
-	token = pg_strtok(&length); /* get the plan_width */
-	node->plan_width = atoi(token);
-
-	token = pg_strtok(&length); /* eat :qptargetlist */
-	node->targetlist = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :qpqual */
-	node->qual = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :lefttree */
-	node->lefttree = (Plan *) nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :righttree */
-	node->righttree = (Plan *) nodeRead(true);
-
-	node->state = (EState *) NULL;		/* never read in */
-
-	return;
-}
-
-/*
- *	Stuff from plannodes.h
- */
-
-/* ----------------
- *		_readPlan
- * ----------------
- */
-static Plan *
-_readPlan(void)
-{
-	Plan	   *local_node;
-
-	local_node = makeNode(Plan);
-
-	_getPlan(local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readResult
- * ----------------
- */
-static Result *
-_readResult(void)
-{
-	Result	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Result);
-
-	_getPlan((Plan *) local_node);
-
-	token = pg_strtok(&length); /* eat :resconstantqual */
-	local_node->resconstantqual = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readAppend
- *
- *	Append is a subclass of Plan.
- * ----------------
- */
-
-static Append *
-_readAppend(void)
-{
-	Append	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Append);
-
-	_getPlan((Plan *) local_node);
-
-	token = pg_strtok(&length); /* eat :appendplans */
-	local_node->appendplans = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :isTarget */
-	token = pg_strtok(&length); /* get isTarget */
-	local_node->isTarget = strtobool(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_getJoin
- * ----------------
- */
-static void
-_getJoin(Join *node)
-{
-	char	   *token;
-	int			length;
-
-	_getPlan((Plan *) node);
-
-	token = pg_strtok(&length); /* skip the :jointype */
-	token = pg_strtok(&length); /* get the jointype */
-	node->jointype = (JoinType) atoi(token);
-
-	token = pg_strtok(&length); /* skip the :joinqual */
-	node->joinqual = nodeRead(true);	/* get the joinqual */
-}
-
-
-/* ----------------
- *		_readJoin
- *
- *	Join is a subclass of Plan
- * ----------------
- */
-static Join *
-_readJoin(void)
-{
-	Join	   *local_node;
-
-	local_node = makeNode(Join);
-
-	_getJoin(local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readNestLoop
- *
- *	NestLoop is a subclass of Join
- * ----------------
- */
-
-static NestLoop *
-_readNestLoop(void)
-{
-	NestLoop   *local_node;
-
-	local_node = makeNode(NestLoop);
-
-	_getJoin((Join *) local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readMergeJoin
- *
- *	MergeJoin is a subclass of Join
- * ----------------
- */
-static MergeJoin *
-_readMergeJoin(void)
-{
-	MergeJoin  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(MergeJoin);
-
-	_getJoin((Join *) local_node);
-
-	token = pg_strtok(&length); /* eat :mergeclauses */
-	local_node->mergeclauses = nodeRead(true);	/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readHashJoin
- *
- *	HashJoin is a subclass of Join.
- * ----------------
- */
-static HashJoin *
-_readHashJoin(void)
-{
-	HashJoin   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(HashJoin);
-
-	_getJoin((Join *) local_node);
-
-	token = pg_strtok(&length); /* eat :hashclauses */
-	local_node->hashclauses = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :hashjoinop */
-	token = pg_strtok(&length); /* get hashjoinop */
-	local_node->hashjoinop = atooid(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_getScan
- *
- *	Scan is a subclass of Plan.
- *
- *	Scan gets its own get function since stuff inherits it.
- * ----------------
- */
-static void
-_getScan(Scan *node)
-{
-	char	   *token;
-	int			length;
-
-	_getPlan((Plan *) node);
-
-	token = pg_strtok(&length); /* eat :scanrelid */
-	token = pg_strtok(&length); /* get scanrelid */
-	node->scanrelid = atoui(token);
-}
-
-/* ----------------
- *		_readScan
- *
- * Scan is a subclass of Plan.
- * ----------------
- */
-static Scan *
-_readScan(void)
-{
-	Scan	   *local_node;
-
-	local_node = makeNode(Scan);
-
-	_getScan(local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readSeqScan
- *
- *	SeqScan is a subclass of Scan
- * ----------------
- */
-static SeqScan *
-_readSeqScan(void)
-{
-	SeqScan    *local_node;
-
-	local_node = makeNode(SeqScan);
-
-	_getScan((Scan *) local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readIndexScan
- *
- *	IndexScan is a subclass of Scan
- * ----------------
- */
-static IndexScan *
-_readIndexScan(void)
-{
-	IndexScan  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(IndexScan);
-
-	_getScan((Scan *) local_node);
-
-	token = pg_strtok(&length); /* eat :indxid */
-	local_node->indxid = toOidList(nodeRead(true));		/* now read it */
-
-	token = pg_strtok(&length); /* eat :indxqual */
-	local_node->indxqual = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* eat :indxqualorig */
-	local_node->indxqualorig = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :indxorderdir */
-	token = pg_strtok(&length); /* get indxorderdir */
-	local_node->indxorderdir = atoi(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readTidScan
- *
- *	TidScan is a subclass of Scan
- * ----------------
- */
-static TidScan *
-_readTidScan(void)
-{
-	TidScan    *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(TidScan);
-
-	_getScan((Scan *) local_node);
-
-	token = pg_strtok(&length); /* eat :needrescan */
-	token = pg_strtok(&length); /* get needrescan */
-	local_node->needRescan = atoi(token);
-
-	token = pg_strtok(&length); /* eat :tideval */
-	local_node->tideval = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readSubqueryScan
- *
- *	SubqueryScan is a subclass of Scan
- * ----------------
- */
-static SubqueryScan *
-_readSubqueryScan(void)
-{
-	SubqueryScan *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(SubqueryScan);
-
-	_getScan((Scan *) local_node);
-
-	token = pg_strtok(&length); /* eat :subplan */
-	local_node->subplan = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readFunctionScan
- *
- *	FunctionScan is a subclass of Scan
- * ----------------
- */
-static FunctionScan *
-_readFunctionScan(void)
-{
-	FunctionScan *local_node;
-
-	local_node = makeNode(FunctionScan);
-
-	_getScan((Scan *) local_node);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readSort
- *
- *	Sort is a subclass of Plan
- * ----------------
- */
-static Sort *
-_readSort(void)
-{
-	Sort	   *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(SetOperationStmt);
 
-	local_node = makeNode(Sort);
+	READ_ENUM_FIELD(op, SetOperation);
+	READ_BOOL_FIELD(all);
+	READ_NODE_FIELD(larg);
+	READ_NODE_FIELD(rarg);
+	READ_OIDLIST_FIELD(colTypes);
 
-	_getPlan((Plan *) local_node);
-
-	token = pg_strtok(&length); /* eat :keycount */
-	token = pg_strtok(&length); /* get keycount */
-	local_node->keycount = atoi(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readHash
- *
- *	Hash is a subclass of Plan
- * ----------------
- */
-static Hash *
-_readHash(void)
-{
-	Hash	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Hash);
-
-	_getPlan((Plan *) local_node);
-
-	token = pg_strtok(&length); /* eat :hashkey */
-	local_node->hashkey = nodeRead(true);
-
-	return local_node;
-}
 
 /*
  *	Stuff from primnodes.h.
  */
 
-/* ----------------
- *		_readResdom
- *
- *	Resdom is a subclass of Node
- * ----------------
+/*
+ * _readResdom
  */
 static Resdom *
 _readResdom(void)
 {
-	Resdom	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Resdom);
-
-	token = pg_strtok(&length); /* eat :resno */
-	token = pg_strtok(&length); /* get resno */
-	local_node->resno = atoi(token);
-
-	token = pg_strtok(&length); /* eat :restype */
-	token = pg_strtok(&length); /* get restype */
-	local_node->restype = atooid(token);
-
-	token = pg_strtok(&length); /* eat :restypmod */
-	token = pg_strtok(&length); /* get restypmod */
-	local_node->restypmod = atoi(token);
-
-	token = pg_strtok(&length); /* eat :resname */
-	token = pg_strtok(&length); /* get the name */
-	local_node->resname = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* eat :reskey */
-	token = pg_strtok(&length); /* get reskey */
-	local_node->reskey = atoui(token);
-
-	token = pg_strtok(&length); /* eat :reskeyop */
-	token = pg_strtok(&length); /* get reskeyop */
-	local_node->reskeyop = atooid(token);
-
-	token = pg_strtok(&length); /* eat :ressortgroupref */
-	token = pg_strtok(&length); /* get ressortgroupref */
-	local_node->ressortgroupref = atoui(token);
+	READ_LOCALS(Resdom);
 
-	token = pg_strtok(&length); /* eat :resjunk */
-	token = pg_strtok(&length); /* get resjunk */
-	local_node->resjunk = strtobool(token);
+	READ_INT_FIELD(resno);
+	READ_OID_FIELD(restype);
+	READ_INT_FIELD(restypmod);
+	READ_STRING_FIELD(resname);
+	READ_UINT_FIELD(ressortgroupref);
+	READ_UINT_FIELD(reskey);
+	READ_OID_FIELD(reskeyop);
+	READ_BOOL_FIELD(resjunk);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readExpr
- *
- *	Expr is a subclass of Node
- * ----------------
+/*
+ * _readExpr
  */
 static Expr *
 _readExpr(void)
 {
-	Expr	   *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(Expr);
 
-	local_node = makeNode(Expr);
+	READ_OID_FIELD(typeOid);
 
-	token = pg_strtok(&length); /* eat :typeOid */
-	token = pg_strtok(&length); /* get typeOid */
-	local_node->typeOid = atooid(token);
-
-	token = pg_strtok(&length); /* eat :opType */
-	token = pg_strtok(&length); /* get opType */
+	/* do-it-yourself enum representation */
+	token = pg_strtok(&length); /* skip :opType */
+	token = pg_strtok(&length); /* get field value */
 	if (strncmp(token, "op", 2) == 0)
 		local_node->opType = OP_EXPR;
 	else if (strncmp(token, "distinct", 8) == 0)
@@ -811,1551 +332,596 @@ _readExpr(void)
 	else
 		elog(ERROR, "_readExpr: unknown opType \"%.*s\"", length, token);
 
-	token = pg_strtok(&length); /* eat :oper */
-	local_node->oper = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :args */
-	local_node->args = nodeRead(true);	/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readCaseExpr
- *
- *	CaseExpr is a subclass of Node
- * ----------------
- */
-static CaseExpr *
-_readCaseExpr(void)
-{
-	CaseExpr   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(CaseExpr);
-
-	token = pg_strtok(&length); /* eat :casetype */
-	token = pg_strtok(&length); /* get casetype */
-	local_node->casetype = atooid(token);
-
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :args */
-	local_node->args = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :defresult */
-	local_node->defresult = nodeRead(true);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readCaseWhen
- *
- *	CaseWhen is a subclass of Node
- * ----------------
- */
-static CaseWhen *
-_readCaseWhen(void)
-{
-	CaseWhen   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(CaseWhen);
-
-	local_node->expr = nodeRead(true);
-	token = pg_strtok(&length); /* eat :then */
-	local_node->result = nodeRead(true);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readNullTest
- *
- *	NullTest is a subclass of Node
- * ----------------
- */
-static NullTest *
-_readNullTest(void)
-{
-	NullTest   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(NullTest);
-
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :nulltesttype */
-	token = pg_strtok(&length); /* get nulltesttype */
-	local_node->nulltesttype = (NullTestType) atoi(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readBooleanTest
- *
- *	BooleanTest is a subclass of Node
- * ----------------
- */
-static BooleanTest *
-_readBooleanTest(void)
-{
-	BooleanTest *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(BooleanTest);
-
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :booltesttype */
-	token = pg_strtok(&length); /* get booltesttype */
-	local_node->booltesttype = (BoolTestType) atoi(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readConstraintTest
- *
- *	ConstraintTest is a subclass of Node
- * ----------------
- */
-static ConstraintTest *
-_readConstraintTest(void)
-{
-	ConstraintTest *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ConstraintTest);
+	READ_NODE_FIELD(oper);
+	READ_NODE_FIELD(args);
 
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :testtype */
-	token = pg_strtok(&length); /* get testtype */
-	local_node->testtype = (ConstraintTestType) atoi(token);
-
-	token = pg_strtok(&length); /* get :name */
-	token = pg_strtok(&length); /* now read it */
-	local_node->name = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* get :domname */
-	token = pg_strtok(&length); /* get domname */
-	local_node->domname = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* eat :check_expr */
-	local_node->check_expr = nodeRead(true);	/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readConstraintTestValue
- *
- *	ConstraintTestValue is a subclass of Node
- * ----------------
- */
-static ConstraintTestValue *
-_readConstraintTestValue(void)
-{
-	ConstraintTestValue *local_node;
-	char   *token;
-	int		length;
-
-	local_node = makeNode(ConstraintTestValue);
-	token = pg_strtok(&length); /* eat :typeid */
-	token = pg_strtok(&length); /* get typeid */
-	local_node->typeId = atooid(token);
-	token = pg_strtok(&length); /* eat :typemod */
-	token = pg_strtok(&length); /* get typemod */
-	local_node->typeMod = atoi(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readDomainConstraintValue
- *
- *	DomainConstraintValue is a subclass of Node
- * ----------------
- */
-static DomainConstraintValue *
-_readDomainConstraintValue(void)
-{
-	DomainConstraintValue *local_node;
-
-	local_node = makeNode(DomainConstraintValue);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readVar
- *
- *	Var is a subclass of Expr
- * ----------------
+/*
+ * _readVar
  */
 static Var *
 _readVar(void)
 {
-	Var		   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Var);
-
-	token = pg_strtok(&length); /* eat :varno */
-	token = pg_strtok(&length); /* get varno */
-	local_node->varno = atoui(token);
-
-	token = pg_strtok(&length); /* eat :varattno */
-	token = pg_strtok(&length); /* get varattno */
-	local_node->varattno = atoi(token);
-
-	token = pg_strtok(&length); /* eat :vartype */
-	token = pg_strtok(&length); /* get vartype */
-	local_node->vartype = atooid(token);
+	READ_LOCALS(Var);
 
-	token = pg_strtok(&length); /* eat :vartypmod */
-	token = pg_strtok(&length); /* get vartypmod */
-	local_node->vartypmod = atoi(token);
+	READ_UINT_FIELD(varno);
+	READ_INT_FIELD(varattno);
+	READ_OID_FIELD(vartype);
+	READ_INT_FIELD(vartypmod);
+	READ_UINT_FIELD(varlevelsup);
+	READ_UINT_FIELD(varnoold);
+	READ_INT_FIELD(varoattno);
 
-	token = pg_strtok(&length); /* eat :varlevelsup */
-	token = pg_strtok(&length); /* get varlevelsup */
-	local_node->varlevelsup = atoui(token);
-
-	token = pg_strtok(&length); /* eat :varnoold */
-	token = pg_strtok(&length); /* get varnoold */
-	local_node->varnoold = atoui(token);
-
-	token = pg_strtok(&length); /* eat :varoattno */
-	token = pg_strtok(&length); /* eat :varoattno */
-	local_node->varoattno = atoi(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
+/*
  * _readArrayRef
- *
- * ArrayRef is a subclass of Expr
- * ----------------
  */
 static ArrayRef *
 _readArrayRef(void)
 {
-	ArrayRef   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ArrayRef);
-
-	token = pg_strtok(&length); /* eat :refrestype */
-	token = pg_strtok(&length); /* get refrestype */
-	local_node->refrestype = atooid(token);
-
-	token = pg_strtok(&length); /* eat :refattrlength */
-	token = pg_strtok(&length); /* get refattrlength */
-	local_node->refattrlength = atoi(token);
-
-	token = pg_strtok(&length); /* eat :refelemlength */
-	token = pg_strtok(&length); /* get refelemlength */
-	local_node->refelemlength = atoi(token);
-
-	token = pg_strtok(&length); /* eat :refelembyval */
-	token = pg_strtok(&length); /* get refelembyval */
-	local_node->refelembyval = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :refelemalign */
-	token = pg_strtok(&length); /* get refelemalign */
-	local_node->refelemalign = token[0];
-
-	token = pg_strtok(&length); /* eat :refupperindexpr */
-	local_node->refupperindexpr = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :reflowerindexpr */
-	local_node->reflowerindexpr = nodeRead(true);
-
-	token = pg_strtok(&length); /* eat :refexpr */
-	local_node->refexpr = nodeRead(true);
+	READ_LOCALS(ArrayRef);
 
-	token = pg_strtok(&length); /* eat :refassgnexpr */
-	local_node->refassgnexpr = nodeRead(true);
+	READ_OID_FIELD(refrestype);
+	READ_INT_FIELD(refattrlength);
+	READ_INT_FIELD(refelemlength);
+	READ_BOOL_FIELD(refelembyval);
+	READ_CHAR_FIELD(refelemalign);
+	READ_NODE_FIELD(refupperindexpr);
+	READ_NODE_FIELD(reflowerindexpr);
+	READ_NODE_FIELD(refexpr);
+	READ_NODE_FIELD(refassgnexpr);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readConst
- *
- *	Const is a subclass of Expr
- * ----------------
+/*
+ * _readConst
  */
 static Const *
 _readConst(void)
 {
-	Const	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Const);
-
-	token = pg_strtok(&length); /* get :consttype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->consttype = atooid(token);
-
-	token = pg_strtok(&length); /* get :constlen */
-	token = pg_strtok(&length); /* now read it */
-	local_node->constlen = atoi(token);
+	READ_LOCALS(Const);
 
-	token = pg_strtok(&length); /* get :constbyval */
-	token = pg_strtok(&length); /* now read it */
-	local_node->constbyval = strtobool(token);
-
-	token = pg_strtok(&length); /* get :constisnull */
-	token = pg_strtok(&length); /* now read it */
-	local_node->constisnull = strtobool(token);
-
-	token = pg_strtok(&length); /* get :constvalue */
+	READ_OID_FIELD(consttype);
+	READ_INT_FIELD(constlen);
+	READ_BOOL_FIELD(constbyval);
+	READ_BOOL_FIELD(constisnull);
+	/* XXX what about constisset, constiscast? */
 
+	token = pg_strtok(&length); /* skip :constvalue */
 	if (local_node->constisnull)
-	{
-		token = pg_strtok(&length);		/* skip "NIL" */
-	}
+		token = pg_strtok(&length);		/* skip "<>" */
 	else
 		local_node->constvalue = readDatum(local_node->constbyval);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readFunc
- *
- *	Func is a subclass of Expr
- * ----------------
+/*
+ * _readFunc
  */
 static Func *
 _readFunc(void)
 {
-	Func	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Func);
-
-	token = pg_strtok(&length); /* get :funcid */
-	token = pg_strtok(&length); /* now read it */
-	local_node->funcid = atooid(token);
-
-	token = pg_strtok(&length); /* get :funcresulttype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->funcresulttype = atooid(token);
-
-	token = pg_strtok(&length); /* get :funcretset */
-	token = pg_strtok(&length); /* now read it */
-	local_node->funcretset = strtobool(token);
+	READ_LOCALS(Func);
 
-	token = pg_strtok(&length); /* get :funcformat */
-	token = pg_strtok(&length); /* now read it */
-	local_node->funcformat = (CoercionForm) atoi(token);
+	READ_OID_FIELD(funcid);
+	READ_OID_FIELD(funcresulttype);
+	READ_BOOL_FIELD(funcretset);
+	READ_ENUM_FIELD(funcformat, CoercionForm);
 
 	local_node->func_fcache = NULL;
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readOper
- *
- *	Oper is a subclass of Expr
- * ----------------
+/*
+ * _readOper
  */
 static Oper *
 _readOper(void)
 {
-	Oper	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Oper);
-
-	token = pg_strtok(&length); /* get :opno */
-	token = pg_strtok(&length); /* now read it */
-	local_node->opno = atooid(token);
+	READ_LOCALS(Oper);
 
-	token = pg_strtok(&length); /* get :opid */
-	token = pg_strtok(&length); /* now read it */
-	local_node->opid = atooid(token);
-
-	token = pg_strtok(&length); /* get :opresulttype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->opresulttype = atooid(token);
-
-	token = pg_strtok(&length); /* get :opretset */
-	token = pg_strtok(&length); /* now read it */
-	local_node->opretset = strtobool(token);
+	READ_OID_FIELD(opno);
+	READ_OID_FIELD(opid);
+	READ_OID_FIELD(opresulttype);
+	READ_BOOL_FIELD(opretset);
 
 	local_node->op_fcache = NULL;
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readParam
- *
- *	Param is a subclass of Expr
- * ----------------
+/*
+ * _readParam
  */
 static Param *
 _readParam(void)
 {
-	Param	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Param);
+	READ_LOCALS(Param);
 
-	token = pg_strtok(&length); /* get :paramkind */
-	token = pg_strtok(&length); /* now read it */
-	local_node->paramkind = atoi(token);
+	READ_INT_FIELD(paramkind);
+	READ_INT_FIELD(paramid);
+	READ_STRING_FIELD(paramname);
+	READ_OID_FIELD(paramtype);
 
-	token = pg_strtok(&length); /* get :paramid */
-	token = pg_strtok(&length); /* now read it */
-	local_node->paramid = atoi(token);
-
-	token = pg_strtok(&length); /* get :paramname */
-	token = pg_strtok(&length); /* now read it */
-	local_node->paramname = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* get :paramtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->paramtype = atooid(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readAggref
- *
- *	Aggref is a subclass of Node
- * ----------------
+/*
+ * _readAggref
  */
 static Aggref *
 _readAggref(void)
 {
-	Aggref	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Aggref);
+	READ_LOCALS(Aggref);
 
-	token = pg_strtok(&length); /* eat :aggfnoid */
-	token = pg_strtok(&length); /* get aggfnoid */
-	local_node->aggfnoid = atooid(token);
+	READ_OID_FIELD(aggfnoid);
+	READ_OID_FIELD(aggtype);
+	READ_NODE_FIELD(target);
+	READ_BOOL_FIELD(aggstar);
+	READ_BOOL_FIELD(aggdistinct);
+	/* aggno is not saved since it is just executor state */
 
-	token = pg_strtok(&length); /* eat :aggtype */
-	token = pg_strtok(&length); /* get aggtype */
-	local_node->aggtype = atooid(token);
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :target */
-	local_node->target = nodeRead(true);		/* now read it */
+static RangeVar *
+_readRangeVar(void)
+{
+	READ_LOCALS(RangeVar);
 
-	token = pg_strtok(&length); /* eat :aggstar */
-	token = pg_strtok(&length); /* get aggstar */
-	local_node->aggstar = strtobool(token);
+	local_node->catalogname = NULL;		/* not currently saved in output
+										 * format */
 
-	token = pg_strtok(&length); /* eat :aggdistinct */
-	token = pg_strtok(&length); /* get aggdistinct */
-	local_node->aggdistinct = strtobool(token);
+	READ_STRING_FIELD(schemaname);
+	READ_STRING_FIELD(relname);
+	READ_ENUM_FIELD(inhOpt, InhOption);
+	READ_BOOL_FIELD(istemp);
+	READ_NODE_FIELD(alias);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readSubLink
- *
- *	SubLink is a subclass of Node
- * ----------------
+/*
+ * _readSubLink
  */
 static SubLink *
 _readSubLink(void)
 {
-	SubLink    *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(SubLink);
-
-	token = pg_strtok(&length); /* eat :subLinkType */
-	token = pg_strtok(&length); /* get subLinkType */
-	local_node->subLinkType = atoi(token);
-
-	token = pg_strtok(&length); /* eat :useor */
-	token = pg_strtok(&length); /* get useor */
-	local_node->useor = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :lefthand */
-	local_node->lefthand = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* eat :oper */
-	local_node->oper = nodeRead(true);	/* now read it */
+	READ_LOCALS(SubLink);
 
-	token = pg_strtok(&length); /* eat :subselect */
-	local_node->subselect = nodeRead(true);		/* now read it */
+	READ_ENUM_FIELD(subLinkType, SubLinkType);
+	READ_BOOL_FIELD(useor);
+	READ_NODE_FIELD(lefthand);
+	READ_NODE_FIELD(oper);
+	READ_NODE_FIELD(subselect);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readFieldSelect
- *
- *	FieldSelect is a subclass of Node
- * ----------------
+/*
+ * _readFieldSelect
  */
 static FieldSelect *
 _readFieldSelect(void)
 {
-	FieldSelect *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(FieldSelect);
-
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
+	READ_LOCALS(FieldSelect);
 
-	token = pg_strtok(&length); /* eat :fieldnum */
-	token = pg_strtok(&length); /* get fieldnum */
-	local_node->fieldnum = (AttrNumber) atoi(token);
+	READ_NODE_FIELD(arg);
+	READ_INT_FIELD(fieldnum);
+	READ_OID_FIELD(resulttype);
+	READ_INT_FIELD(resulttypmod);
 
-	token = pg_strtok(&length); /* eat :resulttype */
-	token = pg_strtok(&length); /* get resulttype */
-	local_node->resulttype = atooid(token);
-
-	token = pg_strtok(&length); /* eat :resulttypmod */
-	token = pg_strtok(&length); /* get resulttypmod */
-	local_node->resulttypmod = atoi(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readRelabelType
- *
- *	RelabelType is a subclass of Node
- * ----------------
+/*
+ * _readRelabelType
  */
 static RelabelType *
 _readRelabelType(void)
 {
-	RelabelType *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(RelabelType);
+	READ_LOCALS(RelabelType);
 
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
+	READ_NODE_FIELD(arg);
+	READ_OID_FIELD(resulttype);
+	READ_INT_FIELD(resulttypmod);
+	READ_ENUM_FIELD(relabelformat, CoercionForm);
 
-	token = pg_strtok(&length); /* eat :resulttype */
-	token = pg_strtok(&length); /* get resulttype */
-	local_node->resulttype = atooid(token);
-
-	token = pg_strtok(&length); /* eat :resulttypmod */
-	token = pg_strtok(&length); /* get resulttypmod */
-	local_node->resulttypmod = atoi(token);
-
-	token = pg_strtok(&length); /* eat :relabelformat */
-	token = pg_strtok(&length); /* get relabelformat */
-	local_node->relabelformat = (CoercionForm) atoi(token);
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readRangeTblRef
- *
- *	RangeTblRef is a subclass of Node
- * ----------------
+/*
+ * _readRangeTblRef
  */
 static RangeTblRef *
 _readRangeTblRef(void)
 {
-	RangeTblRef *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(RangeTblRef);
 
-	local_node = makeNode(RangeTblRef);
+	READ_INT_FIELD(rtindex);
 
-	token = pg_strtok(&length); /* get rtindex */
-	local_node->rtindex = atoi(token);
+	READ_DONE();
+}
 
-	return local_node;
+/*
+ * _readJoinExpr
+ */
+static JoinExpr *
+_readJoinExpr(void)
+{
+	READ_LOCALS(JoinExpr);
+
+	READ_ENUM_FIELD(jointype, JoinType);
+	READ_BOOL_FIELD(isNatural);
+	READ_NODE_FIELD(larg);
+	READ_NODE_FIELD(rarg);
+	READ_NODE_FIELD(using);
+	READ_NODE_FIELD(quals);
+	READ_NODE_FIELD(alias);
+	READ_INT_FIELD(rtindex);
+
+	READ_DONE();
 }
 
-/* ----------------
- *		_readFromExpr
- *
- *	FromExpr is a subclass of Node
- * ----------------
+/*
+ * _readFromExpr
  */
 static FromExpr *
 _readFromExpr(void)
 {
-	FromExpr   *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(FromExpr);
 
-	local_node = makeNode(FromExpr);
+	READ_NODE_FIELD(fromlist);
+	READ_NODE_FIELD(quals);
 
-	token = pg_strtok(&length); /* eat :fromlist */
-	local_node->fromlist = nodeRead(true);		/* now read it */
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :quals */
-	local_node->quals = nodeRead(true); /* now read it */
 
-	return local_node;
-}
+/*
+ *	Stuff from parsenodes.h.
+ */
 
-/* ----------------
- *		_readJoinExpr
- *
- *	JoinExpr is a subclass of Node
- * ----------------
+/*
+ * _readCaseExpr
  */
-static JoinExpr *
-_readJoinExpr(void)
+static CaseExpr *
+_readCaseExpr(void)
 {
-	JoinExpr   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(JoinExpr);
+	READ_LOCALS(CaseExpr);
 
-	token = pg_strtok(&length); /* eat :jointype */
-	token = pg_strtok(&length); /* get jointype */
-	local_node->jointype = (JoinType) atoi(token);
+	READ_OID_FIELD(casetype);
+	READ_NODE_FIELD(arg);
+	READ_NODE_FIELD(args);
+	READ_NODE_FIELD(defresult);
 
-	token = pg_strtok(&length); /* eat :isNatural */
-	token = pg_strtok(&length); /* get isNatural */
-	local_node->isNatural = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :larg */
-	local_node->larg = nodeRead(true);	/* now read it */
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :rarg */
-	local_node->rarg = nodeRead(true);	/* now read it */
+/*
+ * _readCaseWhen
+ */
+static CaseWhen *
+_readCaseWhen(void)
+{
+	READ_LOCALS(CaseWhen);
 
-	token = pg_strtok(&length); /* eat :using */
-	local_node->using = nodeRead(true); /* now read it */
+	READ_NODE_FIELD(expr);
+	READ_NODE_FIELD(result);
 
-	token = pg_strtok(&length); /* eat :quals */
-	local_node->quals = nodeRead(true); /* now read it */
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :alias */
-	local_node->alias = nodeRead(true); /* now read it */
+/*
+ * _readNullTest
+ */
+static NullTest *
+_readNullTest(void)
+{
+	READ_LOCALS(NullTest);
 
-	token = pg_strtok(&length); /* eat :rtindex */
-	token = pg_strtok(&length); /* get rtindex */
-	local_node->rtindex = atoi(token);
+	READ_NODE_FIELD(arg);
+	READ_ENUM_FIELD(nulltesttype, NullTestType);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readTargetEntry
- * ----------------
+/*
+ * _readBooleanTest
  */
-static TargetEntry *
-_readTargetEntry(void)
+static BooleanTest *
+_readBooleanTest(void)
 {
-	TargetEntry *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(BooleanTest);
 
-	local_node = makeNode(TargetEntry);
+	READ_NODE_FIELD(arg);
+	READ_ENUM_FIELD(booltesttype, BoolTestType);
 
-	token = pg_strtok(&length); /* get :resdom */
-	local_node->resdom = nodeRead(true);		/* now read it */
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* get :expr */
-	local_node->expr = nodeRead(true);	/* now read it */
+/*
+ * _readConstraintTest
+ */
+static ConstraintTest *
+_readConstraintTest(void)
+{
+	READ_LOCALS(ConstraintTest);
 
-	return local_node;
+	READ_NODE_FIELD(arg);
+	READ_ENUM_FIELD(testtype, ConstraintTestType);
+	READ_STRING_FIELD(name);
+	READ_STRING_FIELD(domname);
+	READ_NODE_FIELD(check_expr);
+
+	READ_DONE();
 }
 
-static RangeVar *
-_readRangeVar(void)
+/*
+ * _readDomainConstraintValue
+ */
+static DomainConstraintValue *
+_readDomainConstraintValue(void)
 {
-	RangeVar   *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS_NO_FIELDS(DomainConstraintValue);
 
-	local_node = makeNode(RangeVar);
-
-	local_node->catalogname = NULL;		/* not currently saved in output
-										 * format */
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :relation */
-	token = pg_strtok(&length); /* get schemaname */
-	local_node->schemaname = nullable_string(token, length);
+/*
+ * _readConstraintTestValue
+ */
+static ConstraintTestValue *
+_readConstraintTestValue(void)
+{
+	READ_LOCALS(ConstraintTestValue);
 
-	token = pg_strtok(&length); /* eat "." */
-	token = pg_strtok(&length); /* get relname */
-	local_node->relname = nullable_string(token, length);
+	READ_OID_FIELD(typeId);
+	READ_INT_FIELD(typeMod);
 
-	token = pg_strtok(&length); /* eat :inhopt */
-	token = pg_strtok(&length); /* get inhopt */
-	local_node->inhOpt = (InhOption) atoi(token);
+	READ_DONE();
+}
 
-	token = pg_strtok(&length); /* eat :istemp */
-	token = pg_strtok(&length); /* get istemp */
-	local_node->istemp = strtobool(token);
+/*
+ * _readTargetEntry
+ */
+static TargetEntry *
+_readTargetEntry(void)
+{
+	READ_LOCALS(TargetEntry);
 
-	token = pg_strtok(&length); /* eat :alias */
-	local_node->alias = nodeRead(true); /* now read it */
+	READ_NODE_FIELD(resdom);
+	/* fjoin not supported ... */
+	READ_NODE_FIELD(expr);
 
-	return local_node;
+	READ_DONE();
 }
 
 static ColumnRef *
 _readColumnRef(void)
 {
-	ColumnRef  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ColumnRef);
-
-	token = pg_strtok(&length); /* eat :fields */
-	local_node->fields = nodeRead(true);		/* now read it */
+	READ_LOCALS(ColumnRef);
 
-	token = pg_strtok(&length); /* eat :indirection */
-	local_node->indirection = nodeRead(true);	/* now read it */
+	READ_NODE_FIELD(fields);
+	READ_NODE_FIELD(indirection);
 
-	return local_node;
+	READ_DONE();
 }
 
 static ColumnDef *
 _readColumnDef(void)
 {
-	ColumnDef  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ColumnDef);
-
-	token = pg_strtok(&length); /* eat :colname */
-	token = pg_strtok(&length); /* now read it */
-	local_node->colname = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* eat :typename */
-	local_node->typename = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* eat :inhcount */
-	token = pg_strtok(&length); /* get :inhcount */
-	local_node->inhcount = atoi(token);
-
-	token = pg_strtok(&length); /* eat :is_local */
-	token = pg_strtok(&length); /* get :is_local */
-	local_node->is_local = strtobool(token);
+	READ_LOCALS(ColumnDef);
 
-	token = pg_strtok(&length); /* eat :is_not_null */
-	token = pg_strtok(&length); /* get :is_not_null */
-	local_node->is_not_null = strtobool(token);
+	READ_STRING_FIELD(colname);
+	READ_NODE_FIELD(typename);
+	READ_INT_FIELD(inhcount);
+	READ_BOOL_FIELD(is_local);
+	READ_BOOL_FIELD(is_not_null);
+	READ_NODE_FIELD(raw_default);
+	READ_STRING_FIELD(cooked_default);
+	READ_NODE_FIELD(constraints);
+	READ_NODE_FIELD(support);
 
-	token = pg_strtok(&length); /* eat :raw_default */
-	local_node->raw_default = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :cooked_default */
-	token = pg_strtok(&length); /* now read it */
-	local_node->cooked_default = nullable_string(token, length);
-
-	token = pg_strtok(&length); /* eat :constraints */
-	local_node->constraints = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :support */
-	local_node->support = nodeRead(true);		/* now read it */
-
-	return local_node;
+	READ_DONE();
 }
 
 static TypeName *
 _readTypeName(void)
 {
-	TypeName   *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(TypeName);
 
-	local_node = makeNode(TypeName);
+	READ_NODE_FIELD(names);
+	READ_OID_FIELD(typeid);
+	READ_BOOL_FIELD(timezone);
+	READ_BOOL_FIELD(setof);
+	READ_BOOL_FIELD(pct_type);
+	READ_INT_FIELD(typmod);
+	READ_NODE_FIELD(arrayBounds);
 
-	token = pg_strtok(&length); /* eat :names */
-	local_node->names = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* eat :typeid */
-	token = pg_strtok(&length); /* get typeid */
-	local_node->typeid = atooid(token);
-
-	token = pg_strtok(&length); /* eat :timezone */
-	token = pg_strtok(&length); /* get timezone */
-	local_node->timezone = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :setof */
-	token = pg_strtok(&length); /* get setof */
-	local_node->setof = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :pct_type */
-	token = pg_strtok(&length); /* get pct_type */
-	local_node->pct_type = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :typmod */
-	token = pg_strtok(&length); /* get typmod */
-	local_node->typmod = atoi(token);
-
-	token = pg_strtok(&length); /* eat :arrayBounds */
-	local_node->arrayBounds = nodeRead(true);	/* now read it */
-
-	return local_node;
+	READ_DONE();
 }
 
 static ExprFieldSelect *
 _readExprFieldSelect(void)
 {
-	ExprFieldSelect *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ExprFieldSelect);
-
-	token = pg_strtok(&length); /* eat :arg */
-	local_node->arg = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :fields */
-	local_node->fields = nodeRead(true);		/* now read it */
+	READ_LOCALS(ExprFieldSelect);
 
-	token = pg_strtok(&length); /* eat :indirection */
-	local_node->indirection = nodeRead(true);	/* now read it */
+	READ_NODE_FIELD(arg);
+	READ_NODE_FIELD(fields);
+	READ_NODE_FIELD(indirection);
 
-	return local_node;
+	READ_DONE();
 }
 
 static Alias *
 _readAlias(void)
 {
-	Alias	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Alias);
-
-	token = pg_strtok(&length); /* eat :aliasname */
-	token = pg_strtok(&length); /* get aliasname */
-	local_node->aliasname = debackslash(token, length);
+	READ_LOCALS(Alias);
 
-	token = pg_strtok(&length); /* eat :colnames */
-	local_node->colnames = nodeRead(true);		/* now read it */
+	READ_STRING_FIELD(aliasname);
+	READ_NODE_FIELD(colnames);
 
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readRangeTblEntry
- * ----------------
+/*
+ * _readRangeTblEntry
  */
 static RangeTblEntry *
 _readRangeTblEntry(void)
 {
-	RangeTblEntry *local_node;
-	char	   *token;
-	int			length;
+	READ_LOCALS(RangeTblEntry);
 
-	local_node = makeNode(RangeTblEntry);
-
-	token = pg_strtok(&length); /* eat :alias */
-	local_node->alias = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* eat :eref */
-	local_node->eref = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* eat :rtekind */
-	token = pg_strtok(&length); /* get rtekind */
-	local_node->rtekind = (RTEKind) atoi(token);
+	/* put alias + eref first to make dump more legible */
+	READ_NODE_FIELD(alias);
+	READ_NODE_FIELD(eref);
+	READ_ENUM_FIELD(rtekind, RTEKind);
 
 	switch (local_node->rtekind)
 	{
 		case RTE_RELATION:
 		case RTE_SPECIAL:
-			token = pg_strtok(&length); /* eat :relid */
-			token = pg_strtok(&length); /* get :relid */
-			local_node->relid = atooid(token);
+			READ_OID_FIELD(relid);
 			break;
-
 		case RTE_SUBQUERY:
-			token = pg_strtok(&length); /* eat :subquery */
-			local_node->subquery = nodeRead(true);		/* now read it */
+			READ_NODE_FIELD(subquery);
 			break;
-
 		case RTE_FUNCTION:
-			token = pg_strtok(&length); /* eat :funcexpr */
-			local_node->funcexpr = nodeRead(true);		/* now read it */
-
-			token = pg_strtok(&length); /* eat :coldeflist */
-			local_node->coldeflist = nodeRead(true);	/* now read it */
-
+			READ_NODE_FIELD(funcexpr);
+			READ_NODE_FIELD(coldeflist);
 			break;
-
 		case RTE_JOIN:
-			token = pg_strtok(&length); /* eat :jointype */
-			token = pg_strtok(&length); /* get jointype */
-			local_node->jointype = (JoinType) atoi(token);
-
-			token = pg_strtok(&length); /* eat :joinaliasvars */
-			local_node->joinaliasvars = nodeRead(true); /* now read it */
+			READ_ENUM_FIELD(jointype, JoinType);
+			READ_NODE_FIELD(joinaliasvars);
 			break;
-
 		default:
 			elog(ERROR, "bogus rte kind %d", (int) local_node->rtekind);
 			break;
 	}
 
-	token = pg_strtok(&length); /* eat :inh */
-	token = pg_strtok(&length); /* get :inh */
-	local_node->inh = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :inFromCl */
-	token = pg_strtok(&length); /* get :inFromCl */
-	local_node->inFromCl = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :checkForRead */
-	token = pg_strtok(&length); /* get :checkForRead */
-	local_node->checkForRead = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :checkForWrite */
-	token = pg_strtok(&length); /* get :checkForWrite */
-	local_node->checkForWrite = strtobool(token);
-
-	token = pg_strtok(&length); /* eat :checkAsUser */
-	token = pg_strtok(&length); /* get :checkAsUser */
-	local_node->checkAsUser = atooid(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readPath
- *
- *	Path is a subclass of Node.
- * ----------------
- */
-static Path *
-_readPath(void)
-{
-	Path	   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(Path);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->pathkeys = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readIndexPath
- *
- *	IndexPath is a subclass of Path.
- * ----------------
- */
-static IndexPath *
-_readIndexPath(void)
-{
-	IndexPath  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(IndexPath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->path.pathkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :indexinfo */
-	local_node->indexinfo = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :indexqual */
-	local_node->indexqual = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :indexscandir */
-	token = pg_strtok(&length); /* now read it */
-	local_node->indexscandir = (ScanDirection) atoi(token);
-
-	token = pg_strtok(&length); /* get :rows */
-	token = pg_strtok(&length); /* now read it */
-	local_node->rows = atof(token);
-
-	return local_node;
-}
-
-/* ----------------
- *		_readTidPath
- *
- *	TidPath is a subclass of Path.
- * ----------------
- */
-static TidPath *
-_readTidPath(void)
-{
-	TidPath    *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(TidPath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->path.pathkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :tideval */
-	local_node->tideval = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :unjoined_relids */
-	local_node->unjoined_relids = toIntList(nodeRead(true));
-
-	return local_node;
-}
-
-/* ----------------
- *		_readAppendPath
- *
- *	AppendPath is a subclass of Path.
- * ----------------
- */
-static AppendPath *
-_readAppendPath(void)
-{
-	AppendPath *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(AppendPath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->path.pathkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :subpaths */
-	local_node->subpaths = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readResultPath
- *
- *	ResultPath is a subclass of Path.
- * ----------------
- */
-static ResultPath *
-_readResultPath(void)
-{
-	ResultPath *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(ResultPath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->path.pathkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :subpath */
-	local_node->subpath = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :constantqual */
-	local_node->constantqual = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readNestPath
- *
- *	NestPath is a subclass of Path
- * ----------------
- */
-static NestPath *
-_readNestPath(void)
-{
-	NestPath   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(NestPath);
+	READ_BOOL_FIELD(inh);
+	READ_BOOL_FIELD(inFromCl);
+	READ_BOOL_FIELD(checkForRead);
+	READ_BOOL_FIELD(checkForWrite);
+	READ_OID_FIELD(checkAsUser);
 
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->path.pathkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :jointype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jointype = (JoinType) atoi(token);
-
-	token = pg_strtok(&length); /* get :outerjoinpath */
-	local_node->outerjoinpath = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :innerjoinpath */
-	local_node->innerjoinpath = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :joinrestrictinfo */
-	local_node->joinrestrictinfo = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readMergePath
- *
- *	MergePath is a subclass of NestPath.
- * ----------------
- */
-static MergePath *
-_readMergePath(void)
-{
-	MergePath  *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(MergePath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->jpath.path.pathkeys = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :jointype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.jointype = (JoinType) atoi(token);
-
-	token = pg_strtok(&length); /* get :outerjoinpath */
-	local_node->jpath.outerjoinpath = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :innerjoinpath */
-	local_node->jpath.innerjoinpath = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :joinrestrictinfo */
-	local_node->jpath.joinrestrictinfo = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :path_mergeclauses */
-	local_node->path_mergeclauses = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :outersortkeys */
-	local_node->outersortkeys = nodeRead(true); /* now read it */
-
-	token = pg_strtok(&length); /* get :innersortkeys */
-	local_node->innersortkeys = nodeRead(true); /* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readHashPath
- *
- *	HashPath is a subclass of NestPath.
- * ----------------
- */
-static HashPath *
-_readHashPath(void)
-{
-	HashPath   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(HashPath);
-
-	token = pg_strtok(&length); /* get :pathtype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.pathtype = atoi(token);
-
-	token = pg_strtok(&length); /* get :startup_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.startup_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :total_cost */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.path.total_cost = (Cost) atof(token);
-
-	token = pg_strtok(&length); /* get :pathkeys */
-	local_node->jpath.path.pathkeys = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :jointype */
-	token = pg_strtok(&length); /* now read it */
-	local_node->jpath.jointype = (JoinType) atoi(token);
-
-	token = pg_strtok(&length); /* get :outerjoinpath */
-	local_node->jpath.outerjoinpath = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :innerjoinpath */
-	local_node->jpath.innerjoinpath = nodeRead(true);	/* now read it */
-
-	token = pg_strtok(&length); /* get :joinrestrictinfo */
-	local_node->jpath.joinrestrictinfo = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :path_hashclauses */
-	local_node->path_hashclauses = nodeRead(true);		/* now read it */
-
-	return local_node;
-}
-
-/* ----------------
- *		_readPathKeyItem
- *
- *	PathKeyItem is a subclass of Node.
- * ----------------
- */
-static PathKeyItem *
-_readPathKeyItem(void)
-{
-	PathKeyItem *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(PathKeyItem);
-
-	token = pg_strtok(&length); /* get :sortop */
-	token = pg_strtok(&length); /* now read it */
-	local_node->sortop = atooid(token);
-
-	token = pg_strtok(&length); /* get :key */
-	local_node->key = nodeRead(true);	/* now read it */
-
-	return local_node;
+	READ_DONE();
 }
 
-/* ----------------
- *		_readRestrictInfo
- *
- *	RestrictInfo is a subclass of Node.
- * ----------------
- */
-static RestrictInfo *
-_readRestrictInfo(void)
-{
-	RestrictInfo *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(RestrictInfo);
-
-	token = pg_strtok(&length); /* get :clause */
-	local_node->clause = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :ispusheddown */
-	token = pg_strtok(&length); /* now read it */
-	local_node->ispusheddown = strtobool(token);
-
-	token = pg_strtok(&length); /* get :subclauseindices */
-	local_node->subclauseindices = nodeRead(true);		/* now read it */
-
-	token = pg_strtok(&length); /* get :mergejoinoperator */
-	token = pg_strtok(&length); /* now read it */
-	local_node->mergejoinoperator = atooid(token);
-
-	token = pg_strtok(&length); /* get :left_sortop */
-	token = pg_strtok(&length); /* now read it */
-	local_node->left_sortop = atooid(token);
-
-	token = pg_strtok(&length); /* get :right_sortop */
-	token = pg_strtok(&length); /* now read it */
-	local_node->right_sortop = atooid(token);
 
-	token = pg_strtok(&length); /* get :hashjoinoperator */
-	token = pg_strtok(&length); /* now read it */
-	local_node->hashjoinoperator = atooid(token);
-
-	/* eval_cost is not part of saved representation; compute on first use */
-	local_node->eval_cost = -1;
-	/* ditto for this_selec */
-	local_node->this_selec = -1;
-	/* ditto for cached pathkeys, selectivity, bucketsize */
-	local_node->left_pathkey = NIL;
-	local_node->right_pathkey = NIL;
-	local_node->left_mergescansel = -1;
-	local_node->right_mergescansel = -1;
-	local_node->left_bucketsize = -1;
-	local_node->right_bucketsize = -1;
-
-	return local_node;
-}
-
-/* ----------------
- *		_readJoinInfo()
- *
- *	JoinInfo is a subclass of Node.
- * ----------------
- */
-static JoinInfo *
-_readJoinInfo(void)
-{
-	JoinInfo   *local_node;
-	char	   *token;
-	int			length;
-
-	local_node = makeNode(JoinInfo);
-
-	token = pg_strtok(&length); /* get :unjoined_relids */
-	local_node->unjoined_relids = toIntList(nodeRead(true));	/* now read it */
-
-	token = pg_strtok(&length); /* get :jinfo_restrictinfo */
-	local_node->jinfo_restrictinfo = nodeRead(true);	/* now read it */
-
-	return local_node;
-}
-
-
-/* ----------------
- *		parsePlanString
+/*
+ * parseNodeString
  *
- * Given a character string containing a plan, parsePlanString sets up the
- * plan structure representing that plan.
+ * Given a character string representing a node tree, parseNodeString creates
+ * the internal node structure.
  *
  * The string to be read must already have been loaded into pg_strtok().
- * ----------------
  */
 Node *
-parsePlanString(void)
+parseNodeString(void)
 {
-	char	   *token;
-	int			length;
-	void	   *return_value = NULL;
+	void	   *return_value;
+	READ_TEMP_LOCALS();
 
 	token = pg_strtok(&length);
 
-	if (length == 4 && strncmp(token, "PLAN", length) == 0)
-		return_value = _readPlan();
-	else if (length == 6 && strncmp(token, "RESULT", length) == 0)
-		return_value = _readResult();
-	else if (length == 6 && strncmp(token, "APPEND", length) == 0)
-		return_value = _readAppend();
-	else if (length == 4 && strncmp(token, "JOIN", length) == 0)
-		return_value = _readJoin();
-	else if (length == 8 && strncmp(token, "NESTLOOP", length) == 0)
-		return_value = _readNestLoop();
-	else if (length == 9 && strncmp(token, "MERGEJOIN", length) == 0)
-		return_value = _readMergeJoin();
-	else if (length == 8 && strncmp(token, "HASHJOIN", length) == 0)
-		return_value = _readHashJoin();
-	else if (length == 4 && strncmp(token, "SCAN", length) == 0)
-		return_value = _readScan();
-	else if (length == 7 && strncmp(token, "SEQSCAN", length) == 0)
-		return_value = _readSeqScan();
-	else if (length == 9 && strncmp(token, "INDEXSCAN", length) == 0)
-		return_value = _readIndexScan();
-	else if (length == 7 && strncmp(token, "TIDSCAN", length) == 0)
-		return_value = _readTidScan();
-	else if (length == 12 && strncmp(token, "SUBQUERYSCAN", length) == 0)
-		return_value = _readSubqueryScan();
-	else if (length == 12 && strncmp(token, "FUNCTIONSCAN", length) == 0)
-		return_value = _readFunctionScan();
-	else if (length == 4 && strncmp(token, "SORT", length) == 0)
-		return_value = _readSort();
-	else if (length == 6 && strncmp(token, "AGGREG", length) == 0)
+#define MATCH(tokname, namelen) \
+	(length == namelen && strncmp(token, tokname, namelen) == 0)
+
+	if (MATCH("AGGREF", 6))
 		return_value = _readAggref();
-	else if (length == 7 && strncmp(token, "SUBLINK", length) == 0)
+	else if (MATCH("SUBLINK", 7))
 		return_value = _readSubLink();
-	else if (length == 11 && strncmp(token, "FIELDSELECT", length) == 0)
+	else if (MATCH("FIELDSELECT", 11))
 		return_value = _readFieldSelect();
-	else if (length == 11 && strncmp(token, "RELABELTYPE", length) == 0)
+	else if (MATCH("RELABELTYPE", 11))
 		return_value = _readRelabelType();
-	else if (length == 11 && strncmp(token, "RANGETBLREF", length) == 0)
+	else if (MATCH("RANGETBLREF", 11))
 		return_value = _readRangeTblRef();
-	else if (length == 8 && strncmp(token, "FROMEXPR", length) == 0)
+	else if (MATCH("FROMEXPR", 8))
 		return_value = _readFromExpr();
-	else if (length == 8 && strncmp(token, "JOINEXPR", length) == 0)
+	else if (MATCH("JOINEXPR", 8))
 		return_value = _readJoinExpr();
-	else if (length == 4 && strncmp(token, "HASH", length) == 0)
-		return_value = _readHash();
-	else if (length == 6 && strncmp(token, "RESDOM", length) == 0)
+	else if (MATCH("RESDOM", 6))
 		return_value = _readResdom();
-	else if (length == 4 && strncmp(token, "EXPR", length) == 0)
+	else if (MATCH("EXPR", 4))
 		return_value = _readExpr();
-	else if (length == 8 && strncmp(token, "ARRAYREF", length) == 0)
+	else if (MATCH("ARRAYREF", 8))
 		return_value = _readArrayRef();
-	else if (length == 3 && strncmp(token, "VAR", length) == 0)
+	else if (MATCH("VAR", 3))
 		return_value = _readVar();
-	else if (length == 5 && strncmp(token, "CONST", length) == 0)
+	else if (MATCH("CONST", 5))
 		return_value = _readConst();
-	else if (length == 4 && strncmp(token, "FUNC", length) == 0)
+	else if (MATCH("FUNC", 4))
 		return_value = _readFunc();
-	else if (length == 4 && strncmp(token, "OPER", length) == 0)
+	else if (MATCH("OPER", 4))
 		return_value = _readOper();
-	else if (length == 5 && strncmp(token, "PARAM", length) == 0)
+	else if (MATCH("PARAM", 5))
 		return_value = _readParam();
-	else if (length == 11 && strncmp(token, "TARGETENTRY", length) == 0)
+	else if (MATCH("TARGETENTRY", 11))
 		return_value = _readTargetEntry();
-	else if (length == 8 && strncmp(token, "RANGEVAR", length) == 0)
+	else if (MATCH("RANGEVAR", 8))
 		return_value = _readRangeVar();
-	else if (length == 9 && strncmp(token, "COLUMNREF", length) == 0)
+	else if (MATCH("COLUMNREF", 9))
 		return_value = _readColumnRef();
-	else if (length == 9 && strncmp(token, "COLUMNDEF", length) == 0)
+	else if (MATCH("COLUMNDEF", 9))
 		return_value = _readColumnDef();
-	else if (length == 8 && strncmp(token, "TYPENAME", length) == 0)
+	else if (MATCH("TYPENAME", 8))
 		return_value = _readTypeName();
-	else if (length == 15 && strncmp(token, "EXPRFIELDSELECT", length) == 0)
+	else if (MATCH("EXPRFIELDSELECT", 15))
 		return_value = _readExprFieldSelect();
-	else if (length == 5 && strncmp(token, "ALIAS", length) == 0)
+	else if (MATCH("ALIAS", 5))
 		return_value = _readAlias();
-	else if (length == 3 && strncmp(token, "RTE", length) == 0)
+	else if (MATCH("RTE", 3))
 		return_value = _readRangeTblEntry();
-	else if (length == 4 && strncmp(token, "PATH", length) == 0)
-		return_value = _readPath();
-	else if (length == 9 && strncmp(token, "INDEXPATH", length) == 0)
-		return_value = _readIndexPath();
-	else if (length == 7 && strncmp(token, "TIDPATH", length) == 0)
-		return_value = _readTidPath();
-	else if (length == 10 && strncmp(token, "APPENDPATH", length) == 0)
-		return_value = _readAppendPath();
-	else if (length == 10 && strncmp(token, "RESULTPATH", length) == 0)
-		return_value = _readResultPath();
-	else if (length == 8 && strncmp(token, "NESTPATH", length) == 0)
-		return_value = _readNestPath();
-	else if (length == 9 && strncmp(token, "MERGEPATH", length) == 0)
-		return_value = _readMergePath();
-	else if (length == 8 && strncmp(token, "HASHPATH", length) == 0)
-		return_value = _readHashPath();
-	else if (length == 11 && strncmp(token, "PATHKEYITEM", length) == 0)
-		return_value = _readPathKeyItem();
-	else if (length == 12 && strncmp(token, "RESTRICTINFO", length) == 0)
-		return_value = _readRestrictInfo();
-	else if (length == 8 && strncmp(token, "JOININFO", length) == 0)
-		return_value = _readJoinInfo();
-	else if (length == 5 && strncmp(token, "QUERY", length) == 0)
+	else if (MATCH("QUERY", 5))
 		return_value = _readQuery();
-	else if (length == 6 && strncmp(token, "NOTIFY", length) == 0)
+	else if (MATCH("NOTIFY", 6))
 		return_value = _readNotifyStmt();
-	else if (length == 10 && strncmp(token, "SORTCLAUSE", length) == 0)
+	else if (MATCH("SORTCLAUSE", 10))
 		return_value = _readSortClause();
-	else if (length == 11 && strncmp(token, "GROUPCLAUSE", length) == 0)
+	else if (MATCH("GROUPCLAUSE", 11))
 		return_value = _readGroupClause();
-	else if (length == 16 && strncmp(token, "SETOPERATIONSTMT", length) == 0)
+	else if (MATCH("SETOPERATIONSTMT", 16))
 		return_value = _readSetOperationStmt();
-	else if (length == 4 && strncmp(token, "CASE", length) == 0)
+	else if (MATCH("CASE", 4))
 		return_value = _readCaseExpr();
-	else if (length == 4 && strncmp(token, "WHEN", length) == 0)
+	else if (MATCH("WHEN", 4))
 		return_value = _readCaseWhen();
-	else if (length == 8 && strncmp(token, "NULLTEST", length) == 0)
+	else if (MATCH("NULLTEST", 8))
 		return_value = _readNullTest();
-	else if (length == 11 && strncmp(token, "BOOLEANTEST", length) == 0)
+	else if (MATCH("BOOLEANTEST", 11))
 		return_value = _readBooleanTest();
-	else if (length == 14 && strncmp(token, "CONSTRAINTTEST", length) == 0)
+	else if (MATCH("CONSTRAINTTEST", 14))
 		return_value = _readConstraintTest();
-	else if (length == 21 && strncmp(token, "DOMAINCONSTRAINTVALUE", length) == 0)
+	else if (MATCH("DOMAINCONSTRAINTVALUE", 21))
 		return_value = _readDomainConstraintValue();
-	else if (length == 19 && strncmp(token, "CONSTRAINTTESTVALUE", length) == 0)
+	else if (MATCH("CONSTRAINTTESTVALUE", 19))
 		return_value = _readConstraintTestValue();
 	else
-		elog(ERROR, "badly formatted planstring \"%.10s\"...", token);
+	{
+		elog(ERROR, "badly formatted node string \"%.32s\"...", token);
+		return_value = NULL;	/* keep compiler quiet */
+	}
 
 	return (Node *) return_value;
 }
 
-/*------------------------------------------------------------*/
 
-/* ----------------
- *		readDatum
+/*
+ * readDatum
  *
  * Given a string representation of a constant, recreate the appropriate
  * Datum.  The string representation embeds length info, but not byValue,
  * so we must be told that.
- * ----------------
  */
 static Datum
 readDatum(bool typbyval)
diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 529fed99d2c..fc434a9a511 100644
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -37,7 +37,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: catversion.h,v 1.165 2002/11/23 18:13:22 momjian Exp $
+ * $Id: catversion.h,v 1.166 2002/11/25 18:12:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,6 +53,6 @@
  */
 
 /*							yyyymmddN */
-#define CATALOG_VERSION_NO	200211231
+#define CATALOG_VERSION_NO	200211251
 
 #endif
diff --git a/src/include/nodes/readfuncs.h b/src/include/nodes/readfuncs.h
index fc00ce106fa..67009c3f4ee 100644
--- a/src/include/nodes/readfuncs.h
+++ b/src/include/nodes/readfuncs.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: readfuncs.h,v 1.15 2002/06/20 20:29:51 momjian Exp $
+ * $Id: readfuncs.h,v 1.16 2002/11/25 18:12:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -26,6 +26,6 @@ extern void *nodeRead(bool read_car_only);
 /*
  * prototypes for functions in readfuncs.c
  */
-extern Node *parsePlanString(void);
+extern Node *parseNodeString(void);
 
 #endif   /* READFUNCS_H */