pgindent run before 6.3 release, with Thomas' requested changes.

5 files changed, 455 insertions, 430 deletions

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 85ede31987e..7c450104ce7 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.26 1998/02/13 03:36:54 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.27 1998/02/26 04:32:48 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -46,33 +46,44 @@
 static List *switch_outer(List *clauses);
 static Scan *create_scan_node(Path *best_path, List *tlist);
 static Join *create_join_node(JoinPath *best_path, List *tlist);
-static SeqScan *create_seqscan_node(Path *best_path, List *tlist,
+static SeqScan *
+create_seqscan_node(Path *best_path, List *tlist,
 					List *scan_clauses);
-static IndexScan *create_indexscan_node(IndexPath *best_path, List *tlist,
+static IndexScan *
+create_indexscan_node(IndexPath *best_path, List *tlist,
 					  List *scan_clauses);
-static NestLoop *create_nestloop_node(JoinPath *best_path, List *tlist,
+static NestLoop *
+create_nestloop_node(JoinPath *best_path, List *tlist,
 					 List *clauses, Plan *outer_node, List *outer_tlist,
 					 Plan *inner_node, List *inner_tlist);
-static MergeJoin *create_mergejoin_node(MergePath *best_path, List *tlist,
+static MergeJoin *
+create_mergejoin_node(MergePath *best_path, List *tlist,
 					  List *clauses, Plan *outer_node, List *outer_tlist,
 					  Plan *inner_node, List *inner_tlist);
-static HashJoin *create_hashjoin_node(HashPath *best_path, List *tlist,
+static HashJoin *
+create_hashjoin_node(HashPath *best_path, List *tlist,
 					 List *clauses, Plan *outer_node, List *outer_tlist,
 					 Plan *inner_node, List *inner_tlist);
 static Node *fix_indxqual_references(Node *clause, Path *index_path);
-static Temp *make_temp(List *tlist, List *keys, Oid *operators,
+static Temp *
+make_temp(List *tlist, List *keys, Oid *operators,
 		  Plan *plan_node, int temptype);
-static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
+static IndexScan *
+make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
 			   List *indxid, List *indxqual, Cost cost);
-static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
+static NestLoop *
+make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
 			  Plan *righttree);
-static HashJoin *make_hashjoin(List *tlist, List *qpqual,
+static HashJoin *
+make_hashjoin(List *tlist, List *qpqual,
 			  List *hashclauses, Plan *lefttree, Plan *righttree);
 static Hash *make_hash(List *tlist, Var *hashkey, Plan *lefttree);
-static MergeJoin *make_mergesort(List *tlist, List *qpqual,
+static MergeJoin *
+make_mergesort(List *tlist, List *qpqual,
 			   List *mergeclauses, Oid opcode, Oid *rightorder,
 			   Oid *leftorder, Plan *righttree, Plan *lefttree);
-static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
+static Material *
+make_material(List *tlist, Oid tempid, Plan *lefttree,
 			  int keycount);
 
 /*
@@ -90,7 +101,7 @@ static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
  *
  *	  Returns the optimal(?) access plan.
  */
-Plan	   *
+Plan *
 create_plan(Path *best_path)
 {
 	List	   *tlist;
@@ -931,7 +942,7 @@ make_seqscan(List *qptlist,
 	SeqScan    *node = makeNode(SeqScan);
 	Plan	   *plan = &node->plan;
 
-    plan->cost = (lefttree ? lefttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = qptlist;
 	plan->qual = qpqual;
@@ -949,7 +960,7 @@ make_indexscan(List *qptlist,
 			   Index scanrelid,
 			   List *indxid,
 			   List *indxqual,
-			   Cost  cost)
+			   Cost cost)
 {
 	IndexScan  *node = makeNode(IndexScan);
 	Plan	   *plan = &node->scan.plan;
@@ -978,8 +989,8 @@ make_nestloop(List *qptlist,
 	NestLoop   *node = makeNode(NestLoop);
 	Plan	   *plan = &node->join;
 
-    plan->cost = (lefttree ? lefttree->cost : 0) +
-		 (righttree ? righttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0) +
+		(righttree ? righttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = qptlist;
 	plan->qual = qpqual;
@@ -1000,8 +1011,8 @@ make_hashjoin(List *tlist,
 	HashJoin   *node = makeNode(HashJoin);
 	Plan	   *plan = &node->join;
 
-    plan->cost = (lefttree ? lefttree->cost : 0) +
-		 (righttree ? righttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0) +
+		(righttree ? righttree->cost : 0);
 	plan->cost = 0.0;
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
@@ -1023,7 +1034,7 @@ make_hash(List *tlist, Var *hashkey, Plan *lefttree)
 	Hash	   *node = makeNode(Hash);
 	Plan	   *plan = &node->plan;
 
-    plan->cost = (lefttree ? lefttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0);
 	plan->cost = 0.0;
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
@@ -1051,8 +1062,8 @@ make_mergesort(List *tlist,
 	MergeJoin  *node = makeNode(MergeJoin);
 	Plan	   *plan = &node->join;
 
-    plan->cost = (lefttree ? lefttree->cost : 0) +
-		 (righttree ? righttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0) +
+		(righttree ? righttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
 	plan->qual = qpqual;
@@ -1066,13 +1077,13 @@ make_mergesort(List *tlist,
 	return (node);
 }
 
-Sort	   *
+Sort *
 make_sort(List *tlist, Oid tempid, Plan *lefttree, int keycount)
 {
 	Sort	   *node = makeNode(Sort);
 	Plan	   *plan = &node->plan;
 
-    plan->cost = (lefttree ? lefttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
 	plan->qual = NIL;
@@ -1093,7 +1104,7 @@ make_material(List *tlist,
 	Material   *node = makeNode(Material);
 	Plan	   *plan = &node->plan;
 
-    plan->cost = (lefttree ? lefttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
 	plan->qual = NIL;
@@ -1105,12 +1116,12 @@ make_material(List *tlist,
 	return (node);
 }
 
-Agg		   *
+Agg *
 make_agg(List *tlist, Plan *lefttree)
 {
 	Agg		   *node = makeNode(Agg);
 
-    node->plan.cost = (lefttree ? lefttree->cost : 0);
+	node->plan.cost = (lefttree ? lefttree->cost : 0);
 	node->plan.state = (EState *) NULL;
 	node->plan.qual = NULL;
 	node->plan.targetlist = tlist;
@@ -1121,7 +1132,7 @@ make_agg(List *tlist, Plan *lefttree)
 	return (node);
 }
 
-Group	   *
+Group *
 make_group(List *tlist,
 		   bool tuplePerGroup,
 		   int ngrp,
@@ -1130,7 +1141,7 @@ make_group(List *tlist,
 {
 	Group	   *node = makeNode(Group);
 
-    node->plan.cost = (lefttree ? lefttree->plan.cost : 0);
+	node->plan.cost = (lefttree ? lefttree->plan.cost : 0);
 	node->plan.state = (EState *) NULL;
 	node->plan.qual = NULL;
 	node->plan.targetlist = tlist;
@@ -1151,13 +1162,13 @@ make_group(List *tlist,
  * or "*"
  */
 
-Unique	   *
+Unique *
 make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
 {
 	Unique	   *node = makeNode(Unique);
 	Plan	   *plan = &node->plan;
 
-    plan->cost = (lefttree ? lefttree->cost : 0);
+	plan->cost = (lefttree ? lefttree->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
 	plan->qual = NIL;
@@ -1175,7 +1186,7 @@ make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
 }
 
 #ifdef NOT_USED
-List	   *
+List *
 generate_fjoin(List *tlist)
 {
 	List		tlistP;
@@ -1228,5 +1239,5 @@ generate_fjoin(List *tlist)
 	return newTlist;
 	return tlist;				/* do nothing for now - ay 10/94 */
 }
-#endif
 
+#endif
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index ca5859cb04b..132cda732b2 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.19 1998/02/13 03:36:57 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.20 1998/02/26 04:32:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -64,7 +64,7 @@ make_groupPlan(List **tlist, bool tuplePerGroup,
  *
  *	  Returns a query plan.
  */
-Plan	   *
+Plan *
 query_planner(Query *root,
 			  int command_type,
 			  List *tlist,
@@ -74,18 +74,18 @@ query_planner(Query *root,
 	List	   *var_only_tlist = NIL;
 	List	   *level_tlist = NIL;
 	Plan	   *subplan = NULL;
-	
-	if ( PlannerQueryLevel > 1 )
+
+	if (PlannerQueryLevel > 1)
 	{
 		/* should copy be made ? */
-		tlist = (List *) SS_replace_correlation_vars ((Node*)tlist);
-		qual = (List *) SS_replace_correlation_vars ((Node*)qual);
+		tlist = (List *) SS_replace_correlation_vars((Node *) tlist);
+		qual = (List *) SS_replace_correlation_vars((Node *) qual);
 	}
 	if (root->hasSubLinks)
-		qual = (List *) SS_process_sublinks ((Node*) qual);
-	
+		qual = (List *) SS_process_sublinks((Node *) qual);
+
 	qual = cnfify((Expr *) qual, true);
-	
+
 	/*
 	 * A command without a target list or qualification is an error,
 	 * except for "delete foo".
@@ -158,7 +158,7 @@ query_planner(Query *root,
 					if (constant_qual != NULL)
 					{
 						return ((Plan *) make_result(tlist,
-													 (Node *) constant_qual,
+												  (Node *) constant_qual,
 													 (Plan *) scan));
 					}
 					else
@@ -187,10 +187,10 @@ query_planner(Query *root,
 	 */
 	if (constant_qual)
 	{
-		subplan = (Plan *)make_result((!root->hasAggs && !root->groupClause)
-											? tlist : subplan->targetlist,
-										(Node *) constant_qual,
-										subplan);
+		subplan = (Plan *) make_result((!root->hasAggs && !root->groupClause)
+									   ? tlist : subplan->targetlist,
+									   (Node *) constant_qual,
+									   subplan);
 
 		/*
 		 * Change all varno's of the Result's node target list.
@@ -200,6 +200,7 @@ query_planner(Query *root,
 
 		return subplan;
 	}
+
 	/*
 	 * fix up the flattened target list of the plan root node so that
 	 * expressions are evaluated.  this forces expression evaluations that
@@ -213,15 +214,16 @@ query_planner(Query *root,
 	 * aggregates fixing only other entries (i.e. - GroupBy-ed and so
 	 * fixed by make_groupPlan).	 - vadim 04/05/97
 	 */
-	 else
-	 {
+	else
+	{
 		if (!root->hasAggs && !root->groupClause)
 			subplan->targetlist = flatten_tlist_vars(tlist,
-												 subplan->targetlist);
+													 subplan->targetlist);
 		return subplan;
-	 }
-	 
+	}
+
 #ifdef NOT_USED
+
 	/*
 	 * Destructively modify the query plan's targetlist to add fjoin lists
 	 * to flatten functions that return sets of base types
@@ -330,7 +332,7 @@ make_result(List *tlist,
 #ifdef NOT_USED
 	tlist = generate_fjoin(tlist);
 #endif
-    plan->cost = (subplan ? subplan->cost : 0);
+	plan->cost = (subplan ? subplan->cost : 0);
 	plan->state = (EState *) NULL;
 	plan->targetlist = tlist;
 	plan->lefttree = subplan;
@@ -379,9 +381,9 @@ make_groupPlan(List **tlist,
 	 */
 	foreach(sl, sort_tlist)
 	{
-		Resdom		   *resdom = NULL;
-		TargetEntry	   *te = (TargetEntry *) lfirst(sl);
-		int				keyno = 0;
+		Resdom	   *resdom = NULL;
+		TargetEntry *te = (TargetEntry *) lfirst(sl);
+		int			keyno = 0;
 
 		foreach(gl, groupClause)
 		{
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 367978eb57b..824c0d29b35 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.22 1998/02/13 03:36:59 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.23 1998/02/26 04:32:51 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -49,7 +49,8 @@
 #include "executor/executor.h"
 
 static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
-extern Plan *make_groupPlan(List **tlist, bool tuplePerGroup,
+extern Plan *
+make_groupPlan(List **tlist, bool tuplePerGroup,
 			   List *groupClause, Plan *subplan);
 
 /*****************************************************************************
@@ -58,27 +59,27 @@ extern Plan *make_groupPlan(List **tlist, bool tuplePerGroup,
  *
  *****************************************************************************/
 
-Plan*
+Plan *
 planner(Query *parse)
 {
 	Plan	   *result_plan;
-	
+
 	PlannerQueryLevel = 1;
 	PlannerVarParam = NULL;
 	PlannerParamVar = NULL;
 	PlannerInitPlan = NULL;
 	PlannerPlanId = 0;
-	
-	result_plan = union_planner (parse);
-	
-	Assert (PlannerQueryLevel == 1);
-	if ( PlannerPlanId > 0 )
+
+	result_plan = union_planner(parse);
+
+	Assert(PlannerQueryLevel == 1);
+	if (PlannerPlanId > 0)
 	{
 		result_plan->initPlan = PlannerInitPlan;
-		(void) SS_finalize_plan (result_plan);
+		(void) SS_finalize_plan(result_plan);
 	}
-	result_plan->nParamExec = length (PlannerParamVar);
-	
+	result_plan->nParamExec = length(PlannerParamVar);
+
 	return (result_plan);
 }
 
@@ -91,7 +92,7 @@ planner(Query *parse)
  * Returns a query plan.
  *
  */
-Plan	   *
+Plan *
 union_planner(Query *parse)
 {
 	List	   *tlist = parse->targetList;
@@ -100,7 +101,7 @@ union_planner(Query *parse)
 	Plan	   *result_plan = (Plan *) NULL;
 
 	Index		rt_index;
-	
+
 
 	if (parse->unionClause)
 	{
@@ -112,7 +113,7 @@ union_planner(Query *parse)
 									  parse->rtable);
 	}
 	else if ((rt_index =
-				first_inherit_rt_entry(rangetable)) != -1)
+			  first_inherit_rt_entry(rangetable)) != -1)
 	{
 		result_plan = (Plan *) plan_inherit_queries(parse, rt_index);
 		/* XXX do we need to do this? bjm 12/19/97 */
@@ -123,27 +124,27 @@ union_planner(Query *parse)
 	}
 	else
 	{
-		List  **vpm = NULL;
-		
+		List	  **vpm = NULL;
+
 		tlist = preprocess_targetlist(tlist,
 									  parse->commandType,
 									  parse->resultRelation,
 									  parse->rtable);
-		if ( parse->rtable != NULL )
+		if (parse->rtable != NULL)
 		{
-			vpm = (List **) palloc (length (parse->rtable) * sizeof (List*));
-			memset (vpm, 0, length (parse->rtable) * sizeof (List*));
+			vpm = (List **) palloc(length(parse->rtable) * sizeof(List *));
+			memset(vpm, 0, length(parse->rtable) * sizeof(List *));
 		}
-		PlannerVarParam = lcons (vpm, PlannerVarParam);
+		PlannerVarParam = lcons(vpm, PlannerVarParam);
 		result_plan = query_planner(parse,
 									parse->commandType,
 									tlist,
-									(List*) parse->qual);
-		PlannerVarParam = lnext (PlannerVarParam);
-		if ( vpm != NULL )
-			pfree (vpm);
+									(List *) parse->qual);
+		PlannerVarParam = lnext(PlannerVarParam);
+		if (vpm != NULL)
+			pfree(vpm);
 	}
-	
+
 	/*
 	 * If we have a GROUP BY clause, insert a group node (with the
 	 * appropriate sort node.)
@@ -161,10 +162,10 @@ union_planner(Query *parse)
 		tuplePerGroup = parse->hasAggs;
 
 		result_plan =
-			make_groupPlan( &tlist,
-							tuplePerGroup,
-							parse->groupClause,
-							result_plan);
+			make_groupPlan(&tlist,
+						   tuplePerGroup,
+						   parse->groupClause,
+						   result_plan);
 
 	}
 
@@ -173,14 +174,14 @@ union_planner(Query *parse)
 	 */
 	if (parse->hasAggs)
 	{
-		result_plan = (Plan *)make_agg(tlist, result_plan);
+		result_plan = (Plan *) make_agg(tlist, result_plan);
 
 		/*
 		 * set the varno/attno entries to the appropriate references to
 		 * the result tuple of the subplans.
 		 */
-		((Agg *)result_plan)->aggs =
-			set_agg_tlist_references((Agg *)result_plan);
+		((Agg *) result_plan)->aggs =
+			set_agg_tlist_references((Agg *) result_plan);
 	}
 
 	/*
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index fc51657b8d0..c82a711637b 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.18 1998/02/13 03:37:02 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.19 1998/02/26 04:32:53 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -36,9 +36,11 @@
 static void set_join_tlist_references(Join *join);
 static void set_tempscan_tlist_references(SeqScan *tempscan);
 static void set_temp_tlist_references(Temp *temp);
-static List *replace_clause_joinvar_refs(Expr *clause,
+static List *
+replace_clause_joinvar_refs(Expr *clause,
 							List *outer_tlist, List *inner_tlist);
-static List *replace_subclause_joinvar_refs(List *clauses,
+static List *
+replace_subclause_joinvar_refs(List *clauses,
 							   List *outer_tlist, List *inner_tlist);
 static Var *replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist);
 static List *tlist_temp_references(Oid tempid, List *tlist);
@@ -216,7 +218,7 @@ set_temp_tlist_references(Temp *temp)
  * Returns the new join clauses.
  *
  */
-List	   *
+List *
 join_references(List *clauses,
 				List *outer_tlist,
 				List *inner_tlist)
@@ -242,7 +244,7 @@ join_references(List *clauses,
  * Returns the new list of clauses.
  *
  */
-List	   *
+List *
 index_outerjoin_references(List *inner_indxqual,
 						   List *outer_tlist,
 						   Index inner_relid)
@@ -407,19 +409,19 @@ replace_clause_joinvar_refs(Expr *clause,
 	}
 	else if (is_subplan(clause))
 	{
-		((Expr*) clause)->args =
-		replace_subclause_joinvar_refs(((Expr*) clause)->args,
-										outer_tlist,
-										inner_tlist);
-		((SubPlan*) ((Expr*) clause)->oper)->sublink->oper = 
-		replace_subclause_joinvar_refs(((SubPlan*) ((Expr*) clause)->oper)->sublink->oper,
-										outer_tlist,
-										inner_tlist);
-		return ((List*) clause);
+		((Expr *) clause)->args =
+			replace_subclause_joinvar_refs(((Expr *) clause)->args,
+										   outer_tlist,
+										   inner_tlist);
+		((SubPlan *) ((Expr *) clause)->oper)->sublink->oper =
+			replace_subclause_joinvar_refs(((SubPlan *) ((Expr *) clause)->oper)->sublink->oper,
+										   outer_tlist,
+										   inner_tlist);
+		return ((List *) clause);
 	}
 	/* shouldn't reach here */
-	elog (ERROR, "replace_clause_joinvar_refs: unsupported clause %d", 
-			nodeTag (clause));
+	elog(ERROR, "replace_clause_joinvar_refs: unsupported clause %d",
+		 nodeTag(clause));
 	return NULL;
 }
 
@@ -612,7 +614,7 @@ replace_result_clause(Node *clause,
 	}
 	else if (is_funcclause(clause))
 	{
-		List   *subExpr;
+		List	   *subExpr;
 
 		/*
 		 * This is a function. Recursively call this routine for its
@@ -627,7 +629,7 @@ replace_result_clause(Node *clause,
 	else if (IsA(clause, ArrayRef))
 	{
 		ArrayRef   *aref = (ArrayRef *) clause;
-		
+
 		/*
 		 * This is an arrayref. Recursively call this routine for its
 		 * expression and its index expression...
@@ -647,18 +649,18 @@ replace_result_clause(Node *clause,
 	}
 	else if (is_opclause(clause))
 	{
-		Node *subNode;
+		Node	   *subNode;
 
 		/*
 		 * This is an operator. Recursively call this routine for both its
 		 * left and right operands
 		 */
-		subNode = (Node *)get_leftop((Expr *) clause);
+		subNode = (Node *) get_leftop((Expr *) clause);
 		replace_result_clause(subNode, subplanTargetList);
 		subNode = (Node *) get_rightop((Expr *) clause);
 		replace_result_clause(subNode, subplanTargetList);
 	}
-	else if (IsA(clause, Param) || IsA(clause, Const))
+	else if (IsA(clause, Param) ||IsA(clause, Const))
 	{
 		/* do nothing! */
 	}
@@ -730,7 +732,7 @@ set_agg_tlist_references(Agg *aggNode)
 		TargetEntry *tle = lfirst(tl);
 
 		aggreg_list = nconc(
-			replace_agg_clause(tle->expr, subplanTargetList),aggreg_list);
+		  replace_agg_clause(tle->expr, subplanTargetList), aggreg_list);
 	}
 	return aggreg_list;
 }
@@ -739,7 +741,7 @@ static List *
 replace_agg_clause(Node *clause, List *subplanTargetList)
 {
 	List	   *t;
-	List *agg_list = NIL;
+	List	   *agg_list = NIL;
 
 	if (IsA(clause, Var))
 	{
@@ -760,6 +762,7 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
 	}
 	else if (is_funcclause(clause))
 	{
+
 		/*
 		 * This is a function. Recursively call this routine for its
 		 * arguments...
@@ -767,19 +770,19 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
 		foreach(t, ((Expr *) clause)->args)
 		{
 			agg_list = nconc(agg_list,
-				replace_agg_clause(lfirst(t), subplanTargetList));
+					   replace_agg_clause(lfirst(t), subplanTargetList));
 		}
 		return agg_list;
 	}
 	else if (IsA(clause, Aggreg))
 	{
 		return lcons(clause,
-			replace_agg_clause(((Aggreg *) clause)->target, subplanTargetList));
+					 replace_agg_clause(((Aggreg *) clause)->target, subplanTargetList));
 	}
 	else if (IsA(clause, ArrayRef))
 	{
 		ArrayRef   *aref = (ArrayRef *) clause;
-		
+
 		/*
 		 * This is an arrayref. Recursively call this routine for its
 		 * expression and its index expression...
@@ -787,35 +790,36 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
 		foreach(t, aref->refupperindexpr)
 		{
 			agg_list = nconc(agg_list,
-				replace_agg_clause(lfirst(t), subplanTargetList));
+					   replace_agg_clause(lfirst(t), subplanTargetList));
 		}
 		foreach(t, aref->reflowerindexpr)
 		{
 			agg_list = nconc(agg_list,
-				replace_agg_clause(lfirst(t), subplanTargetList));
+					   replace_agg_clause(lfirst(t), subplanTargetList));
 		}
 		agg_list = nconc(agg_list,
-			replace_agg_clause(aref->refexpr, subplanTargetList));
+				   replace_agg_clause(aref->refexpr, subplanTargetList));
 		agg_list = nconc(agg_list,
-			replace_agg_clause(aref->refassgnexpr, subplanTargetList));
+			  replace_agg_clause(aref->refassgnexpr, subplanTargetList));
 
 		return agg_list;
 	}
 	else if (is_opclause(clause))
 	{
+
 		/*
 		 * This is an operator. Recursively call this routine for both its
 		 * left and right operands
 		 */
 		Node	   *left = (Node *) get_leftop((Expr *) clause);
 		Node	   *right = (Node *) get_rightop((Expr *) clause);
-		
+
 		if (left != (Node *) NULL)
 			agg_list = nconc(agg_list,
-				replace_agg_clause(left, subplanTargetList));
+							 replace_agg_clause(left, subplanTargetList));
 		if (right != (Node *) NULL)
 			agg_list = nconc(agg_list,
-				replace_agg_clause(right, subplanTargetList));
+						   replace_agg_clause(right, subplanTargetList));
 
 		return agg_list;
 	}
@@ -840,7 +844,8 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
  *	  Remove the Agg nodes from the target list
  *	  We do this so inheritance only does aggregates in the upper node
  */
-void del_agg_tlist_references(List *tlist)
+void
+del_agg_tlist_references(List *tlist)
 {
 	List	   *tl;
 
@@ -863,6 +868,7 @@ del_agg_clause(Node *clause)
 	}
 	else if (is_funcclause(clause))
 	{
+
 		/*
 		 * This is a function. Recursively call this routine for its
 		 * arguments...
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 4d4378780c2..11e466ce5ef 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -26,61 +26,61 @@
 #include "optimizer/var.h"
 #include "optimizer/cost.h"
 
-int		PlannerQueryLevel;		/* level of current query */
-List   *PlannerVarParam;		/* correlation Vars to Param mapper */
-List   *PlannerParamVar;		/* to get Var from Param->paramid */
-List   *PlannerInitPlan;		/* init subplans for current query */
-int		PlannerPlanId;
+int			PlannerQueryLevel;	/* level of current query */
+List	   *PlannerVarParam;	/* correlation Vars to Param mapper */
+List	   *PlannerParamVar;	/* to get Var from Param->paramid */
+List	   *PlannerInitPlan;	/* init subplans for current query */
+int			PlannerPlanId;
 
 
 static int
-_new_param (Var *var, int varlevel)
+_new_param(Var *var, int varlevel)
 {
-	List   *last;
-	int		i = 0;
-	
-	if ( PlannerParamVar == NULL )
+	List	   *last;
+	int			i = 0;
+
+	if (PlannerParamVar == NULL)
 		last = PlannerParamVar = makeNode(List);
 	else
 	{
-		for (last = PlannerParamVar; ; )
+		for (last = PlannerParamVar;;)
 		{
 			i++;
-			if ( lnext(last) == NULL )
+			if (lnext(last) == NULL)
 				break;
 			last = lnext(last);
 		}
 		lnext(last) = makeNode(List);
 		last = lnext(last);
 	}
-	
+
 	lnext(last) = NULL;
-	lfirst(last) = makeVar (var->varno, var->varattno, var->vartype,
-			var->vartypmod, varlevel, var->varnoold, var->varoattno);
-	
+	lfirst(last) = makeVar(var->varno, var->varattno, var->vartype,
+				var->vartypmod, varlevel, var->varnoold, var->varoattno);
+
 	return (i);
 }
 
-static Param*
-_replace_var (Var *var)
+static Param *
+_replace_var(Var *var)
 {
-	List  **rt = (List**) nth (var->varlevelsup, PlannerVarParam);
-	List   *vpe = rt[var->varno - 1];
-	Param  *retval;
-	int		i;
-	
-	if ( vpe == NULL )
+	List	  **rt = (List **) nth(var->varlevelsup, PlannerVarParam);
+	List	   *vpe = rt[var->varno - 1];
+	Param	   *retval;
+	int			i;
+
+	if (vpe == NULL)
 	{
 		vpe = rt[var->varno - 1] = makeNode(List);
 		lfirsti(vpe) = -1;
 		lnext(vpe) = NULL;
 	}
-	
-	for (i = 1; ; i++)
+
+	for (i = 1;; i++)
 	{
-		if ( i == var->varattno )
+		if (i == var->varattno)
 			break;
-		if ( lnext(vpe) == NULL )
+		if (lnext(vpe) == NULL)
 		{
 			lnext(vpe) = makeNode(List);
 			vpe = lnext(vpe);
@@ -90,381 +90,385 @@ _replace_var (Var *var)
 		else
 			vpe = lnext(vpe);
 	}
-	
-	if ( (i = lfirsti(vpe)) < 0 )	/* parameter is not assigned */
+
+	if ((i = lfirsti(vpe)) < 0) /* parameter is not assigned */
 	{
-		i = _new_param (var, PlannerQueryLevel - var->varlevelsup);
+		i = _new_param(var, PlannerQueryLevel - var->varlevelsup);
 	}
-	
+
 	retval = makeNode(Param);
 	retval->paramkind = PARAM_EXEC;
 	retval->paramid = (AttrNumber) i;
 	retval->paramtype = var->vartype;
-	
+
 	return (retval);
 }
 
-static Node*
-_make_subplan (SubLink *slink)
+static Node *
+_make_subplan(SubLink *slink)
 {
-	SubPlan	   *node = makeNode (SubPlan);
+	SubPlan    *node = makeNode(SubPlan);
 	Plan	   *plan;
 	List	   *lst;
 	Node	   *result;
 	List	   *saved_ip = PlannerInitPlan;
-	
+
 	PlannerInitPlan = NULL;
-	
+
 	PlannerQueryLevel++;		/* we becomes child */
-	
-	node->plan = plan = union_planner ((Query*) slink->subselect);
-	
-	/* 
-	 * Assign subPlan, extParam and locParam to plan nodes.
-	 * At the moment, SS_finalize_plan doesn't handle initPlan-s
-	 * and so we assigne them to the topmost plan node and take
-	 * care about its extParam too.
+
+	node->plan = plan = union_planner((Query *) slink->subselect);
+
+	/*
+	 * Assign subPlan, extParam and locParam to plan nodes. At the moment,
+	 * SS_finalize_plan doesn't handle initPlan-s and so we assigne them
+	 * to the topmost plan node and take care about its extParam too.
 	 */
-	(void) SS_finalize_plan (plan);
+	(void) SS_finalize_plan(plan);
 	plan->initPlan = PlannerInitPlan;
-	
+
 	/* Get extParam from InitPlan-s */
-	foreach (lst, PlannerInitPlan)
+	foreach(lst, PlannerInitPlan)
 	{
-		List   *lp;
-		
-		foreach (lp, ((SubPlan*) lfirst (lst))->plan->extParam)
+		List	   *lp;
+
+		foreach(lp, ((SubPlan *) lfirst(lst))->plan->extParam)
 		{
-			if ( !intMember (lfirsti(lp), plan->extParam) )
-				plan->extParam = lappendi (plan->extParam, lfirsti(lp));
+			if (!intMember(lfirsti(lp), plan->extParam))
+				plan->extParam = lappendi(plan->extParam, lfirsti(lp));
 		}
 	}
-	
+
 	/* and now we are parent again */
 	PlannerInitPlan = saved_ip;
 	PlannerQueryLevel--;
-	
+
 	node->plan_id = PlannerPlanId++;
-	node->rtable = ((Query*) slink->subselect)->rtable;
+	node->rtable = ((Query *) slink->subselect)->rtable;
 	node->sublink = slink;
 	slink->subselect = NULL;	/* cool ?! */
-	
+
 	/* make parParam list */
-	foreach (lst, plan->extParam)
+	foreach(lst, plan->extParam)
 	{
-		Var	   *var = nth (lfirsti(lst), PlannerParamVar);
-		
-		if ( var->varlevelsup == PlannerQueryLevel )
-			node->parParam = lappendi (node->parParam, lfirsti(lst));
+		Var		   *var = nth(lfirsti(lst), PlannerParamVar);
+
+		if (var->varlevelsup == PlannerQueryLevel)
+			node->parParam = lappendi(node->parParam, lfirsti(lst));
 	}
-	
-	/* 
-	 * Un-correlated or undirect correlated plans of EXISTS or EXPR
-	 * types can be used as initPlans...
+
+	/*
+	 * Un-correlated or undirect correlated plans of EXISTS or EXPR types
+	 * can be used as initPlans...
 	 */
-	if ( node->parParam == NULL && slink->subLinkType == EXPR_SUBLINK )
+	if (node->parParam == NULL && slink->subLinkType == EXPR_SUBLINK)
 	{
-		int	i = 0;
-		
+		int			i = 0;
+
 		/* transform right side of all sublink Oper-s into Param */
-		foreach (lst, slink->oper)
+		foreach(lst, slink->oper)
 		{
-			List		   *rside = lnext(((Expr*) lfirst(lst))->args);
-			TargetEntry	   *te = nth (i, plan->targetlist);
-			Var			   *var = makeVar (0, 0, te->resdom->restype, 
-										   te->resdom->restypmod, 
-										   PlannerQueryLevel, 0, 0);
-			Param		   *prm = makeNode(Param);
-			
+			List	   *rside = lnext(((Expr *) lfirst(lst))->args);
+			TargetEntry *te = nth(i, plan->targetlist);
+			Var		   *var = makeVar(0, 0, te->resdom->restype,
+									  te->resdom->restypmod,
+									  PlannerQueryLevel, 0, 0);
+			Param	   *prm = makeNode(Param);
+
 			prm->paramkind = PARAM_EXEC;
-			prm->paramid = (AttrNumber) _new_param (var, PlannerQueryLevel);
+			prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
 			prm->paramtype = var->vartype;
 			lfirst(rside) = prm;
-			node->setParam = lappendi (node->setParam, prm->paramid);
-			pfree (var);
+			node->setParam = lappendi(node->setParam, prm->paramid);
+			pfree(var);
 			i++;
 		}
-		PlannerInitPlan = lappend (PlannerInitPlan, node);
-		if ( i > 1 )
-			result = (Node*) ((slink->useor) ? make_orclause (slink->oper) : 
-											   make_andclause (slink->oper));
+		PlannerInitPlan = lappend(PlannerInitPlan, node);
+		if (i > 1)
+			result = (Node *) ((slink->useor) ? make_orclause(slink->oper) :
+							   make_andclause(slink->oper));
 		else
-			result = (Node*) lfirst (slink->oper);
+			result = (Node *) lfirst(slink->oper);
 	}
-	else if ( node->parParam == NULL && slink->subLinkType == EXISTS_SUBLINK )
+	else if (node->parParam == NULL && slink->subLinkType == EXISTS_SUBLINK)
 	{
-		Var		   *var = makeVar (0, 0, BOOLOID, -1, PlannerQueryLevel, 0, 0);
+		Var		   *var = makeVar(0, 0, BOOLOID, -1, PlannerQueryLevel, 0, 0);
 		Param	   *prm = makeNode(Param);
-		
+
 		prm->paramkind = PARAM_EXEC;
-		prm->paramid = (AttrNumber) _new_param (var, PlannerQueryLevel);
+		prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
 		prm->paramtype = var->vartype;
-		node->setParam = lappendi (node->setParam, prm->paramid);
-		pfree (var);
-		PlannerInitPlan = lappend (PlannerInitPlan, node);
-		result = (Node*) prm;
+		node->setParam = lappendi(node->setParam, prm->paramid);
+		pfree(var);
+		PlannerInitPlan = lappend(PlannerInitPlan, node);
+		result = (Node *) prm;
 	}
-	else	/* make expression of SUBPLAN type */
+	else
+/* make expression of SUBPLAN type */
 	{
-		Expr   *expr = makeNode (Expr);
-		List   *args = NULL;
-		int		i = 0;
-		
+		Expr	   *expr = makeNode(Expr);
+		List	   *args = NULL;
+		int			i = 0;
+
 		expr->typeOid = BOOLOID;
 		expr->opType = SUBPLAN_EXPR;
-		expr->oper = (Node*) node;
-		
-		/* 
-		 * Make expr->args from parParam. Left sides of sublink Oper-s
-		 * are handled by optimizer directly...
-		 * Also, transform right side of sublink Oper-s into Const.
+		expr->oper = (Node *) node;
+
+		/*
+		 * Make expr->args from parParam. Left sides of sublink Oper-s are
+		 * handled by optimizer directly... Also, transform right side of
+		 * sublink Oper-s into Const.
 		 */
-		foreach (lst, node->parParam)
+		foreach(lst, node->parParam)
 		{
-			Var	   *var = nth (lfirsti (lst), PlannerParamVar);
-			
-			var = (Var*) copyObject (var);
+			Var		   *var = nth(lfirsti(lst), PlannerParamVar);
+
+			var = (Var *) copyObject(var);
 			var->varlevelsup = 0;
-			args = lappend (args, var);
+			args = lappend(args, var);
 		}
-		foreach (lst, slink->oper)
+		foreach(lst, slink->oper)
 		{
-			List		   *rside = lnext(((Expr*) lfirst(lst))->args);
-			TargetEntry	   *te = nth (i, plan->targetlist);
-			Const		   *con = makeConst (te->resdom->restype, 
-											 0, 0, true, 0, 0, 0);
+			List	   *rside = lnext(((Expr *) lfirst(lst))->args);
+			TargetEntry *te = nth(i, plan->targetlist);
+			Const	   *con = makeConst(te->resdom->restype,
+										0, 0, true, 0, 0, 0);
+
 			lfirst(rside) = con;
 			i++;
 		}
 		expr->args = args;
-		result = (Node*) expr;
+		result = (Node *) expr;
 	}
-	
+
 	return (result);
-	
+
 }
 
 static List *
-set_unioni (List *l1, List *l2)
+set_unioni(List *l1, List *l2)
 {
 	if (l1 == NULL)
 		return (l2);
 	if (l2 == NULL)
 		return (l1);
-	
-	return (nconc (l1, set_differencei (l2, l1)));
+
+	return (nconc(l1, set_differencei(l2, l1)));
 }
 
 static List *
-_finalize_primnode (void *expr, List **subplan)
+_finalize_primnode(void *expr, List **subplan)
 {
-	List   *result = NULL;
-	
-	if ( expr == NULL )
+	List	   *result = NULL;
+
+	if (expr == NULL)
 		return (NULL);
-	
-	if (IsA (expr, Param))
+
+	if (IsA(expr, Param))
 	{
-		if ( ((Param*) expr)->paramkind == PARAM_EXEC )
-			return (lconsi (((Param*) expr)->paramid, (List*) NULL));
+		if (((Param *) expr)->paramkind == PARAM_EXEC)
+			return (lconsi(((Param *) expr)->paramid, (List *) NULL));
 	}
 	else if (single_node(expr))
 		return (NULL);
-	else if (IsA (expr, List))
+	else if (IsA(expr, List))
 	{
-		List   *le;
-		foreach (le, (List*) expr)
-			result = set_unioni (result, 
-				_finalize_primnode (lfirst(le), subplan));
+		List	   *le;
+
+		foreach(le, (List *) expr)
+			result = set_unioni(result,
+								_finalize_primnode(lfirst(le), subplan));
 	}
-	else if (IsA (expr, Iter))
-		return (_finalize_primnode (((Iter*) expr)->iterexpr, subplan));
-	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) || 
-				not_clause (expr) || is_funcclause(expr))
-		return (_finalize_primnode (((Expr*) expr)->args, subplan));
-	else if (IsA (expr, Aggreg))
-		return (_finalize_primnode (((Aggreg *) expr)->target, subplan));
-	else if (IsA (expr, ArrayRef))
+	else if (IsA(expr, Iter))
+		return (_finalize_primnode(((Iter *) expr)->iterexpr, subplan));
+	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
+			 not_clause(expr) || is_funcclause(expr))
+		return (_finalize_primnode(((Expr *) expr)->args, subplan));
+	else if (IsA(expr, Aggreg))
+		return (_finalize_primnode(((Aggreg *) expr)->target, subplan));
+	else if (IsA(expr, ArrayRef))
 	{
-		result = _finalize_primnode (((ArrayRef*) expr)->refupperindexpr, subplan);
-		result = set_unioni (result, 
-			_finalize_primnode (((ArrayRef *) expr)->reflowerindexpr, subplan));
-		result = set_unioni (result, 
-			_finalize_primnode (((ArrayRef *) expr)->refexpr, subplan));
-		result = set_unioni (result, 
-			_finalize_primnode (((ArrayRef *) expr)->refassgnexpr, subplan));
+		result = _finalize_primnode(((ArrayRef *) expr)->refupperindexpr, subplan);
+		result = set_unioni(result,
+							_finalize_primnode(((ArrayRef *) expr)->reflowerindexpr, subplan));
+		result = set_unioni(result,
+			  _finalize_primnode(((ArrayRef *) expr)->refexpr, subplan));
+		result = set_unioni(result,
+		 _finalize_primnode(((ArrayRef *) expr)->refassgnexpr, subplan));
 	}
-	else if (IsA (expr, TargetEntry))
-		return (_finalize_primnode (((TargetEntry*) expr)->expr, subplan));
-	else if (is_subplan (expr))
+	else if (IsA(expr, TargetEntry))
+		return (_finalize_primnode(((TargetEntry *) expr)->expr, subplan));
+	else if (is_subplan(expr))
 	{
-		List   *lst;
-		
-		*subplan = lappend (*subplan, ((Expr*) expr)->oper);
-		foreach (lst, ((SubPlan*) ((Expr*) expr)->oper)->plan->extParam)
+		List	   *lst;
+
+		*subplan = lappend(*subplan, ((Expr *) expr)->oper);
+		foreach(lst, ((SubPlan *) ((Expr *) expr)->oper)->plan->extParam)
 		{
-			Var	   *var = nth (lfirsti(lst), PlannerParamVar);
-			
-			if ( var->varlevelsup < PlannerQueryLevel && 
-						!intMember (lfirsti(lst), result) )
-				result = lappendi (result, lfirsti(lst));
+			Var		   *var = nth(lfirsti(lst), PlannerParamVar);
+
+			if (var->varlevelsup < PlannerQueryLevel &&
+				!intMember(lfirsti(lst), result))
+				result = lappendi(result, lfirsti(lst));
 		}
 	}
 	else
-		elog (ERROR, "_finalize_primnode: can't handle node %d", 
-			nodeTag (expr));
-	
+		elog(ERROR, "_finalize_primnode: can't handle node %d",
+			 nodeTag(expr));
+
 	return (result);
 }
 
 Node *
-SS_replace_correlation_vars (Node *expr)
+SS_replace_correlation_vars(Node *expr)
 {
 
-	if ( expr == NULL )
+	if (expr == NULL)
 		return (NULL);
-	if (IsA (expr, List))
+	if (IsA(expr, List))
 	{
-		List   *le;
-		foreach (le, (List*) expr)
-			lfirst(le) = SS_replace_correlation_vars ((Node*) lfirst(le));
+		List	   *le;
+
+		foreach(le, (List *) expr)
+			lfirst(le) = SS_replace_correlation_vars((Node *) lfirst(le));
 	}
-	else if (IsA (expr, Var))
+	else if (IsA(expr, Var))
 	{
-		if ( ((Var*) expr)->varlevelsup > 0 )
+		if (((Var *) expr)->varlevelsup > 0)
 		{
-			Assert (((Var*) expr)->varlevelsup < PlannerQueryLevel);
-			expr = (Node*) _replace_var ((Var*) expr);
+			Assert(((Var *) expr)->varlevelsup < PlannerQueryLevel);
+			expr = (Node *) _replace_var((Var *) expr);
 		}
 	}
-	else if (IsA (expr, Iter))
+	else if (IsA(expr, Iter))
 	{
-		((Iter*) expr)->iterexpr = 
-			SS_replace_correlation_vars(((Iter*) expr)->iterexpr);
+		((Iter *) expr)->iterexpr =
+			SS_replace_correlation_vars(((Iter *) expr)->iterexpr);
 	}
 	else if (single_node(expr))
 		return (expr);
-	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) || 
-				not_clause (expr) || is_funcclause(expr))
-		((Expr *) expr)->args = (List*) 
-			SS_replace_correlation_vars ((Node*) ((Expr *) expr)->args);
-	else if (IsA (expr, Aggreg))
-		((Aggreg *) expr)->target = 
-				SS_replace_correlation_vars ((Node*) ((Aggreg *) expr)->target);
-	else if (IsA (expr, ArrayRef))
+	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
+			 not_clause(expr) || is_funcclause(expr))
+		((Expr *) expr)->args = (List *)
+			SS_replace_correlation_vars((Node *) ((Expr *) expr)->args);
+	else if (IsA(expr, Aggreg))
+		((Aggreg *) expr)->target =
+			SS_replace_correlation_vars((Node *) ((Aggreg *) expr)->target);
+	else if (IsA(expr, ArrayRef))
 	{
-		((ArrayRef *) expr)->refupperindexpr = (List*) 
-			SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->refupperindexpr);
-		((ArrayRef *) expr)->reflowerindexpr = (List*) 
-			SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->reflowerindexpr);
-		((ArrayRef *) expr)->refexpr = 
-			SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->refexpr);
-		((ArrayRef *) expr)->refassgnexpr = 
-			SS_replace_correlation_vars (((ArrayRef *) expr)->refassgnexpr);
+		((ArrayRef *) expr)->refupperindexpr = (List *)
+			SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->refupperindexpr);
+		((ArrayRef *) expr)->reflowerindexpr = (List *)
+			SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->reflowerindexpr);
+		((ArrayRef *) expr)->refexpr =
+			SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->refexpr);
+		((ArrayRef *) expr)->refassgnexpr =
+			SS_replace_correlation_vars(((ArrayRef *) expr)->refassgnexpr);
 	}
-	else if (IsA (expr, TargetEntry))
-		((TargetEntry*) expr)->expr = 
-			SS_replace_correlation_vars ((Node*) ((TargetEntry*) expr)->expr);
-	else if (IsA (expr, SubLink))
+	else if (IsA(expr, TargetEntry))
+		((TargetEntry *) expr)->expr =
+			SS_replace_correlation_vars((Node *) ((TargetEntry *) expr)->expr);
+	else if (IsA(expr, SubLink))
 	{
-		List   *le;
-		
-		foreach (le, ((SubLink*) expr)->oper)	/* left sides only */
+		List	   *le;
+
+		foreach(le, ((SubLink *) expr)->oper)	/* left sides only */
 		{
-			List   *oparg = ((Expr*) lfirst (le))->args;
-			
-			lfirst (oparg) = (List*) 
-				SS_replace_correlation_vars ((Node*) lfirst (oparg));
+			List	   *oparg = ((Expr *) lfirst(le))->args;
+
+			lfirst(oparg) = (List *)
+				SS_replace_correlation_vars((Node *) lfirst(oparg));
 		}
-		((SubLink*) expr)->lefthand = (List*) 
-			SS_replace_correlation_vars ((Node*) ((SubLink*) expr)->lefthand);
+		((SubLink *) expr)->lefthand = (List *)
+			SS_replace_correlation_vars((Node *) ((SubLink *) expr)->lefthand);
 	}
 	else
-		elog (NOTICE, "SS_replace_correlation_vars: can't handle node %d", 
-			nodeTag (expr));
-	
+		elog(NOTICE, "SS_replace_correlation_vars: can't handle node %d",
+			 nodeTag(expr));
+
 	return (expr);
 }
 
-Node*
-SS_process_sublinks (Node *expr)
+Node *
+SS_process_sublinks(Node *expr)
 {
-	if ( expr == NULL )
+	if (expr == NULL)
 		return (NULL);
-	if (IsA (expr, List))
+	if (IsA(expr, List))
 	{
-		List   *le;
-		foreach (le, (List*) expr)
-			lfirst(le) = SS_process_sublinks ((Node*) lfirst(le));
+		List	   *le;
+
+		foreach(le, (List *) expr)
+			lfirst(le) = SS_process_sublinks((Node *) lfirst(le));
 	}
-	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) || 
-				not_clause (expr) || is_funcclause(expr))
-		((Expr *) expr)->args = (List*)
-			SS_process_sublinks ((Node*) ((Expr *) expr)->args);
-	else if (IsA (expr, SubLink))		/* got it! */
-		expr = _make_subplan ((SubLink*) expr);
-	
+	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
+			 not_clause(expr) || is_funcclause(expr))
+		((Expr *) expr)->args = (List *)
+			SS_process_sublinks((Node *) ((Expr *) expr)->args);
+	else if (IsA(expr, SubLink))/* got it! */
+		expr = _make_subplan((SubLink *) expr);
+
 	return (expr);
 }
 
-List*
-SS_finalize_plan (Plan *plan)
+List *
+SS_finalize_plan(Plan *plan)
 {
-	List   *extParam = NULL;
-	List   *locParam = NULL;
-	List   *subPlan = NULL;
-	List   *param_list;
-	List   *lst;
-	
-	if ( plan == NULL )
+	List	   *extParam = NULL;
+	List	   *locParam = NULL;
+	List	   *subPlan = NULL;
+	List	   *param_list;
+	List	   *lst;
+
+	if (plan == NULL)
 		return (NULL);
-	
-	param_list = _finalize_primnode (plan->targetlist, &subPlan);
-	Assert (subPlan == NULL);
-	
+
+	param_list = _finalize_primnode(plan->targetlist, &subPlan);
+	Assert(subPlan == NULL);
+
 	switch (nodeTag(plan))
 	{
 		case T_Result:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((Result*) plan)->resconstantqual, &subPlan));
+			param_list = set_unioni(param_list,
+									_finalize_primnode(((Result *) plan)->resconstantqual, &subPlan));
 			break;
 
 		case T_Append:
-			foreach (lst, ((Append*) plan)->unionplans)
-				param_list = set_unioni (param_list, 
-					 SS_finalize_plan ((Plan*) lfirst (lst)));
+			foreach(lst, ((Append *) plan)->unionplans)
+				param_list = set_unioni(param_list,
+								 SS_finalize_plan((Plan *) lfirst(lst)));
 			break;
-		
+
 		case T_IndexScan:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((IndexScan*) plan)->indxqual, &subPlan));
-			Assert (subPlan == NULL);
+			param_list = set_unioni(param_list,
+			_finalize_primnode(((IndexScan *) plan)->indxqual, &subPlan));
+			Assert(subPlan == NULL);
 			break;
 
 		case T_MergeJoin:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((MergeJoin*) plan)->mergeclauses, &subPlan));
-			Assert (subPlan == NULL);
+			param_list = set_unioni(param_list,
+									_finalize_primnode(((MergeJoin *) plan)->mergeclauses, &subPlan));
+			Assert(subPlan == NULL);
 			break;
 
 		case T_HashJoin:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((HashJoin*) plan)->hashclauses, &subPlan));
-			Assert (subPlan == NULL);
+			param_list = set_unioni(param_list,
+									_finalize_primnode(((HashJoin *) plan)->hashclauses, &subPlan));
+			Assert(subPlan == NULL);
 			break;
-		
+
 		case T_Hash:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((Hash*) plan)->hashkey, &subPlan));
-			Assert (subPlan == NULL);
+			param_list = set_unioni(param_list,
+				 _finalize_primnode(((Hash *) plan)->hashkey, &subPlan));
+			Assert(subPlan == NULL);
 			break;
 
 		case T_Agg:
-			param_list = set_unioni (param_list, 
-				_finalize_primnode (((Agg*) plan)->aggs, &subPlan));
-			Assert (subPlan == NULL);
+			param_list = set_unioni(param_list,
+					 _finalize_primnode(((Agg *) plan)->aggs, &subPlan));
+			Assert(subPlan == NULL);
 			break;
-			
+
 		case T_SeqScan:
 		case T_NestLoop:
 		case T_Material:
@@ -476,74 +480,75 @@ SS_finalize_plan (Plan *plan)
 			elog(ERROR, "SS_finalize_plan: node %d unsupported", nodeTag(plan));
 			return (NULL);
 	}
-	
-	param_list = set_unioni (param_list, _finalize_primnode (plan->qual, &subPlan));
-	param_list = set_unioni (param_list, SS_finalize_plan (plan->lefttree));
-	param_list = set_unioni (param_list, SS_finalize_plan (plan->righttree));
-	
-	foreach (lst, param_list)
+
+	param_list = set_unioni(param_list, _finalize_primnode(plan->qual, &subPlan));
+	param_list = set_unioni(param_list, SS_finalize_plan(plan->lefttree));
+	param_list = set_unioni(param_list, SS_finalize_plan(plan->righttree));
+
+	foreach(lst, param_list)
 	{
-		Var	   *var = nth (lfirsti(lst), PlannerParamVar);
-		
-		if ( var->varlevelsup < PlannerQueryLevel )
-			extParam = lappendi (extParam, lfirsti(lst));
-		else if ( var->varlevelsup > PlannerQueryLevel )
-			elog (ERROR, "SS_finalize_plan: plan shouldn't reference subplan' variable");
+		Var		   *var = nth(lfirsti(lst), PlannerParamVar);
+
+		if (var->varlevelsup < PlannerQueryLevel)
+			extParam = lappendi(extParam, lfirsti(lst));
+		else if (var->varlevelsup > PlannerQueryLevel)
+			elog(ERROR, "SS_finalize_plan: plan shouldn't reference subplan' variable");
 		else
 		{
-			Assert (var->varno == 0 && var->varattno == 0);
-			locParam = lappendi (locParam, lfirsti(lst));
+			Assert(var->varno == 0 && var->varattno == 0);
+			locParam = lappendi(locParam, lfirsti(lst));
 		}
 	}
-	
+
 	plan->extParam = extParam;
 	plan->locParam = locParam;
 	plan->subPlan = subPlan;
-	
+
 	return (param_list);
 
 }
 
-List *SS_pull_subplan (void *expr);
+List	   *SS_pull_subplan(void *expr);
 
 List *
-SS_pull_subplan (void *expr)
+SS_pull_subplan(void *expr)
 {
-	List   *result = NULL;
-	
-	if ( expr == NULL || single_node(expr) )
+	List	   *result = NULL;
+
+	if (expr == NULL || single_node(expr))
 		return (NULL);
-	
-	if (IsA (expr, List))
+
+	if (IsA(expr, List))
 	{
-		List   *le;
-		foreach (le, (List*) expr)
-			result = nconc (result, SS_pull_subplan (lfirst(le)));
+		List	   *le;
+
+		foreach(le, (List *) expr)
+			result = nconc(result, SS_pull_subplan(lfirst(le)));
 	}
-	else if (IsA (expr, Iter))
-		return (SS_pull_subplan (((Iter*) expr)->iterexpr));
-	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) || 
-				not_clause (expr) || is_funcclause(expr))
-		return (SS_pull_subplan (((Expr*) expr)->args));
-	else if (IsA (expr, Aggreg))
-		return (SS_pull_subplan (((Aggreg *) expr)->target));
-	else if (IsA (expr, ArrayRef))
+	else if (IsA(expr, Iter))
+		return (SS_pull_subplan(((Iter *) expr)->iterexpr));
+	else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
+			 not_clause(expr) || is_funcclause(expr))
+		return (SS_pull_subplan(((Expr *) expr)->args));
+	else if (IsA(expr, Aggreg))
+		return (SS_pull_subplan(((Aggreg *) expr)->target));
+	else if (IsA(expr, ArrayRef))
 	{
-		result = SS_pull_subplan (((ArrayRef*) expr)->refupperindexpr);
-		result = nconc (result, 
-			SS_pull_subplan (((ArrayRef *) expr)->reflowerindexpr));
-		result = nconc (result, 
-			SS_pull_subplan (((ArrayRef *) expr)->refexpr));
-		result = nconc (result, 
-			SS_pull_subplan (((ArrayRef *) expr)->refassgnexpr));
+		result = SS_pull_subplan(((ArrayRef *) expr)->refupperindexpr);
+		result = nconc(result,
+				  SS_pull_subplan(((ArrayRef *) expr)->reflowerindexpr));
+		result = nconc(result,
+					   SS_pull_subplan(((ArrayRef *) expr)->refexpr));
+		result = nconc(result,
+					 SS_pull_subplan(((ArrayRef *) expr)->refassgnexpr));
 	}
-	else if (IsA (expr, TargetEntry))
-		return (SS_pull_subplan (((TargetEntry*) expr)->expr));
-	else if (is_subplan (expr))
-		return (lcons (((Expr*) expr)->oper, NULL));
+	else if (IsA(expr, TargetEntry))
+		return (SS_pull_subplan(((TargetEntry *) expr)->expr));
+	else if (is_subplan(expr))
+		return (lcons(((Expr *) expr)->oper, NULL));
 	else
-		elog (ERROR, "SS_pull_subplan: can't handle node %d", 
-			nodeTag (expr));
-	
+		elog(ERROR, "SS_pull_subplan: can't handle node %d",
+			 nodeTag(expr));
+
 	return (result);
 }