pgindent run for 9.0

11 files changed, 188 insertions, 184 deletions

diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index 027cb972ee7..1576613bc1a 100644
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -17,7 +17,7 @@
  * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.401 2010/02/12 22:48:56 tgl Exp $
+ *	$PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.402 2010/02/26 02:00:49 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,7 +53,7 @@ static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
 static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
 						  bool isTopLevel, List **colInfo);
 static void determineRecursiveColTypes(ParseState *pstate,
-									   Node *larg, List *lcolinfo);
+						   Node *larg, List *lcolinfo);
 static void applyColumnNames(List *dst, List *src);
 static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
 static List *transformReturningList(ParseState *pstate, List *returningList);
@@ -62,7 +62,7 @@ static Query *transformDeclareCursorStmt(ParseState *pstate,
 static Query *transformExplainStmt(ParseState *pstate,
 					 ExplainStmt *stmt);
 static void transformLockingClause(ParseState *pstate, Query *qry,
-								   LockingClause *lc, bool pushedDown);
+					   LockingClause *lc, bool pushedDown);
 
 
 /*
@@ -823,14 +823,14 @@ transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
 	qry->sortClause = transformSortClause(pstate,
 										  stmt->sortClause,
 										  &qry->targetList,
-										  true /* fix unknowns */,
-										  false /* allow SQL92 rules */);
+										  true /* fix unknowns */ ,
+										  false /* allow SQL92 rules */ );
 
 	qry->groupClause = transformGroupClause(pstate,
 											stmt->groupClause,
 											&qry->targetList,
 											qry->sortClause,
-											false /* allow SQL92 rules */);
+											false /* allow SQL92 rules */ );
 
 	if (stmt->distinctClause == NIL)
 	{
@@ -1040,8 +1040,8 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt)
 	qry->sortClause = transformSortClause(pstate,
 										  stmt->sortClause,
 										  &qry->targetList,
-										  true /* fix unknowns */,
-										  false /* allow SQL92 rules */);
+										  true /* fix unknowns */ ,
+										  false /* allow SQL92 rules */ );
 
 	qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
 											"OFFSET");
@@ -1294,8 +1294,8 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
 	qry->sortClause = transformSortClause(pstate,
 										  sortClause,
 										  &qry->targetList,
-										  false /* no unknowns expected */,
-										  false /* allow SQL92 rules */);
+										  false /* no unknowns expected */ ,
+										  false /* allow SQL92 rules */ );
 
 	pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length);
 	pstate->p_relnamespace = sv_relnamespace;
@@ -1494,8 +1494,8 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
 											 &lcolinfo);
 
 		/*
-		 * If we are processing a recursive union query, now is the time
-		 * to examine the non-recursive term's output columns and mark the
+		 * If we are processing a recursive union query, now is the time to
+		 * examine the non-recursive term's output columns and mark the
 		 * containing CTE as having those result columns.  We should do this
 		 * only at the topmost setop of the CTE, of course.
 		 */
@@ -1552,25 +1552,25 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
 				rescoltypmod = -1;
 
 			/*
-			 * Verify the coercions are actually possible.  If not, we'd
-			 * fail later anyway, but we want to fail now while we have
-			 * sufficient context to produce an error cursor position.
+			 * Verify the coercions are actually possible.	If not, we'd fail
+			 * later anyway, but we want to fail now while we have sufficient
+			 * context to produce an error cursor position.
 			 *
 			 * The if-tests might look wrong, but they are correct: we should
 			 * verify if the input is non-UNKNOWN *or* if it is an UNKNOWN
 			 * Const (to verify the literal is valid for the target data type)
 			 * or Param (to possibly resolve the Param's type).  We should do
 			 * nothing if the input is say an UNKNOWN Var, which can happen in
-			 * some cases.  The planner is sometimes able to fold the Var to a
+			 * some cases.	The planner is sometimes able to fold the Var to a
 			 * constant before it has to coerce the type, so failing now would
 			 * just break cases that might work.
 			 */
 			if (lcoltype != UNKNOWNOID ||
-				IsA(lcolnode, Const) || IsA(lcolnode, Param))
+				IsA(lcolnode, Const) ||IsA(lcolnode, Param))
 				(void) coerce_to_common_type(pstate, lcolnode,
 											 rescoltype, context);
 			if (rcoltype != UNKNOWNOID ||
-				IsA(rcolnode, Const) || IsA(rcolnode, Param))
+				IsA(rcolnode, Const) ||IsA(rcolnode, Param))
 				(void) coerce_to_common_type(pstate, rcolnode,
 											 rescoltype, context);
 
@@ -1647,8 +1647,8 @@ determineRecursiveColTypes(ParseState *pstate, Node *larg, List *lcolinfo)
 	Assert(leftmostQuery != NULL);
 
 	/*
-	 * Generate dummy targetlist using column names of leftmost select
-	 * and dummy result expressions of the non-recursive term.
+	 * Generate dummy targetlist using column names of leftmost select and
+	 * dummy result expressions of the non-recursive term.
 	 */
 	targetList = NIL;
 	left_tlist = list_head(leftmostQuery->targetList);
@@ -2095,12 +2095,13 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
 				case RTE_SUBQUERY:
 					applyLockingClause(qry, i,
 									   lc->forUpdate, lc->noWait, pushedDown);
+
 					/*
 					 * FOR UPDATE/SHARE of subquery is propagated to all of
-					 * subquery's rels, too.  We could do this later (based
-					 * on the marking of the subquery RTE) but it is convenient
-					 * to have local knowledge in each query level about
-					 * which rels need to be opened with RowShareLock.
+					 * subquery's rels, too.  We could do this later (based on
+					 * the marking of the subquery RTE) but it is convenient
+					 * to have local knowledge in each query level about which
+					 * rels need to be opened with RowShareLock.
 					 */
 					transformLockingClause(pstate, rte->subquery,
 										   allrels, true);
diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index e883e283e0b..d30d01261f7 100644
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.91 2010/02/12 17:33:20 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.92 2010/02/26 02:00:49 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -51,7 +51,7 @@ static bool check_ungrouped_columns_walker(Node *node,
  *
  * Here we convert the args list into a targetlist by inserting TargetEntry
  * nodes, and then transform the aggorder and agg_distinct specifications to
- * produce lists of SortGroupClause nodes.  (That might also result in adding
+ * produce lists of SortGroupClause nodes.	(That might also result in adding
  * resjunk expressions to the targetlist.)
  *
  * We must also determine which query level the aggregate actually belongs to,
@@ -61,11 +61,11 @@ static bool check_ungrouped_columns_walker(Node *node,
 void
 transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
 {
-	List       *tlist;
-	List       *torder;
-	List       *tdistinct = NIL;
-	AttrNumber  attno;
-	int         save_next_resno;
+	List	   *tlist;
+	List	   *torder;
+	List	   *tdistinct = NIL;
+	AttrNumber	attno;
+	int			save_next_resno;
 	int			min_varlevel;
 	ListCell   *lc;
 
@@ -77,7 +77,7 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
 	attno = 1;
 	foreach(lc, agg->args)
 	{
-		Expr        *arg  = (Expr *) lfirst(lc);
+		Expr	   *arg = (Expr *) lfirst(lc);
 		TargetEntry *tle = makeTargetEntry(arg, attno++, NULL, false);
 
 		tlist = lappend(tlist, tle);
@@ -98,8 +98,8 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
 	torder = transformSortClause(pstate,
 								 agg->aggorder,
 								 &tlist,
-								 true /* fix unknowns */,
-								 true /* force SQL99 rules */);
+								 true /* fix unknowns */ ,
+								 true /* force SQL99 rules */ );
 
 	/*
 	 * If we have DISTINCT, transform that to produce a distinctList.
@@ -118,12 +118,12 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
 
 			if (!OidIsValid(sortcl->sortop))
 			{
-				Node   *expr = get_sortgroupclause_expr(sortcl, tlist);
+				Node	   *expr = get_sortgroupclause_expr(sortcl, tlist);
 
 				ereport(ERROR,
 						(errcode(ERRCODE_UNDEFINED_FUNCTION),
-						 errmsg("could not identify an ordering operator for type %s",
-								format_type_be(exprType(expr))),
+				errmsg("could not identify an ordering operator for type %s",
+					   format_type_be(exprType(expr))),
 						 errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
 						 parser_errposition(pstate, exprLocation(expr))));
 			}
diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index 54bb867631e..182181f3a60 100644
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.197 2010/02/12 17:33:20 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.198 2010/02/26 02:00:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -73,7 +73,7 @@ static Node *transformFromClauseItem(ParseState *pstate, Node *n,
 static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
 				   Var *l_colvar, Var *r_colvar);
 static void checkExprIsVarFree(ParseState *pstate, Node *n,
-							   const char *constructName);
+				   const char *constructName);
 static TargetEntry *findTargetlistEntrySQL92(ParseState *pstate, Node *node,
 						 List **tlist, int clause);
 static TargetEntry *findTargetlistEntrySQL99(ParseState *pstate, Node *node,
@@ -88,7 +88,7 @@ static List *addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
 					 bool resolveUnknown);
 static WindowClause *findWindowClause(List *wclist, const char *name);
 static Node *transformFrameOffset(ParseState *pstate, int frameOptions,
-								  Node *clause);
+					 Node *clause);
 
 
 /*
@@ -802,7 +802,7 @@ transformFromClauseItem(ParseState *pstate, Node *n,
 			ListCell   *lx,
 					   *rx;
 
-			Assert(j->usingClause == NIL);	/* shouldn't have USING() too */
+			Assert(j->usingClause == NIL);		/* shouldn't have USING() too */
 
 			foreach(lx, l_colnames)
 			{
@@ -1245,9 +1245,9 @@ checkExprIsVarFree(ParseState *pstate, Node *n, const char *constructName)
  *
  * This function supports the old SQL92 ORDER BY interpretation, where the
  * expression is an output column name or number.  If we fail to find a
- * match of that sort, we fall through to the SQL99 rules.  For historical
+ * match of that sort, we fall through to the SQL99 rules.	For historical
  * reasons, Postgres also allows this interpretation for GROUP BY, though
- * the standard never did.  However, for GROUP BY we prefer a SQL99 match.
+ * the standard never did.	However, for GROUP BY we prefer a SQL99 match.
  * This function is *not* used for WINDOW definitions.
  *
  * node		the ORDER BY, GROUP BY, or DISTINCT ON expression to be matched
@@ -1421,7 +1421,7 @@ findTargetlistEntrySQL99(ParseState *pstate, Node *node, List **tlist)
 	/*
 	 * Convert the untransformed node to a transformed expression, and search
 	 * for a match in the tlist.  NOTE: it doesn't really matter whether there
-	 * is more than one match.  Also, we are willing to match an existing
+	 * is more than one match.	Also, we are willing to match an existing
 	 * resjunk target here, though the SQL92 cases above must ignore resjunk
 	 * targets.
 	 */
@@ -1617,13 +1617,13 @@ transformWindowDefinitions(ParseState *pstate,
 		orderClause = transformSortClause(pstate,
 										  windef->orderClause,
 										  targetlist,
-										  true /* fix unknowns */,
-										  true /* force SQL99 rules */);
+										  true /* fix unknowns */ ,
+										  true /* force SQL99 rules */ );
 		partitionClause = transformGroupClause(pstate,
 											   windef->partitionClause,
 											   targetlist,
 											   orderClause,
-											   true /* force SQL99 rules */);
+											   true /* force SQL99 rules */ );
 
 		/*
 		 * And prepare the new WindowClause.
@@ -2220,8 +2220,8 @@ transformFrameOffset(ParseState *pstate, int frameOptions, Node *clause)
 	else if (frameOptions & FRAMEOPTION_RANGE)
 	{
 		/*
-		 * this needs a lot of thought to decide how to support in the
-		 * context of Postgres' extensible datatype framework
+		 * this needs a lot of thought to decide how to support in the context
+		 * of Postgres' extensible datatype framework
 		 */
 		constructName = "RANGE";
 		/* error was already thrown by gram.y, this is just a backstop */
diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
index 66ce032cee6..2000dfb93a9 100644
--- a/src/backend/parser/parse_coerce.c
+++ b/src/backend/parser/parse_coerce.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.180 2010/02/14 18:42:15 rhaas Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.181 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -263,8 +263,8 @@ coerce_type(ParseState *pstate, Node *node,
 		pstate != NULL && pstate->p_coerce_param_hook != NULL)
 	{
 		/*
-		 * Allow the CoerceParamHook to decide what happens.  It can return
-		 * a transformed node (very possibly the same Param node), or return
+		 * Allow the CoerceParamHook to decide what happens.  It can return a
+		 * transformed node (very possibly the same Param node), or return
 		 * NULL to indicate we should proceed with normal coercion.
 		 */
 		result = (*pstate->p_coerce_param_hook) (pstate,
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index 72cb64a63d0..12c93e15f41 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.253 2010/01/02 16:57:49 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.254 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -61,7 +61,7 @@ static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
 static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
 static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
 static Node *transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte,
-								  int location);
+					 int location);
 static Node *transformIndirection(ParseState *pstate, Node *basenode,
 					 List *indirection);
 static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
@@ -172,8 +172,8 @@ transformExpr(ParseState *pstate, Node *expr)
 						 * not a domain, transformTypeCast is a no-op.
 						 */
 						targetType = getBaseTypeAndTypmod(targetType,
-														 &targetTypmod);
-							
+														  &targetTypmod);
+
 						tc = copyObject(tc);
 						tc->arg = transformArrayExpr(pstate,
 													 (A_ArrayExpr *) tc->arg,
@@ -466,7 +466,8 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
 	char	   *colname = NULL;
 	RangeTblEntry *rte;
 	int			levels_up;
-	enum {
+	enum
+	{
 		CRERR_NO_COLUMN,
 		CRERR_NO_RTE,
 		CRERR_WRONG_DB,
@@ -474,7 +475,7 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
 	}			crerr = CRERR_NO_COLUMN;
 
 	/*
-	 * Give the PreParseColumnRefHook, if any, first shot.  If it returns
+	 * Give the PreParseColumnRefHook, if any, first shot.	If it returns
 	 * non-null then that's all, folks.
 	 */
 	if (pstate->p_pre_columnref_hook != NULL)
@@ -708,22 +709,22 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
 				break;
 			}
 		default:
-			crerr = CRERR_TOO_MANY;			/* too many dotted names */
+			crerr = CRERR_TOO_MANY;		/* too many dotted names */
 			break;
 	}
 
 	/*
 	 * Now give the PostParseColumnRefHook, if any, a chance.  We pass the
 	 * translation-so-far so that it can throw an error if it wishes in the
-	 * case that it has a conflicting interpretation of the ColumnRef.
-	 * (If it just translates anyway, we'll throw an error, because we can't
-	 * undo whatever effects the preceding steps may have had on the pstate.)
-	 * If it returns NULL, use the standard translation, or throw a suitable
-	 * error if there is none.
+	 * case that it has a conflicting interpretation of the ColumnRef. (If it
+	 * just translates anyway, we'll throw an error, because we can't undo
+	 * whatever effects the preceding steps may have had on the pstate.) If it
+	 * returns NULL, use the standard translation, or throw a suitable error
+	 * if there is none.
 	 */
 	if (pstate->p_post_columnref_hook != NULL)
 	{
-		Node   *hookresult;
+		Node	   *hookresult;
 
 		hookresult = (*pstate->p_post_columnref_hook) (pstate, cref, node);
 		if (node == NULL)
@@ -765,15 +766,15 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
 			case CRERR_WRONG_DB:
 				ereport(ERROR,
 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-						 errmsg("cross-database references are not implemented: %s",
-								NameListToString(cref->fields)),
+				  errmsg("cross-database references are not implemented: %s",
+						 NameListToString(cref->fields)),
 						 parser_errposition(pstate, cref->location)));
 				break;
 			case CRERR_TOO_MANY:
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
-						 errmsg("improper qualified name (too many dotted names): %s",
-								NameListToString(cref->fields)),
+				errmsg("improper qualified name (too many dotted names): %s",
+					   NameListToString(cref->fields)),
 						 parser_errposition(pstate, cref->location)));
 				break;
 		}
@@ -788,7 +789,7 @@ transformParamRef(ParseState *pstate, ParamRef *pref)
 	Node	   *result;
 
 	/*
-	 * The core parser knows nothing about Params.  If a hook is supplied,
+	 * The core parser knows nothing about Params.	If a hook is supplied,
 	 * call it.  If not, or if the hook returns NULL, throw a generic error.
 	 */
 	if (pstate->p_paramref_hook != NULL)
@@ -1972,10 +1973,10 @@ transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
 
 	/*
 	 * Check to see if the cursor name matches a parameter of type REFCURSOR.
-	 * If so, replace the raw name reference with a parameter reference.
-	 * (This is a hack for the convenience of plpgsql.)
+	 * If so, replace the raw name reference with a parameter reference. (This
+	 * is a hack for the convenience of plpgsql.)
 	 */
-	if (cexpr->cursor_name != NULL)			/* in case already transformed */
+	if (cexpr->cursor_name != NULL)		/* in case already transformed */
 	{
 		ColumnRef  *cref = makeNode(ColumnRef);
 		Node	   *node = NULL;
@@ -1991,13 +1992,13 @@ transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
 			node = (*pstate->p_post_columnref_hook) (pstate, cref, NULL);
 
 		/*
-		 * XXX Should we throw an error if we get a translation that isn't
-		 * a refcursor Param?  For now it seems best to silently ignore
-		 * false matches.
+		 * XXX Should we throw an error if we get a translation that isn't a
+		 * refcursor Param?  For now it seems best to silently ignore false
+		 * matches.
 		 */
 		if (node != NULL && IsA(node, Param))
 		{
-			Param  *p = (Param *) node;
+			Param	   *p = (Param *) node;
 
 			if (p->paramkind == PARAM_EXTERN &&
 				p->paramtype == REFCURSOROID)
diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index df34711af6e..dffc24c09e3 100644
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.221 2010/02/14 18:42:15 rhaas Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.222 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -125,13 +125,13 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 	 *
 	 * We allow mixed notation (some named and some not), but only with all
 	 * the named parameters after all the unnamed ones.  So the name list
-	 * corresponds to the last N actual parameters and we don't need any
-	 * extra bookkeeping to match things up.
+	 * corresponds to the last N actual parameters and we don't need any extra
+	 * bookkeeping to match things up.
 	 */
 	argnames = NIL;
 	foreach(l, fargs)
 	{
-		Node   *arg = lfirst(l);
+		Node	   *arg = lfirst(l);
 
 		if (IsA(arg, NamedArgExpr))
 		{
@@ -144,8 +144,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 				if (strcmp(na->name, (char *) lfirst(lc)) == 0)
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
-							 errmsg("argument name \"%s\" used more than once",
-									na->name),
+						   errmsg("argument name \"%s\" used more than once",
+								  na->name),
 							 parser_errposition(pstate, na->location)));
 			}
 			argnames = lappend(argnames, na->name);
@@ -155,7 +155,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 			if (argnames != NIL)
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
-						 errmsg("positional argument cannot follow named argument"),
+				  errmsg("positional argument cannot follow named argument"),
 						 parser_errposition(pstate, exprLocation(arg))));
 		}
 	}
@@ -246,8 +246,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 		if (agg_order != NIL)
 			ereport(ERROR,
 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
-			   errmsg("ORDER BY specified, but %s is not an aggregate function",
-					  NameListToString(funcname)),
+			errmsg("ORDER BY specified, but %s is not an aggregate function",
+				   NameListToString(funcname)),
 					 parser_errposition(pstate, location)));
 		if (over)
 			ereport(ERROR,
@@ -262,8 +262,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 		/*
 		 * Oops.  Time to die.
 		 *
-		 * If we are dealing with the attribute notation rel.function,
-		 * let the caller handle failure.
+		 * If we are dealing with the attribute notation rel.function, let the
+		 * caller handle failure.
 		 */
 		if (is_column)
 			return NULL;
@@ -408,9 +408,9 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 
 		/*
 		 * Currently it's not possible to define an aggregate with named
-		 * arguments, so this case should be impossible.  Check anyway
-		 * because the planner and executor wouldn't cope with NamedArgExprs
-		 * in an Aggref node.
+		 * arguments, so this case should be impossible.  Check anyway because
+		 * the planner and executor wouldn't cope with NamedArgExprs in an
+		 * Aggref node.
 		 */
 		if (argnames != NIL)
 			ereport(ERROR,
@@ -481,9 +481,9 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 					 parser_errposition(pstate, location)));
 
 		/*
-		 * We might want to support this later, but for now reject it
-		 * because the planner and executor wouldn't cope with NamedArgExprs
-		 * in a WindowFunc node.
+		 * We might want to support this later, but for now reject it because
+		 * the planner and executor wouldn't cope with NamedArgExprs in a
+		 * WindowFunc node.
 		 */
 		if (argnames != NIL)
 			ereport(ERROR,
@@ -1075,10 +1075,9 @@ func_get_detail(List *funcname,
 			return FUNCDETAIL_MULTIPLE;
 
 		/*
-		 * We disallow VARIADIC with named arguments unless the last
-		 * argument (the one with VARIADIC attached) actually matched the
-		 * variadic parameter.  This is mere pedantry, really, but some
-		 * folks insisted.
+		 * We disallow VARIADIC with named arguments unless the last argument
+		 * (the one with VARIADIC attached) actually matched the variadic
+		 * parameter.  This is mere pedantry, really, but some folks insisted.
 		 */
 		if (fargnames != NIL && !expand_variadic && nargs > 0 &&
 			best_candidate->argnumbers[nargs - 1] != nargs - 1)
@@ -1142,17 +1141,17 @@ func_get_detail(List *funcname,
 			{
 				/*
 				 * This is a bit tricky in named notation, since the supplied
-				 * arguments could replace any subset of the defaults.  We
+				 * arguments could replace any subset of the defaults.	We
 				 * work by making a bitmapset of the argnumbers of defaulted
 				 * arguments, then scanning the defaults list and selecting
 				 * the needed items.  (This assumes that defaulted arguments
 				 * should be supplied in their positional order.)
 				 */
-				Bitmapset *defargnumbers;
-				int	   *firstdefarg;
-				List   *newdefaults;
-				ListCell *lc;
-				int		i;
+				Bitmapset  *defargnumbers;
+				int		   *firstdefarg;
+				List	   *newdefaults;
+				ListCell   *lc;
+				int			i;
 
 				defargnumbers = NULL;
 				firstdefarg = &best_candidate->argnumbers[best_candidate->nargs - best_candidate->ndargs];
@@ -1174,8 +1173,8 @@ func_get_detail(List *funcname,
 			else
 			{
 				/*
-				 * Defaults for positional notation are lots easier;
-				 * just remove any unwanted ones from the front.
+				 * Defaults for positional notation are lots easier; just
+				 * remove any unwanted ones from the front.
 				 */
 				int			ndelete;
 
@@ -1226,11 +1225,11 @@ make_fn_arguments(ParseState *pstate,
 		/* types don't match? then force coercion using a function call... */
 		if (actual_arg_types[i] != declared_arg_types[i])
 		{
-			Node   *node = (Node *) lfirst(current_fargs);
+			Node	   *node = (Node *) lfirst(current_fargs);
 
 			/*
-			 * If arg is a NamedArgExpr, coerce its input expr instead ---
-			 * we want the NamedArgExpr to stay at the top level of the list.
+			 * If arg is a NamedArgExpr, coerce its input expr instead --- we
+			 * want the NamedArgExpr to stay at the top level of the list.
 			 */
 			if (IsA(node, NamedArgExpr))
 			{
@@ -1364,7 +1363,7 @@ ParseComplexProjection(ParseState *pstate, char *funcname, Node *first_arg,
  *		The result is something like "foo(integer)".
  *
  * If argnames isn't NIL, it is a list of C strings representing the actual
- * arg names for the last N arguments.  This must be considered part of the
+ * arg names for the last N arguments.	This must be considered part of the
  * function signature too, when dealing with named-notation function calls.
  *
  * This is typically used in the construction of function-not-found error
diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c
index daa9e2341fa..f40f9af348e 100644
--- a/src/backend/parser/parse_oper.c
+++ b/src/backend/parser/parse_oper.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.112 2010/02/14 18:42:15 rhaas Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.113 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -229,11 +229,12 @@ get_sort_group_operators(Oid argtype,
 				lt_opr = gt_opr = InvalidOid;
 			}
 #else
+
 			/*
 			 * ... but for the moment we have to do this.  This is because
 			 * anyarray has sorting but not hashing support.  So, if the
-			 * element type is only hashable, there is nothing we can do
-			 * with the array type.
+			 * element type is only hashable, there is nothing we can do with
+			 * the array type.
 			 */
 			if (!OidIsValid(typentry->lt_opr) ||
 				!OidIsValid(typentry->eq_opr) ||
diff --git a/src/backend/parser/parse_param.c b/src/backend/parser/parse_param.c
index b1282a14626..ba91028c891 100644
--- a/src/backend/parser/parse_param.c
+++ b/src/backend/parser/parse_param.c
@@ -17,7 +17,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_param.c,v 2.3 2010/01/13 01:17:07 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_param.c,v 2.4 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,8 +53,8 @@ typedef struct VarParamState
 static Node *fixed_paramref_hook(ParseState *pstate, ParamRef *pref);
 static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
 static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
-										Oid targetTypeId, int32 targetTypeMod,
-										int location);
+						   Oid targetTypeId, int32 targetTypeMod,
+						   int location);
 static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
 
 
@@ -245,7 +245,7 @@ variable_coerce_param_hook(ParseState *pstate, Param *param,
  * of parsing with parse_variable_parameters.
  *
  * Note: this code intentionally does not check that all parameter positions
- * were used, nor that all got non-UNKNOWN types assigned.  Caller of parser
+ * were used, nor that all got non-UNKNOWN types assigned.	Caller of parser
  * should enforce that if it's important.
  */
 void
diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c
index 34f2dc410bd..9fdcd83d75b 100644
--- a/src/backend/parser/parse_relation.c
+++ b/src/backend/parser/parse_relation.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.149 2010/02/14 18:42:15 rhaas Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.150 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -88,11 +88,11 @@ refnameRangeTblEntry(ParseState *pstate,
 
 		/*
 		 * We can use LookupNamespaceNoError() here because we are only
-		 * interested in finding existing RTEs.  Checking USAGE permission
-		 * on the schema is unnecessary since it would have already been
-		 * checked when the RTE was made.  Furthermore, we want to report
-		 * "RTE not found", not "no permissions for schema", if the name
-		 * happens to match a schema name the user hasn't got access to.
+		 * interested in finding existing RTEs.  Checking USAGE permission on
+		 * the schema is unnecessary since it would have already been checked
+		 * when the RTE was made.  Furthermore, we want to report "RTE not
+		 * found", not "no permissions for schema", if the name happens to
+		 * match a schema name the user hasn't got access to.
 		 */
 		namespaceId = LookupNamespaceNoError(schemaname);
 		if (!OidIsValid(relId))
@@ -2369,8 +2369,8 @@ errorMissingRTE(ParseState *pstate, RangeVar *relation)
 
 	/*
 	 * Check to see if there are any potential matches in the query's
-	 * rangetable.  (Note: cases involving a bad schema name in the
-	 * RangeVar will throw error immediately here.  That seems OK.)
+	 * rangetable.	(Note: cases involving a bad schema name in the RangeVar
+	 * will throw error immediately here.  That seems OK.)
 	 */
 	rte = searchRangeTable(pstate, relation);
 
@@ -2394,11 +2394,11 @@ errorMissingRTE(ParseState *pstate, RangeVar *relation)
 	if (rte)
 		ereport(ERROR,
 				(errcode(ERRCODE_UNDEFINED_TABLE),
-				 errmsg("invalid reference to FROM-clause entry for table \"%s\"",
-						relation->relname),
+			errmsg("invalid reference to FROM-clause entry for table \"%s\"",
+				   relation->relname),
 				 (badAlias ?
-				  errhint("Perhaps you meant to reference the table alias \"%s\".",
-						  badAlias) :
+			errhint("Perhaps you meant to reference the table alias \"%s\".",
+					badAlias) :
 				  errhint("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
 						  rte->eref->aliasname)),
 				 parser_errposition(pstate, relation->location)));
diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c
index dce6f4d01c9..7e04a947830 100644
--- a/src/backend/parser/parse_target.c
+++ b/src/backend/parser/parse_target.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.176 2010/01/02 16:57:50 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.177 2010/02/26 02:00:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -49,9 +49,9 @@ static List *ExpandAllTables(ParseState *pstate, int location);
 static List *ExpandIndirectionStar(ParseState *pstate, A_Indirection *ind,
 					  bool targetlist);
 static List *ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte,
-							   int location, bool targetlist);
+				  int location, bool targetlist);
 static List *ExpandRowReference(ParseState *pstate, Node *expr,
-								bool targetlist);
+				   bool targetlist);
 static int	FigureColnameInternal(Node *node, char **name);
 
 
@@ -884,12 +884,12 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
 		 *
 		 * (e.g., SELECT emp.*, dname FROM emp, dept)
 		 *
-		 * Note: this code is a lot like transformColumnRef; it's tempting
-		 * to call that instead and then replace the resulting whole-row Var
-		 * with a list of Vars.  However, that would leave us with the
-		 * RTE's selectedCols bitmap showing the whole row as needing
-		 * select permission, as well as the individual columns.  That would
-		 * be incorrect (since columns added later shouldn't need select
+		 * Note: this code is a lot like transformColumnRef; it's tempting to
+		 * call that instead and then replace the resulting whole-row Var with
+		 * a list of Vars.	However, that would leave us with the RTE's
+		 * selectedCols bitmap showing the whole row as needing select
+		 * permission, as well as the individual columns.  That would be
+		 * incorrect (since columns added later shouldn't need select
 		 * permissions).  We could try to remove the whole-row permission bit
 		 * after the fact, but duplicating code is less messy.
 		 */
@@ -897,14 +897,15 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
 		char	   *relname = NULL;
 		RangeTblEntry *rte = NULL;
 		int			levels_up;
-		enum {
+		enum
+		{
 			CRSERR_NO_RTE,
 			CRSERR_WRONG_DB,
 			CRSERR_TOO_MANY
 		}			crserr = CRSERR_NO_RTE;
 
 		/*
-		 * Give the PreParseColumnRefHook, if any, first shot.  If it returns
+		 * Give the PreParseColumnRefHook, if any, first shot.	If it returns
 		 * non-null then we should use that expression.
 		 */
 		if (pstate->p_pre_columnref_hook != NULL)
@@ -932,35 +933,35 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
 										   &levels_up);
 				break;
 			case 4:
-			{
-				char	   *catname = strVal(linitial(fields));
-
-				/*
-				 * We check the catalog name and then ignore it.
-				 */
-				if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
 				{
-					crserr = CRSERR_WRONG_DB;
+					char	   *catname = strVal(linitial(fields));
+
+					/*
+					 * We check the catalog name and then ignore it.
+					 */
+					if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
+					{
+						crserr = CRSERR_WRONG_DB;
+						break;
+					}
+					nspname = strVal(lsecond(fields));
+					relname = strVal(lthird(fields));
+					rte = refnameRangeTblEntry(pstate, nspname, relname,
+											   cref->location,
+											   &levels_up);
 					break;
 				}
-				nspname = strVal(lsecond(fields));
-				relname = strVal(lthird(fields));
-				rte = refnameRangeTblEntry(pstate, nspname, relname,
-										   cref->location,
-										   &levels_up);
-				break;
-			}
 			default:
 				crserr = CRSERR_TOO_MANY;
 				break;
 		}
 
 		/*
-		 * Now give the PostParseColumnRefHook, if any, a chance.
-		 * We cheat a bit by passing the RangeTblEntry, not a Var,
-		 * as the planned translation.  (A single Var wouldn't be
-		 * strictly correct anyway.  This convention allows hooks
-		 * that really care to know what is happening.)
+		 * Now give the PostParseColumnRefHook, if any, a chance. We cheat a
+		 * bit by passing the RangeTblEntry, not a Var, as the planned
+		 * translation.  (A single Var wouldn't be strictly correct anyway.
+		 * This convention allows hooks that really care to know what is
+		 * happening.)
 		 */
 		if (pstate->p_post_columnref_hook != NULL)
 		{
@@ -1111,9 +1112,9 @@ ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte,
 				  NULL, &vars);
 
 		/*
-		 * Require read access to the table.  This is normally redundant
-		 * with the markVarForSelectPriv calls below, but not if the table
-		 * has zero columns.
+		 * Require read access to the table.  This is normally redundant with
+		 * the markVarForSelectPriv calls below, but not if the table has zero
+		 * columns.
 		 */
 		rte->requiredPerms |= ACL_SELECT;
 
@@ -1147,7 +1148,7 @@ ExpandRowReference(ParseState *pstate, Node *expr,
 
 	/*
 	 * If the rowtype expression is a whole-row Var, we can expand the fields
-	 * as simple Vars.  Note: if the RTE is a relation, this case leaves us
+	 * as simple Vars.	Note: if the RTE is a relation, this case leaves us
 	 * with the RTE's selectedCols bitmap showing the whole row as needing
 	 * select permission, as well as the individual columns.  However, we can
 	 * only get here for weird notations like (table.*).*, so it's not worth
@@ -1165,8 +1166,8 @@ ExpandRowReference(ParseState *pstate, Node *expr,
 	}
 
 	/*
-	 * Otherwise we have to do it the hard way.  Our current implementation
-	 * is to generate multiple copies of the expression and do FieldSelects.
+	 * Otherwise we have to do it the hard way.  Our current implementation is
+	 * to generate multiple copies of the expression and do FieldSelects.
 	 * (This can be pretty inefficient if the expression involves nontrivial
 	 * computation :-(.)
 	 *
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 4a5a5725455..1657096c6d8 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -19,7 +19,7 @@
  * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.39 2010/02/14 18:42:15 rhaas Exp $
+ *	$PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.40 2010/02/26 02:00:53 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -106,7 +106,7 @@ static void transformTableConstraint(ParseState *pstate,
 static void transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
 					 InhRelation *inhrelation);
 static void transformOfType(ParseState *pstate, CreateStmtContext *cxt,
-					 TypeName *ofTypename);
+				TypeName *ofTypename);
 static char *chooseIndexName(const RangeVar *relation, IndexStmt *index_stmt);
 static IndexStmt *generateClonedIndexStmt(CreateStmtContext *cxt,
 						Relation parent_index, AttrNumber *attmap);
@@ -186,7 +186,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
 	cxt.pkey = NULL;
 	cxt.hasoids = interpretOidsOption(stmt->options);
 
-	Assert(!stmt->ofTypename || !stmt->inhRelations); /* grammar enforces */
+	Assert(!stmt->ofTypename || !stmt->inhRelations);	/* grammar enforces */
 
 	if (stmt->ofTypename)
 		transformOfType(pstate, &cxt, stmt->ofTypename);
@@ -486,6 +486,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
 				break;
 
 			case CONSTR_FOREIGN:
+
 				/*
 				 * Fill in the current attribute's name and throw it into the
 				 * list of FK constraints to be processed later.
@@ -760,11 +761,11 @@ transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
 
 				if (comment != NULL)
 				{
-					CommentStmt	   *stmt;
+					CommentStmt *stmt;
 
 					/*
-					 * We have to assign the index a name now, so that we
-					 * can reference it in CommentStmt.
+					 * We have to assign the index a name now, so that we can
+					 * reference it in CommentStmt.
 					 */
 					if (index_stmt->idxname == NULL)
 						index_stmt->idxname = chooseIndexName(cxt->relation,
@@ -811,7 +812,7 @@ transformOfType(ParseState *pstate, CreateStmtContext *cxt, TypeName *ofTypename
 	tuple = typenameType(NULL, ofTypename, NULL);
 	typ = (Form_pg_type) GETSTRUCT(tuple);
 	ofTypeId = HeapTupleGetOid(tuple);
-	ofTypename->typeOid = ofTypeId; /* cached for later */
+	ofTypename->typeOid = ofTypeId;		/* cached for later */
 
 	if (typ->typtype != TYPTYPE_COMPOSITE)
 		ereport(ERROR,
@@ -823,7 +824,7 @@ transformOfType(ParseState *pstate, CreateStmtContext *cxt, TypeName *ofTypename
 	for (i = 0; i < tupdesc->natts; i++)
 	{
 		Form_pg_attribute attr = tupdesc->attrs[i];
-		ColumnDef *n = makeNode(ColumnDef);
+		ColumnDef  *n = makeNode(ColumnDef);
 
 		n->colname = pstrdup(NameStr(attr->attname));
 		n->typeName = makeTypeNameFromOid(attr->atttypid, attr->atttypmod);
@@ -934,7 +935,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
 	 */
 	if (index->primary || index->unique || idxrelrec->relhasexclusion)
 	{
-		Oid		constraintId = get_index_constraint(source_relid);
+		Oid			constraintId = get_index_constraint(source_relid);
 
 		if (OidIsValid(constraintId))
 		{
@@ -942,7 +943,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
 			Form_pg_constraint conrec;
 
 			ht_constr = SearchSysCache1(CONSTROID,
-									    ObjectIdGetDatum(constraintId));
+										ObjectIdGetDatum(constraintId));
 			if (!HeapTupleIsValid(ht_constr))
 				elog(ERROR, "cache lookup failed for constraint %u",
 					 constraintId);
@@ -955,9 +956,9 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
 			/* If it's an exclusion constraint, we need the operator names */
 			if (idxrelrec->relhasexclusion)
 			{
-				Datum  *elems;
-				int		nElems;
-				int		i;
+				Datum	   *elems;
+				int			nElems;
+				int			i;
 
 				Assert(conrec->contype == CONSTRAINT_EXCLUSION);
 				/* Extract operator OIDs from the pg_constraint tuple */
@@ -1310,17 +1311,17 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt)
 	index->concurrent = false;
 
 	/*
-	 * If it's an EXCLUDE constraint, the grammar returns a list of pairs
-	 * of IndexElems and operator names.  We have to break that apart into
+	 * If it's an EXCLUDE constraint, the grammar returns a list of pairs of
+	 * IndexElems and operator names.  We have to break that apart into
 	 * separate lists.
 	 */
 	if (constraint->contype == CONSTR_EXCLUSION)
 	{
 		foreach(lc, constraint->exclusions)
 		{
-			List	*pair = (List *) lfirst(lc);
-			IndexElem *elem;
-			List   *opname;
+			List	   *pair = (List *) lfirst(lc);
+			IndexElem  *elem;
+			List	   *opname;
 
 			Assert(list_length(pair) == 2);
 			elem = (IndexElem *) linitial(pair);