Allow floating point constants for "def_arg" numeric arguments.

Used in the generic "CREATE xxx" parsing.
Do some automatic type conversion for inserts from other columns.
Previous trouble with "resjunk" regression test remains for now.

src/backend/parser/gram.y

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.12 1998/05/09 23:22:15 thomas Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.13 1998/07/08 14:04:09 thomas Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -204,8 +204,7 @@ Oid	param_type(int t); /* used in parse_expr.c */
 %type <ival>	sub_type
 %type <list>	OptCreateAs, CreateAsList
 %type <node>	CreateAsElement
-%type <value>	NumConst
+%type <value>	NumericOnly, FloatOnly, IntegerOnly
-%type <value>	IntegerOnly
 %type <attr>	event_object, attr
 %type <sortgroupby>		groupby
 %type <sortgroupby>		sortby
@@ -1180,6 +1179,20 @@ OptSeqElem:  CACHE IntegerOnly
 				}
 		;
 
+NumericOnly:  FloatOnly					{ $$ = $1; }
+			| IntegerOnly				{ $$ = $1; }
+
+FloatOnly:  FCONST
+				{
+					$$ = makeFloat($1);
+				}
+			| '-' FCONST
+				{
+					$$ = makeFloat($2);
+					$$->val.dval = - $$->val.dval;
+				}
+		;
+
 IntegerOnly:  Iconst
 				{
 					$$ = makeInteger($1);
@@ -1384,7 +1397,7 @@ def_elem:  def_name '=' def_arg
 
 def_arg:  ColId							{  $$ = (Node *)makeString($1); }
 		| all_Op						{  $$ = (Node *)makeString($1); }
-		| NumConst						{  $$ = (Node *)$1; /* already a Value */ }
+		| NumericOnly					{  $$ = (Node *)$1; }
 		| Sconst						{  $$ = (Node *)makeString($1); }
 		| SETOF ColId
 				{
@@ -4442,10 +4455,6 @@ ParamNo:  PARAM
 				}
 		;
 
-NumConst:  Iconst						{ $$ = makeInteger($1); }
-		| FCONST						{ $$ = makeFloat($1); }
-		;
-
 Iconst:  ICONST							{ $$ = $1; };
 Sconst:  SCONST							{ $$ = $1; };
 UserId:  IDENT							{ $$ = $1; };

src/backend/parser/parse_clause.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.18 1998/06/05 03:49:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.19 1998/07/08 14:04:10 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -198,29 +198,31 @@ find_targetlist_entry(ParseState *pstate, SortGroupBy *sortgroupby, List *tlist)
 		List   *p_target = tlist;
 		TargetEntry *tent = makeNode(TargetEntry);
 		
-
 		if (sortgroupby->range)  {
-			Attr *missingTarget = (Attr *)makeNode(Attr);
+			Attr *missingAttr = (Attr *)makeNode(Attr);
-			missingTarget->type = T_Attr;
+			missingAttr->type = T_Attr;
 
-			missingTarget->relname = palloc(strlen(sortgroupby->range) + 1);
+			missingAttr->relname = palloc(strlen(sortgroupby->range) + 1);
-			strcpy(missingTarget->relname, sortgroupby->range);
+			strcpy(missingAttr->relname, sortgroupby->range);
 
-			missingTarget->attrs = lcons(makeString(sortgroupby->name), NIL);
+			missingAttr->attrs = lcons(makeString(sortgroupby->name), NIL);
 
-			transformTargetId(pstate, (Node*)missingTarget, tent, sortgroupby->name, TRUE);
+			tent = transformTargetIdent(pstate, (Node *)missingAttr, tent,
+										&missingAttr->relname, NULL,
+										missingAttr->relname, TRUE);
 		}
 		else  {
-			Ident *missingTarget = (Ident *)makeNode(Ident);
+			Ident *missingIdent = (Ident *)makeNode(Ident);
-			missingTarget->type = T_Ident;
+			missingIdent->type = T_Ident;
 
-			missingTarget->name = palloc(strlen(sortgroupby->name) + 1);
+			missingIdent->name = palloc(strlen(sortgroupby->name) + 1);
-			strcpy(missingTarget->name, sortgroupby->name);
+			strcpy(missingIdent->name, sortgroupby->name);
 
-			transformTargetId(pstate, (Node*)missingTarget, tent, sortgroupby->name, TRUE);
+			tent = transformTargetIdent(pstate, (Node *)missingIdent, tent,
+										&missingIdent->name, NULL,
+										missingIdent->name, TRUE);
 		}
 
-
 		/* Add to the end of the target list */
 		while (lnext(p_target) != NIL)  {
 			p_target = lnext(p_target);
@@ -457,7 +459,7 @@ transformUnionClause(List *unionClause, List *targetlist)
 					Node *expr;
 
 					expr = ((TargetEntry *)lfirst(next_target))->expr;
-					expr = coerce_target_expr(NULL, expr, itype, otype);
+					expr = CoerceTargetExpr(NULL, expr, itype, otype);
 					if (expr == NULL)
 					{
 						elog(ERROR,"Unable to transform %s to %s"

src/backend/parser/parse_coerce.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.2 1998/05/29 14:00:20 thomas Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.3 1998/07/08 14:04:10 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -273,6 +273,7 @@ TypeCategory(Oid inType)
 
 		case (INT2OID):
 		case (INT4OID):
+		case (INT8OID):
 		case (FLOAT4OID):
 		case (FLOAT8OID):
 		case (CASHOID):
@@ -387,6 +388,7 @@ PromoteTypeToNext(Oid inType)
 			break;
 
 		case (INT4OID):
+		case (INT8OID):
 		case (FLOAT4OID):
 			result = FLOAT8OID;
 			break;

src/backend/parser/parse_expr.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.30 1998/06/15 19:28:54 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.31 1998/07/08 14:04:10 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -312,6 +312,10 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
 		case T_Expr:
 		case T_Var:
 		case T_Const:
+/* T_Param comes from implicit function calls in INSERT/VALUE statements.
+ * - thomas 1998-06-11
+ */
+		case T_Param:
 			{
 				result = (Node *) expr;
 				break;

src/backend/parser/parse_func.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.19 1998/06/15 19:28:55 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.20 1998/07/08 14:04:10 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -153,7 +153,6 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
 	Oid		   *true_oid_array;
 	Node	   *retval;
 	bool		retset;
-	bool		exists;
 	bool		attisset = false;
 	Oid			toid = (Oid) 0;
 	Expr	   *expr;
@@ -370,16 +369,18 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
 		rettype = toid;
 		retset = true;
 		true_oid_array = oid_array;
-		exists = true;
 	}
 	else
 	{
+		bool exists;
+
 		exists = func_get_detail(funcname, nargs, oid_array, &funcid,
 								 &rettype, &retset, &true_oid_array);
-	}
-
 		if (!exists)
-		elog(ERROR, "No such attribute or function '%s'", funcname);
+			elog(ERROR, "No such function '%s' with the specified attributes",
+				 funcname);
+
+	}
 
 	/* got it */
 	funcnode = makeNode(Func);

src/backend/parser/parse_relation.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.11 1998/02/26 04:33:34 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.12 1998/07/08 14:04:11 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -20,6 +20,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "parser/parse_relation.h"
+#include "parser/parse_coerce.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
@@ -371,9 +372,8 @@ attnumTypeId(Relation rd, int attid)
 	return (rd->rd_att->attrs[attid - 1]->atttypid);
 }
 
-/*
+/* handleTargetColname()
- * handleTargetColname -
+ * Use column names from insert.
- *	  use column names from insert
  */
 void
 handleTargetColname(ParseState *pstate, char **resname,
@@ -395,9 +395,8 @@ handleTargetColname(ParseState *pstate, char **resname,
 		checkTargetTypes(pstate, *resname, refname, colname);
 }
 
-/*
+/* checkTargetTypes()
- * checkTargetTypes -
+ * Checks value and target column types.
- *	  checks value and target column types
  */
 static void
 checkTargetTypes(ParseState *pstate, char *target_colname,
@@ -432,6 +431,27 @@ checkTargetTypes(ParseState *pstate, char *target_colname,
 	resdomno_target = attnameAttNum(pstate->p_target_relation, target_colname);
 	attrtype_target = attnumTypeId(pstate->p_target_relation, resdomno_target);
 
+#if FALSE
+	if ((attrtype_id != attrtype_target)
+	 || (get_atttypmod(rte->relid, resdomno_id) !=
+		 get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target)))
+	{
+		if (can_coerce_type(1, &attrtype_id, &attrtype_target))
+		{
+			Node *expr = coerce_type(pstate, expr, attrtype_id, attrtype_target);
+
+			elog(ERROR, "Type %s(%d) can be coerced to match target column %s(%d)",
+				 colname, get_atttypmod(rte->relid, resdomno_id),
+				 target_colname, get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target));
+		}
+		else
+		{
+			elog(ERROR, "Type or size of %s(%d) does not match target column %s(%d)",
+				 colname, get_atttypmod(rte->relid, resdomno_id),
+				 target_colname, get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target));
+		}
+	}
+#else
 	if (attrtype_id != attrtype_target)
 		elog(ERROR, "Type of %s does not match target column %s",
 			 colname, target_colname);
@@ -446,5 +466,5 @@ checkTargetTypes(ParseState *pstate, char *target_colname,
 		get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target))
 		elog(ERROR, "Length of %s is longer than length of target column %s",
 			 colname, target_colname);
-
+#endif
 }

src/backend/parser/parse_target.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.16 1998/06/15 19:28:55 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.17 1998/07/08 14:04:11 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -30,67 +30,169 @@
 #include "utils/syscache.h"
 
 
-static List *expandAllTables(ParseState *pstate);
+static List *ExpandAllTables(ParseState *pstate);
-static char *figureColname(Node *expr, Node *resval);
+static char *FigureColname(Node *expr, Node *resval);
 static TargetEntry *
-make_targetlist_expr(ParseState *pstate,
+MakeTargetlistExpr(ParseState *pstate,
 				   char *colname,
 				   Node *expr,
 				   List *arrayRef);
 Node *
-size_target_expr(ParseState *pstate,
+SizeTargetExpr(ParseState *pstate,
 			   Node *expr,
 			   Oid attrtype,
 			   int16 attrtypmod);
 
 
-/*
+/* transformTargetIdent()
- *   transformTargetId - transforms an Ident Node to a Target Entry
+ * Transforms an Ident Node to a Target Entry
- *   Created this a function to allow the ORDER/GROUP BY clause be able 
+ * Created this function to allow the ORDER/GROUP BY clause to be able 
  *  to construct a TargetEntry from an Ident.
  *
  * resjunk = TRUE will hide the target entry in the final result tuple.
  *      daveh@insightdist.com     5/20/98
+ *
+ * Added more conversion logic to match up types from source to target.
+ * - thomas 1998-06-02
  */
-void
+TargetEntry *
-transformTargetId(ParseState *pstate,
+transformTargetIdent(ParseState *pstate,
+#if FALSE
+					 Ident *ident,
+#else
 					 Node *node,
+#endif
 					 TargetEntry *tent,
-				char *resname,
+					 char **resname,
+					 char *refname,
+					 char *colname,
 					 int16 resjunk)
 {
-	Node   *expr;
+	Node   *expr = NULL;
-	Oid	type_id;
+	Oid		attrtype_target;
-	int16	type_mod;
+
+
+	if (pstate->p_is_insert)
+	{
+		if (pstate->p_insert_columns != NIL)
+		{
+			Ident      *id = lfirst(pstate->p_insert_columns);
+
+			*resname = id->name;
+			pstate->p_insert_columns = lnext(pstate->p_insert_columns);
+		}
+		else
+			elog(ERROR, "insert: more expressions than target columns");
+	}
+
+	if (pstate->p_is_insert || pstate->p_is_update)
+	{
+		Oid         attrtype_id;
+		int         resdomno_id,
+					resdomno_target;
+		RangeTblEntry *rte;
+		char	   *target_colname;
+		int16		attrtypmod,
+					attrtypmod_target;
+
+		target_colname = *resname;
+
+		if (target_colname == NULL || colname == NULL)
+			return (tent);
+
+		if (refname != NULL)
+			rte = refnameRangeTableEntry(pstate, refname);
+		else
+		{
+			rte = colnameRangeTableEntry(pstate, colname);
+			if (rte == (RangeTblEntry *) NULL)
+				elog(ERROR, "attribute %s not found", colname);
+			refname = rte->refname;
+		}
+
+		resdomno_id = get_attnum(rte->relid, colname);
+		attrtype_id = get_atttype(rte->relid, resdomno_id);
+		attrtypmod = get_atttypmod(rte->relid, resdomno_id);
+
+		resdomno_target = attnameAttNum(pstate->p_target_relation, target_colname);
+		attrtype_target = attnumTypeId(pstate->p_target_relation, resdomno_target);
+		attrtypmod_target = get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target);
+
+#ifdef PARSEDEBUG
+printf("transformTargetIdent- transform type %d to %d\n",
+ attrtype_id, attrtype_target);
+#endif
+		if ((attrtype_id != attrtype_target)
+		 || ((attrtypmod_target >= 0) && (attrtypmod_target != attrtypmod)))
+		{
+			if (can_coerce_type(1, &attrtype_id, &attrtype_target))
+			{
+				expr = coerce_type(pstate, node, attrtype_id, attrtype_target);
+				expr = transformExpr(pstate, expr, EXPR_COLUMN_FIRST);
+				tent = MakeTargetlistExpr(pstate, *resname, expr, FALSE);
+				expr = tent->expr;
+			}
+			else
+			{
+#if TRUE
+				elog(ERROR, "Unable to convert %s to %s for column %s",
+					 typeidTypeName(attrtype_id), typeidTypeName(attrtype_target),
+					 target_colname);
+#else
+				elog(ERROR, "Type or size of %s(%d) does not match target column %s(%d)",
+					 colname, attrtypmod, target_colname, attrtypmod_target);
+#endif
+			}
+		}
+	}
 
 	/*
 	 * here we want to look for column names only, not
 	 * relation names (even though they can be stored in
 	 * Ident nodes, too)
 	 */
+	if (expr == NULL)
+	{
+		char   *name;
+		int16	type_mod;
+
+		name = ((*resname != NULL)? *resname: colname);
+
+#ifdef PARSEDEBUG
+printf("transformTargetIdent- call transformIdent()\n");
+#endif
+#if FALSE
+		expr = transformIdent(pstate, (Node *) ident, EXPR_COLUMN_FIRST);
+#else
 		expr = transformExpr(pstate, node, EXPR_COLUMN_FIRST);
-	type_id = exprType(expr);
+#endif
+
+		attrtype_target = exprType(expr);
 		if (nodeTag(expr) == T_Var)
 			type_mod = ((Var *) expr)->vartypmod;
 		else
 			type_mod = -1;
+
+#ifdef PARSEDEBUG
+printf("transformTargetIdent- attrtype_target = %d; type_mod = %d\n", attrtype_target, type_mod);
+#endif
+
 		tent->resdom = makeResdom((AttrNumber) pstate->p_last_resno++,
-							  (Oid) type_id,
+								  (Oid) attrtype_target,
 								  type_mod,
-							  resname,
+								  name,
 								  (Index) 0,
 								  (Oid) 0,
 								  resjunk);
-
 		tent->expr = expr;
-	return;
+	}
-}
+
+	return (tent);
+} /* transformTargetIdent() */
 
 
-
+/* transformTargetList()
-/*
+ * Turns a list of ResTarget's into a list of TargetEntry's.
- * transformTargetList -
- *	  turns a list of ResTarget's into a list of TargetEntry's
  */
 List *
 transformTargetList(ParseState *pstate, List *targetlist)
@@ -108,12 +210,15 @@ transformTargetList(ParseState *pstate, List *targetlist)
 			case T_Ident:
 				{
 					char	   *identname;
+#if FALSE
 					char	   *resname;
+#endif
 
+#ifdef PARSEDEBUG
+printf("transformTargetList: decode T_Ident\n");
+#endif
 					identname = ((Ident *) res->val)->name;
-					handleTargetColname(pstate, &res->name, NULL, identname);
+					tent = transformTargetIdent(pstate, (Node *)res->val, tent, &res->name, NULL, identname, FALSE);
-					resname = (res->name) ? res->name : identname;
-					transformTargetId(pstate, (Node*)res->val, tent, resname, FALSE);
 					break;
 				}
 			case T_ParamNo:
@@ -123,6 +228,9 @@ transformTargetList(ParseState *pstate, List *targetlist)
 				{
 					Node	*expr = transformExpr(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);
 
+#ifdef PARSEDEBUG
+printf("transformTargetList: decode T_Expr\n");
+#endif
 					handleTargetColname(pstate, &res->name, NULL, NULL);
 					/* note indirection has not been transformed */
 					if (pstate->p_is_insert && res->indirection != NIL)
@@ -183,7 +291,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
 						constval = makeNode(Value);
 						constval->type = T_String;
 						constval->val.str = save_str;
-						tent = make_targetlist_expr(pstate, res->name,
+						tent = MakeTargetlistExpr(pstate, res->name,
 												  (Node *) make_const(constval),
 												  NULL);
 						pfree(save_str);
@@ -201,7 +309,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
 							 * at the yacc grammar for why a name can be
 							 * missing. -ay
 							 */
-							colname = figureColname(expr, res->val);
+							colname = FigureColname(expr, res->val);
 						}
 						if (res->indirection)
 						{
@@ -217,7 +325,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
 							}
 						}
 						res->name = colname;
-						tent = make_targetlist_expr(pstate, res->name, expr,
+						tent = MakeTargetlistExpr(pstate, res->name, expr,
 												  res->indirection);
 					}
 					break;
@@ -240,9 +348,9 @@ transformTargetList(ParseState *pstate, List *targetlist)
 					if (att->relname != NULL && !strcmp(att->relname, "*"))
 					{
 						if (tail_p_target == NIL)
-							p_target = tail_p_target = expandAllTables(pstate);
+							p_target = tail_p_target = ExpandAllTables(pstate);
 						else
-							lnext(tail_p_target) = expandAllTables(pstate);
+							lnext(tail_p_target) = ExpandAllTables(pstate);
 
 						while (lnext(tail_p_target) != NIL)
 							/* make sure we point to the last target entry */
@@ -291,6 +399,9 @@ transformTargetList(ParseState *pstate, List *targetlist)
 					 * Target item is fully specified: ie.
 					 * relation.attribute
 					 */
+#ifdef PARSEDEBUG
+printf("transformTargetList: decode T_Attr\n");
+#endif
 					result = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno, EXPR_COLUMN_FIRST);
 					handleTargetColname(pstate, &res->name, att->relname, attrname);
 					if (att->indirection != NIL)
@@ -348,7 +459,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
 
 
 Node *
-coerce_target_expr(ParseState *pstate,
+CoerceTargetExpr(ParseState *pstate,
 				 Node *expr,
 				 Oid type_id,
 				 Oid attrtype)
@@ -356,7 +467,7 @@ coerce_target_expr(ParseState *pstate,
 	if (can_coerce_type(1, &type_id, &attrtype))
 	{
 #ifdef PARSEDEBUG
-printf("parse_target: coerce type from %s to %s\n",
+printf("CoerceTargetExpr: coerce type from %s to %s\n",
  typeidTypeName(type_id), typeidTypeName(attrtype));
 #endif
 		expr = coerce_type(pstate, expr, type_id, attrtype);
@@ -368,7 +479,7 @@ printf("parse_target: coerce type from %s to %s\n",
 	{
 		Oid text_id = TEXTOID;
 #ifdef PARSEDEBUG
-printf("parse_target: try coercing from %s to %s via text\n",
+printf("CoerceTargetExpr: try coercing from %s to %s via text\n",
  typeidTypeName(type_id), typeidTypeName(attrtype));
 #endif
 		if (type_id == TEXTOID)
@@ -385,15 +496,15 @@ printf("parse_target: try coercing from %s to %s via text\n",
 		expr = NULL;
 
 	return expr;
-} /* coerce_target_expr() */
+} /* CoerceTargetExpr() */
 
 
-/* size_target_expr()
+/* SizeTargetExpr()
  * Apparently going to a fixed-length string?
  * Then explicitly size for storage...
  */
 Node *
-size_target_expr(ParseState *pstate,
+SizeTargetExpr(ParseState *pstate,
 			   Node *expr,
 			   Oid attrtype,
 			   int16 attrtypmod)
@@ -407,7 +518,7 @@ size_target_expr(ParseState *pstate,
 	A_Const	   *cons;
 
 #ifdef PARSEDEBUG
-printf("parse_target: ensure target fits storage\n");
+printf("SizeTargetExpr: ensure target fits storage\n");
 #endif
 	funcname = typeidTypeName(attrtype);
 	oid_array[0] = attrtype;
@@ -415,7 +526,7 @@ printf("parse_target: ensure target fits storage\n");
 	for (i = 2; i < 8; i++) oid_array[i] = InvalidOid;
 
 #ifdef PARSEDEBUG
-printf("parse_target: look for conversion function %s(%s,%s)\n",
+printf("SizeTargetExpr: look for conversion function %s(%s,%s)\n",
  funcname, typeidTypeName(attrtype), typeidTypeName(INT4OID));
 #endif
 
@@ -429,7 +540,7 @@ printf("parse_target: look for conversion function %s(%s,%s)\n",
 	if (HeapTupleIsValid(ftup))
 	{
 #ifdef PARSEDEBUG
-printf("parse_target: found conversion function for sizing\n");
+printf("SizeTargetExpr: found conversion function for sizing\n");
 #endif
 		func = makeNode(FuncCall);
 		func->funcname = funcname;
@@ -444,25 +555,24 @@ printf("parse_target: found conversion function for sizing\n");
 #ifdef PARSEDEBUG
 	else
 	{
-printf("parse_target: no conversion function for sizing\n");
+printf("SizeTargetExpr: no conversion function for sizing\n");
 	}
 #endif
 
 	return expr;
-} /* size_target_expr() */
+} /* SizeTargetExpr() */
 
 
-/* make_targetlist_expr()
+/* MakeTargetlistExpr()
- * Make a TargetEntry from an expression
+ * Make a TargetEntry from an expression.
- *
+ * arrayRef is a list of transformed A_Indices.
- * arrayRef is a list of transformed A_Indices
  *
  * For type mismatches between expressions and targets, use the same
  *  techniques as for function and operator type coersion.
  * - thomas 1998-05-08
  */
 static TargetEntry *
-make_targetlist_expr(ParseState *pstate,
+MakeTargetlistExpr(ParseState *pstate,
 					 char *colname,
 					 Node *expr,
 					 List *arrayRef)
@@ -478,7 +588,7 @@ make_targetlist_expr(ParseState *pstate,
 	Resdom	   *resnode;
 
 	if (expr == NULL)
-		elog(ERROR, "make_targetlist_expr: invalid use of NULL expression");
+		elog(ERROR, "MakeTargetlistExpr: invalid use of NULL expression");
 
 	type_id = exprType(expr);
 	if (nodeTag(expr) == T_Var)
@@ -515,10 +625,9 @@ make_targetlist_expr(ParseState *pstate,
 				else
 					typelem = attrtype;
 
-				expr = coerce_target_expr(pstate, expr, type_id, typelem);
+				expr = CoerceTargetExpr(pstate, expr, type_id, typelem);
 
 				if (!HeapTupleIsValid(expr))
-				{
 					elog(ERROR, "parser: attribute '%s' is of type '%s'"
 						 " but expression is of type '%s'"
 						 "\n\tYou will need to rewrite or cast the expression",
@@ -526,17 +635,16 @@ make_targetlist_expr(ParseState *pstate,
 						 typeidTypeName(attrtype),
 						 typeidTypeName(type_id));
 			}
-			}
 
 #ifdef PARSEDEBUG
-printf("parse_target: attrtypmod is %d\n", (int4) attrtypmod);
+printf("MakeTargetlistExpr: attrtypmod is %d\n", (int4) attrtypmod);
 #endif
 
 			/* Apparently going to a fixed-length string?
 			 * Then explicitly size for storage...
 			 */
 			if (attrtypmod > 0)
-				expr = size_target_expr(pstate, expr, attrtype, attrtypmod);
+				expr = SizeTargetExpr(pstate, expr, attrtype, attrtypmod);
 		}
 
 		if (arrayRef != NIL)
@@ -583,8 +691,8 @@ printf("parse_target: attrtypmod is %d\n", (int4) attrtypmod);
 		attrtype = type_id;
 		attrtypmod = type_mod;
 	}
-	tent = makeNode(TargetEntry);
 
+	tent = makeNode(TargetEntry);
 	resnode = makeResdom((AttrNumber) resdomno,
 						 (Oid) attrtype,
 						 attrtypmod,
@@ -597,7 +705,7 @@ printf("parse_target: attrtypmod is %d\n", (int4) attrtypmod);
 	tent->expr = expr;
 
 	return tent;
-} /* make_targetlist_expr() */
+} /* MakeTargetlistExpr() */
 
 
 /*
@@ -656,12 +764,12 @@ makeTargetNames(ParseState *pstate, List *cols)
 }
 
 /*
- * expandAllTables -
+ * ExpandAllTables -
  *	  turns '*' (in the target list) into a list of attributes
  *	   (of all relations in the range table)
  */
 static List *
-expandAllTables(ParseState *pstate)
+ExpandAllTables(ParseState *pstate)
 {
 	List	   *target = NIL;
 	List	   *legit_rtable = NIL;
@@ -720,13 +828,13 @@ expandAllTables(ParseState *pstate)
 }
 
 /*
- * figureColname -
+ * FigureColname -
  *	  if the name of the resulting column is not specified in the target
  *	  list, we have to guess.
  *
  */
 static char *
-figureColname(Node *expr, Node *resval)
+FigureColname(Node *expr, Node *resval)
 {
 	switch (nodeTag(expr))
 	{