*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 72,78 ****
   * _copyPlannedStmt
   */
  static PlannedStmt *
! _copyPlannedStmt(PlannedStmt *from)
  {
  	PlannedStmt *newnode = makeNode(PlannedStmt);
  
--- 72,78 ----
   * _copyPlannedStmt
   */
  static PlannedStmt *
! _copyPlannedStmt(const PlannedStmt *from)
  {
  	PlannedStmt *newnode = makeNode(PlannedStmt);
  
***************
*** 103,109 **** _copyPlannedStmt(PlannedStmt *from)
   *		all the copy functions for classes which inherit from Plan.
   */
  static void
! CopyPlanFields(Plan *from, Plan *newnode)
  {
  	COPY_SCALAR_FIELD(startup_cost);
  	COPY_SCALAR_FIELD(total_cost);
--- 103,109 ----
   *		all the copy functions for classes which inherit from Plan.
   */
  static void
! CopyPlanFields(const Plan *from, Plan *newnode)
  {
  	COPY_SCALAR_FIELD(startup_cost);
  	COPY_SCALAR_FIELD(total_cost);
***************
*** 122,128 **** CopyPlanFields(Plan *from, Plan *newnode)
   * _copyPlan
   */
  static Plan *
! _copyPlan(Plan *from)
  {
  	Plan	   *newnode = makeNode(Plan);
  
--- 122,128 ----
   * _copyPlan
   */
  static Plan *
! _copyPlan(const Plan *from)
  {
  	Plan	   *newnode = makeNode(Plan);
  
***************
*** 139,145 **** _copyPlan(Plan *from)
   * _copyResult
   */
  static Result *
! _copyResult(Result *from)
  {
  	Result	   *newnode = makeNode(Result);
  
--- 139,145 ----
   * _copyResult
   */
  static Result *
! _copyResult(const Result *from)
  {
  	Result	   *newnode = makeNode(Result);
  
***************
*** 160,166 **** _copyResult(Result *from)
   * _copyModifyTable
   */
  static ModifyTable *
! _copyModifyTable(ModifyTable *from)
  {
  	ModifyTable *newnode = makeNode(ModifyTable);
  
--- 160,166 ----
   * _copyModifyTable
   */
  static ModifyTable *
! _copyModifyTable(const ModifyTable *from)
  {
  	ModifyTable *newnode = makeNode(ModifyTable);
  
***************
*** 188,194 **** _copyModifyTable(ModifyTable *from)
   * _copyAppend
   */
  static Append *
! _copyAppend(Append *from)
  {
  	Append	   *newnode = makeNode(Append);
  
--- 188,194 ----
   * _copyAppend
   */
  static Append *
! _copyAppend(const Append *from)
  {
  	Append	   *newnode = makeNode(Append);
  
***************
*** 209,215 **** _copyAppend(Append *from)
   * _copyMergeAppend
   */
  static MergeAppend *
! _copyMergeAppend(MergeAppend *from)
  {
  	MergeAppend *newnode = makeNode(MergeAppend);
  
--- 209,215 ----
   * _copyMergeAppend
   */
  static MergeAppend *
! _copyMergeAppend(const MergeAppend *from)
  {
  	MergeAppend *newnode = makeNode(MergeAppend);
  
***************
*** 235,241 **** _copyMergeAppend(MergeAppend *from)
   * _copyRecursiveUnion
   */
  static RecursiveUnion *
! _copyRecursiveUnion(RecursiveUnion *from)
  {
  	RecursiveUnion *newnode = makeNode(RecursiveUnion);
  
--- 235,241 ----
   * _copyRecursiveUnion
   */
  static RecursiveUnion *
! _copyRecursiveUnion(const RecursiveUnion *from)
  {
  	RecursiveUnion *newnode = makeNode(RecursiveUnion);
  
***************
*** 263,269 **** _copyRecursiveUnion(RecursiveUnion *from)
   * _copyBitmapAnd
   */
  static BitmapAnd *
! _copyBitmapAnd(BitmapAnd *from)
  {
  	BitmapAnd  *newnode = makeNode(BitmapAnd);
  
--- 263,269 ----
   * _copyBitmapAnd
   */
  static BitmapAnd *
! _copyBitmapAnd(const BitmapAnd *from)
  {
  	BitmapAnd  *newnode = makeNode(BitmapAnd);
  
***************
*** 284,290 **** _copyBitmapAnd(BitmapAnd *from)
   * _copyBitmapOr
   */
  static BitmapOr *
! _copyBitmapOr(BitmapOr *from)
  {
  	BitmapOr   *newnode = makeNode(BitmapOr);
  
--- 284,290 ----
   * _copyBitmapOr
   */
  static BitmapOr *
! _copyBitmapOr(const BitmapOr *from)
  {
  	BitmapOr   *newnode = makeNode(BitmapOr);
  
***************
*** 309,315 **** _copyBitmapOr(BitmapOr *from)
   *		all the copy functions for classes which inherit from Scan.
   */
  static void
! CopyScanFields(Scan *from, Scan *newnode)
  {
  	CopyPlanFields((Plan *) from, (Plan *) newnode);
  
--- 309,315 ----
   *		all the copy functions for classes which inherit from Scan.
   */
  static void
! CopyScanFields(const Scan *from, Scan *newnode)
  {
  	CopyPlanFields((Plan *) from, (Plan *) newnode);
  
***************
*** 320,326 **** CopyScanFields(Scan *from, Scan *newnode)
   * _copyScan
   */
  static Scan *
! _copyScan(Scan *from)
  {
  	Scan	   *newnode = makeNode(Scan);
  
--- 320,326 ----
   * _copyScan
   */
  static Scan *
! _copyScan(const Scan *from)
  {
  	Scan	   *newnode = makeNode(Scan);
  
***************
*** 336,342 **** _copyScan(Scan *from)
   * _copySeqScan
   */
  static SeqScan *
! _copySeqScan(SeqScan *from)
  {
  	SeqScan    *newnode = makeNode(SeqScan);
  
--- 336,342 ----
   * _copySeqScan
   */
  static SeqScan *
! _copySeqScan(const SeqScan *from)
  {
  	SeqScan    *newnode = makeNode(SeqScan);
  
***************
*** 352,358 **** _copySeqScan(SeqScan *from)
   * _copyIndexScan
   */
  static IndexScan *
! _copyIndexScan(IndexScan *from)
  {
  	IndexScan  *newnode = makeNode(IndexScan);
  
--- 352,358 ----
   * _copyIndexScan
   */
  static IndexScan *
! _copyIndexScan(const IndexScan *from)
  {
  	IndexScan  *newnode = makeNode(IndexScan);
  
***************
*** 378,384 **** _copyIndexScan(IndexScan *from)
   * _copyIndexOnlyScan
   */
  static IndexOnlyScan *
! _copyIndexOnlyScan(IndexOnlyScan *from)
  {
  	IndexOnlyScan  *newnode = makeNode(IndexOnlyScan);
  
--- 378,384 ----
   * _copyIndexOnlyScan
   */
  static IndexOnlyScan *
! _copyIndexOnlyScan(const IndexOnlyScan *from)
  {
  	IndexOnlyScan  *newnode = makeNode(IndexOnlyScan);
  
***************
*** 403,409 **** _copyIndexOnlyScan(IndexOnlyScan *from)
   * _copyBitmapIndexScan
   */
  static BitmapIndexScan *
! _copyBitmapIndexScan(BitmapIndexScan *from)
  {
  	BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
  
--- 403,409 ----
   * _copyBitmapIndexScan
   */
  static BitmapIndexScan *
! _copyBitmapIndexScan(const BitmapIndexScan *from)
  {
  	BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
  
***************
*** 426,432 **** _copyBitmapIndexScan(BitmapIndexScan *from)
   * _copyBitmapHeapScan
   */
  static BitmapHeapScan *
! _copyBitmapHeapScan(BitmapHeapScan *from)
  {
  	BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
  
--- 426,432 ----
   * _copyBitmapHeapScan
   */
  static BitmapHeapScan *
! _copyBitmapHeapScan(const BitmapHeapScan *from)
  {
  	BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
  
***************
*** 447,453 **** _copyBitmapHeapScan(BitmapHeapScan *from)
   * _copyTidScan
   */
  static TidScan *
! _copyTidScan(TidScan *from)
  {
  	TidScan    *newnode = makeNode(TidScan);
  
--- 447,453 ----
   * _copyTidScan
   */
  static TidScan *
! _copyTidScan(const TidScan *from)
  {
  	TidScan    *newnode = makeNode(TidScan);
  
***************
*** 468,474 **** _copyTidScan(TidScan *from)
   * _copySubqueryScan
   */
  static SubqueryScan *
! _copySubqueryScan(SubqueryScan *from)
  {
  	SubqueryScan *newnode = makeNode(SubqueryScan);
  
--- 468,474 ----
   * _copySubqueryScan
   */
  static SubqueryScan *
! _copySubqueryScan(const SubqueryScan *from)
  {
  	SubqueryScan *newnode = makeNode(SubqueryScan);
  
***************
*** 489,495 **** _copySubqueryScan(SubqueryScan *from)
   * _copyFunctionScan
   */
  static FunctionScan *
! _copyFunctionScan(FunctionScan *from)
  {
  	FunctionScan *newnode = makeNode(FunctionScan);
  
--- 489,495 ----
   * _copyFunctionScan
   */
  static FunctionScan *
! _copyFunctionScan(const FunctionScan *from)
  {
  	FunctionScan *newnode = makeNode(FunctionScan);
  
***************
*** 514,520 **** _copyFunctionScan(FunctionScan *from)
   * _copyValuesScan
   */
  static ValuesScan *
! _copyValuesScan(ValuesScan *from)
  {
  	ValuesScan *newnode = makeNode(ValuesScan);
  
--- 514,520 ----
   * _copyValuesScan
   */
  static ValuesScan *
! _copyValuesScan(const ValuesScan *from)
  {
  	ValuesScan *newnode = makeNode(ValuesScan);
  
***************
*** 535,541 **** _copyValuesScan(ValuesScan *from)
   * _copyCteScan
   */
  static CteScan *
! _copyCteScan(CteScan *from)
  {
  	CteScan    *newnode = makeNode(CteScan);
  
--- 535,541 ----
   * _copyCteScan
   */
  static CteScan *
! _copyCteScan(const CteScan *from)
  {
  	CteScan    *newnode = makeNode(CteScan);
  
***************
*** 557,563 **** _copyCteScan(CteScan *from)
   * _copyWorkTableScan
   */
  static WorkTableScan *
! _copyWorkTableScan(WorkTableScan *from)
  {
  	WorkTableScan *newnode = makeNode(WorkTableScan);
  
--- 557,563 ----
   * _copyWorkTableScan
   */
  static WorkTableScan *
! _copyWorkTableScan(const WorkTableScan *from)
  {
  	WorkTableScan *newnode = makeNode(WorkTableScan);
  
***************
*** 578,584 **** _copyWorkTableScan(WorkTableScan *from)
   * _copyForeignScan
   */
  static ForeignScan *
! _copyForeignScan(ForeignScan *from)
  {
  	ForeignScan *newnode = makeNode(ForeignScan);
  
--- 578,584 ----
   * _copyForeignScan
   */
  static ForeignScan *
! _copyForeignScan(const ForeignScan *from)
  {
  	ForeignScan *newnode = makeNode(ForeignScan);
  
***************
*** 600,606 **** _copyForeignScan(ForeignScan *from)
   * _copyFdwPlan
   */
  static FdwPlan *
! _copyFdwPlan(FdwPlan *from)
  {
  	FdwPlan    *newnode = makeNode(FdwPlan);
  
--- 600,606 ----
   * _copyFdwPlan
   */
  static FdwPlan *
! _copyFdwPlan(const FdwPlan *from)
  {
  	FdwPlan    *newnode = makeNode(FdwPlan);
  
***************
*** 618,624 **** _copyFdwPlan(FdwPlan *from)
   *		all the copy functions for classes which inherit from Join.
   */
  static void
! CopyJoinFields(Join *from, Join *newnode)
  {
  	CopyPlanFields((Plan *) from, (Plan *) newnode);
  
--- 618,624 ----
   *		all the copy functions for classes which inherit from Join.
   */
  static void
! CopyJoinFields(const Join *from, Join *newnode)
  {
  	CopyPlanFields((Plan *) from, (Plan *) newnode);
  
***************
*** 631,637 **** CopyJoinFields(Join *from, Join *newnode)
   * _copyJoin
   */
  static Join *
! _copyJoin(Join *from)
  {
  	Join	   *newnode = makeNode(Join);
  
--- 631,637 ----
   * _copyJoin
   */
  static Join *
! _copyJoin(const Join *from)
  {
  	Join	   *newnode = makeNode(Join);
  
***************
*** 648,654 **** _copyJoin(Join *from)
   * _copyNestLoop
   */
  static NestLoop *
! _copyNestLoop(NestLoop *from)
  {
  	NestLoop   *newnode = makeNode(NestLoop);
  
--- 648,654 ----
   * _copyNestLoop
   */
  static NestLoop *
! _copyNestLoop(const NestLoop *from)
  {
  	NestLoop   *newnode = makeNode(NestLoop);
  
***************
*** 670,676 **** _copyNestLoop(NestLoop *from)
   * _copyMergeJoin
   */
  static MergeJoin *
! _copyMergeJoin(MergeJoin *from)
  {
  	MergeJoin  *newnode = makeNode(MergeJoin);
  	int			numCols;
--- 670,676 ----
   * _copyMergeJoin
   */
  static MergeJoin *
! _copyMergeJoin(const MergeJoin *from)
  {
  	MergeJoin  *newnode = makeNode(MergeJoin);
  	int			numCols;
***************
*** 697,703 **** _copyMergeJoin(MergeJoin *from)
   * _copyHashJoin
   */
  static HashJoin *
! _copyHashJoin(HashJoin *from)
  {
  	HashJoin   *newnode = makeNode(HashJoin);
  
--- 697,703 ----
   * _copyHashJoin
   */
  static HashJoin *
! _copyHashJoin(const HashJoin *from)
  {
  	HashJoin   *newnode = makeNode(HashJoin);
  
***************
*** 719,725 **** _copyHashJoin(HashJoin *from)
   * _copyMaterial
   */
  static Material *
! _copyMaterial(Material *from)
  {
  	Material   *newnode = makeNode(Material);
  
--- 719,725 ----
   * _copyMaterial
   */
  static Material *
! _copyMaterial(const Material *from)
  {
  	Material   *newnode = makeNode(Material);
  
***************
*** 736,742 **** _copyMaterial(Material *from)
   * _copySort
   */
  static Sort *
! _copySort(Sort *from)
  {
  	Sort	   *newnode = makeNode(Sort);
  
--- 736,742 ----
   * _copySort
   */
  static Sort *
! _copySort(const Sort *from)
  {
  	Sort	   *newnode = makeNode(Sort);
  
***************
*** 759,765 **** _copySort(Sort *from)
   * _copyGroup
   */
  static Group *
! _copyGroup(Group *from)
  {
  	Group	   *newnode = makeNode(Group);
  
--- 759,765 ----
   * _copyGroup
   */
  static Group *
! _copyGroup(const Group *from)
  {
  	Group	   *newnode = makeNode(Group);
  
***************
*** 776,782 **** _copyGroup(Group *from)
   * _copyAgg
   */
  static Agg *
! _copyAgg(Agg *from)
  {
  	Agg		   *newnode = makeNode(Agg);
  
--- 776,782 ----
   * _copyAgg
   */
  static Agg *
! _copyAgg(const Agg *from)
  {
  	Agg		   *newnode = makeNode(Agg);
  
***************
*** 798,804 **** _copyAgg(Agg *from)
   * _copyWindowAgg
   */
  static WindowAgg *
! _copyWindowAgg(WindowAgg *from)
  {
  	WindowAgg  *newnode = makeNode(WindowAgg);
  
--- 798,804 ----
   * _copyWindowAgg
   */
  static WindowAgg *
! _copyWindowAgg(const WindowAgg *from)
  {
  	WindowAgg  *newnode = makeNode(WindowAgg);
  
***************
*** 828,834 **** _copyWindowAgg(WindowAgg *from)
   * _copyUnique
   */
  static Unique *
! _copyUnique(Unique *from)
  {
  	Unique	   *newnode = makeNode(Unique);
  
--- 828,834 ----
   * _copyUnique
   */
  static Unique *
! _copyUnique(const Unique *from)
  {
  	Unique	   *newnode = makeNode(Unique);
  
***************
*** 851,857 **** _copyUnique(Unique *from)
   * _copyHash
   */
  static Hash *
! _copyHash(Hash *from)
  {
  	Hash	   *newnode = makeNode(Hash);
  
--- 851,857 ----
   * _copyHash
   */
  static Hash *
! _copyHash(const Hash *from)
  {
  	Hash	   *newnode = makeNode(Hash);
  
***************
*** 876,882 **** _copyHash(Hash *from)
   * _copySetOp
   */
  static SetOp *
! _copySetOp(SetOp *from)
  {
  	SetOp	   *newnode = makeNode(SetOp);
  
--- 876,882 ----
   * _copySetOp
   */
  static SetOp *
! _copySetOp(const SetOp *from)
  {
  	SetOp	   *newnode = makeNode(SetOp);
  
***************
*** 904,910 **** _copySetOp(SetOp *from)
   * _copyLockRows
   */
  static LockRows *
! _copyLockRows(LockRows *from)
  {
  	LockRows   *newnode = makeNode(LockRows);
  
--- 904,910 ----
   * _copyLockRows
   */
  static LockRows *
! _copyLockRows(const LockRows *from)
  {
  	LockRows   *newnode = makeNode(LockRows);
  
***************
*** 926,932 **** _copyLockRows(LockRows *from)
   * _copyLimit
   */
  static Limit *
! _copyLimit(Limit *from)
  {
  	Limit	   *newnode = makeNode(Limit);
  
--- 926,932 ----
   * _copyLimit
   */
  static Limit *
! _copyLimit(const Limit *from)
  {
  	Limit	   *newnode = makeNode(Limit);
  
***************
*** 948,954 **** _copyLimit(Limit *from)
   * _copyNestLoopParam
   */
  static NestLoopParam *
! _copyNestLoopParam(NestLoopParam *from)
  {
  	NestLoopParam *newnode = makeNode(NestLoopParam);
  
--- 948,954 ----
   * _copyNestLoopParam
   */
  static NestLoopParam *
! _copyNestLoopParam(const NestLoopParam *from)
  {
  	NestLoopParam *newnode = makeNode(NestLoopParam);
  
***************
*** 962,968 **** _copyNestLoopParam(NestLoopParam *from)
   * _copyPlanRowMark
   */
  static PlanRowMark *
! _copyPlanRowMark(PlanRowMark *from)
  {
  	PlanRowMark *newnode = makeNode(PlanRowMark);
  
--- 962,968 ----
   * _copyPlanRowMark
   */
  static PlanRowMark *
! _copyPlanRowMark(const PlanRowMark *from)
  {
  	PlanRowMark *newnode = makeNode(PlanRowMark);
  
***************
*** 980,986 **** _copyPlanRowMark(PlanRowMark *from)
   * _copyPlanInvalItem
   */
  static PlanInvalItem *
! _copyPlanInvalItem(PlanInvalItem *from)
  {
  	PlanInvalItem *newnode = makeNode(PlanInvalItem);
  
--- 980,986 ----
   * _copyPlanInvalItem
   */
  static PlanInvalItem *
! _copyPlanInvalItem(const PlanInvalItem *from)
  {
  	PlanInvalItem *newnode = makeNode(PlanInvalItem);
  
***************
*** 999,1005 **** _copyPlanInvalItem(PlanInvalItem *from)
   * _copyAlias
   */
  static Alias *
! _copyAlias(Alias *from)
  {
  	Alias	   *newnode = makeNode(Alias);
  
--- 999,1005 ----
   * _copyAlias
   */
  static Alias *
! _copyAlias(const Alias *from)
  {
  	Alias	   *newnode = makeNode(Alias);
  
***************
*** 1013,1019 **** _copyAlias(Alias *from)
   * _copyRangeVar
   */
  static RangeVar *
! _copyRangeVar(RangeVar *from)
  {
  	RangeVar   *newnode = makeNode(RangeVar);
  
--- 1013,1019 ----
   * _copyRangeVar
   */
  static RangeVar *
! _copyRangeVar(const RangeVar *from)
  {
  	RangeVar   *newnode = makeNode(RangeVar);
  
***************
*** 1032,1038 **** _copyRangeVar(RangeVar *from)
   * _copyIntoClause
   */
  static IntoClause *
! _copyIntoClause(IntoClause *from)
  {
  	IntoClause *newnode = makeNode(IntoClause);
  
--- 1032,1038 ----
   * _copyIntoClause
   */
  static IntoClause *
! _copyIntoClause(const IntoClause *from)
  {
  	IntoClause *newnode = makeNode(IntoClause);
  
***************
*** 1056,1062 **** _copyIntoClause(IntoClause *from)
   * _copyVar
   */
  static Var *
! _copyVar(Var *from)
  {
  	Var		   *newnode = makeNode(Var);
  
--- 1056,1062 ----
   * _copyVar
   */
  static Var *
! _copyVar(const Var *from)
  {
  	Var		   *newnode = makeNode(Var);
  
***************
*** 1077,1083 **** _copyVar(Var *from)
   * _copyConst
   */
  static Const *
! _copyConst(Const *from)
  {
  	Const	   *newnode = makeNode(Const);
  
--- 1077,1083 ----
   * _copyConst
   */
  static Const *
! _copyConst(const Const *from)
  {
  	Const	   *newnode = makeNode(Const);
  
***************
*** 1115,1121 **** _copyConst(Const *from)
   * _copyParam
   */
  static Param *
! _copyParam(Param *from)
  {
  	Param	   *newnode = makeNode(Param);
  
--- 1115,1121 ----
   * _copyParam
   */
  static Param *
! _copyParam(const Param *from)
  {
  	Param	   *newnode = makeNode(Param);
  
***************
*** 1133,1139 **** _copyParam(Param *from)
   * _copyAggref
   */
  static Aggref *
! _copyAggref(Aggref *from)
  {
  	Aggref	   *newnode = makeNode(Aggref);
  
--- 1133,1139 ----
   * _copyAggref
   */
  static Aggref *
! _copyAggref(const Aggref *from)
  {
  	Aggref	   *newnode = makeNode(Aggref);
  
***************
*** 1155,1161 **** _copyAggref(Aggref *from)
   * _copyWindowFunc
   */
  static WindowFunc *
! _copyWindowFunc(WindowFunc *from)
  {
  	WindowFunc *newnode = makeNode(WindowFunc);
  
--- 1155,1161 ----
   * _copyWindowFunc
   */
  static WindowFunc *
! _copyWindowFunc(const WindowFunc *from)
  {
  	WindowFunc *newnode = makeNode(WindowFunc);
  
***************
*** 1176,1182 **** _copyWindowFunc(WindowFunc *from)
   * _copyArrayRef
   */
  static ArrayRef *
! _copyArrayRef(ArrayRef *from)
  {
  	ArrayRef   *newnode = makeNode(ArrayRef);
  
--- 1176,1182 ----
   * _copyArrayRef
   */
  static ArrayRef *
! _copyArrayRef(const ArrayRef *from)
  {
  	ArrayRef   *newnode = makeNode(ArrayRef);
  
***************
*** 1196,1202 **** _copyArrayRef(ArrayRef *from)
   * _copyFuncExpr
   */
  static FuncExpr *
! _copyFuncExpr(FuncExpr *from)
  {
  	FuncExpr   *newnode = makeNode(FuncExpr);
  
--- 1196,1202 ----
   * _copyFuncExpr
   */
  static FuncExpr *
! _copyFuncExpr(const FuncExpr *from)
  {
  	FuncExpr   *newnode = makeNode(FuncExpr);
  
***************
*** 1216,1222 **** _copyFuncExpr(FuncExpr *from)
   * _copyNamedArgExpr *
   */
  static NamedArgExpr *
! _copyNamedArgExpr(NamedArgExpr *from)
  {
  	NamedArgExpr *newnode = makeNode(NamedArgExpr);
  
--- 1216,1222 ----
   * _copyNamedArgExpr *
   */
  static NamedArgExpr *
! _copyNamedArgExpr(const NamedArgExpr *from)
  {
  	NamedArgExpr *newnode = makeNode(NamedArgExpr);
  
***************
*** 1232,1238 **** _copyNamedArgExpr(NamedArgExpr *from)
   * _copyOpExpr
   */
  static OpExpr *
! _copyOpExpr(OpExpr *from)
  {
  	OpExpr	   *newnode = makeNode(OpExpr);
  
--- 1232,1238 ----
   * _copyOpExpr
   */
  static OpExpr *
! _copyOpExpr(const OpExpr *from)
  {
  	OpExpr	   *newnode = makeNode(OpExpr);
  
***************
*** 1252,1258 **** _copyOpExpr(OpExpr *from)
   * _copyDistinctExpr (same as OpExpr)
   */
  static DistinctExpr *
! _copyDistinctExpr(DistinctExpr *from)
  {
  	DistinctExpr *newnode = makeNode(DistinctExpr);
  
--- 1252,1258 ----
   * _copyDistinctExpr (same as OpExpr)
   */
  static DistinctExpr *
! _copyDistinctExpr(const DistinctExpr *from)
  {
  	DistinctExpr *newnode = makeNode(DistinctExpr);
  
***************
*** 1272,1278 **** _copyDistinctExpr(DistinctExpr *from)
   * _copyNullIfExpr (same as OpExpr)
   */
  static NullIfExpr *
! _copyNullIfExpr(NullIfExpr *from)
  {
  	NullIfExpr *newnode = makeNode(NullIfExpr);
  
--- 1272,1278 ----
   * _copyNullIfExpr (same as OpExpr)
   */
  static NullIfExpr *
! _copyNullIfExpr(const NullIfExpr *from)
  {
  	NullIfExpr *newnode = makeNode(NullIfExpr);
  
***************
*** 1292,1298 **** _copyNullIfExpr(NullIfExpr *from)
   * _copyScalarArrayOpExpr
   */
  static ScalarArrayOpExpr *
! _copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
  {
  	ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
  
--- 1292,1298 ----
   * _copyScalarArrayOpExpr
   */
  static ScalarArrayOpExpr *
! _copyScalarArrayOpExpr(const ScalarArrayOpExpr *from)
  {
  	ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
  
***************
*** 1310,1316 **** _copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
   * _copyBoolExpr
   */
  static BoolExpr *
! _copyBoolExpr(BoolExpr *from)
  {
  	BoolExpr   *newnode = makeNode(BoolExpr);
  
--- 1310,1316 ----
   * _copyBoolExpr
   */
  static BoolExpr *
! _copyBoolExpr(const BoolExpr *from)
  {
  	BoolExpr   *newnode = makeNode(BoolExpr);
  
***************
*** 1325,1331 **** _copyBoolExpr(BoolExpr *from)
   * _copySubLink
   */
  static SubLink *
! _copySubLink(SubLink *from)
  {
  	SubLink    *newnode = makeNode(SubLink);
  
--- 1325,1331 ----
   * _copySubLink
   */
  static SubLink *
! _copySubLink(const SubLink *from)
  {
  	SubLink    *newnode = makeNode(SubLink);
  
***************
*** 1342,1348 **** _copySubLink(SubLink *from)
   * _copySubPlan
   */
  static SubPlan *
! _copySubPlan(SubPlan *from)
  {
  	SubPlan    *newnode = makeNode(SubPlan);
  
--- 1342,1348 ----
   * _copySubPlan
   */
  static SubPlan *
! _copySubPlan(const SubPlan *from)
  {
  	SubPlan    *newnode = makeNode(SubPlan);
  
***************
*** 1369,1375 **** _copySubPlan(SubPlan *from)
   * _copyAlternativeSubPlan
   */
  static AlternativeSubPlan *
! _copyAlternativeSubPlan(AlternativeSubPlan *from)
  {
  	AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
  
--- 1369,1375 ----
   * _copyAlternativeSubPlan
   */
  static AlternativeSubPlan *
! _copyAlternativeSubPlan(const AlternativeSubPlan *from)
  {
  	AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
  
***************
*** 1382,1388 **** _copyAlternativeSubPlan(AlternativeSubPlan *from)
   * _copyFieldSelect
   */
  static FieldSelect *
! _copyFieldSelect(FieldSelect *from)
  {
  	FieldSelect *newnode = makeNode(FieldSelect);
  
--- 1382,1388 ----
   * _copyFieldSelect
   */
  static FieldSelect *
! _copyFieldSelect(const FieldSelect *from)
  {
  	FieldSelect *newnode = makeNode(FieldSelect);
  
***************
*** 1399,1405 **** _copyFieldSelect(FieldSelect *from)
   * _copyFieldStore
   */
  static FieldStore *
! _copyFieldStore(FieldStore *from)
  {
  	FieldStore *newnode = makeNode(FieldStore);
  
--- 1399,1405 ----
   * _copyFieldStore
   */
  static FieldStore *
! _copyFieldStore(const FieldStore *from)
  {
  	FieldStore *newnode = makeNode(FieldStore);
  
***************
*** 1415,1421 **** _copyFieldStore(FieldStore *from)
   * _copyRelabelType
   */
  static RelabelType *
! _copyRelabelType(RelabelType *from)
  {
  	RelabelType *newnode = makeNode(RelabelType);
  
--- 1415,1421 ----
   * _copyRelabelType
   */
  static RelabelType *
! _copyRelabelType(const RelabelType *from)
  {
  	RelabelType *newnode = makeNode(RelabelType);
  
***************
*** 1433,1439 **** _copyRelabelType(RelabelType *from)
   * _copyCoerceViaIO
   */
  static CoerceViaIO *
! _copyCoerceViaIO(CoerceViaIO *from)
  {
  	CoerceViaIO *newnode = makeNode(CoerceViaIO);
  
--- 1433,1439 ----
   * _copyCoerceViaIO
   */
  static CoerceViaIO *
! _copyCoerceViaIO(const CoerceViaIO *from)
  {
  	CoerceViaIO *newnode = makeNode(CoerceViaIO);
  
***************
*** 1450,1456 **** _copyCoerceViaIO(CoerceViaIO *from)
   * _copyArrayCoerceExpr
   */
  static ArrayCoerceExpr *
! _copyArrayCoerceExpr(ArrayCoerceExpr *from)
  {
  	ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
  
--- 1450,1456 ----
   * _copyArrayCoerceExpr
   */
  static ArrayCoerceExpr *
! _copyArrayCoerceExpr(const ArrayCoerceExpr *from)
  {
  	ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
  
***************
*** 1470,1476 **** _copyArrayCoerceExpr(ArrayCoerceExpr *from)
   * _copyConvertRowtypeExpr
   */
  static ConvertRowtypeExpr *
! _copyConvertRowtypeExpr(ConvertRowtypeExpr *from)
  {
  	ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
  
--- 1470,1476 ----
   * _copyConvertRowtypeExpr
   */
  static ConvertRowtypeExpr *
! _copyConvertRowtypeExpr(const ConvertRowtypeExpr *from)
  {
  	ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
  
***************
*** 1486,1492 **** _copyConvertRowtypeExpr(ConvertRowtypeExpr *from)
   * _copyCollateExpr
   */
  static CollateExpr *
! _copyCollateExpr(CollateExpr *from)
  {
  	CollateExpr *newnode = makeNode(CollateExpr);
  
--- 1486,1492 ----
   * _copyCollateExpr
   */
  static CollateExpr *
! _copyCollateExpr(const CollateExpr *from)
  {
  	CollateExpr *newnode = makeNode(CollateExpr);
  
***************
*** 1501,1507 **** _copyCollateExpr(CollateExpr *from)
   * _copyCaseExpr
   */
  static CaseExpr *
! _copyCaseExpr(CaseExpr *from)
  {
  	CaseExpr   *newnode = makeNode(CaseExpr);
  
--- 1501,1507 ----
   * _copyCaseExpr
   */
  static CaseExpr *
! _copyCaseExpr(const CaseExpr *from)
  {
  	CaseExpr   *newnode = makeNode(CaseExpr);
  
***************
*** 1519,1525 **** _copyCaseExpr(CaseExpr *from)
   * _copyCaseWhen
   */
  static CaseWhen *
! _copyCaseWhen(CaseWhen *from)
  {
  	CaseWhen   *newnode = makeNode(CaseWhen);
  
--- 1519,1525 ----
   * _copyCaseWhen
   */
  static CaseWhen *
! _copyCaseWhen(const CaseWhen *from)
  {
  	CaseWhen   *newnode = makeNode(CaseWhen);
  
***************
*** 1534,1540 **** _copyCaseWhen(CaseWhen *from)
   * _copyCaseTestExpr
   */
  static CaseTestExpr *
! _copyCaseTestExpr(CaseTestExpr *from)
  {
  	CaseTestExpr *newnode = makeNode(CaseTestExpr);
  
--- 1534,1540 ----
   * _copyCaseTestExpr
   */
  static CaseTestExpr *
! _copyCaseTestExpr(const CaseTestExpr *from)
  {
  	CaseTestExpr *newnode = makeNode(CaseTestExpr);
  
***************
*** 1549,1555 **** _copyCaseTestExpr(CaseTestExpr *from)
   * _copyArrayExpr
   */
  static ArrayExpr *
! _copyArrayExpr(ArrayExpr *from)
  {
  	ArrayExpr  *newnode = makeNode(ArrayExpr);
  
--- 1549,1555 ----
   * _copyArrayExpr
   */
  static ArrayExpr *
! _copyArrayExpr(const ArrayExpr *from)
  {
  	ArrayExpr  *newnode = makeNode(ArrayExpr);
  
***************
*** 1567,1573 **** _copyArrayExpr(ArrayExpr *from)
   * _copyRowExpr
   */
  static RowExpr *
! _copyRowExpr(RowExpr *from)
  {
  	RowExpr    *newnode = makeNode(RowExpr);
  
--- 1567,1573 ----
   * _copyRowExpr
   */
  static RowExpr *
! _copyRowExpr(const RowExpr *from)
  {
  	RowExpr    *newnode = makeNode(RowExpr);
  
***************
*** 1584,1590 **** _copyRowExpr(RowExpr *from)
   * _copyRowCompareExpr
   */
  static RowCompareExpr *
! _copyRowCompareExpr(RowCompareExpr *from)
  {
  	RowCompareExpr *newnode = makeNode(RowCompareExpr);
  
--- 1584,1590 ----
   * _copyRowCompareExpr
   */
  static RowCompareExpr *
! _copyRowCompareExpr(const RowCompareExpr *from)
  {
  	RowCompareExpr *newnode = makeNode(RowCompareExpr);
  
***************
*** 1602,1608 **** _copyRowCompareExpr(RowCompareExpr *from)
   * _copyCoalesceExpr
   */
  static CoalesceExpr *
! _copyCoalesceExpr(CoalesceExpr *from)
  {
  	CoalesceExpr *newnode = makeNode(CoalesceExpr);
  
--- 1602,1608 ----
   * _copyCoalesceExpr
   */
  static CoalesceExpr *
! _copyCoalesceExpr(const CoalesceExpr *from)
  {
  	CoalesceExpr *newnode = makeNode(CoalesceExpr);
  
***************
*** 1618,1624 **** _copyCoalesceExpr(CoalesceExpr *from)
   * _copyMinMaxExpr
   */
  static MinMaxExpr *
! _copyMinMaxExpr(MinMaxExpr *from)
  {
  	MinMaxExpr *newnode = makeNode(MinMaxExpr);
  
--- 1618,1624 ----
   * _copyMinMaxExpr
   */
  static MinMaxExpr *
! _copyMinMaxExpr(const MinMaxExpr *from)
  {
  	MinMaxExpr *newnode = makeNode(MinMaxExpr);
  
***************
*** 1636,1642 **** _copyMinMaxExpr(MinMaxExpr *from)
   * _copyXmlExpr
   */
  static XmlExpr *
! _copyXmlExpr(XmlExpr *from)
  {
  	XmlExpr    *newnode = makeNode(XmlExpr);
  
--- 1636,1642 ----
   * _copyXmlExpr
   */
  static XmlExpr *
! _copyXmlExpr(const XmlExpr *from)
  {
  	XmlExpr    *newnode = makeNode(XmlExpr);
  
***************
*** 1657,1663 **** _copyXmlExpr(XmlExpr *from)
   * _copyNullTest
   */
  static NullTest *
! _copyNullTest(NullTest *from)
  {
  	NullTest   *newnode = makeNode(NullTest);
  
--- 1657,1663 ----
   * _copyNullTest
   */
  static NullTest *
! _copyNullTest(const NullTest *from)
  {
  	NullTest   *newnode = makeNode(NullTest);
  
***************
*** 1672,1678 **** _copyNullTest(NullTest *from)
   * _copyBooleanTest
   */
  static BooleanTest *
! _copyBooleanTest(BooleanTest *from)
  {
  	BooleanTest *newnode = makeNode(BooleanTest);
  
--- 1672,1678 ----
   * _copyBooleanTest
   */
  static BooleanTest *
! _copyBooleanTest(const BooleanTest *from)
  {
  	BooleanTest *newnode = makeNode(BooleanTest);
  
***************
*** 1686,1692 **** _copyBooleanTest(BooleanTest *from)
   * _copyCoerceToDomain
   */
  static CoerceToDomain *
! _copyCoerceToDomain(CoerceToDomain *from)
  {
  	CoerceToDomain *newnode = makeNode(CoerceToDomain);
  
--- 1686,1692 ----
   * _copyCoerceToDomain
   */
  static CoerceToDomain *
! _copyCoerceToDomain(const CoerceToDomain *from)
  {
  	CoerceToDomain *newnode = makeNode(CoerceToDomain);
  
***************
*** 1704,1710 **** _copyCoerceToDomain(CoerceToDomain *from)
   * _copyCoerceToDomainValue
   */
  static CoerceToDomainValue *
! _copyCoerceToDomainValue(CoerceToDomainValue *from)
  {
  	CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
  
--- 1704,1710 ----
   * _copyCoerceToDomainValue
   */
  static CoerceToDomainValue *
! _copyCoerceToDomainValue(const CoerceToDomainValue *from)
  {
  	CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
  
***************
*** 1720,1726 **** _copyCoerceToDomainValue(CoerceToDomainValue *from)
   * _copySetToDefault
   */
  static SetToDefault *
! _copySetToDefault(SetToDefault *from)
  {
  	SetToDefault *newnode = makeNode(SetToDefault);
  
--- 1720,1726 ----
   * _copySetToDefault
   */
  static SetToDefault *
! _copySetToDefault(const SetToDefault *from)
  {
  	SetToDefault *newnode = makeNode(SetToDefault);
  
***************
*** 1736,1742 **** _copySetToDefault(SetToDefault *from)
   * _copyCurrentOfExpr
   */
  static CurrentOfExpr *
! _copyCurrentOfExpr(CurrentOfExpr *from)
  {
  	CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
  
--- 1736,1742 ----
   * _copyCurrentOfExpr
   */
  static CurrentOfExpr *
! _copyCurrentOfExpr(const CurrentOfExpr *from)
  {
  	CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
  
***************
*** 1751,1757 **** _copyCurrentOfExpr(CurrentOfExpr *from)
   * _copyTargetEntry
   */
  static TargetEntry *
! _copyTargetEntry(TargetEntry *from)
  {
  	TargetEntry *newnode = makeNode(TargetEntry);
  
--- 1751,1757 ----
   * _copyTargetEntry
   */
  static TargetEntry *
! _copyTargetEntry(const TargetEntry *from)
  {
  	TargetEntry *newnode = makeNode(TargetEntry);
  
***************
*** 1770,1776 **** _copyTargetEntry(TargetEntry *from)
   * _copyRangeTblRef
   */
  static RangeTblRef *
! _copyRangeTblRef(RangeTblRef *from)
  {
  	RangeTblRef *newnode = makeNode(RangeTblRef);
  
--- 1770,1776 ----
   * _copyRangeTblRef
   */
  static RangeTblRef *
! _copyRangeTblRef(const RangeTblRef *from)
  {
  	RangeTblRef *newnode = makeNode(RangeTblRef);
  
***************
*** 1783,1789 **** _copyRangeTblRef(RangeTblRef *from)
   * _copyJoinExpr
   */
  static JoinExpr *
! _copyJoinExpr(JoinExpr *from)
  {
  	JoinExpr   *newnode = makeNode(JoinExpr);
  
--- 1783,1789 ----
   * _copyJoinExpr
   */
  static JoinExpr *
! _copyJoinExpr(const JoinExpr *from)
  {
  	JoinExpr   *newnode = makeNode(JoinExpr);
  
***************
*** 1803,1809 **** _copyJoinExpr(JoinExpr *from)
   * _copyFromExpr
   */
  static FromExpr *
! _copyFromExpr(FromExpr *from)
  {
  	FromExpr   *newnode = makeNode(FromExpr);
  
--- 1803,1809 ----
   * _copyFromExpr
   */
  static FromExpr *
! _copyFromExpr(const FromExpr *from)
  {
  	FromExpr   *newnode = makeNode(FromExpr);
  
***************
*** 1825,1831 **** _copyFromExpr(FromExpr *from)
   * _copyPathKey
   */
  static PathKey *
! _copyPathKey(PathKey *from)
  {
  	PathKey    *newnode = makeNode(PathKey);
  
--- 1825,1831 ----
   * _copyPathKey
   */
  static PathKey *
! _copyPathKey(const PathKey *from)
  {
  	PathKey    *newnode = makeNode(PathKey);
  
***************
*** 1842,1848 **** _copyPathKey(PathKey *from)
   * _copyRestrictInfo
   */
  static RestrictInfo *
! _copyRestrictInfo(RestrictInfo *from)
  {
  	RestrictInfo *newnode = makeNode(RestrictInfo);
  
--- 1842,1848 ----
   * _copyRestrictInfo
   */
  static RestrictInfo *
! _copyRestrictInfo(const RestrictInfo *from)
  {
  	RestrictInfo *newnode = makeNode(RestrictInfo);
  
***************
*** 1882,1888 **** _copyRestrictInfo(RestrictInfo *from)
   * _copyPlaceHolderVar
   */
  static PlaceHolderVar *
! _copyPlaceHolderVar(PlaceHolderVar *from)
  {
  	PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
  
--- 1882,1888 ----
   * _copyPlaceHolderVar
   */
  static PlaceHolderVar *
! _copyPlaceHolderVar(const PlaceHolderVar *from)
  {
  	PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
  
***************
*** 1898,1904 **** _copyPlaceHolderVar(PlaceHolderVar *from)
   * _copySpecialJoinInfo
   */
  static SpecialJoinInfo *
! _copySpecialJoinInfo(SpecialJoinInfo *from)
  {
  	SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);
  
--- 1898,1904 ----
   * _copySpecialJoinInfo
   */
  static SpecialJoinInfo *
! _copySpecialJoinInfo(const SpecialJoinInfo *from)
  {
  	SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);
  
***************
*** 1918,1924 **** _copySpecialJoinInfo(SpecialJoinInfo *from)
   * _copyAppendRelInfo
   */
  static AppendRelInfo *
! _copyAppendRelInfo(AppendRelInfo *from)
  {
  	AppendRelInfo *newnode = makeNode(AppendRelInfo);
  
--- 1918,1924 ----
   * _copyAppendRelInfo
   */
  static AppendRelInfo *
! _copyAppendRelInfo(const AppendRelInfo *from)
  {
  	AppendRelInfo *newnode = makeNode(AppendRelInfo);
  
***************
*** 1936,1942 **** _copyAppendRelInfo(AppendRelInfo *from)
   * _copyPlaceHolderInfo
   */
  static PlaceHolderInfo *
! _copyPlaceHolderInfo(PlaceHolderInfo *from)
  {
  	PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);
  
--- 1936,1942 ----
   * _copyPlaceHolderInfo
   */
  static PlaceHolderInfo *
! _copyPlaceHolderInfo(const PlaceHolderInfo *from)
  {
  	PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);
  
***************
*** 1956,1962 **** _copyPlaceHolderInfo(PlaceHolderInfo *from)
   */
  
  static RangeTblEntry *
! _copyRangeTblEntry(RangeTblEntry *from)
  {
  	RangeTblEntry *newnode = makeNode(RangeTblEntry);
  
--- 1956,1962 ----
   */
  
  static RangeTblEntry *
! _copyRangeTblEntry(const RangeTblEntry *from)
  {
  	RangeTblEntry *newnode = makeNode(RangeTblEntry);
  
***************
*** 1991,1997 **** _copyRangeTblEntry(RangeTblEntry *from)
  }
  
  static SortGroupClause *
! _copySortGroupClause(SortGroupClause *from)
  {
  	SortGroupClause *newnode = makeNode(SortGroupClause);
  
--- 1991,1997 ----
  }
  
  static SortGroupClause *
! _copySortGroupClause(const SortGroupClause *from)
  {
  	SortGroupClause *newnode = makeNode(SortGroupClause);
  
***************
*** 2005,2011 **** _copySortGroupClause(SortGroupClause *from)
  }
  
  static WindowClause *
! _copyWindowClause(WindowClause *from)
  {
  	WindowClause *newnode = makeNode(WindowClause);
  
--- 2005,2011 ----
  }
  
  static WindowClause *
! _copyWindowClause(const WindowClause *from)
  {
  	WindowClause *newnode = makeNode(WindowClause);
  
***************
*** 2023,2029 **** _copyWindowClause(WindowClause *from)
  }
  
  static RowMarkClause *
! _copyRowMarkClause(RowMarkClause *from)
  {
  	RowMarkClause *newnode = makeNode(RowMarkClause);
  
--- 2023,2029 ----
  }
  
  static RowMarkClause *
! _copyRowMarkClause(const RowMarkClause *from)
  {
  	RowMarkClause *newnode = makeNode(RowMarkClause);
  
***************
*** 2036,2042 **** _copyRowMarkClause(RowMarkClause *from)
  }
  
  static WithClause *
! _copyWithClause(WithClause *from)
  {
  	WithClause *newnode = makeNode(WithClause);
  
--- 2036,2042 ----
  }
  
  static WithClause *
! _copyWithClause(const WithClause *from)
  {
  	WithClause *newnode = makeNode(WithClause);
  
***************
*** 2048,2054 **** _copyWithClause(WithClause *from)
  }
  
  static CommonTableExpr *
! _copyCommonTableExpr(CommonTableExpr *from)
  {
  	CommonTableExpr *newnode = makeNode(CommonTableExpr);
  
--- 2048,2054 ----
  }
  
  static CommonTableExpr *
! _copyCommonTableExpr(const CommonTableExpr *from)
  {
  	CommonTableExpr *newnode = makeNode(CommonTableExpr);
  
***************
*** 2067,2073 **** _copyCommonTableExpr(CommonTableExpr *from)
  }
  
  static A_Expr *
! _copyAExpr(A_Expr *from)
  {
  	A_Expr	   *newnode = makeNode(A_Expr);
  
--- 2067,2073 ----
  }
  
  static A_Expr *
! _copyAExpr(const A_Expr *from)
  {
  	A_Expr	   *newnode = makeNode(A_Expr);
  
***************
*** 2081,2087 **** _copyAExpr(A_Expr *from)
  }
  
  static ColumnRef *
! _copyColumnRef(ColumnRef *from)
  {
  	ColumnRef  *newnode = makeNode(ColumnRef);
  
--- 2081,2087 ----
  }
  
  static ColumnRef *
! _copyColumnRef(const ColumnRef *from)
  {
  	ColumnRef  *newnode = makeNode(ColumnRef);
  
***************
*** 2092,2098 **** _copyColumnRef(ColumnRef *from)
  }
  
  static ParamRef *
! _copyParamRef(ParamRef *from)
  {
  	ParamRef   *newnode = makeNode(ParamRef);
  
--- 2092,2098 ----
  }
  
  static ParamRef *
! _copyParamRef(const ParamRef *from)
  {
  	ParamRef   *newnode = makeNode(ParamRef);
  
***************
*** 2103,2109 **** _copyParamRef(ParamRef *from)
  }
  
  static A_Const *
! _copyAConst(A_Const *from)
  {
  	A_Const    *newnode = makeNode(A_Const);
  
--- 2103,2109 ----
  }
  
  static A_Const *
! _copyAConst(const A_Const *from)
  {
  	A_Const    *newnode = makeNode(A_Const);
  
***************
*** 2134,2140 **** _copyAConst(A_Const *from)
  }
  
  static FuncCall *
! _copyFuncCall(FuncCall *from)
  {
  	FuncCall   *newnode = makeNode(FuncCall);
  
--- 2134,2140 ----
  }
  
  static FuncCall *
! _copyFuncCall(const FuncCall *from)
  {
  	FuncCall   *newnode = makeNode(FuncCall);
  
***************
*** 2151,2157 **** _copyFuncCall(FuncCall *from)
  }
  
  static A_Star *
! _copyAStar(A_Star *from)
  {
  	A_Star	   *newnode = makeNode(A_Star);
  
--- 2151,2157 ----
  }
  
  static A_Star *
! _copyAStar(const A_Star *from)
  {
  	A_Star	   *newnode = makeNode(A_Star);
  
***************
*** 2159,2165 **** _copyAStar(A_Star *from)
  }
  
  static A_Indices *
! _copyAIndices(A_Indices *from)
  {
  	A_Indices  *newnode = makeNode(A_Indices);
  
--- 2159,2165 ----
  }
  
  static A_Indices *
! _copyAIndices(const A_Indices *from)
  {
  	A_Indices  *newnode = makeNode(A_Indices);
  
***************
*** 2170,2176 **** _copyAIndices(A_Indices *from)
  }
  
  static A_Indirection *
! _copyA_Indirection(A_Indirection *from)
  {
  	A_Indirection *newnode = makeNode(A_Indirection);
  
--- 2170,2176 ----
  }
  
  static A_Indirection *
! _copyA_Indirection(const A_Indirection *from)
  {
  	A_Indirection *newnode = makeNode(A_Indirection);
  
***************
*** 2181,2187 **** _copyA_Indirection(A_Indirection *from)
  }
  
  static A_ArrayExpr *
! _copyA_ArrayExpr(A_ArrayExpr *from)
  {
  	A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
  
--- 2181,2187 ----
  }
  
  static A_ArrayExpr *
! _copyA_ArrayExpr(const A_ArrayExpr *from)
  {
  	A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
  
***************
*** 2192,2198 **** _copyA_ArrayExpr(A_ArrayExpr *from)
  }
  
  static ResTarget *
! _copyResTarget(ResTarget *from)
  {
  	ResTarget  *newnode = makeNode(ResTarget);
  
--- 2192,2198 ----
  }
  
  static ResTarget *
! _copyResTarget(const ResTarget *from)
  {
  	ResTarget  *newnode = makeNode(ResTarget);
  
***************
*** 2205,2211 **** _copyResTarget(ResTarget *from)
  }
  
  static TypeName *
! _copyTypeName(TypeName *from)
  {
  	TypeName   *newnode = makeNode(TypeName);
  
--- 2205,2211 ----
  }
  
  static TypeName *
! _copyTypeName(const TypeName *from)
  {
  	TypeName   *newnode = makeNode(TypeName);
  
***************
*** 2222,2228 **** _copyTypeName(TypeName *from)
  }
  
  static SortBy *
! _copySortBy(SortBy *from)
  {
  	SortBy	   *newnode = makeNode(SortBy);
  
--- 2222,2228 ----
  }
  
  static SortBy *
! _copySortBy(const SortBy *from)
  {
  	SortBy	   *newnode = makeNode(SortBy);
  
***************
*** 2236,2242 **** _copySortBy(SortBy *from)
  }
  
  static WindowDef *
! _copyWindowDef(WindowDef *from)
  {
  	WindowDef  *newnode = makeNode(WindowDef);
  
--- 2236,2242 ----
  }
  
  static WindowDef *
! _copyWindowDef(const WindowDef *from)
  {
  	WindowDef  *newnode = makeNode(WindowDef);
  
***************
*** 2253,2259 **** _copyWindowDef(WindowDef *from)
  }
  
  static RangeSubselect *
! _copyRangeSubselect(RangeSubselect *from)
  {
  	RangeSubselect *newnode = makeNode(RangeSubselect);
  
--- 2253,2259 ----
  }
  
  static RangeSubselect *
! _copyRangeSubselect(const RangeSubselect *from)
  {
  	RangeSubselect *newnode = makeNode(RangeSubselect);
  
***************
*** 2264,2270 **** _copyRangeSubselect(RangeSubselect *from)
  }
  
  static RangeFunction *
! _copyRangeFunction(RangeFunction *from)
  {
  	RangeFunction *newnode = makeNode(RangeFunction);
  
--- 2264,2270 ----
  }
  
  static RangeFunction *
! _copyRangeFunction(const RangeFunction *from)
  {
  	RangeFunction *newnode = makeNode(RangeFunction);
  
***************
*** 2276,2282 **** _copyRangeFunction(RangeFunction *from)
  }
  
  static TypeCast *
! _copyTypeCast(TypeCast *from)
  {
  	TypeCast   *newnode = makeNode(TypeCast);
  
--- 2276,2282 ----
  }
  
  static TypeCast *
! _copyTypeCast(const TypeCast *from)
  {
  	TypeCast   *newnode = makeNode(TypeCast);
  
***************
*** 2288,2294 **** _copyTypeCast(TypeCast *from)
  }
  
  static CollateClause *
! _copyCollateClause(CollateClause *from)
  {
  	CollateClause *newnode = makeNode(CollateClause);
  
--- 2288,2294 ----
  }
  
  static CollateClause *
! _copyCollateClause(const CollateClause *from)
  {
  	CollateClause *newnode = makeNode(CollateClause);
  
***************
*** 2300,2306 **** _copyCollateClause(CollateClause *from)
  }
  
  static IndexElem *
! _copyIndexElem(IndexElem *from)
  {
  	IndexElem  *newnode = makeNode(IndexElem);
  
--- 2300,2306 ----
  }
  
  static IndexElem *
! _copyIndexElem(const IndexElem *from)
  {
  	IndexElem  *newnode = makeNode(IndexElem);
  
***************
*** 2316,2322 **** _copyIndexElem(IndexElem *from)
  }
  
  static ColumnDef *
! _copyColumnDef(ColumnDef *from)
  {
  	ColumnDef  *newnode = makeNode(ColumnDef);
  
--- 2316,2322 ----
  }
  
  static ColumnDef *
! _copyColumnDef(const ColumnDef *from)
  {
  	ColumnDef  *newnode = makeNode(ColumnDef);
  
***************
*** 2338,2344 **** _copyColumnDef(ColumnDef *from)
  }
  
  static Constraint *
! _copyConstraint(Constraint *from)
  {
  	Constraint *newnode = makeNode(Constraint);
  
--- 2338,2344 ----
  }
  
  static Constraint *
! _copyConstraint(const Constraint *from)
  {
  	Constraint *newnode = makeNode(Constraint);
  
***************
*** 2369,2375 **** _copyConstraint(Constraint *from)
  }
  
  static DefElem *
! _copyDefElem(DefElem *from)
  {
  	DefElem    *newnode = makeNode(DefElem);
  
--- 2369,2375 ----
  }
  
  static DefElem *
! _copyDefElem(const DefElem *from)
  {
  	DefElem    *newnode = makeNode(DefElem);
  
***************
*** 2382,2388 **** _copyDefElem(DefElem *from)
  }
  
  static LockingClause *
! _copyLockingClause(LockingClause *from)
  {
  	LockingClause *newnode = makeNode(LockingClause);
  
--- 2382,2388 ----
  }
  
  static LockingClause *
! _copyLockingClause(const LockingClause *from)
  {
  	LockingClause *newnode = makeNode(LockingClause);
  
***************
*** 2394,2400 **** _copyLockingClause(LockingClause *from)
  }
  
  static XmlSerialize *
! _copyXmlSerialize(XmlSerialize *from)
  {
  	XmlSerialize *newnode = makeNode(XmlSerialize);
  
--- 2394,2400 ----
  }
  
  static XmlSerialize *
! _copyXmlSerialize(const XmlSerialize *from)
  {
  	XmlSerialize *newnode = makeNode(XmlSerialize);
  
***************
*** 2407,2413 **** _copyXmlSerialize(XmlSerialize *from)
  }
  
  static Query *
! _copyQuery(Query *from)
  {
  	Query	   *newnode = makeNode(Query);
  
--- 2407,2413 ----
  }
  
  static Query *
! _copyQuery(const Query *from)
  {
  	Query	   *newnode = makeNode(Query);
  
***************
*** 2444,2450 **** _copyQuery(Query *from)
  }
  
  static InsertStmt *
! _copyInsertStmt(InsertStmt *from)
  {
  	InsertStmt *newnode = makeNode(InsertStmt);
  
--- 2444,2450 ----
  }
  
  static InsertStmt *
! _copyInsertStmt(const InsertStmt *from)
  {
  	InsertStmt *newnode = makeNode(InsertStmt);
  
***************
*** 2458,2464 **** _copyInsertStmt(InsertStmt *from)
  }
  
  static DeleteStmt *
! _copyDeleteStmt(DeleteStmt *from)
  {
  	DeleteStmt *newnode = makeNode(DeleteStmt);
  
--- 2458,2464 ----
  }
  
  static DeleteStmt *
! _copyDeleteStmt(const DeleteStmt *from)
  {
  	DeleteStmt *newnode = makeNode(DeleteStmt);
  
***************
*** 2472,2478 **** _copyDeleteStmt(DeleteStmt *from)
  }
  
  static UpdateStmt *
! _copyUpdateStmt(UpdateStmt *from)
  {
  	UpdateStmt *newnode = makeNode(UpdateStmt);
  
--- 2472,2478 ----
  }
  
  static UpdateStmt *
! _copyUpdateStmt(const UpdateStmt *from)
  {
  	UpdateStmt *newnode = makeNode(UpdateStmt);
  
***************
*** 2487,2493 **** _copyUpdateStmt(UpdateStmt *from)
  }
  
  static SelectStmt *
! _copySelectStmt(SelectStmt *from)
  {
  	SelectStmt *newnode = makeNode(SelectStmt);
  
--- 2487,2493 ----
  }
  
  static SelectStmt *
! _copySelectStmt(const SelectStmt *from)
  {
  	SelectStmt *newnode = makeNode(SelectStmt);
  
***************
*** 2514,2520 **** _copySelectStmt(SelectStmt *from)
  }
  
  static SetOperationStmt *
! _copySetOperationStmt(SetOperationStmt *from)
  {
  	SetOperationStmt *newnode = makeNode(SetOperationStmt);
  
--- 2514,2520 ----
  }
  
  static SetOperationStmt *
! _copySetOperationStmt(const SetOperationStmt *from)
  {
  	SetOperationStmt *newnode = makeNode(SetOperationStmt);
  
***************
*** 2531,2537 **** _copySetOperationStmt(SetOperationStmt *from)
  }
  
  static AlterTableStmt *
! _copyAlterTableStmt(AlterTableStmt *from)
  {
  	AlterTableStmt *newnode = makeNode(AlterTableStmt);
  
--- 2531,2537 ----
  }
  
  static AlterTableStmt *
! _copyAlterTableStmt(const AlterTableStmt *from)
  {
  	AlterTableStmt *newnode = makeNode(AlterTableStmt);
  
***************
*** 2543,2549 **** _copyAlterTableStmt(AlterTableStmt *from)
  }
  
  static AlterTableCmd *
! _copyAlterTableCmd(AlterTableCmd *from)
  {
  	AlterTableCmd *newnode = makeNode(AlterTableCmd);
  
--- 2543,2549 ----
  }
  
  static AlterTableCmd *
! _copyAlterTableCmd(const AlterTableCmd *from)
  {
  	AlterTableCmd *newnode = makeNode(AlterTableCmd);
  
***************
*** 2557,2563 **** _copyAlterTableCmd(AlterTableCmd *from)
  }
  
  static AlterDomainStmt *
! _copyAlterDomainStmt(AlterDomainStmt *from)
  {
  	AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
  
--- 2557,2563 ----
  }
  
  static AlterDomainStmt *
! _copyAlterDomainStmt(const AlterDomainStmt *from)
  {
  	AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
  
***************
*** 2571,2577 **** _copyAlterDomainStmt(AlterDomainStmt *from)
  }
  
  static GrantStmt *
! _copyGrantStmt(GrantStmt *from)
  {
  	GrantStmt  *newnode = makeNode(GrantStmt);
  
--- 2571,2577 ----
  }
  
  static GrantStmt *
! _copyGrantStmt(const GrantStmt *from)
  {
  	GrantStmt  *newnode = makeNode(GrantStmt);
  
***************
*** 2588,2594 **** _copyGrantStmt(GrantStmt *from)
  }
  
  static PrivGrantee *
! _copyPrivGrantee(PrivGrantee *from)
  {
  	PrivGrantee *newnode = makeNode(PrivGrantee);
  
--- 2588,2594 ----
  }
  
  static PrivGrantee *
! _copyPrivGrantee(const PrivGrantee *from)
  {
  	PrivGrantee *newnode = makeNode(PrivGrantee);
  
***************
*** 2598,2604 **** _copyPrivGrantee(PrivGrantee *from)
  }
  
  static FuncWithArgs *
! _copyFuncWithArgs(FuncWithArgs *from)
  {
  	FuncWithArgs *newnode = makeNode(FuncWithArgs);
  
--- 2598,2604 ----
  }
  
  static FuncWithArgs *
! _copyFuncWithArgs(const FuncWithArgs *from)
  {
  	FuncWithArgs *newnode = makeNode(FuncWithArgs);
  
***************
*** 2609,2615 **** _copyFuncWithArgs(FuncWithArgs *from)
  }
  
  static AccessPriv *
! _copyAccessPriv(AccessPriv *from)
  {
  	AccessPriv *newnode = makeNode(AccessPriv);
  
--- 2609,2615 ----
  }
  
  static AccessPriv *
! _copyAccessPriv(const AccessPriv *from)
  {
  	AccessPriv *newnode = makeNode(AccessPriv);
  
***************
*** 2620,2626 **** _copyAccessPriv(AccessPriv *from)
  }
  
  static GrantRoleStmt *
! _copyGrantRoleStmt(GrantRoleStmt *from)
  {
  	GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
  
--- 2620,2626 ----
  }
  
  static GrantRoleStmt *
! _copyGrantRoleStmt(const GrantRoleStmt *from)
  {
  	GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
  
***************
*** 2635,2641 **** _copyGrantRoleStmt(GrantRoleStmt *from)
  }
  
  static AlterDefaultPrivilegesStmt *
! _copyAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *from)
  {
  	AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);
  
--- 2635,2641 ----
  }
  
  static AlterDefaultPrivilegesStmt *
! _copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from)
  {
  	AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);
  
***************
*** 2646,2652 **** _copyAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *from)
  }
  
  static DeclareCursorStmt *
! _copyDeclareCursorStmt(DeclareCursorStmt *from)
  {
  	DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
  
--- 2646,2652 ----
  }
  
  static DeclareCursorStmt *
! _copyDeclareCursorStmt(const DeclareCursorStmt *from)
  {
  	DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
  
***************
*** 2658,2664 **** _copyDeclareCursorStmt(DeclareCursorStmt *from)
  }
  
  static ClosePortalStmt *
! _copyClosePortalStmt(ClosePortalStmt *from)
  {
  	ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
  
--- 2658,2664 ----
  }
  
  static ClosePortalStmt *
! _copyClosePortalStmt(const ClosePortalStmt *from)
  {
  	ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
  
***************
*** 2668,2674 **** _copyClosePortalStmt(ClosePortalStmt *from)
  }
  
  static ClusterStmt *
! _copyClusterStmt(ClusterStmt *from)
  {
  	ClusterStmt *newnode = makeNode(ClusterStmt);
  
--- 2668,2674 ----
  }
  
  static ClusterStmt *
! _copyClusterStmt(const ClusterStmt *from)
  {
  	ClusterStmt *newnode = makeNode(ClusterStmt);
  
***************
*** 2680,2686 **** _copyClusterStmt(ClusterStmt *from)
  }
  
  static CopyStmt *
! _copyCopyStmt(CopyStmt *from)
  {
  	CopyStmt   *newnode = makeNode(CopyStmt);
  
--- 2680,2686 ----
  }
  
  static CopyStmt *
! _copyCopyStmt(const CopyStmt *from)
  {
  	CopyStmt   *newnode = makeNode(CopyStmt);
  
***************
*** 2701,2707 **** _copyCopyStmt(CopyStmt *from)
   *		copy functions for classes which inherit from CreateStmt.
   */
  static void
! CopyCreateStmtFields(CreateStmt *from, CreateStmt *newnode)
  {
  	COPY_NODE_FIELD(relation);
  	COPY_NODE_FIELD(tableElts);
--- 2701,2707 ----
   *		copy functions for classes which inherit from CreateStmt.
   */
  static void
! CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode)
  {
  	COPY_NODE_FIELD(relation);
  	COPY_NODE_FIELD(tableElts);
***************
*** 2715,2721 **** CopyCreateStmtFields(CreateStmt *from, CreateStmt *newnode)
  }
  
  static CreateStmt *
! _copyCreateStmt(CreateStmt *from)
  {
  	CreateStmt *newnode = makeNode(CreateStmt);
  
--- 2715,2721 ----
  }
  
  static CreateStmt *
! _copyCreateStmt(const CreateStmt *from)
  {
  	CreateStmt *newnode = makeNode(CreateStmt);
  
***************
*** 2725,2731 **** _copyCreateStmt(CreateStmt *from)
  }
  
  static InhRelation *
! _copyInhRelation(InhRelation *from)
  {
  	InhRelation *newnode = makeNode(InhRelation);
  
--- 2725,2731 ----
  }
  
  static InhRelation *
! _copyInhRelation(const InhRelation *from)
  {
  	InhRelation *newnode = makeNode(InhRelation);
  
***************
*** 2736,2742 **** _copyInhRelation(InhRelation *from)
  }
  
  static DefineStmt *
! _copyDefineStmt(DefineStmt *from)
  {
  	DefineStmt *newnode = makeNode(DefineStmt);
  
--- 2736,2742 ----
  }
  
  static DefineStmt *
! _copyDefineStmt(const DefineStmt *from)
  {
  	DefineStmt *newnode = makeNode(DefineStmt);
  
***************
*** 2750,2756 **** _copyDefineStmt(DefineStmt *from)
  }
  
  static DropStmt *
! _copyDropStmt(DropStmt *from)
  {
  	DropStmt   *newnode = makeNode(DropStmt);
  
--- 2750,2756 ----
  }
  
  static DropStmt *
! _copyDropStmt(const DropStmt *from)
  {
  	DropStmt   *newnode = makeNode(DropStmt);
  
***************
*** 2763,2769 **** _copyDropStmt(DropStmt *from)
  }
  
  static TruncateStmt *
! _copyTruncateStmt(TruncateStmt *from)
  {
  	TruncateStmt *newnode = makeNode(TruncateStmt);
  
--- 2763,2769 ----
  }
  
  static TruncateStmt *
! _copyTruncateStmt(const TruncateStmt *from)
  {
  	TruncateStmt *newnode = makeNode(TruncateStmt);
  
***************
*** 2775,2781 **** _copyTruncateStmt(TruncateStmt *from)
  }
  
  static CommentStmt *
! _copyCommentStmt(CommentStmt *from)
  {
  	CommentStmt *newnode = makeNode(CommentStmt);
  
--- 2775,2781 ----
  }
  
  static CommentStmt *
! _copyCommentStmt(const CommentStmt *from)
  {
  	CommentStmt *newnode = makeNode(CommentStmt);
  
***************
*** 2788,2794 **** _copyCommentStmt(CommentStmt *from)
  }
  
  static SecLabelStmt *
! _copySecLabelStmt(SecLabelStmt *from)
  {
  	SecLabelStmt *newnode = makeNode(SecLabelStmt);
  
--- 2788,2794 ----
  }
  
  static SecLabelStmt *
! _copySecLabelStmt(const SecLabelStmt *from)
  {
  	SecLabelStmt *newnode = makeNode(SecLabelStmt);
  
***************
*** 2802,2808 **** _copySecLabelStmt(SecLabelStmt *from)
  }
  
  static FetchStmt *
! _copyFetchStmt(FetchStmt *from)
  {
  	FetchStmt  *newnode = makeNode(FetchStmt);
  
--- 2802,2808 ----
  }
  
  static FetchStmt *
! _copyFetchStmt(const FetchStmt *from)
  {
  	FetchStmt  *newnode = makeNode(FetchStmt);
  
***************
*** 2815,2821 **** _copyFetchStmt(FetchStmt *from)
  }
  
  static IndexStmt *
! _copyIndexStmt(IndexStmt *from)
  {
  	IndexStmt  *newnode = makeNode(IndexStmt);
  
--- 2815,2821 ----
  }
  
  static IndexStmt *
! _copyIndexStmt(const IndexStmt *from)
  {
  	IndexStmt  *newnode = makeNode(IndexStmt);
  
***************
*** 2840,2846 **** _copyIndexStmt(IndexStmt *from)
  }
  
  static CreateFunctionStmt *
! _copyCreateFunctionStmt(CreateFunctionStmt *from)
  {
  	CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
  
--- 2840,2846 ----
  }
  
  static CreateFunctionStmt *
! _copyCreateFunctionStmt(const CreateFunctionStmt *from)
  {
  	CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
  
***************
*** 2855,2861 **** _copyCreateFunctionStmt(CreateFunctionStmt *from)
  }
  
  static FunctionParameter *
! _copyFunctionParameter(FunctionParameter *from)
  {
  	FunctionParameter *newnode = makeNode(FunctionParameter);
  
--- 2855,2861 ----
  }
  
  static FunctionParameter *
! _copyFunctionParameter(const FunctionParameter *from)
  {
  	FunctionParameter *newnode = makeNode(FunctionParameter);
  
***************
*** 2868,2874 **** _copyFunctionParameter(FunctionParameter *from)
  }
  
  static AlterFunctionStmt *
! _copyAlterFunctionStmt(AlterFunctionStmt *from)
  {
  	AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
  
--- 2868,2874 ----
  }
  
  static AlterFunctionStmt *
! _copyAlterFunctionStmt(const AlterFunctionStmt *from)
  {
  	AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
  
***************
*** 2879,2885 **** _copyAlterFunctionStmt(AlterFunctionStmt *from)
  }
  
  static RemoveFuncStmt *
! _copyRemoveFuncStmt(RemoveFuncStmt *from)
  {
  	RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
  
--- 2879,2885 ----
  }
  
  static RemoveFuncStmt *
! _copyRemoveFuncStmt(const RemoveFuncStmt *from)
  {
  	RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
  
***************
*** 2893,2899 **** _copyRemoveFuncStmt(RemoveFuncStmt *from)
  }
  
  static DoStmt *
! _copyDoStmt(DoStmt *from)
  {
  	DoStmt	   *newnode = makeNode(DoStmt);
  
--- 2893,2899 ----
  }
  
  static DoStmt *
! _copyDoStmt(const DoStmt *from)
  {
  	DoStmt	   *newnode = makeNode(DoStmt);
  
***************
*** 2903,2909 **** _copyDoStmt(DoStmt *from)
  }
  
  static RemoveOpClassStmt *
! _copyRemoveOpClassStmt(RemoveOpClassStmt *from)
  {
  	RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
  
--- 2903,2909 ----
  }
  
  static RemoveOpClassStmt *
! _copyRemoveOpClassStmt(const RemoveOpClassStmt *from)
  {
  	RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
  
***************
*** 2916,2922 **** _copyRemoveOpClassStmt(RemoveOpClassStmt *from)
  }
  
  static RemoveOpFamilyStmt *
! _copyRemoveOpFamilyStmt(RemoveOpFamilyStmt *from)
  {
  	RemoveOpFamilyStmt *newnode = makeNode(RemoveOpFamilyStmt);
  
--- 2916,2922 ----
  }
  
  static RemoveOpFamilyStmt *
! _copyRemoveOpFamilyStmt(const RemoveOpFamilyStmt *from)
  {
  	RemoveOpFamilyStmt *newnode = makeNode(RemoveOpFamilyStmt);
  
***************
*** 2929,2935 **** _copyRemoveOpFamilyStmt(RemoveOpFamilyStmt *from)
  }
  
  static RenameStmt *
! _copyRenameStmt(RenameStmt *from)
  {
  	RenameStmt *newnode = makeNode(RenameStmt);
  
--- 2929,2935 ----
  }
  
  static RenameStmt *
! _copyRenameStmt(const RenameStmt *from)
  {
  	RenameStmt *newnode = makeNode(RenameStmt);
  
***************
*** 2945,2951 **** _copyRenameStmt(RenameStmt *from)
  }
  
  static AlterObjectSchemaStmt *
! _copyAlterObjectSchemaStmt(AlterObjectSchemaStmt *from)
  {
  	AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
  
--- 2945,2951 ----
  }
  
  static AlterObjectSchemaStmt *
! _copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from)
  {
  	AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
  
***************
*** 2960,2966 **** _copyAlterObjectSchemaStmt(AlterObjectSchemaStmt *from)
  }
  
  static AlterOwnerStmt *
! _copyAlterOwnerStmt(AlterOwnerStmt *from)
  {
  	AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
  
--- 2960,2966 ----
  }
  
  static AlterOwnerStmt *
! _copyAlterOwnerStmt(const AlterOwnerStmt *from)
  {
  	AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
  
***************
*** 2975,2981 **** _copyAlterOwnerStmt(AlterOwnerStmt *from)
  }
  
  static RuleStmt *
! _copyRuleStmt(RuleStmt *from)
  {
  	RuleStmt   *newnode = makeNode(RuleStmt);
  
--- 2975,2981 ----
  }
  
  static RuleStmt *
! _copyRuleStmt(const RuleStmt *from)
  {
  	RuleStmt   *newnode = makeNode(RuleStmt);
  
***************
*** 2991,2997 **** _copyRuleStmt(RuleStmt *from)
  }
  
  static NotifyStmt *
! _copyNotifyStmt(NotifyStmt *from)
  {
  	NotifyStmt *newnode = makeNode(NotifyStmt);
  
--- 2991,2997 ----
  }
  
  static NotifyStmt *
! _copyNotifyStmt(const NotifyStmt *from)
  {
  	NotifyStmt *newnode = makeNode(NotifyStmt);
  
***************
*** 3002,3008 **** _copyNotifyStmt(NotifyStmt *from)
  }
  
  static ListenStmt *
! _copyListenStmt(ListenStmt *from)
  {
  	ListenStmt *newnode = makeNode(ListenStmt);
  
--- 3002,3008 ----
  }
  
  static ListenStmt *
! _copyListenStmt(const ListenStmt *from)
  {
  	ListenStmt *newnode = makeNode(ListenStmt);
  
***************
*** 3012,3018 **** _copyListenStmt(ListenStmt *from)
  }
  
  static UnlistenStmt *
! _copyUnlistenStmt(UnlistenStmt *from)
  {
  	UnlistenStmt *newnode = makeNode(UnlistenStmt);
  
--- 3012,3018 ----
  }
  
  static UnlistenStmt *
! _copyUnlistenStmt(const UnlistenStmt *from)
  {
  	UnlistenStmt *newnode = makeNode(UnlistenStmt);
  
***************
*** 3022,3028 **** _copyUnlistenStmt(UnlistenStmt *from)
  }
  
  static TransactionStmt *
! _copyTransactionStmt(TransactionStmt *from)
  {
  	TransactionStmt *newnode = makeNode(TransactionStmt);
  
--- 3022,3028 ----
  }
  
  static TransactionStmt *
! _copyTransactionStmt(const TransactionStmt *from)
  {
  	TransactionStmt *newnode = makeNode(TransactionStmt);
  
***************
*** 3034,3040 **** _copyTransactionStmt(TransactionStmt *from)
  }
  
  static CompositeTypeStmt *
! _copyCompositeTypeStmt(CompositeTypeStmt *from)
  {
  	CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
  
--- 3034,3040 ----
  }
  
  static CompositeTypeStmt *
! _copyCompositeTypeStmt(const CompositeTypeStmt *from)
  {
  	CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
  
***************
*** 3045,3051 **** _copyCompositeTypeStmt(CompositeTypeStmt *from)
  }
  
  static CreateEnumStmt *
! _copyCreateEnumStmt(CreateEnumStmt *from)
  {
  	CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
  
--- 3045,3051 ----
  }
  
  static CreateEnumStmt *
! _copyCreateEnumStmt(const CreateEnumStmt *from)
  {
  	CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
  
***************
*** 3056,3062 **** _copyCreateEnumStmt(CreateEnumStmt *from)
  }
  
  static CreateRangeStmt *
! _copyCreateRangeStmt(CreateRangeStmt *from)
  {
  	CreateRangeStmt *newnode = makeNode(CreateRangeStmt);
  
--- 3056,3062 ----
  }
  
  static CreateRangeStmt *
! _copyCreateRangeStmt(const CreateRangeStmt *from)
  {
  	CreateRangeStmt *newnode = makeNode(CreateRangeStmt);
  
***************
*** 3067,3073 **** _copyCreateRangeStmt(CreateRangeStmt *from)
  }
  
  static AlterEnumStmt *
! _copyAlterEnumStmt(AlterEnumStmt *from)
  {
  	AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
  
--- 3067,3073 ----
  }
  
  static AlterEnumStmt *
! _copyAlterEnumStmt(const AlterEnumStmt *from)
  {
  	AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
  
***************
*** 3080,3086 **** _copyAlterEnumStmt(AlterEnumStmt *from)
  }
  
  static ViewStmt *
! _copyViewStmt(ViewStmt *from)
  {
  	ViewStmt   *newnode = makeNode(ViewStmt);
  
--- 3080,3086 ----
  }
  
  static ViewStmt *
! _copyViewStmt(const ViewStmt *from)
  {
  	ViewStmt   *newnode = makeNode(ViewStmt);
  
***************
*** 3093,3099 **** _copyViewStmt(ViewStmt *from)
  }
  
  static LoadStmt *
! _copyLoadStmt(LoadStmt *from)
  {
  	LoadStmt   *newnode = makeNode(LoadStmt);
  
--- 3093,3099 ----
  }
  
  static LoadStmt *
! _copyLoadStmt(const LoadStmt *from)
  {
  	LoadStmt   *newnode = makeNode(LoadStmt);
  
***************
*** 3103,3109 **** _copyLoadStmt(LoadStmt *from)
  }
  
  static CreateDomainStmt *
! _copyCreateDomainStmt(CreateDomainStmt *from)
  {
  	CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
  
--- 3103,3109 ----
  }
  
  static CreateDomainStmt *
! _copyCreateDomainStmt(const CreateDomainStmt *from)
  {
  	CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
  
***************
*** 3116,3122 **** _copyCreateDomainStmt(CreateDomainStmt *from)
  }
  
  static CreateOpClassStmt *
! _copyCreateOpClassStmt(CreateOpClassStmt *from)
  {
  	CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
  
--- 3116,3122 ----
  }
  
  static CreateOpClassStmt *
! _copyCreateOpClassStmt(const CreateOpClassStmt *from)
  {
  	CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
  
***************
*** 3131,3137 **** _copyCreateOpClassStmt(CreateOpClassStmt *from)
  }
  
  static CreateOpClassItem *
! _copyCreateOpClassItem(CreateOpClassItem *from)
  {
  	CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
  
--- 3131,3137 ----
  }
  
  static CreateOpClassItem *
! _copyCreateOpClassItem(const CreateOpClassItem *from)
  {
  	CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
  
***************
*** 3147,3153 **** _copyCreateOpClassItem(CreateOpClassItem *from)
  }
  
  static CreateOpFamilyStmt *
! _copyCreateOpFamilyStmt(CreateOpFamilyStmt *from)
  {
  	CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
  
--- 3147,3153 ----
  }
  
  static CreateOpFamilyStmt *
! _copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from)
  {
  	CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
  
***************
*** 3158,3164 **** _copyCreateOpFamilyStmt(CreateOpFamilyStmt *from)
  }
  
  static AlterOpFamilyStmt *
! _copyAlterOpFamilyStmt(AlterOpFamilyStmt *from)
  {
  	AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
  
--- 3158,3164 ----
  }
  
  static AlterOpFamilyStmt *
! _copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from)
  {
  	AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
  
***************
*** 3171,3177 **** _copyAlterOpFamilyStmt(AlterOpFamilyStmt *from)
  }
  
  static CreatedbStmt *
! _copyCreatedbStmt(CreatedbStmt *from)
  {
  	CreatedbStmt *newnode = makeNode(CreatedbStmt);
  
--- 3171,3177 ----
  }
  
  static CreatedbStmt *
! _copyCreatedbStmt(const CreatedbStmt *from)
  {
  	CreatedbStmt *newnode = makeNode(CreatedbStmt);
  
***************
*** 3182,3188 **** _copyCreatedbStmt(CreatedbStmt *from)
  }
  
  static AlterDatabaseStmt *
! _copyAlterDatabaseStmt(AlterDatabaseStmt *from)
  {
  	AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
  
--- 3182,3188 ----
  }
  
  static AlterDatabaseStmt *
! _copyAlterDatabaseStmt(const AlterDatabaseStmt *from)
  {
  	AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
  
***************
*** 3193,3199 **** _copyAlterDatabaseStmt(AlterDatabaseStmt *from)
  }
  
  static AlterDatabaseSetStmt *
! _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
  {
  	AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
  
--- 3193,3199 ----
  }
  
  static AlterDatabaseSetStmt *
! _copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from)
  {
  	AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
  
***************
*** 3204,3210 **** _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
  }
  
  static DropdbStmt *
! _copyDropdbStmt(DropdbStmt *from)
  {
  	DropdbStmt *newnode = makeNode(DropdbStmt);
  
--- 3204,3210 ----
  }
  
  static DropdbStmt *
! _copyDropdbStmt(const DropdbStmt *from)
  {
  	DropdbStmt *newnode = makeNode(DropdbStmt);
  
***************
*** 3215,3221 **** _copyDropdbStmt(DropdbStmt *from)
  }
  
  static VacuumStmt *
! _copyVacuumStmt(VacuumStmt *from)
  {
  	VacuumStmt *newnode = makeNode(VacuumStmt);
  
--- 3215,3221 ----
  }
  
  static VacuumStmt *
! _copyVacuumStmt(const VacuumStmt *from)
  {
  	VacuumStmt *newnode = makeNode(VacuumStmt);
  
***************
*** 3229,3235 **** _copyVacuumStmt(VacuumStmt *from)
  }
  
  static ExplainStmt *
! _copyExplainStmt(ExplainStmt *from)
  {
  	ExplainStmt *newnode = makeNode(ExplainStmt);
  
--- 3229,3235 ----
  }
  
  static ExplainStmt *
! _copyExplainStmt(const ExplainStmt *from)
  {
  	ExplainStmt *newnode = makeNode(ExplainStmt);
  
***************
*** 3240,3246 **** _copyExplainStmt(ExplainStmt *from)
  }
  
  static CreateSeqStmt *
! _copyCreateSeqStmt(CreateSeqStmt *from)
  {
  	CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
  
--- 3240,3246 ----
  }
  
  static CreateSeqStmt *
! _copyCreateSeqStmt(const CreateSeqStmt *from)
  {
  	CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
  
***************
*** 3252,3258 **** _copyCreateSeqStmt(CreateSeqStmt *from)
  }
  
  static AlterSeqStmt *
! _copyAlterSeqStmt(AlterSeqStmt *from)
  {
  	AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
  
--- 3252,3258 ----
  }
  
  static AlterSeqStmt *
! _copyAlterSeqStmt(const AlterSeqStmt *from)
  {
  	AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
  
***************
*** 3263,3269 **** _copyAlterSeqStmt(AlterSeqStmt *from)
  }
  
  static VariableSetStmt *
! _copyVariableSetStmt(VariableSetStmt *from)
  {
  	VariableSetStmt *newnode = makeNode(VariableSetStmt);
  
--- 3263,3269 ----
  }
  
  static VariableSetStmt *
! _copyVariableSetStmt(const VariableSetStmt *from)
  {
  	VariableSetStmt *newnode = makeNode(VariableSetStmt);
  
***************
*** 3276,3282 **** _copyVariableSetStmt(VariableSetStmt *from)
  }
  
  static VariableShowStmt *
! _copyVariableShowStmt(VariableShowStmt *from)
  {
  	VariableShowStmt *newnode = makeNode(VariableShowStmt);
  
--- 3276,3282 ----
  }
  
  static VariableShowStmt *
! _copyVariableShowStmt(const VariableShowStmt *from)
  {
  	VariableShowStmt *newnode = makeNode(VariableShowStmt);
  
***************
*** 3286,3292 **** _copyVariableShowStmt(VariableShowStmt *from)
  }
  
  static DiscardStmt *
! _copyDiscardStmt(DiscardStmt *from)
  {
  	DiscardStmt *newnode = makeNode(DiscardStmt);
  
--- 3286,3292 ----
  }
  
  static DiscardStmt *
! _copyDiscardStmt(const DiscardStmt *from)
  {
  	DiscardStmt *newnode = makeNode(DiscardStmt);
  
***************
*** 3296,3302 **** _copyDiscardStmt(DiscardStmt *from)
  }
  
  static CreateTableSpaceStmt *
! _copyCreateTableSpaceStmt(CreateTableSpaceStmt *from)
  {
  	CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
  
--- 3296,3302 ----
  }
  
  static CreateTableSpaceStmt *
! _copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from)
  {
  	CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
  
***************
*** 3308,3314 **** _copyCreateTableSpaceStmt(CreateTableSpaceStmt *from)
  }
  
  static DropTableSpaceStmt *
! _copyDropTableSpaceStmt(DropTableSpaceStmt *from)
  {
  	DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
  
--- 3308,3314 ----
  }
  
  static DropTableSpaceStmt *
! _copyDropTableSpaceStmt(const DropTableSpaceStmt *from)
  {
  	DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
  
***************
*** 3319,3325 **** _copyDropTableSpaceStmt(DropTableSpaceStmt *from)
  }
  
  static AlterTableSpaceOptionsStmt *
! _copyAlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt *from)
  {
  	AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);
  
--- 3319,3325 ----
  }
  
  static AlterTableSpaceOptionsStmt *
! _copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from)
  {
  	AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);
  
***************
*** 3331,3337 **** _copyAlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt *from)
  }
  
  static CreateExtensionStmt *
! _copyCreateExtensionStmt(CreateExtensionStmt *from)
  {
  	CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);
  
--- 3331,3337 ----
  }
  
  static CreateExtensionStmt *
! _copyCreateExtensionStmt(const CreateExtensionStmt *from)
  {
  	CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);
  
***************
*** 3343,3349 **** _copyCreateExtensionStmt(CreateExtensionStmt *from)
  }
  
  static AlterExtensionStmt *
! _copyAlterExtensionStmt(AlterExtensionStmt *from)
  {
  	AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);
  
--- 3343,3349 ----
  }
  
  static AlterExtensionStmt *
! _copyAlterExtensionStmt(const AlterExtensionStmt *from)
  {
  	AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);
  
***************
*** 3354,3360 **** _copyAlterExtensionStmt(AlterExtensionStmt *from)
  }
  
  static AlterExtensionContentsStmt *
! _copyAlterExtensionContentsStmt(AlterExtensionContentsStmt *from)
  {
  	AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);
  
--- 3354,3360 ----
  }
  
  static AlterExtensionContentsStmt *
! _copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from)
  {
  	AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);
  
***************
*** 3368,3374 **** _copyAlterExtensionContentsStmt(AlterExtensionContentsStmt *from)
  }
  
  static CreateFdwStmt *
! _copyCreateFdwStmt(CreateFdwStmt *from)
  {
  	CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
  
--- 3368,3374 ----
  }
  
  static CreateFdwStmt *
! _copyCreateFdwStmt(const CreateFdwStmt *from)
  {
  	CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
  
***************
*** 3380,3386 **** _copyCreateFdwStmt(CreateFdwStmt *from)
  }
  
  static AlterFdwStmt *
! _copyAlterFdwStmt(AlterFdwStmt *from)
  {
  	AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
  
--- 3380,3386 ----
  }
  
  static AlterFdwStmt *
! _copyAlterFdwStmt(const AlterFdwStmt *from)
  {
  	AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
  
***************
*** 3392,3398 **** _copyAlterFdwStmt(AlterFdwStmt *from)
  }
  
  static DropFdwStmt *
! _copyDropFdwStmt(DropFdwStmt *from)
  {
  	DropFdwStmt *newnode = makeNode(DropFdwStmt);
  
--- 3392,3398 ----
  }
  
  static DropFdwStmt *
! _copyDropFdwStmt(const DropFdwStmt *from)
  {
  	DropFdwStmt *newnode = makeNode(DropFdwStmt);
  
***************
*** 3404,3410 **** _copyDropFdwStmt(DropFdwStmt *from)
  }
  
  static CreateForeignServerStmt *
! _copyCreateForeignServerStmt(CreateForeignServerStmt *from)
  {
  	CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
  
--- 3404,3410 ----
  }
  
  static CreateForeignServerStmt *
! _copyCreateForeignServerStmt(const CreateForeignServerStmt *from)
  {
  	CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
  
***************
*** 3418,3424 **** _copyCreateForeignServerStmt(CreateForeignServerStmt *from)
  }
  
  static AlterForeignServerStmt *
! _copyAlterForeignServerStmt(AlterForeignServerStmt *from)
  {
  	AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
  
--- 3418,3424 ----
  }
  
  static AlterForeignServerStmt *
! _copyAlterForeignServerStmt(const AlterForeignServerStmt *from)
  {
  	AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
  
***************
*** 3431,3437 **** _copyAlterForeignServerStmt(AlterForeignServerStmt *from)
  }
  
  static DropForeignServerStmt *
! _copyDropForeignServerStmt(DropForeignServerStmt *from)
  {
  	DropForeignServerStmt *newnode = makeNode(DropForeignServerStmt);
  
--- 3431,3437 ----
  }
  
  static DropForeignServerStmt *
! _copyDropForeignServerStmt(const DropForeignServerStmt *from)
  {
  	DropForeignServerStmt *newnode = makeNode(DropForeignServerStmt);
  
***************
*** 3443,3449 **** _copyDropForeignServerStmt(DropForeignServerStmt *from)
  }
  
  static CreateUserMappingStmt *
! _copyCreateUserMappingStmt(CreateUserMappingStmt *from)
  {
  	CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
  
--- 3443,3449 ----
  }
  
  static CreateUserMappingStmt *
! _copyCreateUserMappingStmt(const CreateUserMappingStmt *from)
  {
  	CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
  
***************
*** 3455,3461 **** _copyCreateUserMappingStmt(CreateUserMappingStmt *from)
  }
  
  static AlterUserMappingStmt *
! _copyAlterUserMappingStmt(AlterUserMappingStmt *from)
  {
  	AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
  
--- 3455,3461 ----
  }
  
  static AlterUserMappingStmt *
! _copyAlterUserMappingStmt(const AlterUserMappingStmt *from)
  {
  	AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
  
***************
*** 3467,3473 **** _copyAlterUserMappingStmt(AlterUserMappingStmt *from)
  }
  
  static DropUserMappingStmt *
! _copyDropUserMappingStmt(DropUserMappingStmt *from)
  {
  	DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
  
--- 3467,3473 ----
  }
  
  static DropUserMappingStmt *
! _copyDropUserMappingStmt(const DropUserMappingStmt *from)
  {
  	DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
  
***************
*** 3479,3485 **** _copyDropUserMappingStmt(DropUserMappingStmt *from)
  }
  
  static CreateForeignTableStmt *
! _copyCreateForeignTableStmt(CreateForeignTableStmt *from)
  {
  	CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
  
--- 3479,3485 ----
  }
  
  static CreateForeignTableStmt *
! _copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
  {
  	CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
  
***************
*** 3492,3498 **** _copyCreateForeignTableStmt(CreateForeignTableStmt *from)
  }
  
  static CreateTrigStmt *
! _copyCreateTrigStmt(CreateTrigStmt *from)
  {
  	CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
  
--- 3492,3498 ----
  }
  
  static CreateTrigStmt *
! _copyCreateTrigStmt(const CreateTrigStmt *from)
  {
  	CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
  
***************
*** 3514,3520 **** _copyCreateTrigStmt(CreateTrigStmt *from)
  }
  
  static DropPropertyStmt *
! _copyDropPropertyStmt(DropPropertyStmt *from)
  {
  	DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
  
--- 3514,3520 ----
  }
  
  static DropPropertyStmt *
! _copyDropPropertyStmt(const DropPropertyStmt *from)
  {
  	DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
  
***************
*** 3528,3534 **** _copyDropPropertyStmt(DropPropertyStmt *from)
  }
  
  static CreatePLangStmt *
! _copyCreatePLangStmt(CreatePLangStmt *from)
  {
  	CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
  
--- 3528,3534 ----
  }
  
  static CreatePLangStmt *
! _copyCreatePLangStmt(const CreatePLangStmt *from)
  {
  	CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
  
***************
*** 3543,3549 **** _copyCreatePLangStmt(CreatePLangStmt *from)
  }
  
  static DropPLangStmt *
! _copyDropPLangStmt(DropPLangStmt *from)
  {
  	DropPLangStmt *newnode = makeNode(DropPLangStmt);
  
--- 3543,3549 ----
  }
  
  static DropPLangStmt *
! _copyDropPLangStmt(const DropPLangStmt *from)
  {
  	DropPLangStmt *newnode = makeNode(DropPLangStmt);
  
***************
*** 3555,3561 **** _copyDropPLangStmt(DropPLangStmt *from)
  }
  
  static CreateRoleStmt *
! _copyCreateRoleStmt(CreateRoleStmt *from)
  {
  	CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
  
--- 3555,3561 ----
  }
  
  static CreateRoleStmt *
! _copyCreateRoleStmt(const CreateRoleStmt *from)
  {
  	CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
  
***************
*** 3567,3573 **** _copyCreateRoleStmt(CreateRoleStmt *from)
  }
  
  static AlterRoleStmt *
! _copyAlterRoleStmt(AlterRoleStmt *from)
  {
  	AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
  
--- 3567,3573 ----
  }
  
  static AlterRoleStmt *
! _copyAlterRoleStmt(const AlterRoleStmt *from)
  {
  	AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
  
***************
*** 3579,3585 **** _copyAlterRoleStmt(AlterRoleStmt *from)
  }
  
  static AlterRoleSetStmt *
! _copyAlterRoleSetStmt(AlterRoleSetStmt *from)
  {
  	AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
  
--- 3579,3585 ----
  }
  
  static AlterRoleSetStmt *
! _copyAlterRoleSetStmt(const AlterRoleSetStmt *from)
  {
  	AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
  
***************
*** 3591,3597 **** _copyAlterRoleSetStmt(AlterRoleSetStmt *from)
  }
  
  static DropRoleStmt *
! _copyDropRoleStmt(DropRoleStmt *from)
  {
  	DropRoleStmt *newnode = makeNode(DropRoleStmt);
  
--- 3591,3597 ----
  }
  
  static DropRoleStmt *
! _copyDropRoleStmt(const DropRoleStmt *from)
  {
  	DropRoleStmt *newnode = makeNode(DropRoleStmt);
  
***************
*** 3602,3608 **** _copyDropRoleStmt(DropRoleStmt *from)
  }
  
  static LockStmt *
! _copyLockStmt(LockStmt *from)
  {
  	LockStmt   *newnode = makeNode(LockStmt);
  
--- 3602,3608 ----
  }
  
  static LockStmt *
! _copyLockStmt(const LockStmt *from)
  {
  	LockStmt   *newnode = makeNode(LockStmt);
  
***************
*** 3614,3620 **** _copyLockStmt(LockStmt *from)
  }
  
  static ConstraintsSetStmt *
! _copyConstraintsSetStmt(ConstraintsSetStmt *from)
  {
  	ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
  
--- 3614,3620 ----
  }
  
  static ConstraintsSetStmt *
! _copyConstraintsSetStmt(const ConstraintsSetStmt *from)
  {
  	ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
  
***************
*** 3625,3631 **** _copyConstraintsSetStmt(ConstraintsSetStmt *from)
  }
  
  static ReindexStmt *
! _copyReindexStmt(ReindexStmt *from)
  {
  	ReindexStmt *newnode = makeNode(ReindexStmt);
  
--- 3625,3631 ----
  }
  
  static ReindexStmt *
! _copyReindexStmt(const ReindexStmt *from)
  {
  	ReindexStmt *newnode = makeNode(ReindexStmt);
  
***************
*** 3639,3645 **** _copyReindexStmt(ReindexStmt *from)
  }
  
  static CreateSchemaStmt *
! _copyCreateSchemaStmt(CreateSchemaStmt *from)
  {
  	CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
  
--- 3639,3645 ----
  }
  
  static CreateSchemaStmt *
! _copyCreateSchemaStmt(const CreateSchemaStmt *from)
  {
  	CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
  
***************
*** 3651,3657 **** _copyCreateSchemaStmt(CreateSchemaStmt *from)
  }
  
  static CreateConversionStmt *
! _copyCreateConversionStmt(CreateConversionStmt *from)
  {
  	CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
  
--- 3651,3657 ----
  }
  
  static CreateConversionStmt *
! _copyCreateConversionStmt(const CreateConversionStmt *from)
  {
  	CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
  
***************
*** 3665,3671 **** _copyCreateConversionStmt(CreateConversionStmt *from)
  }
  
  static CreateCastStmt *
! _copyCreateCastStmt(CreateCastStmt *from)
  {
  	CreateCastStmt *newnode = makeNode(CreateCastStmt);
  
--- 3665,3671 ----
  }
  
  static CreateCastStmt *
! _copyCreateCastStmt(const CreateCastStmt *from)
  {
  	CreateCastStmt *newnode = makeNode(CreateCastStmt);
  
***************
*** 3679,3685 **** _copyCreateCastStmt(CreateCastStmt *from)
  }
  
  static DropCastStmt *
! _copyDropCastStmt(DropCastStmt *from)
  {
  	DropCastStmt *newnode = makeNode(DropCastStmt);
  
--- 3679,3685 ----
  }
  
  static DropCastStmt *
! _copyDropCastStmt(const DropCastStmt *from)
  {
  	DropCastStmt *newnode = makeNode(DropCastStmt);
  
***************
*** 3692,3698 **** _copyDropCastStmt(DropCastStmt *from)
  }
  
  static PrepareStmt *
! _copyPrepareStmt(PrepareStmt *from)
  {
  	PrepareStmt *newnode = makeNode(PrepareStmt);
  
--- 3692,3698 ----
  }
  
  static PrepareStmt *
! _copyPrepareStmt(const PrepareStmt *from)
  {
  	PrepareStmt *newnode = makeNode(PrepareStmt);
  
***************
*** 3704,3710 **** _copyPrepareStmt(PrepareStmt *from)
  }
  
  static ExecuteStmt *
! _copyExecuteStmt(ExecuteStmt *from)
  {
  	ExecuteStmt *newnode = makeNode(ExecuteStmt);
  
--- 3704,3710 ----
  }
  
  static ExecuteStmt *
! _copyExecuteStmt(const ExecuteStmt *from)
  {
  	ExecuteStmt *newnode = makeNode(ExecuteStmt);
  
***************
*** 3716,3722 **** _copyExecuteStmt(ExecuteStmt *from)
  }
  
  static DeallocateStmt *
! _copyDeallocateStmt(DeallocateStmt *from)
  {
  	DeallocateStmt *newnode = makeNode(DeallocateStmt);
  
--- 3716,3722 ----
  }
  
  static DeallocateStmt *
! _copyDeallocateStmt(const DeallocateStmt *from)
  {
  	DeallocateStmt *newnode = makeNode(DeallocateStmt);
  
***************
*** 3726,3732 **** _copyDeallocateStmt(DeallocateStmt *from)
  }
  
  static DropOwnedStmt *
! _copyDropOwnedStmt(DropOwnedStmt *from)
  {
  	DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
  
--- 3726,3732 ----
  }
  
  static DropOwnedStmt *
! _copyDropOwnedStmt(const DropOwnedStmt *from)
  {
  	DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
  
***************
*** 3737,3743 **** _copyDropOwnedStmt(DropOwnedStmt *from)
  }
  
  static ReassignOwnedStmt *
! _copyReassignOwnedStmt(ReassignOwnedStmt *from)
  {
  	ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
  
--- 3737,3743 ----
  }
  
  static ReassignOwnedStmt *
! _copyReassignOwnedStmt(const ReassignOwnedStmt *from)
  {
  	ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
  
***************
*** 3748,3754 **** _copyReassignOwnedStmt(ReassignOwnedStmt *from)
  }
  
  static AlterTSDictionaryStmt *
! _copyAlterTSDictionaryStmt(AlterTSDictionaryStmt *from)
  {
  	AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);
  
--- 3748,3754 ----
  }
  
  static AlterTSDictionaryStmt *
! _copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from)
  {
  	AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);
  
***************
*** 3759,3765 **** _copyAlterTSDictionaryStmt(AlterTSDictionaryStmt *from)
  }
  
  static AlterTSConfigurationStmt *
! _copyAlterTSConfigurationStmt(AlterTSConfigurationStmt *from)
  {
  	AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);
  
--- 3759,3765 ----
  }
  
  static AlterTSConfigurationStmt *
! _copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from)
  {
  	AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);
  
***************
*** 3820,3826 **** _copyList(List *from)
   * ****************************************************************
   */
  static Value *
! _copyValue(Value *from)
  {
  	Value	   *newnode = makeNode(Value);
  
--- 3820,3826 ----
   * ****************************************************************
   */
  static Value *
! _copyValue(const Value *from)
  {
  	Value	   *newnode = makeNode(Value);
  
***************
*** 4585,4591 **** copyObject(void *from)
  
  		default:
  			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
! 			retval = from;		/* keep compiler quiet */
  			break;
  	}
  
--- 4585,4591 ----
  
  		default:
  			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
! 			retval = NULL;		/* keep compiler quiet */
  			break;
  	}
  
*** a/src/backend/nodes/equalfuncs.c
--- b/src/backend/nodes/equalfuncs.c
***************
*** 89,95 ****
   */
  
  static bool
! _equalAlias(Alias *a, Alias *b)
  {
  	COMPARE_STRING_FIELD(aliasname);
  	COMPARE_NODE_FIELD(colnames);
--- 89,95 ----
   */
  
  static bool
! _equalAlias(const Alias *a, const Alias *b)
  {
  	COMPARE_STRING_FIELD(aliasname);
  	COMPARE_NODE_FIELD(colnames);
***************
*** 98,104 **** _equalAlias(Alias *a, Alias *b)
  }
  
  static bool
! _equalRangeVar(RangeVar *a, RangeVar *b)
  {
  	COMPARE_STRING_FIELD(catalogname);
  	COMPARE_STRING_FIELD(schemaname);
--- 98,104 ----
  }
  
  static bool
! _equalRangeVar(const RangeVar *a, const RangeVar *b)
  {
  	COMPARE_STRING_FIELD(catalogname);
  	COMPARE_STRING_FIELD(schemaname);
***************
*** 112,118 **** _equalRangeVar(RangeVar *a, RangeVar *b)
  }
  
  static bool
! _equalIntoClause(IntoClause *a, IntoClause *b)
  {
  	COMPARE_NODE_FIELD(rel);
  	COMPARE_NODE_FIELD(colNames);
--- 112,118 ----
  }
  
  static bool
! _equalIntoClause(const IntoClause *a, const IntoClause *b)
  {
  	COMPARE_NODE_FIELD(rel);
  	COMPARE_NODE_FIELD(colNames);
***************
*** 131,137 **** _equalIntoClause(IntoClause *a, IntoClause *b)
   */
  
  static bool
! _equalVar(Var *a, Var *b)
  {
  	COMPARE_SCALAR_FIELD(varno);
  	COMPARE_SCALAR_FIELD(varattno);
--- 131,137 ----
   */
  
  static bool
! _equalVar(const Var *a, const Var *b)
  {
  	COMPARE_SCALAR_FIELD(varno);
  	COMPARE_SCALAR_FIELD(varattno);
***************
*** 147,153 **** _equalVar(Var *a, Var *b)
  }
  
  static bool
! _equalConst(Const *a, Const *b)
  {
  	COMPARE_SCALAR_FIELD(consttype);
  	COMPARE_SCALAR_FIELD(consttypmod);
--- 147,153 ----
  }
  
  static bool
! _equalConst(const Const *a, const Const *b)
  {
  	COMPARE_SCALAR_FIELD(consttype);
  	COMPARE_SCALAR_FIELD(consttypmod);
***************
*** 168,174 **** _equalConst(Const *a, Const *b)
  }
  
  static bool
! _equalParam(Param *a, Param *b)
  {
  	COMPARE_SCALAR_FIELD(paramkind);
  	COMPARE_SCALAR_FIELD(paramid);
--- 168,174 ----
  }
  
  static bool
! _equalParam(const Param *a, const Param *b)
  {
  	COMPARE_SCALAR_FIELD(paramkind);
  	COMPARE_SCALAR_FIELD(paramid);
***************
*** 181,187 **** _equalParam(Param *a, Param *b)
  }
  
  static bool
! _equalAggref(Aggref *a, Aggref *b)
  {
  	COMPARE_SCALAR_FIELD(aggfnoid);
  	COMPARE_SCALAR_FIELD(aggtype);
--- 181,187 ----
  }
  
  static bool
! _equalAggref(const Aggref *a, const Aggref *b)
  {
  	COMPARE_SCALAR_FIELD(aggfnoid);
  	COMPARE_SCALAR_FIELD(aggtype);
***************
*** 198,204 **** _equalAggref(Aggref *a, Aggref *b)
  }
  
  static bool
! _equalWindowFunc(WindowFunc *a, WindowFunc *b)
  {
  	COMPARE_SCALAR_FIELD(winfnoid);
  	COMPARE_SCALAR_FIELD(wintype);
--- 198,204 ----
  }
  
  static bool
! _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
  {
  	COMPARE_SCALAR_FIELD(winfnoid);
  	COMPARE_SCALAR_FIELD(wintype);
***************
*** 214,220 **** _equalWindowFunc(WindowFunc *a, WindowFunc *b)
  }
  
  static bool
! _equalArrayRef(ArrayRef *a, ArrayRef *b)
  {
  	COMPARE_SCALAR_FIELD(refarraytype);
  	COMPARE_SCALAR_FIELD(refelemtype);
--- 214,220 ----
  }
  
  static bool
! _equalArrayRef(const ArrayRef *a, const ArrayRef *b)
  {
  	COMPARE_SCALAR_FIELD(refarraytype);
  	COMPARE_SCALAR_FIELD(refelemtype);
***************
*** 229,235 **** _equalArrayRef(ArrayRef *a, ArrayRef *b)
  }
  
  static bool
! _equalFuncExpr(FuncExpr *a, FuncExpr *b)
  {
  	COMPARE_SCALAR_FIELD(funcid);
  	COMPARE_SCALAR_FIELD(funcresulttype);
--- 229,235 ----
  }
  
  static bool
! _equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
  {
  	COMPARE_SCALAR_FIELD(funcid);
  	COMPARE_SCALAR_FIELD(funcresulttype);
***************
*** 253,259 **** _equalFuncExpr(FuncExpr *a, FuncExpr *b)
  }
  
  static bool
! _equalNamedArgExpr(NamedArgExpr *a, NamedArgExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_STRING_FIELD(name);
--- 253,259 ----
  }
  
  static bool
! _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_STRING_FIELD(name);
***************
*** 264,270 **** _equalNamedArgExpr(NamedArgExpr *a, NamedArgExpr *b)
  }
  
  static bool
! _equalOpExpr(OpExpr *a, OpExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
--- 264,270 ----
  }
  
  static bool
! _equalOpExpr(const OpExpr *a, const OpExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
***************
*** 290,296 **** _equalOpExpr(OpExpr *a, OpExpr *b)
  }
  
  static bool
! _equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
--- 290,296 ----
  }
  
  static bool
! _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
***************
*** 316,322 **** _equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
  }
  
  static bool
! _equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
--- 316,322 ----
  }
  
  static bool
! _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
***************
*** 342,348 **** _equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
  }
  
  static bool
! _equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
--- 342,348 ----
  }
  
  static bool
! _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
  {
  	COMPARE_SCALAR_FIELD(opno);
  
***************
*** 366,372 **** _equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
  }
  
  static bool
! _equalBoolExpr(BoolExpr *a, BoolExpr *b)
  {
  	COMPARE_SCALAR_FIELD(boolop);
  	COMPARE_NODE_FIELD(args);
--- 366,372 ----
  }
  
  static bool
! _equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
  {
  	COMPARE_SCALAR_FIELD(boolop);
  	COMPARE_NODE_FIELD(args);
***************
*** 376,382 **** _equalBoolExpr(BoolExpr *a, BoolExpr *b)
  }
  
  static bool
! _equalSubLink(SubLink *a, SubLink *b)
  {
  	COMPARE_SCALAR_FIELD(subLinkType);
  	COMPARE_NODE_FIELD(testexpr);
--- 376,382 ----
  }
  
  static bool
! _equalSubLink(const SubLink *a, const SubLink *b)
  {
  	COMPARE_SCALAR_FIELD(subLinkType);
  	COMPARE_NODE_FIELD(testexpr);
***************
*** 388,394 **** _equalSubLink(SubLink *a, SubLink *b)
  }
  
  static bool
! _equalSubPlan(SubPlan *a, SubPlan *b)
  {
  	COMPARE_SCALAR_FIELD(subLinkType);
  	COMPARE_NODE_FIELD(testexpr);
--- 388,394 ----
  }
  
  static bool
! _equalSubPlan(const SubPlan *a, const SubPlan *b)
  {
  	COMPARE_SCALAR_FIELD(subLinkType);
  	COMPARE_NODE_FIELD(testexpr);
***************
*** 410,416 **** _equalSubPlan(SubPlan *a, SubPlan *b)
  }
  
  static bool
! _equalAlternativeSubPlan(AlternativeSubPlan *a, AlternativeSubPlan *b)
  {
  	COMPARE_NODE_FIELD(subplans);
  
--- 410,416 ----
  }
  
  static bool
! _equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
  {
  	COMPARE_NODE_FIELD(subplans);
  
***************
*** 418,424 **** _equalAlternativeSubPlan(AlternativeSubPlan *a, AlternativeSubPlan *b)
  }
  
  static bool
! _equalFieldSelect(FieldSelect *a, FieldSelect *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(fieldnum);
--- 418,424 ----
  }
  
  static bool
! _equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(fieldnum);
***************
*** 430,436 **** _equalFieldSelect(FieldSelect *a, FieldSelect *b)
  }
  
  static bool
! _equalFieldStore(FieldStore *a, FieldStore *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(newvals);
--- 430,436 ----
  }
  
  static bool
! _equalFieldStore(const FieldStore *a, const FieldStore *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(newvals);
***************
*** 441,447 **** _equalFieldStore(FieldStore *a, FieldStore *b)
  }
  
  static bool
! _equalRelabelType(RelabelType *a, RelabelType *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
--- 441,447 ----
  }
  
  static bool
! _equalRelabelType(const RelabelType *a, const RelabelType *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
***************
*** 463,469 **** _equalRelabelType(RelabelType *a, RelabelType *b)
  }
  
  static bool
! _equalCoerceViaIO(CoerceViaIO *a, CoerceViaIO *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
--- 463,469 ----
  }
  
  static bool
! _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
***************
*** 484,490 **** _equalCoerceViaIO(CoerceViaIO *a, CoerceViaIO *b)
  }
  
  static bool
! _equalArrayCoerceExpr(ArrayCoerceExpr *a, ArrayCoerceExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(elemfuncid);
--- 484,490 ----
  }
  
  static bool
! _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(elemfuncid);
***************
*** 508,514 **** _equalArrayCoerceExpr(ArrayCoerceExpr *a, ArrayCoerceExpr *b)
  }
  
  static bool
! _equalConvertRowtypeExpr(ConvertRowtypeExpr *a, ConvertRowtypeExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
--- 508,514 ----
  }
  
  static bool
! _equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
***************
*** 528,534 **** _equalConvertRowtypeExpr(ConvertRowtypeExpr *a, ConvertRowtypeExpr *b)
  }
  
  static bool
! _equalCollateExpr(CollateExpr *a, CollateExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(collOid);
--- 528,534 ----
  }
  
  static bool
! _equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(collOid);
***************
*** 538,544 **** _equalCollateExpr(CollateExpr *a, CollateExpr *b)
  }
  
  static bool
! _equalCaseExpr(CaseExpr *a, CaseExpr *b)
  {
  	COMPARE_SCALAR_FIELD(casetype);
  	COMPARE_SCALAR_FIELD(casecollid);
--- 538,544 ----
  }
  
  static bool
! _equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
  {
  	COMPARE_SCALAR_FIELD(casetype);
  	COMPARE_SCALAR_FIELD(casecollid);
***************
*** 551,557 **** _equalCaseExpr(CaseExpr *a, CaseExpr *b)
  }
  
  static bool
! _equalCaseWhen(CaseWhen *a, CaseWhen *b)
  {
  	COMPARE_NODE_FIELD(expr);
  	COMPARE_NODE_FIELD(result);
--- 551,557 ----
  }
  
  static bool
! _equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
  {
  	COMPARE_NODE_FIELD(expr);
  	COMPARE_NODE_FIELD(result);
***************
*** 561,567 **** _equalCaseWhen(CaseWhen *a, CaseWhen *b)
  }
  
  static bool
! _equalCaseTestExpr(CaseTestExpr *a, CaseTestExpr *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
--- 561,567 ----
  }
  
  static bool
! _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
***************
*** 571,577 **** _equalCaseTestExpr(CaseTestExpr *a, CaseTestExpr *b)
  }
  
  static bool
! _equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
  {
  	COMPARE_SCALAR_FIELD(array_typeid);
  	COMPARE_SCALAR_FIELD(array_collid);
--- 571,577 ----
  }
  
  static bool
! _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
  {
  	COMPARE_SCALAR_FIELD(array_typeid);
  	COMPARE_SCALAR_FIELD(array_collid);
***************
*** 584,590 **** _equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
  }
  
  static bool
! _equalRowExpr(RowExpr *a, RowExpr *b)
  {
  	COMPARE_NODE_FIELD(args);
  	COMPARE_SCALAR_FIELD(row_typeid);
--- 584,590 ----
  }
  
  static bool
! _equalRowExpr(const RowExpr *a, const RowExpr *b)
  {
  	COMPARE_NODE_FIELD(args);
  	COMPARE_SCALAR_FIELD(row_typeid);
***************
*** 605,611 **** _equalRowExpr(RowExpr *a, RowExpr *b)
  }
  
  static bool
! _equalRowCompareExpr(RowCompareExpr *a, RowCompareExpr *b)
  {
  	COMPARE_SCALAR_FIELD(rctype);
  	COMPARE_NODE_FIELD(opnos);
--- 605,611 ----
  }
  
  static bool
! _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
  {
  	COMPARE_SCALAR_FIELD(rctype);
  	COMPARE_NODE_FIELD(opnos);
***************
*** 618,624 **** _equalRowCompareExpr(RowCompareExpr *a, RowCompareExpr *b)
  }
  
  static bool
! _equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
  {
  	COMPARE_SCALAR_FIELD(coalescetype);
  	COMPARE_SCALAR_FIELD(coalescecollid);
--- 618,624 ----
  }
  
  static bool
! _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
  {
  	COMPARE_SCALAR_FIELD(coalescetype);
  	COMPARE_SCALAR_FIELD(coalescecollid);
***************
*** 629,635 **** _equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
  }
  
  static bool
! _equalMinMaxExpr(MinMaxExpr *a, MinMaxExpr *b)
  {
  	COMPARE_SCALAR_FIELD(minmaxtype);
  	COMPARE_SCALAR_FIELD(minmaxcollid);
--- 629,635 ----
  }
  
  static bool
! _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
  {
  	COMPARE_SCALAR_FIELD(minmaxtype);
  	COMPARE_SCALAR_FIELD(minmaxcollid);
***************
*** 642,648 **** _equalMinMaxExpr(MinMaxExpr *a, MinMaxExpr *b)
  }
  
  static bool
! _equalXmlExpr(XmlExpr *a, XmlExpr *b)
  {
  	COMPARE_SCALAR_FIELD(op);
  	COMPARE_STRING_FIELD(name);
--- 642,648 ----
  }
  
  static bool
! _equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
  {
  	COMPARE_SCALAR_FIELD(op);
  	COMPARE_STRING_FIELD(name);
***************
*** 658,664 **** _equalXmlExpr(XmlExpr *a, XmlExpr *b)
  }
  
  static bool
! _equalNullTest(NullTest *a, NullTest *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(nulltesttype);
--- 658,664 ----
  }
  
  static bool
! _equalNullTest(const NullTest *a, const NullTest *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(nulltesttype);
***************
*** 668,674 **** _equalNullTest(NullTest *a, NullTest *b)
  }
  
  static bool
! _equalBooleanTest(BooleanTest *a, BooleanTest *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(booltesttype);
--- 668,674 ----
  }
  
  static bool
! _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(booltesttype);
***************
*** 677,683 **** _equalBooleanTest(BooleanTest *a, BooleanTest *b)
  }
  
  static bool
! _equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
--- 677,683 ----
  }
  
  static bool
! _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_SCALAR_FIELD(resulttype);
***************
*** 699,705 **** _equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
  }
  
  static bool
! _equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
--- 699,705 ----
  }
  
  static bool
! _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
***************
*** 710,716 **** _equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
  }
  
  static bool
! _equalSetToDefault(SetToDefault *a, SetToDefault *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
--- 710,716 ----
  }
  
  static bool
! _equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
***************
*** 721,727 **** _equalSetToDefault(SetToDefault *a, SetToDefault *b)
  }
  
  static bool
! _equalCurrentOfExpr(CurrentOfExpr *a, CurrentOfExpr *b)
  {
  	COMPARE_SCALAR_FIELD(cvarno);
  	COMPARE_STRING_FIELD(cursor_name);
--- 721,727 ----
  }
  
  static bool
! _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
  {
  	COMPARE_SCALAR_FIELD(cvarno);
  	COMPARE_STRING_FIELD(cursor_name);
***************
*** 731,737 **** _equalCurrentOfExpr(CurrentOfExpr *a, CurrentOfExpr *b)
  }
  
  static bool
! _equalTargetEntry(TargetEntry *a, TargetEntry *b)
  {
  	COMPARE_NODE_FIELD(expr);
  	COMPARE_SCALAR_FIELD(resno);
--- 731,737 ----
  }
  
  static bool
! _equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
  {
  	COMPARE_NODE_FIELD(expr);
  	COMPARE_SCALAR_FIELD(resno);
***************
*** 745,751 **** _equalTargetEntry(TargetEntry *a, TargetEntry *b)
  }
  
  static bool
! _equalRangeTblRef(RangeTblRef *a, RangeTblRef *b)
  {
  	COMPARE_SCALAR_FIELD(rtindex);
  
--- 745,751 ----
  }
  
  static bool
! _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
  {
  	COMPARE_SCALAR_FIELD(rtindex);
  
***************
*** 753,759 **** _equalRangeTblRef(RangeTblRef *a, RangeTblRef *b)
  }
  
  static bool
! _equalJoinExpr(JoinExpr *a, JoinExpr *b)
  {
  	COMPARE_SCALAR_FIELD(jointype);
  	COMPARE_SCALAR_FIELD(isNatural);
--- 753,759 ----
  }
  
  static bool
! _equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
  {
  	COMPARE_SCALAR_FIELD(jointype);
  	COMPARE_SCALAR_FIELD(isNatural);
***************
*** 768,774 **** _equalJoinExpr(JoinExpr *a, JoinExpr *b)
  }
  
  static bool
! _equalFromExpr(FromExpr *a, FromExpr *b)
  {
  	COMPARE_NODE_FIELD(fromlist);
  	COMPARE_NODE_FIELD(quals);
--- 768,774 ----
  }
  
  static bool
! _equalFromExpr(const FromExpr *a, const FromExpr *b)
  {
  	COMPARE_NODE_FIELD(fromlist);
  	COMPARE_NODE_FIELD(quals);
***************
*** 782,788 **** _equalFromExpr(FromExpr *a, FromExpr *b)
   */
  
  static bool
! _equalPathKey(PathKey *a, PathKey *b)
  {
  	/*
  	 * This is normally used on non-canonicalized PathKeys, so must chase up
--- 782,788 ----
   */
  
  static bool
! _equalPathKey(const PathKey *a, const PathKey *b)
  {
  	/*
  	 * This is normally used on non-canonicalized PathKeys, so must chase up
***************
*** 808,814 **** _equalPathKey(PathKey *a, PathKey *b)
  }
  
  static bool
! _equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
  {
  	COMPARE_NODE_FIELD(clause);
  	COMPARE_SCALAR_FIELD(is_pushed_down);
--- 808,814 ----
  }
  
  static bool
! _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
  {
  	COMPARE_NODE_FIELD(clause);
  	COMPARE_SCALAR_FIELD(is_pushed_down);
***************
*** 825,831 **** _equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
  }
  
  static bool
! _equalPlaceHolderVar(PlaceHolderVar *a, PlaceHolderVar *b)
  {
  	/*
  	 * We intentionally do not compare phexpr.	Two PlaceHolderVars with the
--- 825,831 ----
  }
  
  static bool
! _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
  {
  	/*
  	 * We intentionally do not compare phexpr.	Two PlaceHolderVars with the
***************
*** 846,852 **** _equalPlaceHolderVar(PlaceHolderVar *a, PlaceHolderVar *b)
  }
  
  static bool
! _equalSpecialJoinInfo(SpecialJoinInfo *a, SpecialJoinInfo *b)
  {
  	COMPARE_BITMAPSET_FIELD(min_lefthand);
  	COMPARE_BITMAPSET_FIELD(min_righthand);
--- 846,852 ----
  }
  
  static bool
! _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
  {
  	COMPARE_BITMAPSET_FIELD(min_lefthand);
  	COMPARE_BITMAPSET_FIELD(min_righthand);
***************
*** 861,867 **** _equalSpecialJoinInfo(SpecialJoinInfo *a, SpecialJoinInfo *b)
  }
  
  static bool
! _equalAppendRelInfo(AppendRelInfo *a, AppendRelInfo *b)
  {
  	COMPARE_SCALAR_FIELD(parent_relid);
  	COMPARE_SCALAR_FIELD(child_relid);
--- 861,867 ----
  }
  
  static bool
! _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
  {
  	COMPARE_SCALAR_FIELD(parent_relid);
  	COMPARE_SCALAR_FIELD(child_relid);
***************
*** 874,880 **** _equalAppendRelInfo(AppendRelInfo *a, AppendRelInfo *b)
  }
  
  static bool
! _equalPlaceHolderInfo(PlaceHolderInfo *a, PlaceHolderInfo *b)
  {
  	COMPARE_SCALAR_FIELD(phid);
  	COMPARE_NODE_FIELD(ph_var);
--- 874,880 ----
  }
  
  static bool
! _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
  {
  	COMPARE_SCALAR_FIELD(phid);
  	COMPARE_NODE_FIELD(ph_var);
***************
*** 892,898 **** _equalPlaceHolderInfo(PlaceHolderInfo *a, PlaceHolderInfo *b)
   */
  
  static bool
! _equalQuery(Query *a, Query *b)
  {
  	COMPARE_SCALAR_FIELD(commandType);
  	COMPARE_SCALAR_FIELD(querySource);
--- 892,898 ----
   */
  
  static bool
! _equalQuery(const Query *a, const Query *b)
  {
  	COMPARE_SCALAR_FIELD(commandType);
  	COMPARE_SCALAR_FIELD(querySource);
***************
*** 927,933 **** _equalQuery(Query *a, Query *b)
  }
  
  static bool
! _equalInsertStmt(InsertStmt *a, InsertStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(cols);
--- 927,933 ----
  }
  
  static bool
! _equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(cols);
***************
*** 939,945 **** _equalInsertStmt(InsertStmt *a, InsertStmt *b)
  }
  
  static bool
! _equalDeleteStmt(DeleteStmt *a, DeleteStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(usingClause);
--- 939,945 ----
  }
  
  static bool
! _equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(usingClause);
***************
*** 951,957 **** _equalDeleteStmt(DeleteStmt *a, DeleteStmt *b)
  }
  
  static bool
! _equalUpdateStmt(UpdateStmt *a, UpdateStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(targetList);
--- 951,957 ----
  }
  
  static bool
! _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(targetList);
***************
*** 964,970 **** _equalUpdateStmt(UpdateStmt *a, UpdateStmt *b)
  }
  
  static bool
! _equalSelectStmt(SelectStmt *a, SelectStmt *b)
  {
  	COMPARE_NODE_FIELD(distinctClause);
  	COMPARE_NODE_FIELD(intoClause);
--- 964,970 ----
  }
  
  static bool
! _equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
  {
  	COMPARE_NODE_FIELD(distinctClause);
  	COMPARE_NODE_FIELD(intoClause);
***************
*** 989,995 **** _equalSelectStmt(SelectStmt *a, SelectStmt *b)
  }
  
  static bool
! _equalSetOperationStmt(SetOperationStmt *a, SetOperationStmt *b)
  {
  	COMPARE_SCALAR_FIELD(op);
  	COMPARE_SCALAR_FIELD(all);
--- 989,995 ----
  }
  
  static bool
! _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
  {
  	COMPARE_SCALAR_FIELD(op);
  	COMPARE_SCALAR_FIELD(all);
***************
*** 1004,1010 **** _equalSetOperationStmt(SetOperationStmt *a, SetOperationStmt *b)
  }
  
  static bool
! _equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(cmds);
--- 1004,1010 ----
  }
  
  static bool
! _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(cmds);
***************
*** 1014,1020 **** _equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
  }
  
  static bool
! _equalAlterTableCmd(AlterTableCmd *a, AlterTableCmd *b)
  {
  	COMPARE_SCALAR_FIELD(subtype);
  	COMPARE_STRING_FIELD(name);
--- 1014,1020 ----
  }
  
  static bool
! _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
  {
  	COMPARE_SCALAR_FIELD(subtype);
  	COMPARE_STRING_FIELD(name);
***************
*** 1026,1032 **** _equalAlterTableCmd(AlterTableCmd *a, AlterTableCmd *b)
  }
  
  static bool
! _equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
  {
  	COMPARE_SCALAR_FIELD(subtype);
  	COMPARE_NODE_FIELD(typeName);
--- 1026,1032 ----
  }
  
  static bool
! _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
  {
  	COMPARE_SCALAR_FIELD(subtype);
  	COMPARE_NODE_FIELD(typeName);
***************
*** 1038,1044 **** _equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
  }
  
  static bool
! _equalGrantStmt(GrantStmt *a, GrantStmt *b)
  {
  	COMPARE_SCALAR_FIELD(is_grant);
  	COMPARE_SCALAR_FIELD(targtype);
--- 1038,1044 ----
  }
  
  static bool
! _equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
  {
  	COMPARE_SCALAR_FIELD(is_grant);
  	COMPARE_SCALAR_FIELD(targtype);
***************
*** 1053,1059 **** _equalGrantStmt(GrantStmt *a, GrantStmt *b)
  }
  
  static bool
! _equalPrivGrantee(PrivGrantee *a, PrivGrantee *b)
  {
  	COMPARE_STRING_FIELD(rolname);
  
--- 1053,1059 ----
  }
  
  static bool
! _equalPrivGrantee(const PrivGrantee *a, const PrivGrantee *b)
  {
  	COMPARE_STRING_FIELD(rolname);
  
***************
*** 1061,1067 **** _equalPrivGrantee(PrivGrantee *a, PrivGrantee *b)
  }
  
  static bool
! _equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
  {
  	COMPARE_NODE_FIELD(funcname);
  	COMPARE_NODE_FIELD(funcargs);
--- 1061,1067 ----
  }
  
  static bool
! _equalFuncWithArgs(const FuncWithArgs *a, const FuncWithArgs *b)
  {
  	COMPARE_NODE_FIELD(funcname);
  	COMPARE_NODE_FIELD(funcargs);
***************
*** 1070,1076 **** _equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
  }
  
  static bool
! _equalAccessPriv(AccessPriv *a, AccessPriv *b)
  {
  	COMPARE_STRING_FIELD(priv_name);
  	COMPARE_NODE_FIELD(cols);
--- 1070,1076 ----
  }
  
  static bool
! _equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
  {
  	COMPARE_STRING_FIELD(priv_name);
  	COMPARE_NODE_FIELD(cols);
***************
*** 1079,1085 **** _equalAccessPriv(AccessPriv *a, AccessPriv *b)
  }
  
  static bool
! _equalGrantRoleStmt(GrantRoleStmt *a, GrantRoleStmt *b)
  {
  	COMPARE_NODE_FIELD(granted_roles);
  	COMPARE_NODE_FIELD(grantee_roles);
--- 1079,1085 ----
  }
  
  static bool
! _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
  {
  	COMPARE_NODE_FIELD(granted_roles);
  	COMPARE_NODE_FIELD(grantee_roles);
***************
*** 1092,1098 **** _equalGrantRoleStmt(GrantRoleStmt *a, GrantRoleStmt *b)
  }
  
  static bool
! _equalAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *a, AlterDefaultPrivilegesStmt *b)
  {
  	COMPARE_NODE_FIELD(options);
  	COMPARE_NODE_FIELD(action);
--- 1092,1098 ----
  }
  
  static bool
! _equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
  {
  	COMPARE_NODE_FIELD(options);
  	COMPARE_NODE_FIELD(action);
***************
*** 1101,1107 **** _equalAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *a, AlterDefaultPriv
  }
  
  static bool
! _equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
  {
  	COMPARE_STRING_FIELD(portalname);
  	COMPARE_SCALAR_FIELD(options);
--- 1101,1107 ----
  }
  
  static bool
! _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
  {
  	COMPARE_STRING_FIELD(portalname);
  	COMPARE_SCALAR_FIELD(options);
***************
*** 1111,1117 **** _equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
  }
  
  static bool
! _equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b)
  {
  	COMPARE_STRING_FIELD(portalname);
  
--- 1111,1117 ----
  }
  
  static bool
! _equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
  {
  	COMPARE_STRING_FIELD(portalname);
  
***************
*** 1119,1125 **** _equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b)
  }
  
  static bool
! _equalClusterStmt(ClusterStmt *a, ClusterStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(indexname);
--- 1119,1125 ----
  }
  
  static bool
! _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(indexname);
***************
*** 1129,1135 **** _equalClusterStmt(ClusterStmt *a, ClusterStmt *b)
  }
  
  static bool
! _equalCopyStmt(CopyStmt *a, CopyStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(query);
--- 1129,1135 ----
  }
  
  static bool
! _equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(query);
***************
*** 1142,1148 **** _equalCopyStmt(CopyStmt *a, CopyStmt *b)
  }
  
  static bool
! _equalCreateStmt(CreateStmt *a, CreateStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(tableElts);
--- 1142,1148 ----
  }
  
  static bool
! _equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_NODE_FIELD(tableElts);
***************
*** 1158,1164 **** _equalCreateStmt(CreateStmt *a, CreateStmt *b)
  }
  
  static bool
! _equalInhRelation(InhRelation *a, InhRelation *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_SCALAR_FIELD(options);
--- 1158,1164 ----
  }
  
  static bool
! _equalInhRelation(const InhRelation *a, const InhRelation *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_SCALAR_FIELD(options);
***************
*** 1167,1173 **** _equalInhRelation(InhRelation *a, InhRelation *b)
  }
  
  static bool
! _equalDefineStmt(DefineStmt *a, DefineStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_SCALAR_FIELD(oldstyle);
--- 1167,1173 ----
  }
  
  static bool
! _equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_SCALAR_FIELD(oldstyle);
***************
*** 1179,1185 **** _equalDefineStmt(DefineStmt *a, DefineStmt *b)
  }
  
  static bool
! _equalDropStmt(DropStmt *a, DropStmt *b)
  {
  	COMPARE_NODE_FIELD(objects);
  	COMPARE_SCALAR_FIELD(removeType);
--- 1179,1185 ----
  }
  
  static bool
! _equalDropStmt(const DropStmt *a, const DropStmt *b)
  {
  	COMPARE_NODE_FIELD(objects);
  	COMPARE_SCALAR_FIELD(removeType);
***************
*** 1190,1196 **** _equalDropStmt(DropStmt *a, DropStmt *b)
  }
  
  static bool
! _equalTruncateStmt(TruncateStmt *a, TruncateStmt *b)
  {
  	COMPARE_NODE_FIELD(relations);
  	COMPARE_SCALAR_FIELD(restart_seqs);
--- 1190,1196 ----
  }
  
  static bool
! _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
  {
  	COMPARE_NODE_FIELD(relations);
  	COMPARE_SCALAR_FIELD(restart_seqs);
***************
*** 1200,1206 **** _equalTruncateStmt(TruncateStmt *a, TruncateStmt *b)
  }
  
  static bool
! _equalCommentStmt(CommentStmt *a, CommentStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objtype);
  	COMPARE_NODE_FIELD(objname);
--- 1200,1206 ----
  }
  
  static bool
! _equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objtype);
  	COMPARE_NODE_FIELD(objname);
***************
*** 1211,1217 **** _equalCommentStmt(CommentStmt *a, CommentStmt *b)
  }
  
  static bool
! _equalSecLabelStmt(SecLabelStmt *a, SecLabelStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objtype);
  	COMPARE_NODE_FIELD(objname);
--- 1211,1217 ----
  }
  
  static bool
! _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objtype);
  	COMPARE_NODE_FIELD(objname);
***************
*** 1223,1229 **** _equalSecLabelStmt(SecLabelStmt *a, SecLabelStmt *b)
  }
  
  static bool
! _equalFetchStmt(FetchStmt *a, FetchStmt *b)
  {
  	COMPARE_SCALAR_FIELD(direction);
  	COMPARE_SCALAR_FIELD(howMany);
--- 1223,1229 ----
  }
  
  static bool
! _equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
  {
  	COMPARE_SCALAR_FIELD(direction);
  	COMPARE_SCALAR_FIELD(howMany);
***************
*** 1234,1240 **** _equalFetchStmt(FetchStmt *a, FetchStmt *b)
  }
  
  static bool
! _equalIndexStmt(IndexStmt *a, IndexStmt *b)
  {
  	COMPARE_STRING_FIELD(idxname);
  	COMPARE_NODE_FIELD(relation);
--- 1234,1240 ----
  }
  
  static bool
! _equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
  {
  	COMPARE_STRING_FIELD(idxname);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1257,1263 **** _equalIndexStmt(IndexStmt *a, IndexStmt *b)
  }
  
  static bool
! _equalCreateFunctionStmt(CreateFunctionStmt *a, CreateFunctionStmt *b)
  {
  	COMPARE_SCALAR_FIELD(replace);
  	COMPARE_NODE_FIELD(funcname);
--- 1257,1263 ----
  }
  
  static bool
! _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
  {
  	COMPARE_SCALAR_FIELD(replace);
  	COMPARE_NODE_FIELD(funcname);
***************
*** 1270,1276 **** _equalCreateFunctionStmt(CreateFunctionStmt *a, CreateFunctionStmt *b)
  }
  
  static bool
! _equalFunctionParameter(FunctionParameter *a, FunctionParameter *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(argType);
--- 1270,1276 ----
  }
  
  static bool
! _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(argType);
***************
*** 1281,1287 **** _equalFunctionParameter(FunctionParameter *a, FunctionParameter *b)
  }
  
  static bool
! _equalAlterFunctionStmt(AlterFunctionStmt *a, AlterFunctionStmt *b)
  {
  	COMPARE_NODE_FIELD(func);
  	COMPARE_NODE_FIELD(actions);
--- 1281,1287 ----
  }
  
  static bool
! _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
  {
  	COMPARE_NODE_FIELD(func);
  	COMPARE_NODE_FIELD(actions);
***************
*** 1290,1296 **** _equalAlterFunctionStmt(AlterFunctionStmt *a, AlterFunctionStmt *b)
  }
  
  static bool
! _equalRemoveFuncStmt(RemoveFuncStmt *a, RemoveFuncStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(name);
--- 1290,1296 ----
  }
  
  static bool
! _equalRemoveFuncStmt(const RemoveFuncStmt *a, const RemoveFuncStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(name);
***************
*** 1302,1308 **** _equalRemoveFuncStmt(RemoveFuncStmt *a, RemoveFuncStmt *b)
  }
  
  static bool
! _equalDoStmt(DoStmt *a, DoStmt *b)
  {
  	COMPARE_NODE_FIELD(args);
  
--- 1302,1308 ----
  }
  
  static bool
! _equalDoStmt(const DoStmt *a, const DoStmt *b)
  {
  	COMPARE_NODE_FIELD(args);
  
***************
*** 1310,1316 **** _equalDoStmt(DoStmt *a, DoStmt *b)
  }
  
  static bool
! _equalRemoveOpClassStmt(RemoveOpClassStmt *a, RemoveOpClassStmt *b)
  {
  	COMPARE_NODE_FIELD(opclassname);
  	COMPARE_STRING_FIELD(amname);
--- 1310,1316 ----
  }
  
  static bool
! _equalRemoveOpClassStmt(const RemoveOpClassStmt *a, const RemoveOpClassStmt *b)
  {
  	COMPARE_NODE_FIELD(opclassname);
  	COMPARE_STRING_FIELD(amname);
***************
*** 1321,1327 **** _equalRemoveOpClassStmt(RemoveOpClassStmt *a, RemoveOpClassStmt *b)
  }
  
  static bool
! _equalRemoveOpFamilyStmt(RemoveOpFamilyStmt *a, RemoveOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
--- 1321,1327 ----
  }
  
  static bool
! _equalRemoveOpFamilyStmt(const RemoveOpFamilyStmt *a, const RemoveOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
***************
*** 1332,1338 **** _equalRemoveOpFamilyStmt(RemoveOpFamilyStmt *a, RemoveOpFamilyStmt *b)
  }
  
  static bool
! _equalRenameStmt(RenameStmt *a, RenameStmt *b)
  {
  	COMPARE_SCALAR_FIELD(renameType);
  	COMPARE_NODE_FIELD(relation);
--- 1332,1338 ----
  }
  
  static bool
! _equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
  {
  	COMPARE_SCALAR_FIELD(renameType);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1346,1352 **** _equalRenameStmt(RenameStmt *a, RenameStmt *b)
  }
  
  static bool
! _equalAlterObjectSchemaStmt(AlterObjectSchemaStmt *a, AlterObjectSchemaStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objectType);
  	COMPARE_NODE_FIELD(relation);
--- 1346,1352 ----
  }
  
  static bool
! _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objectType);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1359,1365 **** _equalAlterObjectSchemaStmt(AlterObjectSchemaStmt *a, AlterObjectSchemaStmt *b)
  }
  
  static bool
! _equalAlterOwnerStmt(AlterOwnerStmt *a, AlterOwnerStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objectType);
  	COMPARE_NODE_FIELD(relation);
--- 1359,1365 ----
  }
  
  static bool
! _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
  {
  	COMPARE_SCALAR_FIELD(objectType);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1372,1378 **** _equalAlterOwnerStmt(AlterOwnerStmt *a, AlterOwnerStmt *b)
  }
  
  static bool
! _equalRuleStmt(RuleStmt *a, RuleStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(rulename);
--- 1372,1378 ----
  }
  
  static bool
! _equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(rulename);
***************
*** 1386,1392 **** _equalRuleStmt(RuleStmt *a, RuleStmt *b)
  }
  
  static bool
! _equalNotifyStmt(NotifyStmt *a, NotifyStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  	COMPARE_STRING_FIELD(payload);
--- 1386,1392 ----
  }
  
  static bool
! _equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  	COMPARE_STRING_FIELD(payload);
***************
*** 1395,1401 **** _equalNotifyStmt(NotifyStmt *a, NotifyStmt *b)
  }
  
  static bool
! _equalListenStmt(ListenStmt *a, ListenStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  
--- 1395,1401 ----
  }
  
  static bool
! _equalListenStmt(const ListenStmt *a, const ListenStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  
***************
*** 1403,1409 **** _equalListenStmt(ListenStmt *a, ListenStmt *b)
  }
  
  static bool
! _equalUnlistenStmt(UnlistenStmt *a, UnlistenStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  
--- 1403,1409 ----
  }
  
  static bool
! _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
  {
  	COMPARE_STRING_FIELD(conditionname);
  
***************
*** 1411,1417 **** _equalUnlistenStmt(UnlistenStmt *a, UnlistenStmt *b)
  }
  
  static bool
! _equalTransactionStmt(TransactionStmt *a, TransactionStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(options);
--- 1411,1417 ----
  }
  
  static bool
! _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(options);
***************
*** 1421,1427 **** _equalTransactionStmt(TransactionStmt *a, TransactionStmt *b)
  }
  
  static bool
! _equalCompositeTypeStmt(CompositeTypeStmt *a, CompositeTypeStmt *b)
  {
  	COMPARE_NODE_FIELD(typevar);
  	COMPARE_NODE_FIELD(coldeflist);
--- 1421,1427 ----
  }
  
  static bool
! _equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
  {
  	COMPARE_NODE_FIELD(typevar);
  	COMPARE_NODE_FIELD(coldeflist);
***************
*** 1430,1436 **** _equalCompositeTypeStmt(CompositeTypeStmt *a, CompositeTypeStmt *b)
  }
  
  static bool
! _equalCreateEnumStmt(CreateEnumStmt *a, CreateEnumStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_NODE_FIELD(vals);
--- 1430,1436 ----
  }
  
  static bool
! _equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_NODE_FIELD(vals);
***************
*** 1439,1445 **** _equalCreateEnumStmt(CreateEnumStmt *a, CreateEnumStmt *b)
  }
  
  static bool
! _equalCreateRangeStmt(CreateRangeStmt *a, CreateRangeStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_NODE_FIELD(params);
--- 1439,1445 ----
  }
  
  static bool
! _equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_NODE_FIELD(params);
***************
*** 1448,1454 **** _equalCreateRangeStmt(CreateRangeStmt *a, CreateRangeStmt *b)
  }
  
  static bool
! _equalAlterEnumStmt(AlterEnumStmt *a, AlterEnumStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_STRING_FIELD(newVal);
--- 1448,1454 ----
  }
  
  static bool
! _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
  {
  	COMPARE_NODE_FIELD(typeName);
  	COMPARE_STRING_FIELD(newVal);
***************
*** 1459,1465 **** _equalAlterEnumStmt(AlterEnumStmt *a, AlterEnumStmt *b)
  }
  
  static bool
! _equalViewStmt(ViewStmt *a, ViewStmt *b)
  {
  	COMPARE_NODE_FIELD(view);
  	COMPARE_NODE_FIELD(aliases);
--- 1459,1465 ----
  }
  
  static bool
! _equalViewStmt(const ViewStmt *a, const ViewStmt *b)
  {
  	COMPARE_NODE_FIELD(view);
  	COMPARE_NODE_FIELD(aliases);
***************
*** 1470,1476 **** _equalViewStmt(ViewStmt *a, ViewStmt *b)
  }
  
  static bool
! _equalLoadStmt(LoadStmt *a, LoadStmt *b)
  {
  	COMPARE_STRING_FIELD(filename);
  
--- 1470,1476 ----
  }
  
  static bool
! _equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
  {
  	COMPARE_STRING_FIELD(filename);
  
***************
*** 1478,1484 **** _equalLoadStmt(LoadStmt *a, LoadStmt *b)
  }
  
  static bool
! _equalCreateDomainStmt(CreateDomainStmt *a, CreateDomainStmt *b)
  {
  	COMPARE_NODE_FIELD(domainname);
  	COMPARE_NODE_FIELD(typeName);
--- 1478,1484 ----
  }
  
  static bool
! _equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
  {
  	COMPARE_NODE_FIELD(domainname);
  	COMPARE_NODE_FIELD(typeName);
***************
*** 1489,1495 **** _equalCreateDomainStmt(CreateDomainStmt *a, CreateDomainStmt *b)
  }
  
  static bool
! _equalCreateOpClassStmt(CreateOpClassStmt *a, CreateOpClassStmt *b)
  {
  	COMPARE_NODE_FIELD(opclassname);
  	COMPARE_NODE_FIELD(opfamilyname);
--- 1489,1495 ----
  }
  
  static bool
! _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
  {
  	COMPARE_NODE_FIELD(opclassname);
  	COMPARE_NODE_FIELD(opfamilyname);
***************
*** 1502,1508 **** _equalCreateOpClassStmt(CreateOpClassStmt *a, CreateOpClassStmt *b)
  }
  
  static bool
! _equalCreateOpClassItem(CreateOpClassItem *a, CreateOpClassItem *b)
  {
  	COMPARE_SCALAR_FIELD(itemtype);
  	COMPARE_NODE_FIELD(name);
--- 1502,1508 ----
  }
  
  static bool
! _equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
  {
  	COMPARE_SCALAR_FIELD(itemtype);
  	COMPARE_NODE_FIELD(name);
***************
*** 1516,1522 **** _equalCreateOpClassItem(CreateOpClassItem *a, CreateOpClassItem *b)
  }
  
  static bool
! _equalCreateOpFamilyStmt(CreateOpFamilyStmt *a, CreateOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
--- 1516,1522 ----
  }
  
  static bool
! _equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
***************
*** 1525,1531 **** _equalCreateOpFamilyStmt(CreateOpFamilyStmt *a, CreateOpFamilyStmt *b)
  }
  
  static bool
! _equalAlterOpFamilyStmt(AlterOpFamilyStmt *a, AlterOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
--- 1525,1531 ----
  }
  
  static bool
! _equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
  {
  	COMPARE_NODE_FIELD(opfamilyname);
  	COMPARE_STRING_FIELD(amname);
***************
*** 1536,1542 **** _equalAlterOpFamilyStmt(AlterOpFamilyStmt *a, AlterOpFamilyStmt *b)
  }
  
  static bool
! _equalCreatedbStmt(CreatedbStmt *a, CreatedbStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(options);
--- 1536,1542 ----
  }
  
  static bool
! _equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(options);
***************
*** 1545,1551 **** _equalCreatedbStmt(CreatedbStmt *a, CreatedbStmt *b)
  }
  
  static bool
! _equalAlterDatabaseStmt(AlterDatabaseStmt *a, AlterDatabaseStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(options);
--- 1545,1551 ----
  }
  
  static bool
! _equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(options);
***************
*** 1554,1560 **** _equalAlterDatabaseStmt(AlterDatabaseStmt *a, AlterDatabaseStmt *b)
  }
  
  static bool
! _equalAlterDatabaseSetStmt(AlterDatabaseSetStmt *a, AlterDatabaseSetStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(setstmt);
--- 1554,1560 ----
  }
  
  static bool
! _equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_NODE_FIELD(setstmt);
***************
*** 1563,1569 **** _equalAlterDatabaseSetStmt(AlterDatabaseSetStmt *a, AlterDatabaseSetStmt *b)
  }
  
  static bool
! _equalDropdbStmt(DropdbStmt *a, DropdbStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_SCALAR_FIELD(missing_ok);
--- 1563,1569 ----
  }
  
  static bool
! _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
  {
  	COMPARE_STRING_FIELD(dbname);
  	COMPARE_SCALAR_FIELD(missing_ok);
***************
*** 1572,1578 **** _equalDropdbStmt(DropdbStmt *a, DropdbStmt *b)
  }
  
  static bool
! _equalVacuumStmt(VacuumStmt *a, VacuumStmt *b)
  {
  	COMPARE_SCALAR_FIELD(options);
  	COMPARE_SCALAR_FIELD(freeze_min_age);
--- 1572,1578 ----
  }
  
  static bool
! _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
  {
  	COMPARE_SCALAR_FIELD(options);
  	COMPARE_SCALAR_FIELD(freeze_min_age);
***************
*** 1584,1590 **** _equalVacuumStmt(VacuumStmt *a, VacuumStmt *b)
  }
  
  static bool
! _equalExplainStmt(ExplainStmt *a, ExplainStmt *b)
  {
  	COMPARE_NODE_FIELD(query);
  	COMPARE_NODE_FIELD(options);
--- 1584,1590 ----
  }
  
  static bool
! _equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
  {
  	COMPARE_NODE_FIELD(query);
  	COMPARE_NODE_FIELD(options);
***************
*** 1593,1599 **** _equalExplainStmt(ExplainStmt *a, ExplainStmt *b)
  }
  
  static bool
! _equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
  {
  	COMPARE_NODE_FIELD(sequence);
  	COMPARE_NODE_FIELD(options);
--- 1593,1599 ----
  }
  
  static bool
! _equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
  {
  	COMPARE_NODE_FIELD(sequence);
  	COMPARE_NODE_FIELD(options);
***************
*** 1603,1609 **** _equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
  }
  
  static bool
! _equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
  {
  	COMPARE_NODE_FIELD(sequence);
  	COMPARE_NODE_FIELD(options);
--- 1603,1609 ----
  }
  
  static bool
! _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
  {
  	COMPARE_NODE_FIELD(sequence);
  	COMPARE_NODE_FIELD(options);
***************
*** 1612,1618 **** _equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
  }
  
  static bool
! _equalVariableSetStmt(VariableSetStmt *a, VariableSetStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_STRING_FIELD(name);
--- 1612,1618 ----
  }
  
  static bool
! _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_STRING_FIELD(name);
***************
*** 1623,1629 **** _equalVariableSetStmt(VariableSetStmt *a, VariableSetStmt *b)
  }
  
  static bool
! _equalVariableShowStmt(VariableShowStmt *a, VariableShowStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  
--- 1623,1629 ----
  }
  
  static bool
! _equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  
***************
*** 1631,1637 **** _equalVariableShowStmt(VariableShowStmt *a, VariableShowStmt *b)
  }
  
  static bool
! _equalDiscardStmt(DiscardStmt *a, DiscardStmt *b)
  {
  	COMPARE_SCALAR_FIELD(target);
  
--- 1631,1637 ----
  }
  
  static bool
! _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
  {
  	COMPARE_SCALAR_FIELD(target);
  
***************
*** 1639,1645 **** _equalDiscardStmt(DiscardStmt *a, DiscardStmt *b)
  }
  
  static bool
! _equalCreateTableSpaceStmt(CreateTableSpaceStmt *a, CreateTableSpaceStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_STRING_FIELD(owner);
--- 1639,1645 ----
  }
  
  static bool
! _equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_STRING_FIELD(owner);
***************
*** 1649,1655 **** _equalCreateTableSpaceStmt(CreateTableSpaceStmt *a, CreateTableSpaceStmt *b)
  }
  
  static bool
! _equalDropTableSpaceStmt(DropTableSpaceStmt *a, DropTableSpaceStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_SCALAR_FIELD(missing_ok);
--- 1649,1655 ----
  }
  
  static bool
! _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_SCALAR_FIELD(missing_ok);
***************
*** 1658,1665 **** _equalDropTableSpaceStmt(DropTableSpaceStmt *a, DropTableSpaceStmt *b)
  }
  
  static bool
! _equalAlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt *a,
! 								 AlterTableSpaceOptionsStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_NODE_FIELD(options);
--- 1658,1665 ----
  }
  
  static bool
! _equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a,
! 								 const AlterTableSpaceOptionsStmt *b)
  {
  	COMPARE_STRING_FIELD(tablespacename);
  	COMPARE_NODE_FIELD(options);
***************
*** 1669,1675 **** _equalAlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt *a,
  }
  
  static bool
! _equalCreateExtensionStmt(CreateExtensionStmt *a, CreateExtensionStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_SCALAR_FIELD(if_not_exists);
--- 1669,1675 ----
  }
  
  static bool
! _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_SCALAR_FIELD(if_not_exists);
***************
*** 1679,1685 **** _equalCreateExtensionStmt(CreateExtensionStmt *a, CreateExtensionStmt *b)
  }
  
  static bool
! _equalAlterExtensionStmt(AlterExtensionStmt *a, AlterExtensionStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_NODE_FIELD(options);
--- 1679,1685 ----
  }
  
  static bool
! _equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_NODE_FIELD(options);
***************
*** 1688,1694 **** _equalAlterExtensionStmt(AlterExtensionStmt *a, AlterExtensionStmt *b)
  }
  
  static bool
! _equalAlterExtensionContentsStmt(AlterExtensionContentsStmt *a, AlterExtensionContentsStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_SCALAR_FIELD(action);
--- 1688,1694 ----
  }
  
  static bool
! _equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
  {
  	COMPARE_STRING_FIELD(extname);
  	COMPARE_SCALAR_FIELD(action);
***************
*** 1700,1706 **** _equalAlterExtensionContentsStmt(AlterExtensionContentsStmt *a, AlterExtensionCo
  }
  
  static bool
! _equalCreateFdwStmt(CreateFdwStmt *a, CreateFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_NODE_FIELD(func_options);
--- 1700,1706 ----
  }
  
  static bool
! _equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_NODE_FIELD(func_options);
***************
*** 1710,1716 **** _equalCreateFdwStmt(CreateFdwStmt *a, CreateFdwStmt *b)
  }
  
  static bool
! _equalAlterFdwStmt(AlterFdwStmt *a, AlterFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_NODE_FIELD(func_options);
--- 1710,1716 ----
  }
  
  static bool
! _equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_NODE_FIELD(func_options);
***************
*** 1720,1726 **** _equalAlterFdwStmt(AlterFdwStmt *a, AlterFdwStmt *b)
  }
  
  static bool
! _equalDropFdwStmt(DropFdwStmt *a, DropFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_SCALAR_FIELD(missing_ok);
--- 1720,1726 ----
  }
  
  static bool
! _equalDropFdwStmt(const DropFdwStmt *a, const DropFdwStmt *b)
  {
  	COMPARE_STRING_FIELD(fdwname);
  	COMPARE_SCALAR_FIELD(missing_ok);
***************
*** 1730,1736 **** _equalDropFdwStmt(DropFdwStmt *a, DropFdwStmt *b)
  }
  
  static bool
! _equalCreateForeignServerStmt(CreateForeignServerStmt *a, CreateForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_STRING_FIELD(servertype);
--- 1730,1736 ----
  }
  
  static bool
! _equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_STRING_FIELD(servertype);
***************
*** 1742,1748 **** _equalCreateForeignServerStmt(CreateForeignServerStmt *a, CreateForeignServerStm
  }
  
  static bool
! _equalAlterForeignServerStmt(AlterForeignServerStmt *a, AlterForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_STRING_FIELD(version);
--- 1742,1748 ----
  }
  
  static bool
! _equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_STRING_FIELD(version);
***************
*** 1753,1759 **** _equalAlterForeignServerStmt(AlterForeignServerStmt *a, AlterForeignServerStmt *
  }
  
  static bool
! _equalDropForeignServerStmt(DropForeignServerStmt *a, DropForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_SCALAR_FIELD(missing_ok);
--- 1753,1759 ----
  }
  
  static bool
! _equalDropForeignServerStmt(const DropForeignServerStmt *a, const DropForeignServerStmt *b)
  {
  	COMPARE_STRING_FIELD(servername);
  	COMPARE_SCALAR_FIELD(missing_ok);
***************
*** 1763,1769 **** _equalDropForeignServerStmt(DropForeignServerStmt *a, DropForeignServerStmt *b)
  }
  
  static bool
! _equalCreateUserMappingStmt(CreateUserMappingStmt *a, CreateUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
--- 1763,1769 ----
  }
  
  static bool
! _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
***************
*** 1773,1779 **** _equalCreateUserMappingStmt(CreateUserMappingStmt *a, CreateUserMappingStmt *b)
  }
  
  static bool
! _equalAlterUserMappingStmt(AlterUserMappingStmt *a, AlterUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
--- 1773,1779 ----
  }
  
  static bool
! _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
***************
*** 1783,1789 **** _equalAlterUserMappingStmt(AlterUserMappingStmt *a, AlterUserMappingStmt *b)
  }
  
  static bool
! _equalDropUserMappingStmt(DropUserMappingStmt *a, DropUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
--- 1783,1789 ----
  }
  
  static bool
! _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
  {
  	COMPARE_STRING_FIELD(username);
  	COMPARE_STRING_FIELD(servername);
***************
*** 1793,1799 **** _equalDropUserMappingStmt(DropUserMappingStmt *a, DropUserMappingStmt *b)
  }
  
  static bool
! _equalCreateForeignTableStmt(CreateForeignTableStmt *a, CreateForeignTableStmt *b)
  {
  	if (!_equalCreateStmt(&a->base, &b->base))
  		return false;
--- 1793,1799 ----
  }
  
  static bool
! _equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
  {
  	if (!_equalCreateStmt(&a->base, &b->base))
  		return false;
***************
*** 1805,1811 **** _equalCreateForeignTableStmt(CreateForeignTableStmt *a, CreateForeignTableStmt *
  }
  
  static bool
! _equalCreateTrigStmt(CreateTrigStmt *a, CreateTrigStmt *b)
  {
  	COMPARE_STRING_FIELD(trigname);
  	COMPARE_NODE_FIELD(relation);
--- 1805,1811 ----
  }
  
  static bool
! _equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
  {
  	COMPARE_STRING_FIELD(trigname);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1825,1831 **** _equalCreateTrigStmt(CreateTrigStmt *a, CreateTrigStmt *b)
  }
  
  static bool
! _equalDropPropertyStmt(DropPropertyStmt *a, DropPropertyStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(property);
--- 1825,1831 ----
  }
  
  static bool
! _equalDropPropertyStmt(const DropPropertyStmt *a, const DropPropertyStmt *b)
  {
  	COMPARE_NODE_FIELD(relation);
  	COMPARE_STRING_FIELD(property);
***************
*** 1837,1843 **** _equalDropPropertyStmt(DropPropertyStmt *a, DropPropertyStmt *b)
  }
  
  static bool
! _equalCreatePLangStmt(CreatePLangStmt *a, CreatePLangStmt *b)
  {
  	COMPARE_SCALAR_FIELD(replace);
  	COMPARE_STRING_FIELD(plname);
--- 1837,1843 ----
  }
  
  static bool
! _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
  {
  	COMPARE_SCALAR_FIELD(replace);
  	COMPARE_STRING_FIELD(plname);
***************
*** 1850,1856 **** _equalCreatePLangStmt(CreatePLangStmt *a, CreatePLangStmt *b)
  }
  
  static bool
! _equalDropPLangStmt(DropPLangStmt *a, DropPLangStmt *b)
  {
  	COMPARE_STRING_FIELD(plname);
  	COMPARE_SCALAR_FIELD(behavior);
--- 1850,1856 ----
  }
  
  static bool
! _equalDropPLangStmt(const DropPLangStmt *a, const DropPLangStmt *b)
  {
  	COMPARE_STRING_FIELD(plname);
  	COMPARE_SCALAR_FIELD(behavior);
***************
*** 1860,1866 **** _equalDropPLangStmt(DropPLangStmt *a, DropPLangStmt *b)
  }
  
  static bool
! _equalCreateRoleStmt(CreateRoleStmt *a, CreateRoleStmt *b)
  {
  	COMPARE_SCALAR_FIELD(stmt_type);
  	COMPARE_STRING_FIELD(role);
--- 1860,1866 ----
  }
  
  static bool
! _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
  {
  	COMPARE_SCALAR_FIELD(stmt_type);
  	COMPARE_STRING_FIELD(role);
***************
*** 1870,1876 **** _equalCreateRoleStmt(CreateRoleStmt *a, CreateRoleStmt *b)
  }
  
  static bool
! _equalAlterRoleStmt(AlterRoleStmt *a, AlterRoleStmt *b)
  {
  	COMPARE_STRING_FIELD(role);
  	COMPARE_NODE_FIELD(options);
--- 1870,1876 ----
  }
  
  static bool
! _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
  {
  	COMPARE_STRING_FIELD(role);
  	COMPARE_NODE_FIELD(options);
***************
*** 1880,1886 **** _equalAlterRoleStmt(AlterRoleStmt *a, AlterRoleStmt *b)
  }
  
  static bool
! _equalAlterRoleSetStmt(AlterRoleSetStmt *a, AlterRoleSetStmt *b)
  {
  	COMPARE_STRING_FIELD(role);
  	COMPARE_STRING_FIELD(database);
--- 1880,1886 ----
  }
  
  static bool
! _equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
  {
  	COMPARE_STRING_FIELD(role);
  	COMPARE_STRING_FIELD(database);
***************
*** 1890,1896 **** _equalAlterRoleSetStmt(AlterRoleSetStmt *a, AlterRoleSetStmt *b)
  }
  
  static bool
! _equalDropRoleStmt(DropRoleStmt *a, DropRoleStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_SCALAR_FIELD(missing_ok);
--- 1890,1896 ----
  }
  
  static bool
! _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_SCALAR_FIELD(missing_ok);
***************
*** 1899,1905 **** _equalDropRoleStmt(DropRoleStmt *a, DropRoleStmt *b)
  }
  
  static bool
! _equalLockStmt(LockStmt *a, LockStmt *b)
  {
  	COMPARE_NODE_FIELD(relations);
  	COMPARE_SCALAR_FIELD(mode);
--- 1899,1905 ----
  }
  
  static bool
! _equalLockStmt(const LockStmt *a, const LockStmt *b)
  {
  	COMPARE_NODE_FIELD(relations);
  	COMPARE_SCALAR_FIELD(mode);
***************
*** 1909,1915 **** _equalLockStmt(LockStmt *a, LockStmt *b)
  }
  
  static bool
! _equalConstraintsSetStmt(ConstraintsSetStmt *a, ConstraintsSetStmt *b)
  {
  	COMPARE_NODE_FIELD(constraints);
  	COMPARE_SCALAR_FIELD(deferred);
--- 1909,1915 ----
  }
  
  static bool
! _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
  {
  	COMPARE_NODE_FIELD(constraints);
  	COMPARE_SCALAR_FIELD(deferred);
***************
*** 1918,1924 **** _equalConstraintsSetStmt(ConstraintsSetStmt *a, ConstraintsSetStmt *b)
  }
  
  static bool
! _equalReindexStmt(ReindexStmt *a, ReindexStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(relation);
--- 1918,1924 ----
  }
  
  static bool
! _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(relation);
***************
*** 1930,1936 **** _equalReindexStmt(ReindexStmt *a, ReindexStmt *b)
  }
  
  static bool
! _equalCreateSchemaStmt(CreateSchemaStmt *a, CreateSchemaStmt *b)
  {
  	COMPARE_STRING_FIELD(schemaname);
  	COMPARE_STRING_FIELD(authid);
--- 1930,1936 ----
  }
  
  static bool
! _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
  {
  	COMPARE_STRING_FIELD(schemaname);
  	COMPARE_STRING_FIELD(authid);
***************
*** 1940,1946 **** _equalCreateSchemaStmt(CreateSchemaStmt *a, CreateSchemaStmt *b)
  }
  
  static bool
! _equalCreateConversionStmt(CreateConversionStmt *a, CreateConversionStmt *b)
  {
  	COMPARE_NODE_FIELD(conversion_name);
  	COMPARE_STRING_FIELD(for_encoding_name);
--- 1940,1946 ----
  }
  
  static bool
! _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
  {
  	COMPARE_NODE_FIELD(conversion_name);
  	COMPARE_STRING_FIELD(for_encoding_name);
***************
*** 1952,1958 **** _equalCreateConversionStmt(CreateConversionStmt *a, CreateConversionStmt *b)
  }
  
  static bool
! _equalCreateCastStmt(CreateCastStmt *a, CreateCastStmt *b)
  {
  	COMPARE_NODE_FIELD(sourcetype);
  	COMPARE_NODE_FIELD(targettype);
--- 1952,1958 ----
  }
  
  static bool
! _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
  {
  	COMPARE_NODE_FIELD(sourcetype);
  	COMPARE_NODE_FIELD(targettype);
***************
*** 1964,1970 **** _equalCreateCastStmt(CreateCastStmt *a, CreateCastStmt *b)
  }
  
  static bool
! _equalDropCastStmt(DropCastStmt *a, DropCastStmt *b)
  {
  	COMPARE_NODE_FIELD(sourcetype);
  	COMPARE_NODE_FIELD(targettype);
--- 1964,1970 ----
  }
  
  static bool
! _equalDropCastStmt(const DropCastStmt *a, const DropCastStmt *b)
  {
  	COMPARE_NODE_FIELD(sourcetype);
  	COMPARE_NODE_FIELD(targettype);
***************
*** 1975,1981 **** _equalDropCastStmt(DropCastStmt *a, DropCastStmt *b)
  }
  
  static bool
! _equalPrepareStmt(PrepareStmt *a, PrepareStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(argtypes);
--- 1975,1981 ----
  }
  
  static bool
! _equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(argtypes);
***************
*** 1985,1991 **** _equalPrepareStmt(PrepareStmt *a, PrepareStmt *b)
  }
  
  static bool
! _equalExecuteStmt(ExecuteStmt *a, ExecuteStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(into);
--- 1985,1991 ----
  }
  
  static bool
! _equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(into);
***************
*** 1995,2001 **** _equalExecuteStmt(ExecuteStmt *a, ExecuteStmt *b)
  }
  
  static bool
! _equalDeallocateStmt(DeallocateStmt *a, DeallocateStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  
--- 1995,2001 ----
  }
  
  static bool
! _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
  {
  	COMPARE_STRING_FIELD(name);
  
***************
*** 2003,2009 **** _equalDeallocateStmt(DeallocateStmt *a, DeallocateStmt *b)
  }
  
  static bool
! _equalDropOwnedStmt(DropOwnedStmt *a, DropOwnedStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_SCALAR_FIELD(behavior);
--- 2003,2009 ----
  }
  
  static bool
! _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_SCALAR_FIELD(behavior);
***************
*** 2012,2018 **** _equalDropOwnedStmt(DropOwnedStmt *a, DropOwnedStmt *b)
  }
  
  static bool
! _equalReassignOwnedStmt(ReassignOwnedStmt *a, ReassignOwnedStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_NODE_FIELD(newrole);
--- 2012,2018 ----
  }
  
  static bool
! _equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
  {
  	COMPARE_NODE_FIELD(roles);
  	COMPARE_NODE_FIELD(newrole);
***************
*** 2021,2027 **** _equalReassignOwnedStmt(ReassignOwnedStmt *a, ReassignOwnedStmt *b)
  }
  
  static bool
! _equalAlterTSDictionaryStmt(AlterTSDictionaryStmt *a, AlterTSDictionaryStmt *b)
  {
  	COMPARE_NODE_FIELD(dictname);
  	COMPARE_NODE_FIELD(options);
--- 2021,2027 ----
  }
  
  static bool
! _equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
  {
  	COMPARE_NODE_FIELD(dictname);
  	COMPARE_NODE_FIELD(options);
***************
*** 2030,2037 **** _equalAlterTSDictionaryStmt(AlterTSDictionaryStmt *a, AlterTSDictionaryStmt *b)
  }
  
  static bool
! _equalAlterTSConfigurationStmt(AlterTSConfigurationStmt *a,
! 							   AlterTSConfigurationStmt *b)
  {
  	COMPARE_NODE_FIELD(cfgname);
  	COMPARE_NODE_FIELD(tokentype);
--- 2030,2037 ----
  }
  
  static bool
! _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a,
! 							   const AlterTSConfigurationStmt *b)
  {
  	COMPARE_NODE_FIELD(cfgname);
  	COMPARE_NODE_FIELD(tokentype);
***************
*** 2044,2050 **** _equalAlterTSConfigurationStmt(AlterTSConfigurationStmt *a,
  }
  
  static bool
! _equalAExpr(A_Expr *a, A_Expr *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(name);
--- 2044,2050 ----
  }
  
  static bool
! _equalAExpr(const A_Expr *a, const A_Expr *b)
  {
  	COMPARE_SCALAR_FIELD(kind);
  	COMPARE_NODE_FIELD(name);
***************
*** 2056,2062 **** _equalAExpr(A_Expr *a, A_Expr *b)
  }
  
  static bool
! _equalColumnRef(ColumnRef *a, ColumnRef *b)
  {
  	COMPARE_NODE_FIELD(fields);
  	COMPARE_LOCATION_FIELD(location);
--- 2056,2062 ----
  }
  
  static bool
! _equalColumnRef(const ColumnRef *a, const ColumnRef *b)
  {
  	COMPARE_NODE_FIELD(fields);
  	COMPARE_LOCATION_FIELD(location);
***************
*** 2065,2071 **** _equalColumnRef(ColumnRef *a, ColumnRef *b)
  }
  
  static bool
! _equalParamRef(ParamRef *a, ParamRef *b)
  {
  	COMPARE_SCALAR_FIELD(number);
  	COMPARE_LOCATION_FIELD(location);
--- 2065,2071 ----
  }
  
  static bool
! _equalParamRef(const ParamRef *a, const ParamRef *b)
  {
  	COMPARE_SCALAR_FIELD(number);
  	COMPARE_LOCATION_FIELD(location);
***************
*** 2084,2090 **** _equalAConst(A_Const *a, A_Const *b)
  }
  
  static bool
! _equalFuncCall(FuncCall *a, FuncCall *b)
  {
  	COMPARE_NODE_FIELD(funcname);
  	COMPARE_NODE_FIELD(args);
--- 2084,2090 ----
  }
  
  static bool
! _equalFuncCall(const FuncCall *a, const FuncCall *b)
  {
  	COMPARE_NODE_FIELD(funcname);
  	COMPARE_NODE_FIELD(args);
***************
*** 2099,2111 **** _equalFuncCall(FuncCall *a, FuncCall *b)
  }
  
  static bool
! _equalAStar(A_Star *a, A_Star *b)
  {
  	return true;
  }
  
  static bool
! _equalAIndices(A_Indices *a, A_Indices *b)
  {
  	COMPARE_NODE_FIELD(lidx);
  	COMPARE_NODE_FIELD(uidx);
--- 2099,2111 ----
  }
  
  static bool
! _equalAStar(const A_Star *a, const A_Star *b)
  {
  	return true;
  }
  
  static bool
! _equalAIndices(const A_Indices *a, const A_Indices *b)
  {
  	COMPARE_NODE_FIELD(lidx);
  	COMPARE_NODE_FIELD(uidx);
***************
*** 2114,2120 **** _equalAIndices(A_Indices *a, A_Indices *b)
  }
  
  static bool
! _equalA_Indirection(A_Indirection *a, A_Indirection *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(indirection);
--- 2114,2120 ----
  }
  
  static bool
! _equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(indirection);
***************
*** 2123,2129 **** _equalA_Indirection(A_Indirection *a, A_Indirection *b)
  }
  
  static bool
! _equalA_ArrayExpr(A_ArrayExpr *a, A_ArrayExpr *b)
  {
  	COMPARE_NODE_FIELD(elements);
  	COMPARE_LOCATION_FIELD(location);
--- 2123,2129 ----
  }
  
  static bool
! _equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
  {
  	COMPARE_NODE_FIELD(elements);
  	COMPARE_LOCATION_FIELD(location);
***************
*** 2132,2138 **** _equalA_ArrayExpr(A_ArrayExpr *a, A_ArrayExpr *b)
  }
  
  static bool
! _equalResTarget(ResTarget *a, ResTarget *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(indirection);
--- 2132,2138 ----
  }
  
  static bool
! _equalResTarget(const ResTarget *a, const ResTarget *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(indirection);
***************
*** 2143,2149 **** _equalResTarget(ResTarget *a, ResTarget *b)
  }
  
  static bool
! _equalTypeName(TypeName *a, TypeName *b)
  {
  	COMPARE_NODE_FIELD(names);
  	COMPARE_SCALAR_FIELD(typeOid);
--- 2143,2149 ----
  }
  
  static bool
! _equalTypeName(const TypeName *a, const TypeName *b)
  {
  	COMPARE_NODE_FIELD(names);
  	COMPARE_SCALAR_FIELD(typeOid);
***************
*** 2158,2164 **** _equalTypeName(TypeName *a, TypeName *b)
  }
  
  static bool
! _equalTypeCast(TypeCast *a, TypeCast *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(typeName);
--- 2158,2164 ----
  }
  
  static bool
! _equalTypeCast(const TypeCast *a, const TypeCast *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(typeName);
***************
*** 2168,2174 **** _equalTypeCast(TypeCast *a, TypeCast *b)
  }
  
  static bool
! _equalCollateClause(CollateClause *a, CollateClause *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(collname);
--- 2168,2174 ----
  }
  
  static bool
! _equalCollateClause(const CollateClause *a, const CollateClause *b)
  {
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(collname);
***************
*** 2178,2184 **** _equalCollateClause(CollateClause *a, CollateClause *b)
  }
  
  static bool
! _equalSortBy(SortBy *a, SortBy *b)
  {
  	COMPARE_NODE_FIELD(node);
  	COMPARE_SCALAR_FIELD(sortby_dir);
--- 2178,2184 ----
  }
  
  static bool
! _equalSortBy(const SortBy *a, const SortBy *b)
  {
  	COMPARE_NODE_FIELD(node);
  	COMPARE_SCALAR_FIELD(sortby_dir);
***************
*** 2190,2196 **** _equalSortBy(SortBy *a, SortBy *b)
  }
  
  static bool
! _equalWindowDef(WindowDef *a, WindowDef *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_STRING_FIELD(refname);
--- 2190,2196 ----
  }
  
  static bool
! _equalWindowDef(const WindowDef *a, const WindowDef *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_STRING_FIELD(refname);
***************
*** 2205,2211 **** _equalWindowDef(WindowDef *a, WindowDef *b)
  }
  
  static bool
! _equalRangeSubselect(RangeSubselect *a, RangeSubselect *b)
  {
  	COMPARE_NODE_FIELD(subquery);
  	COMPARE_NODE_FIELD(alias);
--- 2205,2211 ----
  }
  
  static bool
! _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
  {
  	COMPARE_NODE_FIELD(subquery);
  	COMPARE_NODE_FIELD(alias);
***************
*** 2214,2220 **** _equalRangeSubselect(RangeSubselect *a, RangeSubselect *b)
  }
  
  static bool
! _equalRangeFunction(RangeFunction *a, RangeFunction *b)
  {
  	COMPARE_NODE_FIELD(funccallnode);
  	COMPARE_NODE_FIELD(alias);
--- 2214,2220 ----
  }
  
  static bool
! _equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
  {
  	COMPARE_NODE_FIELD(funccallnode);
  	COMPARE_NODE_FIELD(alias);
***************
*** 2224,2230 **** _equalRangeFunction(RangeFunction *a, RangeFunction *b)
  }
  
  static bool
! _equalIndexElem(IndexElem *a, IndexElem *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(expr);
--- 2224,2230 ----
  }
  
  static bool
! _equalIndexElem(const IndexElem *a, const IndexElem *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_NODE_FIELD(expr);
***************
*** 2238,2244 **** _equalIndexElem(IndexElem *a, IndexElem *b)
  }
  
  static bool
! _equalColumnDef(ColumnDef *a, ColumnDef *b)
  {
  	COMPARE_STRING_FIELD(colname);
  	COMPARE_NODE_FIELD(typeName);
--- 2238,2244 ----
  }
  
  static bool
! _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
  {
  	COMPARE_STRING_FIELD(colname);
  	COMPARE_NODE_FIELD(typeName);
***************
*** 2257,2263 **** _equalColumnDef(ColumnDef *a, ColumnDef *b)
  }
  
  static bool
! _equalConstraint(Constraint *a, Constraint *b)
  {
  	COMPARE_SCALAR_FIELD(contype);
  	COMPARE_STRING_FIELD(conname);
--- 2257,2263 ----
  }
  
  static bool
! _equalConstraint(const Constraint *a, const Constraint *b)
  {
  	COMPARE_SCALAR_FIELD(contype);
  	COMPARE_STRING_FIELD(conname);
***************
*** 2286,2292 **** _equalConstraint(Constraint *a, Constraint *b)
  }
  
  static bool
! _equalDefElem(DefElem *a, DefElem *b)
  {
  	COMPARE_STRING_FIELD(defnamespace);
  	COMPARE_STRING_FIELD(defname);
--- 2286,2292 ----
  }
  
  static bool
! _equalDefElem(const DefElem *a, const DefElem *b)
  {
  	COMPARE_STRING_FIELD(defnamespace);
  	COMPARE_STRING_FIELD(defname);
***************
*** 2297,2303 **** _equalDefElem(DefElem *a, DefElem *b)
  }
  
  static bool
! _equalLockingClause(LockingClause *a, LockingClause *b)
  {
  	COMPARE_NODE_FIELD(lockedRels);
  	COMPARE_SCALAR_FIELD(forUpdate);
--- 2297,2303 ----
  }
  
  static bool
! _equalLockingClause(const LockingClause *a, const LockingClause *b)
  {
  	COMPARE_NODE_FIELD(lockedRels);
  	COMPARE_SCALAR_FIELD(forUpdate);
***************
*** 2307,2313 **** _equalLockingClause(LockingClause *a, LockingClause *b)
  }
  
  static bool
! _equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
  {
  	COMPARE_SCALAR_FIELD(rtekind);
  	COMPARE_SCALAR_FIELD(relid);
--- 2307,2313 ----
  }
  
  static bool
! _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
  {
  	COMPARE_SCALAR_FIELD(rtekind);
  	COMPARE_SCALAR_FIELD(relid);
***************
*** 2340,2346 **** _equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
  }
  
  static bool
! _equalSortGroupClause(SortGroupClause *a, SortGroupClause *b)
  {
  	COMPARE_SCALAR_FIELD(tleSortGroupRef);
  	COMPARE_SCALAR_FIELD(eqop);
--- 2340,2346 ----
  }
  
  static bool
! _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
  {
  	COMPARE_SCALAR_FIELD(tleSortGroupRef);
  	COMPARE_SCALAR_FIELD(eqop);
***************
*** 2352,2358 **** _equalSortGroupClause(SortGroupClause *a, SortGroupClause *b)
  }
  
  static bool
! _equalWindowClause(WindowClause *a, WindowClause *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_STRING_FIELD(refname);
--- 2352,2358 ----
  }
  
  static bool
! _equalWindowClause(const WindowClause *a, const WindowClause *b)
  {
  	COMPARE_STRING_FIELD(name);
  	COMPARE_STRING_FIELD(refname);
***************
*** 2368,2374 **** _equalWindowClause(WindowClause *a, WindowClause *b)
  }
  
  static bool
! _equalRowMarkClause(RowMarkClause *a, RowMarkClause *b)
  {
  	COMPARE_SCALAR_FIELD(rti);
  	COMPARE_SCALAR_FIELD(forUpdate);
--- 2368,2374 ----
  }
  
  static bool
! _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
  {
  	COMPARE_SCALAR_FIELD(rti);
  	COMPARE_SCALAR_FIELD(forUpdate);
***************
*** 2379,2385 **** _equalRowMarkClause(RowMarkClause *a, RowMarkClause *b)
  }
  
  static bool
! _equalWithClause(WithClause *a, WithClause *b)
  {
  	COMPARE_NODE_FIELD(ctes);
  	COMPARE_SCALAR_FIELD(recursive);
--- 2379,2385 ----
  }
  
  static bool
! _equalWithClause(const WithClause *a, const WithClause *b)
  {
  	COMPARE_NODE_FIELD(ctes);
  	COMPARE_SCALAR_FIELD(recursive);
***************
*** 2389,2395 **** _equalWithClause(WithClause *a, WithClause *b)
  }
  
  static bool
! _equalCommonTableExpr(CommonTableExpr *a, CommonTableExpr *b)
  {
  	COMPARE_STRING_FIELD(ctename);
  	COMPARE_NODE_FIELD(aliascolnames);
--- 2389,2395 ----
  }
  
  static bool
! _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
  {
  	COMPARE_STRING_FIELD(ctename);
  	COMPARE_NODE_FIELD(aliascolnames);
***************
*** 2406,2412 **** _equalCommonTableExpr(CommonTableExpr *a, CommonTableExpr *b)
  }
  
  static bool
! _equalXmlSerialize(XmlSerialize *a, XmlSerialize *b)
  {
  	COMPARE_SCALAR_FIELD(xmloption);
  	COMPARE_NODE_FIELD(expr);
--- 2406,2412 ----
  }
  
  static bool
! _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
  {
  	COMPARE_SCALAR_FIELD(xmloption);
  	COMPARE_NODE_FIELD(expr);
***************
*** 2423,2430 **** _equalXmlSerialize(XmlSerialize *a, XmlSerialize *b)
  static bool
  _equalList(List *a, List *b)
  {
! 	ListCell   *item_a;
! 	ListCell   *item_b;
  
  	/*
  	 * Try to reject by simple scalar checks before grovelling through all the
--- 2423,2430 ----
  static bool
  _equalList(List *a, List *b)
  {
! 	const ListCell   *item_a;
! 	const ListCell   *item_b;
  
  	/*
  	 * Try to reject by simple scalar checks before grovelling through all the
***************
*** 2480,2486 **** _equalList(List *a, List *b)
   */
  
  static bool
! _equalValue(Value *a, Value *b)
  {
  	COMPARE_SCALAR_FIELD(type);
  
--- 2480,2486 ----
   */
  
  static bool
! _equalValue(const Value *a, const Value *b)
  {
  	COMPARE_SCALAR_FIELD(type);
  
*** a/src/backend/nodes/list.c
--- b/src/backend/nodes/list.c
***************
*** 443,449 **** list_nth_oid(List *list, int n)
  bool
  list_member(List *list, void *datum)
  {
! 	ListCell   *cell;
  
  	Assert(IsPointerList(list));
  	check_list_invariants(list);
--- 443,449 ----
  bool
  list_member(List *list, void *datum)
  {
! 	const ListCell   *cell;
  
  	Assert(IsPointerList(list));
  	check_list_invariants(list);
***************
*** 462,470 **** list_member(List *list, void *datum)
   * determined by using simple pointer comparison.
   */
  bool
! list_member_ptr(List *list, void *datum)
  {
! 	ListCell   *cell;
  
  	Assert(IsPointerList(list));
  	check_list_invariants(list);
--- 462,470 ----
   * determined by using simple pointer comparison.
   */
  bool
! list_member_ptr(List *list, const void *datum)
  {
! 	const ListCell   *cell;
  
  	Assert(IsPointerList(list));
  	check_list_invariants(list);
***************
*** 484,490 **** list_member_ptr(List *list, void *datum)
  bool
  list_member_int(List *list, int datum)
  {
! 	ListCell   *cell;
  
  	Assert(IsIntegerList(list));
  	check_list_invariants(list);
--- 484,490 ----
  bool
  list_member_int(List *list, int datum)
  {
! 	const ListCell   *cell;
  
  	Assert(IsIntegerList(list));
  	check_list_invariants(list);
***************
*** 504,510 **** list_member_int(List *list, int datum)
  bool
  list_member_oid(List *list, Oid datum)
  {
! 	ListCell   *cell;
  
  	Assert(IsOidList(list));
  	check_list_invariants(list);
--- 504,510 ----
  bool
  list_member_oid(List *list, Oid datum)
  {
! 	const ListCell   *cell;
  
  	Assert(IsOidList(list));
  	check_list_invariants(list);
***************
*** 697,703 **** List *
  list_union(List *list1, List *list2)
  {
  	List	   *result;
! 	ListCell   *cell;
  
  	Assert(IsPointerList(list1));
  	Assert(IsPointerList(list2));
--- 697,703 ----
  list_union(List *list1, List *list2)
  {
  	List	   *result;
! 	const ListCell   *cell;
  
  	Assert(IsPointerList(list1));
  	Assert(IsPointerList(list2));
***************
*** 721,727 **** List *
  list_union_ptr(List *list1, List *list2)
  {
  	List	   *result;
! 	ListCell   *cell;
  
  	Assert(IsPointerList(list1));
  	Assert(IsPointerList(list2));
--- 721,727 ----
  list_union_ptr(List *list1, List *list2)
  {
  	List	   *result;
! 	const ListCell   *cell;
  
  	Assert(IsPointerList(list1));
  	Assert(IsPointerList(list2));
***************
*** 744,750 **** List *
  list_union_int(List *list1, List *list2)
  {
  	List	   *result;
! 	ListCell   *cell;
  
  	Assert(IsIntegerList(list1));
  	Assert(IsIntegerList(list2));
--- 744,750 ----
  list_union_int(List *list1, List *list2)
  {
  	List	   *result;
! 	const ListCell   *cell;
  
  	Assert(IsIntegerList(list1));
  	Assert(IsIntegerList(list2));
***************
*** 767,773 **** List *
  list_union_oid(List *list1, List *list2)
  {
  	List	   *result;
! 	ListCell   *cell;
  
  	Assert(IsOidList(list1));
  	Assert(IsOidList(list2));
--- 767,773 ----
  list_union_oid(List *list1, List *list2)
  {
  	List	   *result;
! 	const ListCell   *cell;
  
  	Assert(IsOidList(list1));
  	Assert(IsOidList(list2));
***************
*** 800,806 **** List *
  list_intersection(List *list1, List *list2)
  {
  	List	   *result;
! 	ListCell   *cell;
  
  	if (list1 == NIL || list2 == NIL)
  		return NIL;
--- 800,806 ----
  list_intersection(List *list1, List *list2)
  {
  	List	   *result;
! 	const ListCell   *cell;
  
  	if (list1 == NIL || list2 == NIL)
  		return NIL;
***************
*** 831,837 **** list_intersection(List *list1, List *list2)
  List *
  list_difference(List *list1, List *list2)
  {
! 	ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsPointerList(list1));
--- 831,837 ----
  List *
  list_difference(List *list1, List *list2)
  {
! 	const ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsPointerList(list1));
***************
*** 857,863 **** list_difference(List *list1, List *list2)
  List *
  list_difference_ptr(List *list1, List *list2)
  {
! 	ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsPointerList(list1));
--- 857,863 ----
  List *
  list_difference_ptr(List *list1, List *list2)
  {
! 	const ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsPointerList(list1));
***************
*** 882,888 **** list_difference_ptr(List *list1, List *list2)
  List *
  list_difference_int(List *list1, List *list2)
  {
! 	ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsIntegerList(list1));
--- 882,888 ----
  List *
  list_difference_int(List *list1, List *list2)
  {
! 	const ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsIntegerList(list1));
***************
*** 907,913 **** list_difference_int(List *list1, List *list2)
  List *
  list_difference_oid(List *list1, List *list2)
  {
! 	ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsOidList(list1));
--- 907,913 ----
  List *
  list_difference_oid(List *list1, List *list2)
  {
! 	const ListCell   *cell;
  	List	   *result = NIL;
  
  	Assert(IsOidList(list1));
*** a/src/backend/nodes/nodeFuncs.c
--- b/src/backend/nodes/nodeFuncs.c
***************
*** 32,38 **** static int	leftmostLoc(int loc1, int loc2);
   *	  returns the Oid of the type of the expression's result.
   */
  Oid
! exprType(Node *expr)
  {
  	Oid			type;
  
--- 32,38 ----
   *	  returns the Oid of the type of the expression's result.
   */
  Oid
! exprType(const Node *expr)
  {
  	Oid			type;
  
***************
*** 241,247 **** exprType(Node *expr)
   *	  if it can be determined.	In many cases, it can't and we return -1.
   */
  int32
! exprTypmod(Node *expr)
  {
  	if (!expr)
  		return -1;
--- 241,247 ----
   *	  if it can be determined.	In many cases, it can't and we return -1.
   */
  int32
! exprTypmod(const Node *expr)
  {
  	if (!expr)
  		return -1;
***************
*** 481,487 **** exprTypmod(Node *expr)
   * length coercion by this routine.
   */
  bool
! exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
  {
  	if (coercedTypmod != NULL)
  		*coercedTypmod = -1;	/* default result on failure */
--- 481,487 ----
   * length coercion by this routine.
   */
  bool
! exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
  {
  	if (coercedTypmod != NULL)
  		*coercedTypmod = -1;	/* default result on failure */
***************
*** 632,638 **** expression_returns_set_walker(Node *node, void *context)
   * or vice versa, the two are different.
   */
  Oid
! exprCollation(Node *expr)
  {
  	Oid			coll;
  
--- 632,638 ----
   * or vice versa, the two are different.
   */
  Oid
! exprCollation(const Node *expr)
  {
  	Oid			coll;
  
***************
*** 822,828 **** exprCollation(Node *expr)
   * Result is InvalidOid if the node type doesn't store this information.
   */
  Oid
! exprInputCollation(Node *expr)
  {
  	Oid			coll;
  
--- 822,828 ----
   * Result is InvalidOid if the node type doesn't store this information.
   */
  Oid
! exprInputCollation(const Node *expr)
  {
  	Oid			coll;
  
***************
*** 1078,1084 **** exprSetInputCollation(Node *expr, Oid inputcollation)
   * known and unknown locations in a tree.
   */
  int
! exprLocation(Node *expr)
  {
  	int			loc;
  
--- 1078,1084 ----
   * known and unknown locations in a tree.
   */
  int
! exprLocation(const Node *expr)
  {
  	int			loc;
  
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 105,111 **** static void _outNode(StringInfo str, void *obj);
   *	  If a null or empty string is given, it is encoded as "<>".
   */
  static void
! _outToken(StringInfo str, char *s)
  {
  	if (s == NULL || *s == '\0')
  	{
--- 105,111 ----
   *	  If a null or empty string is given, it is encoded as "<>".
   */
  static void
! _outToken(StringInfo str, const char *s)
  {
  	if (s == NULL || *s == '\0')
  	{
***************
*** 139,145 **** _outToken(StringInfo str, char *s)
  static void
  _outList(StringInfo str, List *node)
  {
! 	ListCell   *lc;
  
  	appendStringInfoChar(str, '(');
  
--- 139,145 ----
  static void
  _outList(StringInfo str, List *node)
  {
! 	const ListCell   *lc;
  
  	appendStringInfoChar(str, '(');
  
***************
*** 180,186 **** _outList(StringInfo str, List *node)
   * Note: the output format is "(b int int ...)", similar to an integer List.
   */
  static void
! _outBitmapset(StringInfo str, Bitmapset *bms)
  {
  	Bitmapset  *tmpset;
  	int			x;
--- 180,186 ----
   * Note: the output format is "(b int int ...)", similar to an integer List.
   */
  static void
! _outBitmapset(StringInfo str, const Bitmapset *bms)
  {
  	Bitmapset  *tmpset;
  	int			x;
***************
*** 235,241 **** _outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
   */
  
  static void
! _outPlannedStmt(StringInfo str, PlannedStmt *node)
  {
  	WRITE_NODE_TYPE("PLANNEDSTMT");
  
--- 235,241 ----
   */
  
  static void
! _outPlannedStmt(StringInfo str, const PlannedStmt *node)
  {
  	WRITE_NODE_TYPE("PLANNEDSTMT");
  
***************
*** 261,267 **** _outPlannedStmt(StringInfo str, PlannedStmt *node)
   * print the basic stuff of all nodes that inherit from Plan
   */
  static void
! _outPlanInfo(StringInfo str, Plan *node)
  {
  	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
  	WRITE_FLOAT_FIELD(total_cost, "%.2f");
--- 261,267 ----
   * print the basic stuff of all nodes that inherit from Plan
   */
  static void
! _outPlanInfo(StringInfo str, const Plan *node)
  {
  	WRITE_FLOAT_FIELD(startup_cost, "%.2f");
  	WRITE_FLOAT_FIELD(total_cost, "%.2f");
***************
*** 280,288 **** _outPlanInfo(StringInfo str, Plan *node)
   * print the basic stuff of all nodes that inherit from Scan
   */
  static void
! _outScanInfo(StringInfo str, Scan *node)
  {
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_UINT_FIELD(scanrelid);
  }
--- 280,288 ----
   * print the basic stuff of all nodes that inherit from Scan
   */
  static void
! _outScanInfo(StringInfo str, const Scan *node)
  {
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_UINT_FIELD(scanrelid);
  }
***************
*** 291,299 **** _outScanInfo(StringInfo str, Scan *node)
   * 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);
--- 291,299 ----
   * print the basic stuff of all nodes that inherit from Join
   */
  static void
! _outJoinPlanInfo(StringInfo str, const Join *node)
  {
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_ENUM_FIELD(jointype, JoinType);
  	WRITE_NODE_FIELD(joinqual);
***************
*** 301,329 **** _outJoinPlanInfo(StringInfo str, Join *node)
  
  
  static void
! _outPlan(StringInfo str, Plan *node)
  {
  	WRITE_NODE_TYPE("PLAN");
  
! 	_outPlanInfo(str, (Plan *) node);
  }
  
  static void
! _outResult(StringInfo str, Result *node)
  {
  	WRITE_NODE_TYPE("RESULT");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(resconstantqual);
  }
  
  static void
! _outModifyTable(StringInfo str, ModifyTable *node)
  {
  	WRITE_NODE_TYPE("MODIFYTABLE");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_BOOL_FIELD(canSetTag);
--- 301,329 ----
  
  
  static void
! _outPlan(StringInfo str, const Plan *node)
  {
  	WRITE_NODE_TYPE("PLAN");
  
! 	_outPlanInfo(str, (const Plan *) node);
  }
  
  static void
! _outResult(StringInfo str, const Result *node)
  {
  	WRITE_NODE_TYPE("RESULT");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(resconstantqual);
  }
  
  static void
! _outModifyTable(StringInfo str, const ModifyTable *node)
  {
  	WRITE_NODE_TYPE("MODIFYTABLE");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_BOOL_FIELD(canSetTag);
***************
*** 336,358 **** _outModifyTable(StringInfo str, ModifyTable *node)
  }
  
  static void
! _outAppend(StringInfo str, Append *node)
  {
  	WRITE_NODE_TYPE("APPEND");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(appendplans);
  }
  
  static void
! _outMergeAppend(StringInfo str, MergeAppend *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("MERGEAPPEND");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(mergeplans);
  
--- 336,358 ----
  }
  
  static void
! _outAppend(StringInfo str, const Append *node)
  {
  	WRITE_NODE_TYPE("APPEND");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(appendplans);
  }
  
  static void
! _outMergeAppend(StringInfo str, const MergeAppend *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("MERGEAPPEND");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(mergeplans);
  
***************
*** 376,388 **** _outMergeAppend(StringInfo str, MergeAppend *node)
  }
  
  static void
! _outRecursiveUnion(StringInfo str, RecursiveUnion *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("RECURSIVEUNION");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_INT_FIELD(wtParam);
  	WRITE_INT_FIELD(numCols);
--- 376,388 ----
  }
  
  static void
! _outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("RECURSIVEUNION");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_INT_FIELD(wtParam);
  	WRITE_INT_FIELD(numCols);
***************
*** 399,445 **** _outRecursiveUnion(StringInfo str, RecursiveUnion *node)
  }
  
  static void
! _outBitmapAnd(StringInfo str, BitmapAnd *node)
  {
  	WRITE_NODE_TYPE("BITMAPAND");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(bitmapplans);
  }
  
  static void
! _outBitmapOr(StringInfo str, BitmapOr *node)
  {
  	WRITE_NODE_TYPE("BITMAPOR");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(bitmapplans);
  }
  
  static void
! _outScan(StringInfo str, Scan *node)
  {
  	WRITE_NODE_TYPE("SCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  }
  
  static void
! _outSeqScan(StringInfo str, SeqScan *node)
  {
  	WRITE_NODE_TYPE("SEQSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  }
  
  static void
! _outIndexScan(StringInfo str, IndexScan *node)
  {
  	WRITE_NODE_TYPE("INDEXSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
--- 399,445 ----
  }
  
  static void
! _outBitmapAnd(StringInfo str, const BitmapAnd *node)
  {
  	WRITE_NODE_TYPE("BITMAPAND");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(bitmapplans);
  }
  
  static void
! _outBitmapOr(StringInfo str, const BitmapOr *node)
  {
  	WRITE_NODE_TYPE("BITMAPOR");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(bitmapplans);
  }
  
  static void
! _outScan(StringInfo str, const Scan *node)
  {
  	WRITE_NODE_TYPE("SCAN");
  
! 	_outScanInfo(str, node);
  }
  
  static void
! _outSeqScan(StringInfo str, const SeqScan *node)
  {
  	WRITE_NODE_TYPE("SEQSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  }
  
  static void
! _outIndexScan(StringInfo str, const IndexScan *node)
  {
  	WRITE_NODE_TYPE("INDEXSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
***************
*** 450,460 **** _outIndexScan(StringInfo str, IndexScan *node)
  }
  
  static void
! _outIndexOnlyScan(StringInfo str, IndexOnlyScan *node)
  {
  	WRITE_NODE_TYPE("INDEXONLYSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
--- 450,460 ----
  }
  
  static void
! _outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
  {
  	WRITE_NODE_TYPE("INDEXONLYSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
***************
*** 464,474 **** _outIndexOnlyScan(StringInfo str, IndexOnlyScan *node)
  }
  
  static void
! _outBitmapIndexScan(StringInfo str, BitmapIndexScan *node)
  {
  	WRITE_NODE_TYPE("BITMAPINDEXSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
--- 464,474 ----
  }
  
  static void
! _outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
  {
  	WRITE_NODE_TYPE("BITMAPINDEXSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_OID_FIELD(indexid);
  	WRITE_NODE_FIELD(indexqual);
***************
*** 476,516 **** _outBitmapIndexScan(StringInfo str, BitmapIndexScan *node)
  }
  
  static void
! _outBitmapHeapScan(StringInfo str, BitmapHeapScan *node)
  {
  	WRITE_NODE_TYPE("BITMAPHEAPSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_NODE_FIELD(bitmapqualorig);
  }
  
  static void
! _outTidScan(StringInfo str, TidScan *node)
  {
  	WRITE_NODE_TYPE("TIDSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_NODE_FIELD(tidquals);
  }
  
  static void
! _outSubqueryScan(StringInfo str, SubqueryScan *node)
  {
  	WRITE_NODE_TYPE("SUBQUERYSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_NODE_FIELD(subplan);
  }
  
  static void
! _outFunctionScan(StringInfo str, FunctionScan *node)
  {
  	WRITE_NODE_TYPE("FUNCTIONSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_NODE_FIELD(funcexpr);
  	WRITE_NODE_FIELD(funccolnames);
--- 476,516 ----
  }
  
  static void
! _outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
  {
  	WRITE_NODE_TYPE("BITMAPHEAPSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_NODE_FIELD(bitmapqualorig);
  }
  
  static void
! _outTidScan(StringInfo str, const TidScan *node)
  {
  	WRITE_NODE_TYPE("TIDSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_NODE_FIELD(tidquals);
  }
  
  static void
! _outSubqueryScan(StringInfo str, const SubqueryScan *node)
  {
  	WRITE_NODE_TYPE("SUBQUERYSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_NODE_FIELD(subplan);
  }
  
  static void
! _outFunctionScan(StringInfo str, const FunctionScan *node)
  {
  	WRITE_NODE_TYPE("FUNCTIONSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_NODE_FIELD(funcexpr);
  	WRITE_NODE_FIELD(funccolnames);
***************
*** 520,568 **** _outFunctionScan(StringInfo str, FunctionScan *node)
  }
  
  static void
! _outValuesScan(StringInfo str, ValuesScan *node)
  {
  	WRITE_NODE_TYPE("VALUESSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_NODE_FIELD(values_lists);
  }
  
  static void
! _outCteScan(StringInfo str, CteScan *node)
  {
  	WRITE_NODE_TYPE("CTESCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_INT_FIELD(ctePlanId);
  	WRITE_INT_FIELD(cteParam);
  }
  
  static void
! _outWorkTableScan(StringInfo str, WorkTableScan *node)
  {
  	WRITE_NODE_TYPE("WORKTABLESCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_INT_FIELD(wtParam);
  }
  
  static void
! _outForeignScan(StringInfo str, ForeignScan *node)
  {
  	WRITE_NODE_TYPE("FOREIGNSCAN");
  
! 	_outScanInfo(str, (Scan *) node);
  
  	WRITE_BOOL_FIELD(fsSystemCol);
  	WRITE_NODE_FIELD(fdwplan);
  }
  
  static void
! _outFdwPlan(StringInfo str, FdwPlan *node)
  {
  	WRITE_NODE_TYPE("FDWPLAN");
  
--- 520,568 ----
  }
  
  static void
! _outValuesScan(StringInfo str, const ValuesScan *node)
  {
  	WRITE_NODE_TYPE("VALUESSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_NODE_FIELD(values_lists);
  }
  
  static void
! _outCteScan(StringInfo str, const CteScan *node)
  {
  	WRITE_NODE_TYPE("CTESCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_INT_FIELD(ctePlanId);
  	WRITE_INT_FIELD(cteParam);
  }
  
  static void
! _outWorkTableScan(StringInfo str, const WorkTableScan *node)
  {
  	WRITE_NODE_TYPE("WORKTABLESCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_INT_FIELD(wtParam);
  }
  
  static void
! _outForeignScan(StringInfo str, const ForeignScan *node)
  {
  	WRITE_NODE_TYPE("FOREIGNSCAN");
  
! 	_outScanInfo(str, (const Scan *) node);
  
  	WRITE_BOOL_FIELD(fsSystemCol);
  	WRITE_NODE_FIELD(fdwplan);
  }
  
  static void
! _outFdwPlan(StringInfo str, const FdwPlan *node)
  {
  	WRITE_NODE_TYPE("FDWPLAN");
  
***************
*** 572,603 **** _outFdwPlan(StringInfo str, FdwPlan *node)
  }
  
  static void
! _outJoin(StringInfo str, Join *node)
  {
  	WRITE_NODE_TYPE("JOIN");
  
! 	_outJoinPlanInfo(str, (Join *) node);
  }
  
  static void
! _outNestLoop(StringInfo str, NestLoop *node)
  {
  	WRITE_NODE_TYPE("NESTLOOP");
  
! 	_outJoinPlanInfo(str, (Join *) node);
  
  	WRITE_NODE_FIELD(nestParams);
  }
  
  static void
! _outMergeJoin(StringInfo str, MergeJoin *node)
  {
  	int			numCols;
  	int			i;
  
  	WRITE_NODE_TYPE("MERGEJOIN");
  
! 	_outJoinPlanInfo(str, (Join *) node);
  
  	WRITE_NODE_FIELD(mergeclauses);
  
--- 572,603 ----
  }
  
  static void
! _outJoin(StringInfo str, const Join *node)
  {
  	WRITE_NODE_TYPE("JOIN");
  
! 	_outJoinPlanInfo(str, (const Join *) node);
  }
  
  static void
! _outNestLoop(StringInfo str, const NestLoop *node)
  {
  	WRITE_NODE_TYPE("NESTLOOP");
  
! 	_outJoinPlanInfo(str, (const Join *) node);
  
  	WRITE_NODE_FIELD(nestParams);
  }
  
  static void
! _outMergeJoin(StringInfo str, const MergeJoin *node)
  {
  	int			numCols;
  	int			i;
  
  	WRITE_NODE_TYPE("MERGEJOIN");
  
! 	_outJoinPlanInfo(str, (const Join *) node);
  
  	WRITE_NODE_FIELD(mergeclauses);
  
***************
*** 621,643 **** _outMergeJoin(StringInfo str, MergeJoin *node)
  }
  
  static void
! _outHashJoin(StringInfo str, HashJoin *node)
  {
  	WRITE_NODE_TYPE("HASHJOIN");
  
! 	_outJoinPlanInfo(str, (Join *) node);
  
  	WRITE_NODE_FIELD(hashclauses);
  }
  
  static void
! _outAgg(StringInfo str, Agg *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("AGG");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
  	WRITE_INT_FIELD(numCols);
--- 621,643 ----
  }
  
  static void
! _outHashJoin(StringInfo str, const HashJoin *node)
  {
  	WRITE_NODE_TYPE("HASHJOIN");
  
! 	_outJoinPlanInfo(str, (const Join *) node);
  
  	WRITE_NODE_FIELD(hashclauses);
  }
  
  static void
! _outAgg(StringInfo str, const Agg *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("AGG");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
  	WRITE_INT_FIELD(numCols);
***************
*** 654,666 **** _outAgg(StringInfo str, Agg *node)
  }
  
  static void
! _outWindowAgg(StringInfo str, WindowAgg *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("WINDOWAGG");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_UINT_FIELD(winref);
  	WRITE_INT_FIELD(partNumCols);
--- 654,666 ----
  }
  
  static void
! _outWindowAgg(StringInfo str, const WindowAgg *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("WINDOWAGG");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_UINT_FIELD(winref);
  	WRITE_INT_FIELD(partNumCols);
***************
*** 689,701 **** _outWindowAgg(StringInfo str, WindowAgg *node)
  }
  
  static void
! _outGroup(StringInfo str, Group *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("GROUP");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
--- 689,701 ----
  }
  
  static void
! _outGroup(StringInfo str, const Group *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("GROUP");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
***************
*** 709,729 **** _outGroup(StringInfo str, Group *node)
  }
  
  static void
! _outMaterial(StringInfo str, Material *node)
  {
  	WRITE_NODE_TYPE("MATERIAL");
  
! 	_outPlanInfo(str, (Plan *) node);
  }
  
  static void
! _outSort(StringInfo str, Sort *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("SORT");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
--- 709,729 ----
  }
  
  static void
! _outMaterial(StringInfo str, const Material *node)
  {
  	WRITE_NODE_TYPE("MATERIAL");
  
! 	_outPlanInfo(str, (const Plan *) node);
  }
  
  static void
! _outSort(StringInfo str, const Sort *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("SORT");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
***************
*** 745,757 **** _outSort(StringInfo str, Sort *node)
  }
  
  static void
! _outUnique(StringInfo str, Unique *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("UNIQUE");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
--- 745,757 ----
  }
  
  static void
! _outUnique(StringInfo str, const Unique *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("UNIQUE");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_INT_FIELD(numCols);
  
***************
*** 765,775 **** _outUnique(StringInfo str, Unique *node)
  }
  
  static void
! _outHash(StringInfo str, Hash *node)
  {
  	WRITE_NODE_TYPE("HASH");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_OID_FIELD(skewTable);
  	WRITE_INT_FIELD(skewColumn);
--- 765,775 ----
  }
  
  static void
! _outHash(StringInfo str, const Hash *node)
  {
  	WRITE_NODE_TYPE("HASH");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_OID_FIELD(skewTable);
  	WRITE_INT_FIELD(skewColumn);
***************
*** 779,791 **** _outHash(StringInfo str, Hash *node)
  }
  
  static void
! _outSetOp(StringInfo str, SetOp *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("SETOP");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_ENUM_FIELD(cmd, SetOpCmd);
  	WRITE_ENUM_FIELD(strategy, SetOpStrategy);
--- 779,791 ----
  }
  
  static void
! _outSetOp(StringInfo str, const SetOp *node)
  {
  	int			i;
  
  	WRITE_NODE_TYPE("SETOP");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_ENUM_FIELD(cmd, SetOpCmd);
  	WRITE_ENUM_FIELD(strategy, SetOpStrategy);
***************
*** 805,833 **** _outSetOp(StringInfo str, SetOp *node)
  }
  
  static void
! _outLockRows(StringInfo str, LockRows *node)
  {
  	WRITE_NODE_TYPE("LOCKROWS");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  }
  
  static void
! _outLimit(StringInfo str, Limit *node)
  {
  	WRITE_NODE_TYPE("LIMIT");
  
! 	_outPlanInfo(str, (Plan *) node);
  
  	WRITE_NODE_FIELD(limitOffset);
  	WRITE_NODE_FIELD(limitCount);
  }
  
  static void
! _outNestLoopParam(StringInfo str, NestLoopParam *node)
  {
  	WRITE_NODE_TYPE("NESTLOOPPARAM");
  
--- 805,833 ----
  }
  
  static void
! _outLockRows(StringInfo str, const LockRows *node)
  {
  	WRITE_NODE_TYPE("LOCKROWS");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  }
  
  static void
! _outLimit(StringInfo str, const Limit *node)
  {
  	WRITE_NODE_TYPE("LIMIT");
  
! 	_outPlanInfo(str, (const Plan *) node);
  
  	WRITE_NODE_FIELD(limitOffset);
  	WRITE_NODE_FIELD(limitCount);
  }
  
  static void
! _outNestLoopParam(StringInfo str, const NestLoopParam *node)
  {
  	WRITE_NODE_TYPE("NESTLOOPPARAM");
  
***************
*** 836,842 **** _outNestLoopParam(StringInfo str, NestLoopParam *node)
  }
  
  static void
! _outPlanRowMark(StringInfo str, PlanRowMark *node)
  {
  	WRITE_NODE_TYPE("PLANROWMARK");
  
--- 836,842 ----
  }
  
  static void
! _outPlanRowMark(StringInfo str, const PlanRowMark *node)
  {
  	WRITE_NODE_TYPE("PLANROWMARK");
  
***************
*** 849,855 **** _outPlanRowMark(StringInfo str, PlanRowMark *node)
  }
  
  static void
! _outPlanInvalItem(StringInfo str, PlanInvalItem *node)
  {
  	WRITE_NODE_TYPE("PLANINVALITEM");
  
--- 849,855 ----
  }
  
  static void
! _outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
  {
  	WRITE_NODE_TYPE("PLANINVALITEM");
  
***************
*** 864,870 **** _outPlanInvalItem(StringInfo str, PlanInvalItem *node)
   *****************************************************************************/
  
  static void
! _outAlias(StringInfo str, Alias *node)
  {
  	WRITE_NODE_TYPE("ALIAS");
  
--- 864,870 ----
   *****************************************************************************/
  
  static void
! _outAlias(StringInfo str, const Alias *node)
  {
  	WRITE_NODE_TYPE("ALIAS");
  
***************
*** 873,879 **** _outAlias(StringInfo str, Alias *node)
  }
  
  static void
! _outRangeVar(StringInfo str, RangeVar *node)
  {
  	WRITE_NODE_TYPE("RANGEVAR");
  
--- 873,879 ----
  }
  
  static void
! _outRangeVar(StringInfo str, const RangeVar *node)
  {
  	WRITE_NODE_TYPE("RANGEVAR");
  
***************
*** 890,896 **** _outRangeVar(StringInfo str, RangeVar *node)
  }
  
  static void
! _outIntoClause(StringInfo str, IntoClause *node)
  {
  	WRITE_NODE_TYPE("INTOCLAUSE");
  
--- 890,896 ----
  }
  
  static void
! _outIntoClause(StringInfo str, const IntoClause *node)
  {
  	WRITE_NODE_TYPE("INTOCLAUSE");
  
***************
*** 902,908 **** _outIntoClause(StringInfo str, IntoClause *node)
  }
  
  static void
! _outVar(StringInfo str, Var *node)
  {
  	WRITE_NODE_TYPE("VAR");
  
--- 902,908 ----
  }
  
  static void
! _outVar(StringInfo str, const Var *node)
  {
  	WRITE_NODE_TYPE("VAR");
  
***************
*** 918,924 **** _outVar(StringInfo str, Var *node)
  }
  
  static void
! _outConst(StringInfo str, Const *node)
  {
  	WRITE_NODE_TYPE("CONST");
  
--- 918,924 ----
  }
  
  static void
! _outConst(StringInfo str, const Const *node)
  {
  	WRITE_NODE_TYPE("CONST");
  
***************
*** 938,944 **** _outConst(StringInfo str, Const *node)
  }
  
  static void
! _outParam(StringInfo str, Param *node)
  {
  	WRITE_NODE_TYPE("PARAM");
  
--- 938,944 ----
  }
  
  static void
! _outParam(StringInfo str, const Param *node)
  {
  	WRITE_NODE_TYPE("PARAM");
  
***************
*** 951,957 **** _outParam(StringInfo str, Param *node)
  }
  
  static void
! _outAggref(StringInfo str, Aggref *node)
  {
  	WRITE_NODE_TYPE("AGGREF");
  
--- 951,957 ----
  }
  
  static void
! _outAggref(StringInfo str, const Aggref *node)
  {
  	WRITE_NODE_TYPE("AGGREF");
  
***************
*** 968,974 **** _outAggref(StringInfo str, Aggref *node)
  }
  
  static void
! _outWindowFunc(StringInfo str, WindowFunc *node)
  {
  	WRITE_NODE_TYPE("WINDOWFUNC");
  
--- 968,974 ----
  }
  
  static void
! _outWindowFunc(StringInfo str, const WindowFunc *node)
  {
  	WRITE_NODE_TYPE("WINDOWFUNC");
  
***************
*** 984,990 **** _outWindowFunc(StringInfo str, WindowFunc *node)
  }
  
  static void
! _outArrayRef(StringInfo str, ArrayRef *node)
  {
  	WRITE_NODE_TYPE("ARRAYREF");
  
--- 984,990 ----
  }
  
  static void
! _outArrayRef(StringInfo str, const ArrayRef *node)
  {
  	WRITE_NODE_TYPE("ARRAYREF");
  
***************
*** 999,1005 **** _outArrayRef(StringInfo str, ArrayRef *node)
  }
  
  static void
! _outFuncExpr(StringInfo str, FuncExpr *node)
  {
  	WRITE_NODE_TYPE("FUNCEXPR");
  
--- 999,1005 ----
  }
  
  static void
! _outFuncExpr(StringInfo str, const FuncExpr *node)
  {
  	WRITE_NODE_TYPE("FUNCEXPR");
  
***************
*** 1014,1020 **** _outFuncExpr(StringInfo str, FuncExpr *node)
  }
  
  static void
! _outNamedArgExpr(StringInfo str, NamedArgExpr *node)
  {
  	WRITE_NODE_TYPE("NAMEDARGEXPR");
  
--- 1014,1020 ----
  }
  
  static void
! _outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
  {
  	WRITE_NODE_TYPE("NAMEDARGEXPR");
  
***************
*** 1025,1031 **** _outNamedArgExpr(StringInfo str, NamedArgExpr *node)
  }
  
  static void
! _outOpExpr(StringInfo str, OpExpr *node)
  {
  	WRITE_NODE_TYPE("OPEXPR");
  
--- 1025,1031 ----
  }
  
  static void
! _outOpExpr(StringInfo str, const OpExpr *node)
  {
  	WRITE_NODE_TYPE("OPEXPR");
  
***************
*** 1040,1046 **** _outOpExpr(StringInfo str, OpExpr *node)
  }
  
  static void
! _outDistinctExpr(StringInfo str, DistinctExpr *node)
  {
  	WRITE_NODE_TYPE("DISTINCTEXPR");
  
--- 1040,1046 ----
  }
  
  static void
! _outDistinctExpr(StringInfo str, const DistinctExpr *node)
  {
  	WRITE_NODE_TYPE("DISTINCTEXPR");
  
***************
*** 1055,1061 **** _outDistinctExpr(StringInfo str, DistinctExpr *node)
  }
  
  static void
! _outNullIfExpr(StringInfo str, NullIfExpr *node)
  {
  	WRITE_NODE_TYPE("NULLIFEXPR");
  
--- 1055,1061 ----
  }
  
  static void
! _outNullIfExpr(StringInfo str, const NullIfExpr *node)
  {
  	WRITE_NODE_TYPE("NULLIFEXPR");
  
***************
*** 1070,1076 **** _outNullIfExpr(StringInfo str, NullIfExpr *node)
  }
  
  static void
! _outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr *node)
  {
  	WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
  
--- 1070,1076 ----
  }
  
  static void
! _outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
  {
  	WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
  
***************
*** 1083,1089 **** _outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr *node)
  }
  
  static void
! _outBoolExpr(StringInfo str, BoolExpr *node)
  {
  	char	   *opstr = NULL;
  
--- 1083,1089 ----
  }
  
  static void
! _outBoolExpr(StringInfo str, const BoolExpr *node)
  {
  	char	   *opstr = NULL;
  
***************
*** 1110,1116 **** _outBoolExpr(StringInfo str, BoolExpr *node)
  }
  
  static void
! _outSubLink(StringInfo str, SubLink *node)
  {
  	WRITE_NODE_TYPE("SUBLINK");
  
--- 1110,1116 ----
  }
  
  static void
! _outSubLink(StringInfo str, const SubLink *node)
  {
  	WRITE_NODE_TYPE("SUBLINK");
  
***************
*** 1122,1128 **** _outSubLink(StringInfo str, SubLink *node)
  }
  
  static void
! _outSubPlan(StringInfo str, SubPlan *node)
  {
  	WRITE_NODE_TYPE("SUBPLAN");
  
--- 1122,1128 ----
  }
  
  static void
! _outSubPlan(StringInfo str, const SubPlan *node)
  {
  	WRITE_NODE_TYPE("SUBPLAN");
  
***************
*** 1144,1150 **** _outSubPlan(StringInfo str, SubPlan *node)
  }
  
  static void
! _outAlternativeSubPlan(StringInfo str, AlternativeSubPlan *node)
  {
  	WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
  
--- 1144,1150 ----
  }
  
  static void
! _outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
  {
  	WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
  
***************
*** 1152,1158 **** _outAlternativeSubPlan(StringInfo str, AlternativeSubPlan *node)
  }
  
  static void
! _outFieldSelect(StringInfo str, FieldSelect *node)
  {
  	WRITE_NODE_TYPE("FIELDSELECT");
  
--- 1152,1158 ----
  }
  
  static void
! _outFieldSelect(StringInfo str, const FieldSelect *node)
  {
  	WRITE_NODE_TYPE("FIELDSELECT");
  
***************
*** 1164,1170 **** _outFieldSelect(StringInfo str, FieldSelect *node)
  }
  
  static void
! _outFieldStore(StringInfo str, FieldStore *node)
  {
  	WRITE_NODE_TYPE("FIELDSTORE");
  
--- 1164,1170 ----
  }
  
  static void
! _outFieldStore(StringInfo str, const FieldStore *node)
  {
  	WRITE_NODE_TYPE("FIELDSTORE");
  
***************
*** 1175,1181 **** _outFieldStore(StringInfo str, FieldStore *node)
  }
  
  static void
! _outRelabelType(StringInfo str, RelabelType *node)
  {
  	WRITE_NODE_TYPE("RELABELTYPE");
  
--- 1175,1181 ----
  }
  
  static void
! _outRelabelType(StringInfo str, const RelabelType *node)
  {
  	WRITE_NODE_TYPE("RELABELTYPE");
  
***************
*** 1188,1194 **** _outRelabelType(StringInfo str, RelabelType *node)
  }
  
  static void
! _outCoerceViaIO(StringInfo str, CoerceViaIO *node)
  {
  	WRITE_NODE_TYPE("COERCEVIAIO");
  
--- 1188,1194 ----
  }
  
  static void
! _outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
  {
  	WRITE_NODE_TYPE("COERCEVIAIO");
  
***************
*** 1200,1206 **** _outCoerceViaIO(StringInfo str, CoerceViaIO *node)
  }
  
  static void
! _outArrayCoerceExpr(StringInfo str, ArrayCoerceExpr *node)
  {
  	WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
  
--- 1200,1206 ----
  }
  
  static void
! _outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
  {
  	WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
  
***************
*** 1215,1221 **** _outArrayCoerceExpr(StringInfo str, ArrayCoerceExpr *node)
  }
  
  static void
! _outConvertRowtypeExpr(StringInfo str, ConvertRowtypeExpr *node)
  {
  	WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
  
--- 1215,1221 ----
  }
  
  static void
! _outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
  {
  	WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
  
***************
*** 1226,1232 **** _outConvertRowtypeExpr(StringInfo str, ConvertRowtypeExpr *node)
  }
  
  static void
! _outCollateExpr(StringInfo str, CollateExpr *node)
  {
  	WRITE_NODE_TYPE("COLLATE");
  
--- 1226,1232 ----
  }
  
  static void
! _outCollateExpr(StringInfo str, const CollateExpr *node)
  {
  	WRITE_NODE_TYPE("COLLATE");
  
***************
*** 1236,1242 **** _outCollateExpr(StringInfo str, CollateExpr *node)
  }
  
  static void
! _outCaseExpr(StringInfo str, CaseExpr *node)
  {
  	WRITE_NODE_TYPE("CASE");
  
--- 1236,1242 ----
  }
  
  static void
! _outCaseExpr(StringInfo str, const CaseExpr *node)
  {
  	WRITE_NODE_TYPE("CASE");
  
***************
*** 1249,1255 **** _outCaseExpr(StringInfo str, CaseExpr *node)
  }
  
  static void
! _outCaseWhen(StringInfo str, CaseWhen *node)
  {
  	WRITE_NODE_TYPE("WHEN");
  
--- 1249,1255 ----
  }
  
  static void
! _outCaseWhen(StringInfo str, const CaseWhen *node)
  {
  	WRITE_NODE_TYPE("WHEN");
  
***************
*** 1259,1265 **** _outCaseWhen(StringInfo str, CaseWhen *node)
  }
  
  static void
! _outCaseTestExpr(StringInfo str, CaseTestExpr *node)
  {
  	WRITE_NODE_TYPE("CASETESTEXPR");
  
--- 1259,1265 ----
  }
  
  static void
! _outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
  {
  	WRITE_NODE_TYPE("CASETESTEXPR");
  
***************
*** 1269,1275 **** _outCaseTestExpr(StringInfo str, CaseTestExpr *node)
  }
  
  static void
! _outArrayExpr(StringInfo str, ArrayExpr *node)
  {
  	WRITE_NODE_TYPE("ARRAY");
  
--- 1269,1275 ----
  }
  
  static void
! _outArrayExpr(StringInfo str, const ArrayExpr *node)
  {
  	WRITE_NODE_TYPE("ARRAY");
  
***************
*** 1282,1288 **** _outArrayExpr(StringInfo str, ArrayExpr *node)
  }
  
  static void
! _outRowExpr(StringInfo str, RowExpr *node)
  {
  	WRITE_NODE_TYPE("ROW");
  
--- 1282,1288 ----
  }
  
  static void
! _outRowExpr(StringInfo str, const RowExpr *node)
  {
  	WRITE_NODE_TYPE("ROW");
  
***************
*** 1294,1300 **** _outRowExpr(StringInfo str, RowExpr *node)
  }
  
  static void
! _outRowCompareExpr(StringInfo str, RowCompareExpr *node)
  {
  	WRITE_NODE_TYPE("ROWCOMPARE");
  
--- 1294,1300 ----
  }
  
  static void
! _outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
  {
  	WRITE_NODE_TYPE("ROWCOMPARE");
  
***************
*** 1307,1313 **** _outRowCompareExpr(StringInfo str, RowCompareExpr *node)
  }
  
  static void
! _outCoalesceExpr(StringInfo str, CoalesceExpr *node)
  {
  	WRITE_NODE_TYPE("COALESCE");
  
--- 1307,1313 ----
  }
  
  static void
! _outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
  {
  	WRITE_NODE_TYPE("COALESCE");
  
***************
*** 1318,1324 **** _outCoalesceExpr(StringInfo str, CoalesceExpr *node)
  }
  
  static void
! _outMinMaxExpr(StringInfo str, MinMaxExpr *node)
  {
  	WRITE_NODE_TYPE("MINMAX");
  
--- 1318,1324 ----
  }
  
  static void
! _outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
  {
  	WRITE_NODE_TYPE("MINMAX");
  
***************
*** 1331,1337 **** _outMinMaxExpr(StringInfo str, MinMaxExpr *node)
  }
  
  static void
! _outXmlExpr(StringInfo str, XmlExpr *node)
  {
  	WRITE_NODE_TYPE("XMLEXPR");
  
--- 1331,1337 ----
  }
  
  static void
! _outXmlExpr(StringInfo str, const XmlExpr *node)
  {
  	WRITE_NODE_TYPE("XMLEXPR");
  
***************
*** 1347,1353 **** _outXmlExpr(StringInfo str, XmlExpr *node)
  }
  
  static void
! _outNullTest(StringInfo str, NullTest *node)
  {
  	WRITE_NODE_TYPE("NULLTEST");
  
--- 1347,1353 ----
  }
  
  static void
! _outNullTest(StringInfo str, const NullTest *node)
  {
  	WRITE_NODE_TYPE("NULLTEST");
  
***************
*** 1357,1363 **** _outNullTest(StringInfo str, NullTest *node)
  }
  
  static void
! _outBooleanTest(StringInfo str, BooleanTest *node)
  {
  	WRITE_NODE_TYPE("BOOLEANTEST");
  
--- 1357,1363 ----
  }
  
  static void
! _outBooleanTest(StringInfo str, const BooleanTest *node)
  {
  	WRITE_NODE_TYPE("BOOLEANTEST");
  
***************
*** 1366,1372 **** _outBooleanTest(StringInfo str, BooleanTest *node)
  }
  
  static void
! _outCoerceToDomain(StringInfo str, CoerceToDomain *node)
  {
  	WRITE_NODE_TYPE("COERCETODOMAIN");
  
--- 1366,1372 ----
  }
  
  static void
! _outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
  {
  	WRITE_NODE_TYPE("COERCETODOMAIN");
  
***************
*** 1379,1385 **** _outCoerceToDomain(StringInfo str, CoerceToDomain *node)
  }
  
  static void
! _outCoerceToDomainValue(StringInfo str, CoerceToDomainValue *node)
  {
  	WRITE_NODE_TYPE("COERCETODOMAINVALUE");
  
--- 1379,1385 ----
  }
  
  static void
! _outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
  {
  	WRITE_NODE_TYPE("COERCETODOMAINVALUE");
  
***************
*** 1390,1396 **** _outCoerceToDomainValue(StringInfo str, CoerceToDomainValue *node)
  }
  
  static void
! _outSetToDefault(StringInfo str, SetToDefault *node)
  {
  	WRITE_NODE_TYPE("SETTODEFAULT");
  
--- 1390,1396 ----
  }
  
  static void
! _outSetToDefault(StringInfo str, const SetToDefault *node)
  {
  	WRITE_NODE_TYPE("SETTODEFAULT");
  
***************
*** 1401,1407 **** _outSetToDefault(StringInfo str, SetToDefault *node)
  }
  
  static void
! _outCurrentOfExpr(StringInfo str, CurrentOfExpr *node)
  {
  	WRITE_NODE_TYPE("CURRENTOFEXPR");
  
--- 1401,1407 ----
  }
  
  static void
! _outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
  {
  	WRITE_NODE_TYPE("CURRENTOFEXPR");
  
***************
*** 1411,1417 **** _outCurrentOfExpr(StringInfo str, CurrentOfExpr *node)
  }
  
  static void
! _outTargetEntry(StringInfo str, TargetEntry *node)
  {
  	WRITE_NODE_TYPE("TARGETENTRY");
  
--- 1411,1417 ----
  }
  
  static void
! _outTargetEntry(StringInfo str, const TargetEntry *node)
  {
  	WRITE_NODE_TYPE("TARGETENTRY");
  
***************
*** 1425,1431 **** _outTargetEntry(StringInfo str, TargetEntry *node)
  }
  
  static void
! _outRangeTblRef(StringInfo str, RangeTblRef *node)
  {
  	WRITE_NODE_TYPE("RANGETBLREF");
  
--- 1425,1431 ----
  }
  
  static void
! _outRangeTblRef(StringInfo str, const RangeTblRef *node)
  {
  	WRITE_NODE_TYPE("RANGETBLREF");
  
***************
*** 1433,1439 **** _outRangeTblRef(StringInfo str, RangeTblRef *node)
  }
  
  static void
! _outJoinExpr(StringInfo str, JoinExpr *node)
  {
  	WRITE_NODE_TYPE("JOINEXPR");
  
--- 1433,1439 ----
  }
  
  static void
! _outJoinExpr(StringInfo str, const JoinExpr *node)
  {
  	WRITE_NODE_TYPE("JOINEXPR");
  
***************
*** 1448,1454 **** _outJoinExpr(StringInfo str, JoinExpr *node)
  }
  
  static void
! _outFromExpr(StringInfo str, FromExpr *node)
  {
  	WRITE_NODE_TYPE("FROMEXPR");
  
--- 1448,1454 ----
  }
  
  static void
! _outFromExpr(StringInfo str, const FromExpr *node)
  {
  	WRITE_NODE_TYPE("FROMEXPR");
  
***************
*** 1469,1475 **** _outFromExpr(StringInfo str, FromExpr *node)
   * We can print the parent's relids for identification purposes, though.
   */
  static void
! _outPathInfo(StringInfo str, Path *node)
  {
  	WRITE_ENUM_FIELD(pathtype, NodeTag);
  	appendStringInfo(str, " :parent_relids ");
--- 1469,1475 ----
   * We can print the parent's relids for identification purposes, though.
   */
  static void
! _outPathInfo(StringInfo str, const Path *node)
  {
  	WRITE_ENUM_FIELD(pathtype, NodeTag);
  	appendStringInfo(str, " :parent_relids ");
***************
*** 1483,1491 **** _outPathInfo(StringInfo str, Path *node)
   * print the basic stuff of all nodes that inherit from JoinPath
   */
  static void
! _outJoinPathInfo(StringInfo str, JoinPath *node)
  {
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_ENUM_FIELD(jointype, JoinType);
  	WRITE_NODE_FIELD(outerjoinpath);
--- 1483,1491 ----
   * print the basic stuff of all nodes that inherit from JoinPath
   */
  static void
! _outJoinPathInfo(StringInfo str, const JoinPath *node)
  {
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_ENUM_FIELD(jointype, JoinType);
  	WRITE_NODE_FIELD(outerjoinpath);
***************
*** 1494,1512 **** _outJoinPathInfo(StringInfo str, JoinPath *node)
  }
  
  static void
! _outPath(StringInfo str, Path *node)
  {
  	WRITE_NODE_TYPE("PATH");
  
! 	_outPathInfo(str, (Path *) node);
  }
  
  static void
! _outIndexPath(StringInfo str, IndexPath *node)
  {
  	WRITE_NODE_TYPE("INDEXPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(indexinfo);
  	WRITE_NODE_FIELD(indexclauses);
--- 1494,1512 ----
  }
  
  static void
! _outPath(StringInfo str, const Path *node)
  {
  	WRITE_NODE_TYPE("PATH");
  
! 	_outPathInfo(str, (const Path *) node);
  }
  
  static void
! _outIndexPath(StringInfo str, const IndexPath *node)
  {
  	WRITE_NODE_TYPE("INDEXPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(indexinfo);
  	WRITE_NODE_FIELD(indexclauses);
***************
*** 1520,1530 **** _outIndexPath(StringInfo str, IndexPath *node)
  }
  
  static void
! _outBitmapHeapPath(StringInfo str, BitmapHeapPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPHEAPPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(bitmapqual);
  	WRITE_BOOL_FIELD(isjoininner);
--- 1520,1530 ----
  }
  
  static void
! _outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPHEAPPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(bitmapqual);
  	WRITE_BOOL_FIELD(isjoininner);
***************
*** 1532,1538 **** _outBitmapHeapPath(StringInfo str, BitmapHeapPath *node)
  }
  
  static void
! _outBitmapAndPath(StringInfo str, BitmapAndPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPANDPATH");
  
--- 1532,1538 ----
  }
  
  static void
! _outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPANDPATH");
  
***************
*** 1543,1580 **** _outBitmapAndPath(StringInfo str, BitmapAndPath *node)
  }
  
  static void
! _outBitmapOrPath(StringInfo str, BitmapOrPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPORPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(bitmapquals);
  	WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
  }
  
  static void
! _outTidPath(StringInfo str, TidPath *node)
  {
  	WRITE_NODE_TYPE("TIDPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(tidquals);
  }
  
  static void
! _outForeignPath(StringInfo str, ForeignPath *node)
  {
  	WRITE_NODE_TYPE("FOREIGNPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(fdwplan);
  }
  
  static void
! _outAppendPath(StringInfo str, AppendPath *node)
  {
  	WRITE_NODE_TYPE("APPENDPATH");
  
--- 1543,1580 ----
  }
  
  static void
! _outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
  {
  	WRITE_NODE_TYPE("BITMAPORPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(bitmapquals);
  	WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
  }
  
  static void
! _outTidPath(StringInfo str, const TidPath *node)
  {
  	WRITE_NODE_TYPE("TIDPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(tidquals);
  }
  
  static void
! _outForeignPath(StringInfo str, const ForeignPath *node)
  {
  	WRITE_NODE_TYPE("FOREIGNPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(fdwplan);
  }
  
  static void
! _outAppendPath(StringInfo str, const AppendPath *node)
  {
  	WRITE_NODE_TYPE("APPENDPATH");
  
***************
*** 1584,1625 **** _outAppendPath(StringInfo str, AppendPath *node)
  }
  
  static void
! _outMergeAppendPath(StringInfo str, MergeAppendPath *node)
  {
  	WRITE_NODE_TYPE("MERGEAPPENDPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(subpaths);
  	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
  }
  
  static void
! _outResultPath(StringInfo str, ResultPath *node)
  {
  	WRITE_NODE_TYPE("RESULTPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(quals);
  }
  
  static void
! _outMaterialPath(StringInfo str, MaterialPath *node)
  {
  	WRITE_NODE_TYPE("MATERIALPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(subpath);
  }
  
  static void
! _outUniquePath(StringInfo str, UniquePath *node)
  {
  	WRITE_NODE_TYPE("UNIQUEPATH");
  
! 	_outPathInfo(str, (Path *) node);
  
  	WRITE_NODE_FIELD(subpath);
  	WRITE_ENUM_FIELD(umethod, UniquePathMethod);
--- 1584,1625 ----
  }
  
  static void
! _outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
  {
  	WRITE_NODE_TYPE("MERGEAPPENDPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(subpaths);
  	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
  }
  
  static void
! _outResultPath(StringInfo str, const ResultPath *node)
  {
  	WRITE_NODE_TYPE("RESULTPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(quals);
  }
  
  static void
! _outMaterialPath(StringInfo str, const MaterialPath *node)
  {
  	WRITE_NODE_TYPE("MATERIALPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(subpath);
  }
  
  static void
! _outUniquePath(StringInfo str, const UniquePath *node)
  {
  	WRITE_NODE_TYPE("UNIQUEPATH");
  
! 	_outPathInfo(str, (const Path *) node);
  
  	WRITE_NODE_FIELD(subpath);
  	WRITE_ENUM_FIELD(umethod, UniquePathMethod);
***************
*** 1629,1647 **** _outUniquePath(StringInfo str, UniquePath *node)
  }
  
  static void
! _outNestPath(StringInfo str, NestPath *node)
  {
  	WRITE_NODE_TYPE("NESTPATH");
  
! 	_outJoinPathInfo(str, (JoinPath *) node);
  }
  
  static void
! _outMergePath(StringInfo str, MergePath *node)
  {
  	WRITE_NODE_TYPE("MERGEPATH");
  
! 	_outJoinPathInfo(str, (JoinPath *) node);
  
  	WRITE_NODE_FIELD(path_mergeclauses);
  	WRITE_NODE_FIELD(outersortkeys);
--- 1629,1647 ----
  }
  
  static void
! _outNestPath(StringInfo str, const NestPath *node)
  {
  	WRITE_NODE_TYPE("NESTPATH");
  
! 	_outJoinPathInfo(str, (const JoinPath *) node);
  }
  
  static void
! _outMergePath(StringInfo str, const MergePath *node)
  {
  	WRITE_NODE_TYPE("MERGEPATH");
  
! 	_outJoinPathInfo(str, (const JoinPath *) node);
  
  	WRITE_NODE_FIELD(path_mergeclauses);
  	WRITE_NODE_FIELD(outersortkeys);
***************
*** 1650,1667 **** _outMergePath(StringInfo str, MergePath *node)
  }
  
  static void
! _outHashPath(StringInfo str, HashPath *node)
  {
  	WRITE_NODE_TYPE("HASHPATH");
  
! 	_outJoinPathInfo(str, (JoinPath *) node);
  
  	WRITE_NODE_FIELD(path_hashclauses);
  	WRITE_INT_FIELD(num_batches);
  }
  
  static void
! _outPlannerGlobal(StringInfo str, PlannerGlobal *node)
  {
  	WRITE_NODE_TYPE("PLANNERGLOBAL");
  
--- 1650,1667 ----
  }
  
  static void
! _outHashPath(StringInfo str, const HashPath *node)
  {
  	WRITE_NODE_TYPE("HASHPATH");
  
! 	_outJoinPathInfo(str, (const JoinPath *) node);
  
  	WRITE_NODE_FIELD(path_hashclauses);
  	WRITE_INT_FIELD(num_batches);
  }
  
  static void
! _outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
  {
  	WRITE_NODE_TYPE("PLANNERGLOBAL");
  
***************
*** 1680,1686 **** _outPlannerGlobal(StringInfo str, PlannerGlobal *node)
  }
  
  static void
! _outPlannerInfo(StringInfo str, PlannerInfo *node)
  {
  	WRITE_NODE_TYPE("PLANNERINFO");
  
--- 1680,1686 ----
  }
  
  static void
! _outPlannerInfo(StringInfo str, const PlannerInfo *node)
  {
  	WRITE_NODE_TYPE("PLANNERINFO");
  
***************
*** 1721,1727 **** _outPlannerInfo(StringInfo str, PlannerInfo *node)
  }
  
  static void
! _outRelOptInfo(StringInfo str, RelOptInfo *node)
  {
  	WRITE_NODE_TYPE("RELOPTINFO");
  
--- 1721,1727 ----
  }
  
  static void
! _outRelOptInfo(StringInfo str, const RelOptInfo *node)
  {
  	WRITE_NODE_TYPE("RELOPTINFO");
  
***************
*** 1754,1760 **** _outRelOptInfo(StringInfo str, RelOptInfo *node)
  }
  
  static void
! _outIndexOptInfo(StringInfo str, IndexOptInfo *node)
  {
  	WRITE_NODE_TYPE("INDEXOPTINFO");
  
--- 1754,1760 ----
  }
  
  static void
! _outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
  {
  	WRITE_NODE_TYPE("INDEXOPTINFO");
  
***************
*** 1775,1781 **** _outIndexOptInfo(StringInfo str, IndexOptInfo *node)
  }
  
  static void
! _outEquivalenceClass(StringInfo str, EquivalenceClass *node)
  {
  	/*
  	 * To simplify reading, we just chase up to the topmost merged EC and
--- 1775,1781 ----
  }
  
  static void
! _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
  {
  	/*
  	 * To simplify reading, we just chase up to the topmost merged EC and
***************
*** 1800,1806 **** _outEquivalenceClass(StringInfo str, EquivalenceClass *node)
  }
  
  static void
! _outEquivalenceMember(StringInfo str, EquivalenceMember *node)
  {
  	WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
  
--- 1800,1806 ----
  }
  
  static void
! _outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
  {
  	WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
  
***************
*** 1812,1818 **** _outEquivalenceMember(StringInfo str, EquivalenceMember *node)
  }
  
  static void
! _outPathKey(StringInfo str, PathKey *node)
  {
  	WRITE_NODE_TYPE("PATHKEY");
  
--- 1812,1818 ----
  }
  
  static void
! _outPathKey(StringInfo str, const PathKey *node)
  {
  	WRITE_NODE_TYPE("PATHKEY");
  
***************
*** 1823,1829 **** _outPathKey(StringInfo str, PathKey *node)
  }
  
  static void
! _outRestrictInfo(StringInfo str, RestrictInfo *node)
  {
  	WRITE_NODE_TYPE("RESTRICTINFO");
  
--- 1823,1829 ----
  }
  
  static void
! _outRestrictInfo(StringInfo str, const RestrictInfo *node)
  {
  	WRITE_NODE_TYPE("RESTRICTINFO");
  
***************
*** 1852,1858 **** _outRestrictInfo(StringInfo str, RestrictInfo *node)
  }
  
  static void
! _outInnerIndexscanInfo(StringInfo str, InnerIndexscanInfo *node)
  {
  	WRITE_NODE_TYPE("INNERINDEXSCANINFO");
  	WRITE_BITMAPSET_FIELD(other_relids);
--- 1852,1858 ----
  }
  
  static void
! _outInnerIndexscanInfo(StringInfo str, const InnerIndexscanInfo *node)
  {
  	WRITE_NODE_TYPE("INNERINDEXSCANINFO");
  	WRITE_BITMAPSET_FIELD(other_relids);
***************
*** 1862,1868 **** _outInnerIndexscanInfo(StringInfo str, InnerIndexscanInfo *node)
  }
  
  static void
! _outPlaceHolderVar(StringInfo str, PlaceHolderVar *node)
  {
  	WRITE_NODE_TYPE("PLACEHOLDERVAR");
  
--- 1862,1868 ----
  }
  
  static void
! _outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
  {
  	WRITE_NODE_TYPE("PLACEHOLDERVAR");
  
***************
*** 1873,1879 **** _outPlaceHolderVar(StringInfo str, PlaceHolderVar *node)
  }
  
  static void
! _outSpecialJoinInfo(StringInfo str, SpecialJoinInfo *node)
  {
  	WRITE_NODE_TYPE("SPECIALJOININFO");
  
--- 1873,1879 ----
  }
  
  static void
! _outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
  {
  	WRITE_NODE_TYPE("SPECIALJOININFO");
  
***************
*** 1888,1894 **** _outSpecialJoinInfo(StringInfo str, SpecialJoinInfo *node)
  }
  
  static void
! _outAppendRelInfo(StringInfo str, AppendRelInfo *node)
  {
  	WRITE_NODE_TYPE("APPENDRELINFO");
  
--- 1888,1894 ----
  }
  
  static void
! _outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
  {
  	WRITE_NODE_TYPE("APPENDRELINFO");
  
***************
*** 1901,1907 **** _outAppendRelInfo(StringInfo str, AppendRelInfo *node)
  }
  
  static void
! _outPlaceHolderInfo(StringInfo str, PlaceHolderInfo *node)
  {
  	WRITE_NODE_TYPE("PLACEHOLDERINFO");
  
--- 1901,1907 ----
  }
  
  static void
! _outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
  {
  	WRITE_NODE_TYPE("PLACEHOLDERINFO");
  
***************
*** 1914,1920 **** _outPlaceHolderInfo(StringInfo str, PlaceHolderInfo *node)
  }
  
  static void
! _outMinMaxAggInfo(StringInfo str, MinMaxAggInfo *node)
  {
  	WRITE_NODE_TYPE("MINMAXAGGINFO");
  
--- 1914,1920 ----
  }
  
  static void
! _outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
  {
  	WRITE_NODE_TYPE("MINMAXAGGINFO");
  
***************
*** 1928,1934 **** _outMinMaxAggInfo(StringInfo str, MinMaxAggInfo *node)
  }
  
  static void
! _outPlannerParamItem(StringInfo str, PlannerParamItem *node)
  {
  	WRITE_NODE_TYPE("PLANNERPARAMITEM");
  
--- 1928,1934 ----
  }
  
  static void
! _outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
  {
  	WRITE_NODE_TYPE("PLANNERPARAMITEM");
  
***************
*** 1943,1949 **** _outPlannerParamItem(StringInfo str, PlannerParamItem *node)
   *****************************************************************************/
  
  static void
! _outCreateStmt(StringInfo str, CreateStmt *node)
  {
  	WRITE_NODE_TYPE("CREATESTMT");
  
--- 1943,1949 ----
   *****************************************************************************/
  
  static void
! _outCreateStmt(StringInfo str, const CreateStmt *node)
  {
  	WRITE_NODE_TYPE("CREATESTMT");
  
***************
*** 1959,1965 **** _outCreateStmt(StringInfo str, CreateStmt *node)
  }
  
  static void
! _outCreateForeignTableStmt(StringInfo str, CreateForeignTableStmt *node)
  {
  	WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
  
--- 1959,1965 ----
  }
  
  static void
! _outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
  {
  	WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
  
***************
*** 1970,1976 **** _outCreateForeignTableStmt(StringInfo str, CreateForeignTableStmt *node)
  }
  
  static void
! _outIndexStmt(StringInfo str, IndexStmt *node)
  {
  	WRITE_NODE_TYPE("INDEXSTMT");
  
--- 1970,1976 ----
  }
  
  static void
! _outIndexStmt(StringInfo str, const IndexStmt *node)
  {
  	WRITE_NODE_TYPE("INDEXSTMT");
  
***************
*** 1993,1999 **** _outIndexStmt(StringInfo str, IndexStmt *node)
  }
  
  static void
! _outNotifyStmt(StringInfo str, NotifyStmt *node)
  {
  	WRITE_NODE_TYPE("NOTIFY");
  
--- 1993,1999 ----
  }
  
  static void
! _outNotifyStmt(StringInfo str, const NotifyStmt *node)
  {
  	WRITE_NODE_TYPE("NOTIFY");
  
***************
*** 2002,2008 **** _outNotifyStmt(StringInfo str, NotifyStmt *node)
  }
  
  static void
! _outDeclareCursorStmt(StringInfo str, DeclareCursorStmt *node)
  {
  	WRITE_NODE_TYPE("DECLARECURSOR");
  
--- 2002,2008 ----
  }
  
  static void
! _outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
  {
  	WRITE_NODE_TYPE("DECLARECURSOR");
  
***************
*** 2012,2018 **** _outDeclareCursorStmt(StringInfo str, DeclareCursorStmt *node)
  }
  
  static void
! _outSelectStmt(StringInfo str, SelectStmt *node)
  {
  	WRITE_NODE_TYPE("SELECT");
  
--- 2012,2018 ----
  }
  
  static void
! _outSelectStmt(StringInfo str, const SelectStmt *node)
  {
  	WRITE_NODE_TYPE("SELECT");
  
***************
*** 2037,2043 **** _outSelectStmt(StringInfo str, SelectStmt *node)
  }
  
  static void
! _outFuncCall(StringInfo str, FuncCall *node)
  {
  	WRITE_NODE_TYPE("FUNCCALL");
  
--- 2037,2043 ----
  }
  
  static void
! _outFuncCall(StringInfo str, const FuncCall *node)
  {
  	WRITE_NODE_TYPE("FUNCCALL");
  
***************
*** 2052,2058 **** _outFuncCall(StringInfo str, FuncCall *node)
  }
  
  static void
! _outDefElem(StringInfo str, DefElem *node)
  {
  	WRITE_NODE_TYPE("DEFELEM");
  
--- 2052,2058 ----
  }
  
  static void
! _outDefElem(StringInfo str, const DefElem *node)
  {
  	WRITE_NODE_TYPE("DEFELEM");
  
***************
*** 2063,2069 **** _outDefElem(StringInfo str, DefElem *node)
  }
  
  static void
! _outInhRelation(StringInfo str, InhRelation *node)
  {
  	WRITE_NODE_TYPE("INHRELATION");
  
--- 2063,2069 ----
  }
  
  static void
! _outInhRelation(StringInfo str, const InhRelation *node)
  {
  	WRITE_NODE_TYPE("INHRELATION");
  
***************
*** 2072,2078 **** _outInhRelation(StringInfo str, InhRelation *node)
  }
  
  static void
! _outLockingClause(StringInfo str, LockingClause *node)
  {
  	WRITE_NODE_TYPE("LOCKINGCLAUSE");
  
--- 2072,2078 ----
  }
  
  static void
! _outLockingClause(StringInfo str, const LockingClause *node)
  {
  	WRITE_NODE_TYPE("LOCKINGCLAUSE");
  
***************
*** 2082,2088 **** _outLockingClause(StringInfo str, LockingClause *node)
  }
  
  static void
! _outXmlSerialize(StringInfo str, XmlSerialize *node)
  {
  	WRITE_NODE_TYPE("XMLSERIALIZE");
  
--- 2082,2088 ----
  }
  
  static void
! _outXmlSerialize(StringInfo str, const XmlSerialize *node)
  {
  	WRITE_NODE_TYPE("XMLSERIALIZE");
  
***************
*** 2093,2099 **** _outXmlSerialize(StringInfo str, XmlSerialize *node)
  }
  
  static void
! _outColumnDef(StringInfo str, ColumnDef *node)
  {
  	WRITE_NODE_TYPE("COLUMNDEF");
  
--- 2093,2099 ----
  }
  
  static void
! _outColumnDef(StringInfo str, const ColumnDef *node)
  {
  	WRITE_NODE_TYPE("COLUMNDEF");
  
***************
*** 2113,2119 **** _outColumnDef(StringInfo str, ColumnDef *node)
  }
  
  static void
! _outTypeName(StringInfo str, TypeName *node)
  {
  	WRITE_NODE_TYPE("TYPENAME");
  
--- 2113,2119 ----
  }
  
  static void
! _outTypeName(StringInfo str, const TypeName *node)
  {
  	WRITE_NODE_TYPE("TYPENAME");
  
***************
*** 2128,2134 **** _outTypeName(StringInfo str, TypeName *node)
  }
  
  static void
! _outTypeCast(StringInfo str, TypeCast *node)
  {
  	WRITE_NODE_TYPE("TYPECAST");
  
--- 2128,2134 ----
  }
  
  static void
! _outTypeCast(StringInfo str, const TypeCast *node)
  {
  	WRITE_NODE_TYPE("TYPECAST");
  
***************
*** 2138,2144 **** _outTypeCast(StringInfo str, TypeCast *node)
  }
  
  static void
! _outCollateClause(StringInfo str, CollateClause *node)
  {
  	WRITE_NODE_TYPE("COLLATECLAUSE");
  
--- 2138,2144 ----
  }
  
  static void
! _outCollateClause(StringInfo str, const CollateClause *node)
  {
  	WRITE_NODE_TYPE("COLLATECLAUSE");
  
***************
*** 2148,2154 **** _outCollateClause(StringInfo str, CollateClause *node)
  }
  
  static void
! _outIndexElem(StringInfo str, IndexElem *node)
  {
  	WRITE_NODE_TYPE("INDEXELEM");
  
--- 2148,2154 ----
  }
  
  static void
! _outIndexElem(StringInfo str, const IndexElem *node)
  {
  	WRITE_NODE_TYPE("INDEXELEM");
  
***************
*** 2162,2168 **** _outIndexElem(StringInfo str, IndexElem *node)
  }
  
  static void
! _outQuery(StringInfo str, Query *node)
  {
  	WRITE_NODE_TYPE("QUERY");
  
--- 2162,2168 ----
  }
  
  static void
! _outQuery(StringInfo str, const Query *node)
  {
  	WRITE_NODE_TYPE("QUERY");
  
***************
*** 2222,2228 **** _outQuery(StringInfo str, Query *node)
  }
  
  static void
! _outSortGroupClause(StringInfo str, SortGroupClause *node)
  {
  	WRITE_NODE_TYPE("SORTGROUPCLAUSE");
  
--- 2222,2228 ----
  }
  
  static void
! _outSortGroupClause(StringInfo str, const SortGroupClause *node)
  {
  	WRITE_NODE_TYPE("SORTGROUPCLAUSE");
  
***************
*** 2234,2240 **** _outSortGroupClause(StringInfo str, SortGroupClause *node)
  }
  
  static void
! _outWindowClause(StringInfo str, WindowClause *node)
  {
  	WRITE_NODE_TYPE("WINDOWCLAUSE");
  
--- 2234,2240 ----
  }
  
  static void
! _outWindowClause(StringInfo str, const WindowClause *node)
  {
  	WRITE_NODE_TYPE("WINDOWCLAUSE");
  
***************
*** 2250,2256 **** _outWindowClause(StringInfo str, WindowClause *node)
  }
  
  static void
! _outRowMarkClause(StringInfo str, RowMarkClause *node)
  {
  	WRITE_NODE_TYPE("ROWMARKCLAUSE");
  
--- 2250,2256 ----
  }
  
  static void
! _outRowMarkClause(StringInfo str, const RowMarkClause *node)
  {
  	WRITE_NODE_TYPE("ROWMARKCLAUSE");
  
***************
*** 2261,2267 **** _outRowMarkClause(StringInfo str, RowMarkClause *node)
  }
  
  static void
! _outWithClause(StringInfo str, WithClause *node)
  {
  	WRITE_NODE_TYPE("WITHCLAUSE");
  
--- 2261,2267 ----
  }
  
  static void
! _outWithClause(StringInfo str, const WithClause *node)
  {
  	WRITE_NODE_TYPE("WITHCLAUSE");
  
***************
*** 2271,2277 **** _outWithClause(StringInfo str, WithClause *node)
  }
  
  static void
! _outCommonTableExpr(StringInfo str, CommonTableExpr *node)
  {
  	WRITE_NODE_TYPE("COMMONTABLEEXPR");
  
--- 2271,2277 ----
  }
  
  static void
! _outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
  {
  	WRITE_NODE_TYPE("COMMONTABLEEXPR");
  
***************
*** 2288,2294 **** _outCommonTableExpr(StringInfo str, CommonTableExpr *node)
  }
  
  static void
! _outSetOperationStmt(StringInfo str, SetOperationStmt *node)
  {
  	WRITE_NODE_TYPE("SETOPERATIONSTMT");
  
--- 2288,2294 ----
  }
  
  static void
! _outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
  {
  	WRITE_NODE_TYPE("SETOPERATIONSTMT");
  
***************
*** 2303,2309 **** _outSetOperationStmt(StringInfo str, SetOperationStmt *node)
  }
  
  static void
! _outRangeTblEntry(StringInfo str, RangeTblEntry *node)
  {
  	WRITE_NODE_TYPE("RTE");
  
--- 2303,2309 ----
  }
  
  static void
! _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
  {
  	WRITE_NODE_TYPE("RTE");
  
***************
*** 2357,2363 **** _outRangeTblEntry(StringInfo str, RangeTblEntry *node)
  }
  
  static void
! _outAExpr(StringInfo str, A_Expr *node)
  {
  	WRITE_NODE_TYPE("AEXPR");
  
--- 2357,2363 ----
  }
  
  static void
! _outAExpr(StringInfo str, const A_Expr *node)
  {
  	WRITE_NODE_TYPE("AEXPR");
  
***************
*** 2413,2419 **** _outAExpr(StringInfo str, A_Expr *node)
  }
  
  static void
! _outValue(StringInfo str, Value *value)
  {
  	switch (value->type)
  	{
--- 2413,2419 ----
  }
  
  static void
! _outValue(StringInfo str, const Value *value)
  {
  	switch (value->type)
  	{
***************
*** 2448,2454 **** _outValue(StringInfo str, Value *value)
  }
  
  static void
! _outColumnRef(StringInfo str, ColumnRef *node)
  {
  	WRITE_NODE_TYPE("COLUMNREF");
  
--- 2448,2454 ----
  }
  
  static void
! _outColumnRef(StringInfo str, const ColumnRef *node)
  {
  	WRITE_NODE_TYPE("COLUMNREF");
  
***************
*** 2457,2463 **** _outColumnRef(StringInfo str, ColumnRef *node)
  }
  
  static void
! _outParamRef(StringInfo str, ParamRef *node)
  {
  	WRITE_NODE_TYPE("PARAMREF");
  
--- 2457,2463 ----
  }
  
  static void
! _outParamRef(StringInfo str, const ParamRef *node)
  {
  	WRITE_NODE_TYPE("PARAMREF");
  
***************
*** 2466,2472 **** _outParamRef(StringInfo str, ParamRef *node)
  }
  
  static void
! _outAConst(StringInfo str, A_Const *node)
  {
  	WRITE_NODE_TYPE("A_CONST");
  
--- 2466,2472 ----
  }
  
  static void
! _outAConst(StringInfo str, const A_Const *node)
  {
  	WRITE_NODE_TYPE("A_CONST");
  
***************
*** 2476,2488 **** _outAConst(StringInfo str, A_Const *node)
  }
  
  static void
! _outA_Star(StringInfo str, A_Star *node)
  {
  	WRITE_NODE_TYPE("A_STAR");
  }
  
  static void
! _outA_Indices(StringInfo str, A_Indices *node)
  {
  	WRITE_NODE_TYPE("A_INDICES");
  
--- 2476,2488 ----
  }
  
  static void
! _outA_Star(StringInfo str, const A_Star *node)
  {
  	WRITE_NODE_TYPE("A_STAR");
  }
  
  static void
! _outA_Indices(StringInfo str, const A_Indices *node)
  {
  	WRITE_NODE_TYPE("A_INDICES");
  
***************
*** 2491,2497 **** _outA_Indices(StringInfo str, A_Indices *node)
  }
  
  static void
! _outA_Indirection(StringInfo str, A_Indirection *node)
  {
  	WRITE_NODE_TYPE("A_INDIRECTION");
  
--- 2491,2497 ----
  }
  
  static void
! _outA_Indirection(StringInfo str, const A_Indirection *node)
  {
  	WRITE_NODE_TYPE("A_INDIRECTION");
  
***************
*** 2500,2506 **** _outA_Indirection(StringInfo str, A_Indirection *node)
  }
  
  static void
! _outA_ArrayExpr(StringInfo str, A_ArrayExpr *node)
  {
  	WRITE_NODE_TYPE("A_ARRAYEXPR");
  
--- 2500,2506 ----
  }
  
  static void
! _outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
  {
  	WRITE_NODE_TYPE("A_ARRAYEXPR");
  
***************
*** 2509,2515 **** _outA_ArrayExpr(StringInfo str, A_ArrayExpr *node)
  }
  
  static void
! _outResTarget(StringInfo str, ResTarget *node)
  {
  	WRITE_NODE_TYPE("RESTARGET");
  
--- 2509,2515 ----
  }
  
  static void
! _outResTarget(StringInfo str, const ResTarget *node)
  {
  	WRITE_NODE_TYPE("RESTARGET");
  
***************
*** 2520,2526 **** _outResTarget(StringInfo str, ResTarget *node)
  }
  
  static void
! _outSortBy(StringInfo str, SortBy *node)
  {
  	WRITE_NODE_TYPE("SORTBY");
  
--- 2520,2526 ----
  }
  
  static void
! _outSortBy(StringInfo str, const SortBy *node)
  {
  	WRITE_NODE_TYPE("SORTBY");
  
***************
*** 2532,2538 **** _outSortBy(StringInfo str, SortBy *node)
  }
  
  static void
! _outWindowDef(StringInfo str, WindowDef *node)
  {
  	WRITE_NODE_TYPE("WINDOWDEF");
  
--- 2532,2538 ----
  }
  
  static void
! _outWindowDef(StringInfo str, const WindowDef *node)
  {
  	WRITE_NODE_TYPE("WINDOWDEF");
  
***************
*** 2547,2553 **** _outWindowDef(StringInfo str, WindowDef *node)
  }
  
  static void
! _outRangeSubselect(StringInfo str, RangeSubselect *node)
  {
  	WRITE_NODE_TYPE("RANGESUBSELECT");
  
--- 2547,2553 ----
  }
  
  static void
! _outRangeSubselect(StringInfo str, const RangeSubselect *node)
  {
  	WRITE_NODE_TYPE("RANGESUBSELECT");
  
***************
*** 2556,2562 **** _outRangeSubselect(StringInfo str, RangeSubselect *node)
  }
  
  static void
! _outRangeFunction(StringInfo str, RangeFunction *node)
  {
  	WRITE_NODE_TYPE("RANGEFUNCTION");
  
--- 2556,2562 ----
  }
  
  static void
! _outRangeFunction(StringInfo str, const RangeFunction *node)
  {
  	WRITE_NODE_TYPE("RANGEFUNCTION");
  
***************
*** 2566,2572 **** _outRangeFunction(StringInfo str, RangeFunction *node)
  }
  
  static void
! _outConstraint(StringInfo str, Constraint *node)
  {
  	WRITE_NODE_TYPE("CONSTRAINT");
  
--- 2566,2572 ----
  }
  
  static void
! _outConstraint(StringInfo str, const Constraint *node)
  {
  	WRITE_NODE_TYPE("CONSTRAINT");
  
*** a/src/backend/nodes/print.c
--- b/src/backend/nodes/print.c
***************
*** 251,257 **** pretty_format_node_dump(const char *dump)
  void
  print_rt(List *rtable)
  {
! 	ListCell   *l;
  	int			i = 1;
  
  	printf("resno\trefname  \trelid\tinFromCl\n");
--- 251,257 ----
  void
  print_rt(List *rtable)
  {
! 	const ListCell   *l;
  	int			i = 1;
  
  	printf("resno\trefname  \trelid\tinFromCl\n");
***************
*** 304,310 **** print_rt(List *rtable)
   *	  print an expression
   */
  void
! print_expr(Node *expr, List *rtable)
  {
  	if (expr == NULL)
  	{
--- 304,310 ----
   *	  print an expression
   */
  void
! print_expr(const Node *expr, List *rtable)
  {
  	if (expr == NULL)
  	{
***************
*** 412,418 **** print_expr(Node *expr, List *rtable)
  void
  print_pathkeys(List *pathkeys, List *rtable)
  {
! 	ListCell   *i;
  
  	printf("(");
  	foreach(i, pathkeys)
--- 412,418 ----
  void
  print_pathkeys(List *pathkeys, List *rtable)
  {
! 	const ListCell   *i;
  
  	printf("(");
  	foreach(i, pathkeys)
***************
*** 452,458 **** print_pathkeys(List *pathkeys, List *rtable)
  void
  print_tl(List *tlist, List *rtable)
  {
! 	ListCell   *tl;
  
  	printf("(\n");
  	foreach(tl, tlist)
--- 452,458 ----
  void
  print_tl(List *tlist, List *rtable)
  {
! 	const ListCell   *tl;
  
  	printf("(\n");
  	foreach(tl, tlist)
*** a/src/include/nodes/nodeFuncs.h
--- b/src/include/nodes/nodeFuncs.h
***************
*** 26,42 ****
  #define QTW_DONT_COPY_QUERY			0x20		/* do not copy top Query */
  
  
! extern Oid	exprType(Node *expr);
! extern int32 exprTypmod(Node *expr);
! extern bool exprIsLengthCoercion(Node *expr, int32 *coercedTypmod);
  extern bool expression_returns_set(Node *clause);
  
! extern Oid	exprCollation(Node *expr);
! extern Oid	exprInputCollation(Node *expr);
  extern void exprSetCollation(Node *expr, Oid collation);
  extern void exprSetInputCollation(Node *expr, Oid inputcollation);
  
! extern int	exprLocation(Node *expr);
  
  extern bool expression_tree_walker(Node *node, bool (*walker) (),
  											   void *context);
--- 26,42 ----
  #define QTW_DONT_COPY_QUERY			0x20		/* do not copy top Query */
  
  
! extern Oid	exprType(const Node *expr);
! extern int32 exprTypmod(const Node *expr);
! extern bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod);
  extern bool expression_returns_set(Node *clause);
  
! extern Oid	exprCollation(const Node *expr);
! extern Oid	exprInputCollation(const Node *expr);
  extern void exprSetCollation(Node *expr, Oid collation);
  extern void exprSetInputCollation(Node *expr, Oid inputcollation);
  
! extern int	exprLocation(const Node *expr);
  
  extern bool expression_tree_walker(Node *node, bool (*walker) (),
  											   void *context);
*** a/src/include/nodes/pg_list.h
--- b/src/include/nodes/pg_list.h
***************
*** 211,217 **** extern int	list_nth_int(List *list, int n);
  extern Oid	list_nth_oid(List *list, int n);
  
  extern bool list_member(List *list, void *datum);
! extern bool list_member_ptr(List *list, void *datum);
  extern bool list_member_int(List *list, int datum);
  extern bool list_member_oid(List *list, Oid datum);
  
--- 211,217 ----
  extern Oid	list_nth_oid(List *list, int n);
  
  extern bool list_member(List *list, void *datum);
! extern bool list_member_ptr(List *list, const void *datum);
  extern bool list_member_int(List *list, int datum);
  extern bool list_member_oid(List *list, Oid datum);
  
*** a/src/include/nodes/print.h
--- b/src/include/nodes/print.h
***************
*** 26,32 **** extern void elog_node_display(int lev, const char *title,
  extern char *format_node_dump(const char *dump);
  extern char *pretty_format_node_dump(const char *dump);
  extern void print_rt(List *rtable);
! extern void print_expr(Node *expr, List *rtable);
  extern void print_pathkeys(List *pathkeys, List *rtable);
  extern void print_tl(List *tlist, List *rtable);
  extern void print_slot(TupleTableSlot *slot);
--- 26,32 ----
  extern char *format_node_dump(const char *dump);
  extern char *pretty_format_node_dump(const char *dump);
  extern void print_rt(List *rtable);
! extern void print_expr(const Node *expr, List *rtable);
  extern void print_pathkeys(List *pathkeys, List *rtable);
  extern void print_tl(List *tlist, List *rtable);
  extern void print_slot(TupleTableSlot *slot);